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
  74 /* Note on debug output:
  75  *
  76  * This is set up so that -Dr turns on debugging like all other flags that are
  77  * enabled by -DDEBUGGING.  -Drv gives more verbose output.  This applies to
  78  * all regular expressions encountered in a program, and gives a huge amount of
  79  * output for all but the shortest programs.
  80  *
  81  * The ability to output pattern debugging information lexically, and with much
  82  * finer grained control was added, with 'use re qw(Debug ....);' available even
  83  * in non-DEBUGGING builds.  This is accomplished by copying the contents of
  84  * regcomp.c to ext/re/re_comp.c, and regexec.c is copied to ext/re/re_exec.c.
  85  * Those files are compiled and linked into the perl executable, and they are
  86  * compiled essentially as if DEBUGGING were enabled, and controlled by calls
  87  * to re.pm.
  88  *
  89  * That would normally mean linking errors when two functions of the same name
  90  * are attempted to be placed into the same executable.  That is solved in one
  91  * of four ways:
  92  *  1)  Static functions aren't known outside the file they are in, so for the
  93  *      many functions of that type in this file, it just isn't a problem.
  94  *  2)  Most externally known functions are enclosed in
  95  *          #ifndef PERL_IN_XSUB_RE
  96  *          ...
  97  *          #endif
  98  *      blocks, so there is only one defintion for them in the whole
  99  *      executable, the one in regcomp.c (or regexec.c).  The implication of
 100  *      that is any debugging info that comes from them is controlled only by
 101  *      -Dr.  Further, any static function they call will also be the version
 102  *      in regcomp.c (or regexec.c), so its debugging will also be by -Dr.
 103  *  3)  About a dozen external functions are re-#defined in ext/re/re_top.h, to
 104  *      have different names, so that what gets loaded in the executable is
 105  *      'Perl_foo' from regcomp.c (and regexec.c), and the identical function
 106  *      from re_comp.c (and re_exec.c), but with the name 'my_foo'  Debugging
 107  *      in the 'Perl_foo' versions is controlled by -Dr, but the 'my_foo'
 108  *      versions and their callees are under control of re.pm.   The catch is
 109  *      that references to all these go through the regexp_engine structure,
 110  *      which is initialized in regcomp.h to the Perl_foo versions, and
 111  *      substituted out in lexical scopes where 'use re' is in effect to the
 112  *      'my_foo' ones.   That structure is public API, so it would be a hard
 113  *      sell to add any additional members.
 114  *  4)  For functions in regcomp.c and re_comp.c that are called only from,
 115  *      respectively, regexec.c and re_exec.c, they can have two different
 116  *      names, depending on #ifdef'ing PERL_IN_XSUB_RE, in both regexec.c and
 117  *      embed.fnc.
 118  *
 119  * The bottom line is that if you add code to one of the public functions
 120  * listed in ext/re/re_top.h, debugging automagically works.  But if you write
 121  * a new function that needs to do debugging or there is a chain of calls from
 122  * it that need to do debugging, all functions in the chain should use options
 123  * 2) or 4) above.
 124  *
 125  * A function may have to be split so that debugging stuff is static, but it
 126  * calls out to some other function that only gets compiled in regcomp.c to
 127  * access data that we don't want to duplicate.
 128  */
 129
 130 #include "EXTERN.h"
 131 #define PERL_IN_REGCOMP_C
 132 #include "perl.h"
 133
 134 #define REG_COMP_C
 135 #ifdef PERL_IN_XSUB_RE
 136 #  include "re_comp.h"
 137 EXTERN_C const struct regexp_engine my_reg_engine;
 138 EXTERN_C const struct regexp_engine wild_reg_engine;
 139 #else
 140 #  include "regcomp.h"
 141 #endif
 142
 143 #include "invlist_inline.h"
 144 #include "unicode_constants.h"
 145
 146 #ifndef STATIC
 147 #define STATIC  static
 148 #endif
 149
 150 /* this is a chain of data about sub patterns we are processing that
 151    need to be handled separately/specially in study_chunk. Its so
 152    we can simulate recursion without losing state.  */
 153 struct scan_frame;
 154 typedef struct scan_frame {
 155     regnode *last_regnode;      /* last node to process in this frame */
 156     regnode *next_regnode;      /* next node to process when last is reached */
 157     U32 prev_recursed_depth;
 158     I32 stopparen;              /* what stopparen do we use */
 159     bool in_gosub;              /* this or an outer frame is for GOSUB */
 160
 161     struct scan_frame *this_prev_frame; /* this previous frame */
 162     struct scan_frame *prev_frame;      /* previous frame */
 163     struct scan_frame *next_frame;      /* next frame */
 164 } scan_frame;
 165
 166 /* Certain characters are output as a sequence with the first being a
 167  * backslash. */
 168 #define isBACKSLASHED_PUNCT(c)  memCHRs("-[]\\^", c)
 169
 170
 171 struct RExC_state_t {
 172     U32         flags;                  /* RXf_* are we folding, multilining? */
 173     U32         pm_flags;               /* PMf_* stuff from the calling PMOP */
 174     char        *precomp;               /* uncompiled string. */
 175     char        *precomp_end;           /* pointer to end of uncompiled string. */
 176     REGEXP      *rx_sv;                 /* The SV that is the regexp. */
 177     regexp      *rx;                    /* perl core regexp structure */
 178     regexp_internal     *rxi;           /* internal data for regexp object
 179                                            pprivate field */
 180     char        *start;                 /* Start of input for compile */
 181     char        *end;                   /* End of input for compile */
 182     char        *parse;                 /* Input-scan pointer. */
 183     char        *copy_start;            /* start of copy of input within
 184                                            constructed parse string */
 185     char        *save_copy_start;       /* Provides one level of saving
 186                                            and restoring 'copy_start' */
 187     char        *copy_start_in_input;   /* Position in input string
 188                                            corresponding to copy_start */
 189     SSize_t     whilem_seen;            /* number of WHILEM in this expr */
 190     regnode     *emit_start;            /* Start of emitted-code area */
 191     regnode_offset emit;                /* Code-emit pointer */
 192     I32         naughty;                /* How bad is this pattern? */
 193     I32         sawback;                /* Did we see \1, ...? */
 194     SSize_t     size;                   /* Number of regnode equivalents in
 195                                            pattern */
 196     Size_t      sets_depth;              /* Counts recursion depth of already-
 197                                            compiled regex set patterns */
 198     U32         seen;
 199
 200     I32      parens_buf_size;           /* #slots malloced open/close_parens */
 201     regnode_offset *open_parens;        /* offsets to open parens */
 202     regnode_offset *close_parens;       /* offsets to close parens */
 203     HV          *paren_names;           /* Paren names */
 204
 205     /* position beyond 'precomp' of the warning message furthest away from
 206      * 'precomp'.  During the parse, no warnings are raised for any problems
 207      * earlier in the parse than this position.  This works if warnings are
 208      * raised the first time a given spot is parsed, and if only one
 209      * independent warning is raised for any given spot */
 210     Size_t      latest_warn_offset;
 211
 212     I32         npar;                   /* Capture buffer count so far in the
 213                                            parse, (OPEN) plus one. ("par" 0 is
 214                                            the whole pattern)*/
 215     I32         total_par;              /* During initial parse, is either 0,
 216                                            or -1; the latter indicating a
 217                                            reparse is needed.  After that pass,
 218                                            it is what 'npar' became after the
 219                                            pass.  Hence, it being > 0 indicates
 220                                            we are in a reparse situation */
 221     I32         nestroot;               /* root parens we are in - used by
 222                                            accept */
 223     I32         seen_zerolen;
 224     regnode     *end_op;                /* END node in program */
 225     I32         utf8;           /* whether the pattern is utf8 or not */
 226     I32         orig_utf8;      /* whether the pattern was originally in utf8 */
 227                                 /* XXX use this for future optimisation of case
 228                                  * where pattern must be upgraded to utf8. */
 229     I32         uni_semantics;  /* If a d charset modifier should use unicode
 230                                    rules, even if the pattern is not in
 231                                    utf8 */
 232
 233     I32         recurse_count;          /* Number of recurse regops we have generated */
 234     regnode     **recurse;              /* Recurse regops */
 235     U8          *study_chunk_recursed;  /* bitmap of which subs we have moved
 236                                            through */
 237     U32         study_chunk_recursed_bytes;  /* bytes in bitmap */
 238     I32         in_lookaround;
 239     I32         contains_locale;
 240     I32         override_recoding;
 241     I32         recode_x_to_native;
 242     I32         in_multi_char_class;
 243     int         code_index;             /* next code_blocks[] slot */
 244     struct reg_code_blocks *code_blocks;/* positions of literal (?{})
 245                                             within pattern */
 246     SSize_t     maxlen;                        /* mininum possible number of chars in string to match */
 247     scan_frame *frame_head;
 248     scan_frame *frame_last;
 249     U32         frame_count;
 250     AV         *warn_text;
 251     HV         *unlexed_names;
 252     SV          *runtime_code_qr;       /* qr with the runtime code blocks */
 253 #ifdef DEBUGGING
 254     const char  *lastparse;
 255     I32         lastnum;
 256     U32         study_chunk_recursed_count;
 257     AV          *paren_name_list;       /* idx -> name */
 258     SV          *mysv1;
 259     SV          *mysv2;
 260
 261 #define RExC_lastparse  (pRExC_state->lastparse)
 262 #define RExC_lastnum    (pRExC_state->lastnum)
 263 #define RExC_paren_name_list    (pRExC_state->paren_name_list)
 264 #define RExC_study_chunk_recursed_count    (pRExC_state->study_chunk_recursed_count)
 265 #define RExC_mysv       (pRExC_state->mysv1)
 266 #define RExC_mysv1      (pRExC_state->mysv1)
 267 #define RExC_mysv2      (pRExC_state->mysv2)
 268
 269 #endif
 270     bool        seen_d_op;
 271     bool        strict;
 272     bool        study_started;
 273     bool        in_script_run;
 274     bool        use_BRANCHJ;
 275     bool        sWARN_EXPERIMENTAL__VLB;
 276     bool        sWARN_EXPERIMENTAL__REGEX_SETS;
 277 };
 278
 279 #define RExC_flags      (pRExC_state->flags)
 280 #define RExC_pm_flags   (pRExC_state->pm_flags)
 281 #define RExC_precomp    (pRExC_state->precomp)
 282 #define RExC_copy_start_in_input (pRExC_state->copy_start_in_input)
 283 #define RExC_copy_start_in_constructed  (pRExC_state->copy_start)
 284 #define RExC_save_copy_start_in_constructed  (pRExC_state->save_copy_start)
 285 #define RExC_precomp_end (pRExC_state->precomp_end)
 286 #define RExC_rx_sv      (pRExC_state->rx_sv)
 287 #define RExC_rx         (pRExC_state->rx)
 288 #define RExC_rxi        (pRExC_state->rxi)
 289 #define RExC_start      (pRExC_state->start)
 290 #define RExC_end        (pRExC_state->end)
 291 #define RExC_parse      (pRExC_state->parse)
 292 #define RExC_latest_warn_offset (pRExC_state->latest_warn_offset )
 293 #define RExC_whilem_seen        (pRExC_state->whilem_seen)
 294 #define RExC_seen_d_op (pRExC_state->seen_d_op) /* Seen something that differs
 295                                                    under /d from /u ? */
 296
 297 #ifdef RE_TRACK_PATTERN_OFFSETS
 298 #  define RExC_offsets  (RExC_rxi->u.offsets) /* I am not like the
 299                                                          others */
 300 #endif
 301 #define RExC_emit       (pRExC_state->emit)
 302 #define RExC_emit_start (pRExC_state->emit_start)
 303 #define RExC_sawback    (pRExC_state->sawback)
 304 #define RExC_seen       (pRExC_state->seen)
 305 #define RExC_size       (pRExC_state->size)
 306 #define RExC_maxlen        (pRExC_state->maxlen)
 307 #define RExC_npar       (pRExC_state->npar)
 308 #define RExC_total_parens       (pRExC_state->total_par)
 309 #define RExC_parens_buf_size    (pRExC_state->parens_buf_size)
 310 #define RExC_nestroot   (pRExC_state->nestroot)
 311 #define RExC_seen_zerolen       (pRExC_state->seen_zerolen)
 312 #define RExC_utf8       (pRExC_state->utf8)
 313 #define RExC_uni_semantics      (pRExC_state->uni_semantics)
 314 #define RExC_orig_utf8  (pRExC_state->orig_utf8)
 315 #define RExC_open_parens        (pRExC_state->open_parens)
 316 #define RExC_close_parens       (pRExC_state->close_parens)
 317 #define RExC_end_op     (pRExC_state->end_op)
 318 #define RExC_paren_names        (pRExC_state->paren_names)
 319 #define RExC_recurse    (pRExC_state->recurse)
 320 #define RExC_recurse_count      (pRExC_state->recurse_count)
 321 #define RExC_sets_depth         (pRExC_state->sets_depth)
 322 #define RExC_study_chunk_recursed        (pRExC_state->study_chunk_recursed)
 323 #define RExC_study_chunk_recursed_bytes  \
 324                                    (pRExC_state->study_chunk_recursed_bytes)
 325 #define RExC_in_lookaround      (pRExC_state->in_lookaround)
 326 #define RExC_contains_locale    (pRExC_state->contains_locale)
 327 #define RExC_recode_x_to_native (pRExC_state->recode_x_to_native)
 328
 329 #ifdef EBCDIC
 330 #  define SET_recode_x_to_native(x)                                         \
 331                     STMT_START { RExC_recode_x_to_native = (x); } STMT_END
 332 #else
 333 #  define SET_recode_x_to_native(x) NOOP
 334 #endif
 335
 336 #define RExC_in_multi_char_class (pRExC_state->in_multi_char_class)
 337 #define RExC_frame_head (pRExC_state->frame_head)
 338 #define RExC_frame_last (pRExC_state->frame_last)
 339 #define RExC_frame_count (pRExC_state->frame_count)
 340 #define RExC_strict (pRExC_state->strict)
 341 #define RExC_study_started      (pRExC_state->study_started)
 342 #define RExC_warn_text (pRExC_state->warn_text)
 343 #define RExC_in_script_run      (pRExC_state->in_script_run)
 344 #define RExC_use_BRANCHJ        (pRExC_state->use_BRANCHJ)
 345 #define RExC_warned_WARN_EXPERIMENTAL__VLB (pRExC_state->sWARN_EXPERIMENTAL__VLB)
 346 #define RExC_warned_WARN_EXPERIMENTAL__REGEX_SETS (pRExC_state->sWARN_EXPERIMENTAL__REGEX_SETS)
 347 #define RExC_unlexed_names (pRExC_state->unlexed_names)
 348
 349 /* Heuristic check on the complexity of the pattern: if TOO_NAUGHTY, we set
 350  * a flag to disable back-off on the fixed/floating substrings - if it's
 351  * a high complexity pattern we assume the benefit of avoiding a full match
 352  * is worth the cost of checking for the substrings even if they rarely help.
 353  */
 354 #define RExC_naughty    (pRExC_state->naughty)
 355 #define TOO_NAUGHTY (10)
 356 #define MARK_NAUGHTY(add) \
 357     if (RExC_naughty < TOO_NAUGHTY) \
 358         RExC_naughty += (add)
 359 #define MARK_NAUGHTY_EXP(exp, add) \
 360     if (RExC_naughty < TOO_NAUGHTY) \
 361         RExC_naughty += RExC_naughty / (exp) + (add)
 362
 363 #define ISMULT1(c)      ((c) == '*' || (c) == '+' || (c) == '?')
 364 #define ISMULT2(s)      (ISMULT1(*s) || ((*s) == '{' && regcurly(s)))
 365
 366 /*
 367  * Flags to be passed up and down.
 368  */
 369 #define HASWIDTH        0x01    /* Known to not match null strings, could match
 370                                    non-null ones. */
 371 #define SIMPLE          0x02    /* Exactly one character wide */
 372                                 /* (or LNBREAK as a special case) */
 373 #define POSTPONED       0x08    /* (?1),(?&name), (??{...}) or similar */
 374 #define TRYAGAIN        0x10    /* Weeded out a declaration. */
 375 #define RESTART_PARSE   0x20    /* Need to redo the parse */
 376 #define NEED_UTF8       0x40    /* In conjunction with RESTART_PARSE, need to
 377                                    calcuate sizes as UTF-8 */
 378
 379 #define REG_NODE_NUM(x) ((x) ? (int)((x)-RExC_emit_start) : -1)
 380
 381 /* whether trie related optimizations are enabled */
 382 #if PERL_ENABLE_EXTENDED_TRIE_OPTIMISATION
 383 #define TRIE_STUDY_OPT
 384 #define FULL_TRIE_STUDY
 385 #define TRIE_STCLASS
 386 #endif
 387
 388
 389
 390 #define PBYTE(u8str,paren) ((U8*)(u8str))[(paren) >> 3]
 391 #define PBITVAL(paren) (1 << ((paren) & 7))
 392 #define PAREN_OFFSET(depth) \
 393     (RExC_study_chunk_recursed + (depth) * RExC_study_chunk_recursed_bytes)
 394 #define PAREN_TEST(depth, paren) \
 395     (PBYTE(PAREN_OFFSET(depth), paren) & PBITVAL(paren))
 396 #define PAREN_SET(depth, paren) \
 397     (PBYTE(PAREN_OFFSET(depth), paren) |= PBITVAL(paren))
 398 #define PAREN_UNSET(depth, paren) \
 399     (PBYTE(PAREN_OFFSET(depth), paren) &= ~PBITVAL(paren))
 400
 401 #define REQUIRE_UTF8(flagp) STMT_START {                                   \
 402                                      if (!UTF) {                           \
 403                                          *flagp = RESTART_PARSE|NEED_UTF8; \
 404                                          return 0;                         \
 405                                      }                                     \
 406                              } STMT_END
 407
 408 /* /u is to be chosen if we are supposed to use Unicode rules, or if the
 409  * pattern is in UTF-8.  This latter condition is in case the outermost rules
 410  * are locale.  See GH #17278 */
 411 #define toUSE_UNI_CHARSET_NOT_DEPENDS (RExC_uni_semantics || UTF)
 412
 413 /* Change from /d into /u rules, and restart the parse.  RExC_uni_semantics is
 414  * a flag that indicates we need to override /d with /u as a result of
 415  * something in the pattern.  It should only be used in regards to calling
 416  * set_regex_charset() or get_regex_charset() */
 417 #define REQUIRE_UNI_RULES(flagp, restart_retval)                            \
 418     STMT_START {                                                            \
 419             if (DEPENDS_SEMANTICS) {                                        \
 420                 set_regex_charset(&RExC_flags, REGEX_UNICODE_CHARSET);      \
 421                 RExC_uni_semantics = 1;                                     \
 422                 if (RExC_seen_d_op && LIKELY(! IN_PARENS_PASS)) {           \
 423                     /* No need to restart the parse if we haven't seen      \
 424                      * anything that differs between /u and /d, and no need \
 425                      * to restart immediately if we're going to reparse     \
 426                      * anyway to count parens */                            \
 427                     *flagp |= RESTART_PARSE;                                \
 428                     return restart_retval;                                  \
 429                 }                                                           \
 430             }                                                               \
 431     } STMT_END
 432
 433 #define REQUIRE_BRANCHJ(flagp, restart_retval)                              \
 434     STMT_START {                                                            \
 435                 RExC_use_BRANCHJ = 1;                                       \
 436                 *flagp |= RESTART_PARSE;                                    \
 437                 return restart_retval;                                      \
 438     } STMT_END
 439
 440 /* Until we have completed the parse, we leave RExC_total_parens at 0 or
 441  * less.  After that, it must always be positive, because the whole re is
 442  * considered to be surrounded by virtual parens.  Setting it to negative
 443  * indicates there is some construct that needs to know the actual number of
 444  * parens to be properly handled.  And that means an extra pass will be
 445  * required after we've counted them all */
 446 #define ALL_PARENS_COUNTED (RExC_total_parens > 0)
 447 #define REQUIRE_PARENS_PASS                                                 \
 448     STMT_START {  /* No-op if have completed a pass */                      \
 449                     if (! ALL_PARENS_COUNTED) RExC_total_parens = -1;       \
 450     } STMT_END
 451 #define IN_PARENS_PASS (RExC_total_parens < 0)
 452
 453
 454 /* This is used to return failure (zero) early from the calling function if
 455  * various flags in 'flags' are set.  Two flags always cause a return:
 456  * 'RESTART_PARSE' and 'NEED_UTF8'.   'extra' can be used to specify any
 457  * additional flags that should cause a return; 0 if none.  If the return will
 458  * be done, '*flagp' is first set to be all of the flags that caused the
 459  * return. */
 460 #define RETURN_FAIL_ON_RESTART_OR_FLAGS(flags,flagp,extra)                  \
 461     STMT_START {                                                            \
 462             if ((flags) & (RESTART_PARSE|NEED_UTF8|(extra))) {              \
 463                 *(flagp) = (flags) & (RESTART_PARSE|NEED_UTF8|(extra));     \
 464                 return 0;                                                   \
 465             }                                                               \
 466     } STMT_END
 467
 468 #define MUST_RESTART(flags) ((flags) & (RESTART_PARSE))
 469
 470 #define RETURN_FAIL_ON_RESTART(flags,flagp)                                 \
 471                         RETURN_FAIL_ON_RESTART_OR_FLAGS( flags, flagp, 0)
 472 #define RETURN_FAIL_ON_RESTART_FLAGP(flagp)                                 \
 473                                     if (MUST_RESTART(*(flagp))) return 0
 474
 475 /* This converts the named class defined in regcomp.h to its equivalent class
 476  * number defined in handy.h. */
 477 #define namedclass_to_classnum(class)  ((int) ((class) / 2))
 478 #define classnum_to_namedclass(classnum)  ((classnum) * 2)
 479
 480 #define _invlist_union_complement_2nd(a, b, output) \
 481                         _invlist_union_maybe_complement_2nd(a, b, TRUE, output)
 482 #define _invlist_intersection_complement_2nd(a, b, output) \
 483                  _invlist_intersection_maybe_complement_2nd(a, b, TRUE, output)
 484
 485 /* We add a marker if we are deferring expansion of a property that is both
 486  * 1) potentiallly user-defined; and
 487  * 2) could also be an official Unicode property.
 488  *
 489  * Without this marker, any deferred expansion can only be for a user-defined
 490  * one.  This marker shouldn't conflict with any that could be in a legal name,
 491  * and is appended to its name to indicate this.  There is a string and
 492  * character form */
 493 #define DEFERRED_COULD_BE_OFFICIAL_MARKERs  "~"
 494 #define DEFERRED_COULD_BE_OFFICIAL_MARKERc  '~'
 495
 496 /* What is infinity for optimization purposes */
 497 #define OPTIMIZE_INFTY  SSize_t_MAX
 498
 499 /* About scan_data_t.
 500
 501   During optimisation we recurse through the regexp program performing
 502   various inplace (keyhole style) optimisations. In addition study_chunk
 503   and scan_commit populate this data structure with information about
 504   what strings MUST appear in the pattern. We look for the longest
 505   string that must appear at a fixed location, and we look for the
 506   longest string that may appear at a floating location. So for instance
 507   in the pattern:
 508
 509     /FOO[xX]A.*B[xX]BAR/
 510
 511   Both 'FOO' and 'A' are fixed strings. Both 'B' and 'BAR' are floating
 512   strings (because they follow a .* construct). study_chunk will identify
 513   both FOO and BAR as being the longest fixed and floating strings respectively.
 514
 515   The strings can be composites, for instance
 516
 517      /(f)(o)(o)/
 518
 519   will result in a composite fixed substring 'foo'.
 520
 521   For each string some basic information is maintained:
 522
 523   - min_offset
 524     This is the position the string must appear at, or not before.
 525     It also implicitly (when combined with minlenp) tells us how many
 526     characters must match before the string we are searching for.
 527     Likewise when combined with minlenp and the length of the string it
 528     tells us how many characters must appear after the string we have
 529     found.
 530
 531   - max_offset
 532     Only used for floating strings. This is the rightmost point that
 533     the string can appear at. If set to OPTIMIZE_INFTY it indicates that the
 534     string can occur infinitely far to the right.
 535     For fixed strings, it is equal to min_offset.
 536
 537   - minlenp
 538     A pointer to the minimum number of characters of the pattern that the
 539     string was found inside. This is important as in the case of positive
 540     lookahead or positive lookbehind we can have multiple patterns
 541     involved. Consider
 542
 543     /(?=FOO).*F/
 544
 545     The minimum length of the pattern overall is 3, the minimum length
 546     of the lookahead part is 3, but the minimum length of the part that
 547     will actually match is 1. So 'FOO's minimum length is 3, but the
 548     minimum length for the F is 1. This is important as the minimum length
 549     is used to determine offsets in front of and behind the string being
 550     looked for.  Since strings can be composites this is the length of the
 551     pattern at the time it was committed with a scan_commit. Note that
 552     the length is calculated by study_chunk, so that the minimum lengths
 553     are not known until the full pattern has been compiled, thus the
 554     pointer to the value.
 555
 556   - lookbehind
 557
 558     In the case of lookbehind the string being searched for can be
 559     offset past the start point of the final matching string.
 560     If this value was just blithely removed from the min_offset it would
 561     invalidate some of the calculations for how many chars must match
 562     before or after (as they are derived from min_offset and minlen and
 563     the length of the string being searched for).
 564     When the final pattern is compiled and the data is moved from the
 565     scan_data_t structure into the regexp structure the information
 566     about lookbehind is factored in, with the information that would
 567     have been lost precalculated in the end_shift field for the
 568     associated string.
 569
 570   The fields pos_min and pos_delta are used to store the minimum offset
 571   and the delta to the maximum offset at the current point in the pattern.
 572
 573 */
 574
 575 struct scan_data_substrs {
 576     SV      *str;       /* longest substring found in pattern */
 577     SSize_t min_offset; /* earliest point in string it can appear */
 578     SSize_t max_offset; /* latest point in string it can appear */
 579     SSize_t *minlenp;   /* pointer to the minlen relevant to the string */
 580     SSize_t lookbehind; /* is the pos of the string modified by LB */
 581     I32 flags;          /* per substring SF_* and SCF_* flags */
 582 };
 583
 584 typedef struct scan_data_t {
 585     /*I32 len_min;      unused */
 586     /*I32 len_delta;    unused */
 587     SSize_t pos_min;
 588     SSize_t pos_delta;
 589     SV *last_found;
 590     SSize_t last_end;       /* min value, <0 unless valid. */
 591     SSize_t last_start_min;
 592     SSize_t last_start_max;
 593     U8      cur_is_floating; /* whether the last_* values should be set as
 594                               * the next fixed (0) or floating (1)
 595                               * substring */
 596
 597     /* [0] is longest fixed substring so far, [1] is longest float so far */
 598     struct scan_data_substrs  substrs[2];
 599
 600     I32 flags;             /* common SF_* and SCF_* flags */
 601     I32 whilem_c;
 602     SSize_t *last_closep;
 603     regnode_ssc *start_class;
 604 } scan_data_t;
 605
 606 /*
 607  * Forward declarations for pregcomp()'s friends.
 608  */
 609
 610 static const scan_data_t zero_scan_data = {
 611     0, 0, NULL, 0, 0, 0, 0,
 612     {
 613         { NULL, 0, 0, 0, 0, 0 },
 614         { NULL, 0, 0, 0, 0, 0 },
 615     },
 616     0, 0, NULL, NULL
 617 };
 618
 619 /* study flags */
 620
 621 #define SF_BEFORE_SEOL          0x0001
 622 #define SF_BEFORE_MEOL          0x0002
 623 #define SF_BEFORE_EOL           (SF_BEFORE_SEOL|SF_BEFORE_MEOL)
 624
 625 #define SF_IS_INF               0x0040
 626 #define SF_HAS_PAR              0x0080
 627 #define SF_IN_PAR               0x0100
 628 #define SF_HAS_EVAL             0x0200
 629
 630
 631 /* SCF_DO_SUBSTR is the flag that tells the regexp analyzer to track the
 632  * longest substring in the pattern. When it is not set the optimiser keeps
 633  * track of position, but does not keep track of the actual strings seen,
 634  *
 635  * So for instance /foo/ will be parsed with SCF_DO_SUBSTR being true, but
 636  * /foo/i will not.
 637  *
 638  * Similarly, /foo.*(blah|erm|huh).*fnorble/ will have "foo" and "fnorble"
 639  * parsed with SCF_DO_SUBSTR on, but while processing the (...) it will be
 640  * turned off because of the alternation (BRANCH). */
 641 #define SCF_DO_SUBSTR           0x0400
 642
 643 #define SCF_DO_STCLASS_AND      0x0800
 644 #define SCF_DO_STCLASS_OR       0x1000
 645 #define SCF_DO_STCLASS          (SCF_DO_STCLASS_AND|SCF_DO_STCLASS_OR)
 646 #define SCF_WHILEM_VISITED_POS  0x2000
 647
 648 #define SCF_TRIE_RESTUDY        0x4000 /* Do restudy? */
 649 #define SCF_SEEN_ACCEPT         0x8000
 650 #define SCF_TRIE_DOING_RESTUDY 0x10000
 651 #define SCF_IN_DEFINE          0x20000
 652
 653
 654
 655
 656 #define UTF cBOOL(RExC_utf8)
 657
 658 /* The enums for all these are ordered so things work out correctly */
 659 #define LOC (get_regex_charset(RExC_flags) == REGEX_LOCALE_CHARSET)
 660 #define DEPENDS_SEMANTICS (get_regex_charset(RExC_flags)                    \
 661                                                      == REGEX_DEPENDS_CHARSET)
 662 #define UNI_SEMANTICS (get_regex_charset(RExC_flags) == REGEX_UNICODE_CHARSET)
 663 #define AT_LEAST_UNI_SEMANTICS (get_regex_charset(RExC_flags)                \
 664                                                      >= REGEX_UNICODE_CHARSET)
 665 #define ASCII_RESTRICTED (get_regex_charset(RExC_flags)                      \
 666                                             == REGEX_ASCII_RESTRICTED_CHARSET)
 667 #define AT_LEAST_ASCII_RESTRICTED (get_regex_charset(RExC_flags)             \
 668                                             >= REGEX_ASCII_RESTRICTED_CHARSET)
 669 #define ASCII_FOLD_RESTRICTED (get_regex_charset(RExC_flags)                 \
 670                                         == REGEX_ASCII_MORE_RESTRICTED_CHARSET)
 671
 672 #define FOLD cBOOL(RExC_flags & RXf_PMf_FOLD)
 673
 674 /* For programs that want to be strictly Unicode compatible by dying if any
 675  * attempt is made to match a non-Unicode code point against a Unicode
 676  * property.  */
 677 #define ALWAYS_WARN_SUPER  ckDEAD(packWARN(WARN_NON_UNICODE))
 678
 679 #define OOB_NAMEDCLASS          -1
 680
 681 /* There is no code point that is out-of-bounds, so this is problematic.  But
 682  * its only current use is to initialize a variable that is always set before
 683  * looked at. */
 684 #define OOB_UNICODE             0xDEADBEEF
 685
 686 #define CHR_SVLEN(sv) (UTF ? sv_len_utf8(sv) : SvCUR(sv))
 687
 688
 689 /* length of regex to show in messages that don't mark a position within */
 690 #define RegexLengthToShowInErrorMessages 127
 691
 692 /*
 693  * If MARKER[12] are adjusted, be sure to adjust the constants at the top
 694  * of t/op/regmesg.t, the tests in t/op/re_tests, and those in
 695  * op/pragma/warn/regcomp.
 696  */
 697 #define MARKER1 "<-- HERE"    /* marker as it appears in the description */
 698 #define MARKER2 " <-- HERE "  /* marker as it appears within the regex */
 699
 700 #define REPORT_LOCATION " in regex; marked by " MARKER1    \
 701                         " in m/%" UTF8f MARKER2 "%" UTF8f "/"
 702
 703 /* The code in this file in places uses one level of recursion with parsing
 704  * rebased to an alternate string constructed by us in memory.  This can take
 705  * the form of something that is completely different from the input, or
 706  * something that uses the input as part of the alternate.  In the first case,
 707  * there should be no possibility of an error, as we are in complete control of
 708  * the alternate string.  But in the second case we don't completely control
 709  * the input portion, so there may be errors in that.  Here's an example:
 710  *      /[abc\x{DF}def]/ui
 711  * is handled specially because \x{df} folds to a sequence of more than one
 712  * character: 'ss'.  What is done is to create and parse an alternate string,
 713  * which looks like this:
 714  *      /(?:\x{DF}|[abc\x{DF}def])/ui
 715  * where it uses the input unchanged in the middle of something it constructs,
 716  * which is a branch for the DF outside the character class, and clustering
 717  * parens around the whole thing. (It knows enough to skip the DF inside the
 718  * class while in this substitute parse.) 'abc' and 'def' may have errors that
 719  * need to be reported.  The general situation looks like this:
 720  *
 721  *                                       |<------- identical ------>|
 722  *              sI                       tI               xI       eI
 723  * Input:       ---------------------------------------------------------------
 724  * Constructed:         ---------------------------------------------------
 725  *                      sC               tC               xC       eC     EC
 726  *                                       |<------- identical ------>|
 727  *
 728  * sI..eI   is the portion of the input pattern we are concerned with here.
 729  * sC..EC   is the constructed substitute parse string.
 730  *  sC..tC  is constructed by us
 731  *  tC..eC  is an exact duplicate of the portion of the input pattern tI..eI.
 732  *          In the diagram, these are vertically aligned.
 733  *  eC..EC  is also constructed by us.
 734  * xC       is the position in the substitute parse string where we found a
 735  *          problem.
 736  * xI       is the position in the original pattern corresponding to xC.
 737  *
 738  * We want to display a message showing the real input string.  Thus we need to
 739  * translate from xC to xI.  We know that xC >= tC, since the portion of the
 740  * string sC..tC has been constructed by us, and so shouldn't have errors.  We
 741  * get:
 742  *      xI = tI + (xC - tC)
 743  *
 744  * When the substitute parse is constructed, the code needs to set:
 745  *      RExC_start (sC)
 746  *      RExC_end (eC)
 747  *      RExC_copy_start_in_input  (tI)
 748  *      RExC_copy_start_in_constructed (tC)
 749  * and restore them when done.
 750  *
 751  * During normal processing of the input pattern, both
 752  * 'RExC_copy_start_in_input' and 'RExC_copy_start_in_constructed' are set to
 753  * sI, so that xC equals xI.
 754  */
 755
 756 #define sI              RExC_precomp
 757 #define eI              RExC_precomp_end
 758 #define sC              RExC_start
 759 #define eC              RExC_end
 760 #define tI              RExC_copy_start_in_input
 761 #define tC              RExC_copy_start_in_constructed
 762 #define xI(xC)          (tI + (xC - tC))
 763 #define xI_offset(xC)   (xI(xC) - sI)
 764
 765 #define REPORT_LOCATION_ARGS(xC)                                            \
 766     UTF8fARG(UTF,                                                           \
 767              (xI(xC) > eI) /* Don't run off end */                          \
 768               ? eI - sI   /* Length before the <--HERE */                   \
 769               : ((xI_offset(xC) >= 0)                                       \
 770                  ? xI_offset(xC)                                            \
 771                  : (Perl_croak(aTHX_ "panic: %s: %d: negative offset: %"    \
 772                                     IVdf " trying to output message for "   \
 773                                     " pattern %.*s",                        \
 774                                     __FILE__, __LINE__, (IV) xI_offset(xC), \
 775                                     ((int) (eC - sC)), sC), 0)),            \
 776              sI),         /* The input pattern printed up to the <--HERE */ \
 777     UTF8fARG(UTF,                                                           \
 778              (xI(xC) > eI) ? 0 : eI - xI(xC), /* Length after <--HERE */    \
 779              (xI(xC) > eI) ? eI : xI(xC))     /* pattern after <--HERE */
 780
 781 /* Used to point after bad bytes for an error message, but avoid skipping
 782  * past a nul byte. */
 783 #define SKIP_IF_CHAR(s, e) (!*(s) ? 0 : UTF ? UTF8_SAFE_SKIP(s, e) : 1)
 784
 785 /* Set up to clean up after our imminent demise */
 786 #define PREPARE_TO_DIE                                                      \
 787     STMT_START {                                                            \
 788         if (RExC_rx_sv)                                                     \
 789             SAVEFREESV(RExC_rx_sv);                                         \
 790         if (RExC_open_parens)                                               \
 791             SAVEFREEPV(RExC_open_parens);                                   \
 792         if (RExC_close_parens)                                              \
 793             SAVEFREEPV(RExC_close_parens);                                  \
 794     } STMT_END
 795
 796 /*
 797  * Calls SAVEDESTRUCTOR_X if needed, then calls Perl_croak with the given
 798  * arg. Show regex, up to a maximum length. If it's too long, chop and add
 799  * "...".
 800  */
 801 #define _FAIL(code) STMT_START {                                        \
 802     const char *ellipses = "";                                          \
 803     IV len = RExC_precomp_end - RExC_precomp;                           \
 804                                                                         \
 805     PREPARE_TO_DIE;                                                     \
 806     if (len > RegexLengthToShowInErrorMessages) {                       \
 807         /* chop 10 shorter than the max, to ensure meaning of "..." */  \
 808         len = RegexLengthToShowInErrorMessages - 10;                    \
 809         ellipses = "...";                                               \
 810     }                                                                   \
 811     code;                                                               \
 812 } STMT_END
 813
 814 #define FAIL(msg) _FAIL(                            \
 815     Perl_croak(aTHX_ "%s in regex m/%" UTF8f "%s/",         \
 816             msg, UTF8fARG(UTF, len, RExC_precomp), ellipses))
 817
 818 #define FAIL2(msg,arg) _FAIL(                       \
 819     Perl_croak(aTHX_ msg " in regex m/%" UTF8f "%s/",       \
 820             arg, UTF8fARG(UTF, len, RExC_precomp), ellipses))
 821
 822 #define FAIL3(msg,arg1,arg2) _FAIL(                         \
 823     Perl_croak(aTHX_ msg " in regex m/%" UTF8f "%s/",       \
 824      arg1, arg2, UTF8fARG(UTF, len, RExC_precomp), ellipses))
 825
 826 /*
 827  * Simple_vFAIL -- like FAIL, but marks the current location in the scan
 828  */
 829 #define Simple_vFAIL(m) STMT_START {                                    \
 830     Perl_croak(aTHX_ "%s" REPORT_LOCATION,                              \
 831             m, REPORT_LOCATION_ARGS(RExC_parse));                       \
 832 } STMT_END
 833
 834 /*
 835  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL()
 836  */
 837 #define vFAIL(m) STMT_START {                           \
 838     PREPARE_TO_DIE;                                     \
 839     Simple_vFAIL(m);                                    \
 840 } STMT_END
 841
 842 /*
 843  * Like Simple_vFAIL(), but accepts two arguments.
 844  */
 845 #define Simple_vFAIL2(m,a1) STMT_START {                        \
 846     S_re_croak(aTHX_ UTF, m REPORT_LOCATION, a1,                \
 847                       REPORT_LOCATION_ARGS(RExC_parse));        \
 848 } STMT_END
 849
 850 /*
 851  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL2().
 852  */
 853 #define vFAIL2(m,a1) STMT_START {                       \
 854     PREPARE_TO_DIE;                                     \
 855     Simple_vFAIL2(m, a1);                               \
 856 } STMT_END
 857
 858
 859 /*
 860  * Like Simple_vFAIL(), but accepts three arguments.
 861  */
 862 #define Simple_vFAIL3(m, a1, a2) STMT_START {                   \
 863     S_re_croak(aTHX_ UTF, m REPORT_LOCATION, a1, a2,            \
 864             REPORT_LOCATION_ARGS(RExC_parse));                  \
 865 } STMT_END
 866
 867 /*
 868  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL3().
 869  */
 870 #define vFAIL3(m,a1,a2) STMT_START {                    \
 871     PREPARE_TO_DIE;                                     \
 872     Simple_vFAIL3(m, a1, a2);                           \
 873 } STMT_END
 874
 875 /*
 876  * Like Simple_vFAIL(), but accepts four arguments.
 877  */
 878 #define Simple_vFAIL4(m, a1, a2, a3) STMT_START {               \
 879     S_re_croak(aTHX_ UTF, m REPORT_LOCATION, a1, a2, a3,        \
 880             REPORT_LOCATION_ARGS(RExC_parse));                  \
 881 } STMT_END
 882
 883 #define vFAIL4(m,a1,a2,a3) STMT_START {                 \
 884     PREPARE_TO_DIE;                                     \
 885     Simple_vFAIL4(m, a1, a2, a3);                       \
 886 } STMT_END
 887
 888 /* A specialized version of vFAIL2 that works with UTF8f */
 889 #define vFAIL2utf8f(m, a1) STMT_START {             \
 890     PREPARE_TO_DIE;                                 \
 891     S_re_croak(aTHX_ UTF, m REPORT_LOCATION, a1,  \
 892             REPORT_LOCATION_ARGS(RExC_parse));      \
 893 } STMT_END
 894
 895 #define vFAIL3utf8f(m, a1, a2) STMT_START {             \
 896     PREPARE_TO_DIE;                                     \
 897     S_re_croak(aTHX_ UTF, m REPORT_LOCATION, a1, a2,  \
 898             REPORT_LOCATION_ARGS(RExC_parse));          \
 899 } STMT_END
 900
 901 /* Setting this to NULL is a signal to not output warnings */
 902 #define TURN_OFF_WARNINGS_IN_SUBSTITUTE_PARSE                               \
 903     STMT_START {                                                            \
 904       RExC_save_copy_start_in_constructed  = RExC_copy_start_in_constructed;\
 905       RExC_copy_start_in_constructed = NULL;                                \
 906     } STMT_END
 907 #define RESTORE_WARNINGS                                                    \
 908     RExC_copy_start_in_constructed = RExC_save_copy_start_in_constructed
 909
 910 /* Since a warning can be generated multiple times as the input is reparsed, we
 911  * output it the first time we come to that point in the parse, but suppress it
 912  * otherwise.  'RExC_copy_start_in_constructed' being NULL is a flag to not
 913  * generate any warnings */
 914 #define TO_OUTPUT_WARNINGS(loc)                                         \
 915   (   RExC_copy_start_in_constructed                                    \
 916    && ((xI(loc)) - RExC_precomp) > (Ptrdiff_t) RExC_latest_warn_offset)
 917
 918 /* After we've emitted a warning, we save the position in the input so we don't
 919  * output it again */
 920 #define UPDATE_WARNINGS_LOC(loc)                                        \
 921     STMT_START {                                                        \
 922         if (TO_OUTPUT_WARNINGS(loc)) {                                  \
 923             RExC_latest_warn_offset = MAX(sI, MIN(eI, xI(loc)))         \
 924                                                        - RExC_precomp;  \
 925         }                                                               \
 926     } STMT_END
 927
 928 /* 'warns' is the output of the packWARNx macro used in 'code' */
 929 #define _WARN_HELPER(loc, warns, code)                                  \
 930     STMT_START {                                                        \
 931         if (! RExC_copy_start_in_constructed) {                         \
 932             Perl_croak( aTHX_ "panic! %s: %d: Tried to warn when none"  \
 933                               " expected at '%s'",                      \
 934                               __FILE__, __LINE__, loc);                 \
 935         }                                                               \
 936         if (TO_OUTPUT_WARNINGS(loc)) {                                  \
 937             if (ckDEAD(warns))                                          \
 938                 PREPARE_TO_DIE;                                         \
 939             code;                                                       \
 940             UPDATE_WARNINGS_LOC(loc);                                   \
 941         }                                                               \
 942     } STMT_END
 943
 944 /* m is not necessarily a "literal string", in this macro */
 945 #define warn_non_literal_string(loc, packed_warn, m)                    \
 946     _WARN_HELPER(loc, packed_warn,                                      \
 947                       Perl_warner(aTHX_ packed_warn,                    \
 948                                        "%s" REPORT_LOCATION,            \
 949                                   m, REPORT_LOCATION_ARGS(loc)))
 950 #define reg_warn_non_literal_string(loc, m)                             \
 951                 warn_non_literal_string(loc, packWARN(WARN_REGEXP), m)
 952
 953 #define ckWARN2_non_literal_string(loc, packwarn, m, a1)                    \
 954     STMT_START {                                                            \
 955                 char * format;                                              \
 956                 Size_t format_size = strlen(m) + strlen(REPORT_LOCATION)+ 1;\
 957                 Newx(format, format_size, char);                            \
 958                 my_strlcpy(format, m, format_size);                         \
 959                 my_strlcat(format, REPORT_LOCATION, format_size);           \
 960                 SAVEFREEPV(format);                                         \
 961                 _WARN_HELPER(loc, packwarn,                                 \
 962                       Perl_ck_warner(aTHX_ packwarn,                        \
 963                                         format,                             \
 964                                         a1, REPORT_LOCATION_ARGS(loc)));    \
 965     } STMT_END
 966
 967 #define ckWARNreg(loc,m)                                                \
 968     _WARN_HELPER(loc, packWARN(WARN_REGEXP),                            \
 969                       Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP),       \
 970                                           m REPORT_LOCATION,            \
 971                                           REPORT_LOCATION_ARGS(loc)))
 972
 973 #define vWARN(loc, m)                                                   \
 974     _WARN_HELPER(loc, packWARN(WARN_REGEXP),                            \
 975                       Perl_warner(aTHX_ packWARN(WARN_REGEXP),          \
 976                                        m REPORT_LOCATION,               \
 977                                        REPORT_LOCATION_ARGS(loc)))      \
 978
 979 #define vWARN_dep(loc, m)                                               \
 980     _WARN_HELPER(loc, packWARN(WARN_DEPRECATED),                        \
 981                       Perl_warner(aTHX_ packWARN(WARN_DEPRECATED),      \
 982                                        m REPORT_LOCATION,               \
 983                                        REPORT_LOCATION_ARGS(loc)))
 984
 985 #define ckWARNdep(loc,m)                                                \
 986     _WARN_HELPER(loc, packWARN(WARN_DEPRECATED),                        \
 987                       Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED), \
 988                                             m REPORT_LOCATION,          \
 989                                             REPORT_LOCATION_ARGS(loc)))
 990
 991 #define ckWARNregdep(loc,m)                                                 \
 992     _WARN_HELPER(loc, packWARN2(WARN_DEPRECATED, WARN_REGEXP),              \
 993                       Perl_ck_warner_d(aTHX_ packWARN2(WARN_DEPRECATED,     \
 994                                                       WARN_REGEXP),         \
 995                                              m REPORT_LOCATION,             \
 996                                              REPORT_LOCATION_ARGS(loc)))
 997
 998 #define ckWARN2reg_d(loc,m, a1)                                             \
 999     _WARN_HELPER(loc, packWARN(WARN_REGEXP),                                \
1000                       Perl_ck_warner_d(aTHX_ packWARN(WARN_REGEXP),         \
1001                                             m REPORT_LOCATION,              \
1002                                             a1, REPORT_LOCATION_ARGS(loc)))
1003
1004 #define ckWARN2reg(loc, m, a1)                                              \
1005     _WARN_HELPER(loc, packWARN(WARN_REGEXP),                                \
1006                       Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP),           \
1007                                           m REPORT_LOCATION,                \
1008                                           a1, REPORT_LOCATION_ARGS(loc)))
1009
1010 #define vWARN3(loc, m, a1, a2)                                              \
1011     _WARN_HELPER(loc, packWARN(WARN_REGEXP),                                \
1012                       Perl_warner(aTHX_ packWARN(WARN_REGEXP),              \
1013                                        m REPORT_LOCATION,                   \
1014                                        a1, a2, REPORT_LOCATION_ARGS(loc)))
1015
1016 #define ckWARN3reg(loc, m, a1, a2)                                          \
1017     _WARN_HELPER(loc, packWARN(WARN_REGEXP),                                \
1018                       Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP),           \
1019                                           m REPORT_LOCATION,                \
1020                                           a1, a2,                           \
1021                                           REPORT_LOCATION_ARGS(loc)))
1022
1023 #define vWARN4(loc, m, a1, a2, a3)                                      \
1024     _WARN_HELPER(loc, packWARN(WARN_REGEXP),                            \
1025                       Perl_warner(aTHX_ packWARN(WARN_REGEXP),          \
1026                                        m REPORT_LOCATION,               \
1027                                        a1, a2, a3,                      \
1028                                        REPORT_LOCATION_ARGS(loc)))
1029
1030 #define ckWARN4reg(loc, m, a1, a2, a3)                                  \
1031     _WARN_HELPER(loc, packWARN(WARN_REGEXP),                            \
1032                       Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP),       \
1033                                           m REPORT_LOCATION,            \
1034                                           a1, a2, a3,                   \
1035                                           REPORT_LOCATION_ARGS(loc)))
1036
1037 #define vWARN5(loc, m, a1, a2, a3, a4)                                  \
1038     _WARN_HELPER(loc, packWARN(WARN_REGEXP),                            \
1039                       Perl_warner(aTHX_ packWARN(WARN_REGEXP),          \
1040                                        m REPORT_LOCATION,               \
1041                                        a1, a2, a3, a4,                  \
1042                                        REPORT_LOCATION_ARGS(loc)))
1043
1044 #define ckWARNexperimental(loc, class, m)                               \
1045     STMT_START {                                                        \
1046         if (! RExC_warned_ ## class) { /* warn once per compilation */  \
1047             RExC_warned_ ## class = 1;                                  \
1048             _WARN_HELPER(loc, packWARN(class),                          \
1049                       Perl_ck_warner_d(aTHX_ packWARN(class),           \
1050                                             m REPORT_LOCATION,          \
1051                                             REPORT_LOCATION_ARGS(loc)));\
1052         }                                                               \
1053     } STMT_END
1054
1055 /* Convert between a pointer to a node and its offset from the beginning of the
1056  * program */
1057 #define REGNODE_p(offset)    (RExC_emit_start + (offset))
1058 #define REGNODE_OFFSET(node) ((node) - RExC_emit_start)
1059
1060 /* Macros for recording node offsets.   20001227 mjd@plover.com
1061  * Nodes are numbered 1, 2, 3, 4.  Node #n's position is recorded in
1062  * element 2*n-1 of the array.  Element #2n holds the byte length node #n.
1063  * Element 0 holds the number n.
1064  * Position is 1 indexed.
1065  */
1066 #ifndef RE_TRACK_PATTERN_OFFSETS
1067 #define Set_Node_Offset_To_R(offset,byte)
1068 #define Set_Node_Offset(node,byte)
1069 #define Set_Cur_Node_Offset
1070 #define Set_Node_Length_To_R(node,len)
1071 #define Set_Node_Length(node,len)
1072 #define Set_Node_Cur_Length(node,start)
1073 #define Node_Offset(n)
1074 #define Node_Length(n)
1075 #define Set_Node_Offset_Length(node,offset,len)
1076 #define ProgLen(ri) ri->u.proglen
1077 #define SetProgLen(ri,x) ri->u.proglen = x
1078 #define Track_Code(code)
1079 #else
1080 #define ProgLen(ri) ri->u.offsets[0]
1081 #define SetProgLen(ri,x) ri->u.offsets[0] = x
1082 #define Set_Node_Offset_To_R(offset,byte) STMT_START {                  \
1083         MJD_OFFSET_DEBUG(("** (%d) offset of node %d is %d.\n",         \
1084                     __LINE__, (int)(offset), (int)(byte)));             \
1085         if((offset) < 0) {                                              \
1086             Perl_croak(aTHX_ "value of node is %d in Offset macro",     \
1087                                          (int)(offset));                \
1088         } else {                                                        \
1089             RExC_offsets[2*(offset)-1] = (byte);                        \
1090         }                                                               \
1091 } STMT_END
1092
1093 #define Set_Node_Offset(node,byte)                                      \
1094     Set_Node_Offset_To_R(REGNODE_OFFSET(node), (byte)-RExC_start)
1095 #define Set_Cur_Node_Offset Set_Node_Offset(RExC_emit, RExC_parse)
1096
1097 #define Set_Node_Length_To_R(node,len) STMT_START {                     \
1098         MJD_OFFSET_DEBUG(("** (%d) size of node %d is %d.\n",           \
1099                 __LINE__, (int)(node), (int)(len)));                    \
1100         if((node) < 0) {                                                \
1101             Perl_croak(aTHX_ "value of node is %d in Length macro",     \
1102                                          (int)(node));                  \
1103         } else {                                                        \
1104             RExC_offsets[2*(node)] = (len);                             \
1105         }                                                               \
1106 } STMT_END
1107
1108 #define Set_Node_Length(node,len) \
1109     Set_Node_Length_To_R(REGNODE_OFFSET(node), len)
1110 #define Set_Node_Cur_Length(node, start)                \
1111     Set_Node_Length(node, RExC_parse - start)
1112
1113 /* Get offsets and lengths */
1114 #define Node_Offset(n) (RExC_offsets[2*(REGNODE_OFFSET(n))-1])
1115 #define Node_Length(n) (RExC_offsets[2*(REGNODE_OFFSET(n))])
1116
1117 #define Set_Node_Offset_Length(node,offset,len) STMT_START {    \
1118     Set_Node_Offset_To_R(REGNODE_OFFSET(node), (offset));       \
1119     Set_Node_Length_To_R(REGNODE_OFFSET(node), (len));  \
1120 } STMT_END
1121
1122 #define Track_Code(code) STMT_START { code } STMT_END
1123 #endif
1124
1125 #if PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS
1126 #define EXPERIMENTAL_INPLACESCAN
1127 #endif /*PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS*/
1128
1129 #ifdef DEBUGGING
1130 int
1131 Perl_re_printf(pTHX_ const char *fmt, ...)
1132 {
1133     va_list ap;
1134     int result;
1135     PerlIO *f= Perl_debug_log;
1136     PERL_ARGS_ASSERT_RE_PRINTF;
1137     va_start(ap, fmt);
1138     result = PerlIO_vprintf(f, fmt, ap);
1139     va_end(ap);
1140     return result;
1141 }
1142
1143 int
1144 Perl_re_indentf(pTHX_ const char *fmt, U32 depth, ...)
1145 {
1146     va_list ap;
1147     int result;
1148     PerlIO *f= Perl_debug_log;
1149     PERL_ARGS_ASSERT_RE_INDENTF;
1150     va_start(ap, depth);
1151     PerlIO_printf(f, "%*s", ( (int)depth % 20 ) * 2, "");
1152     result = PerlIO_vprintf(f, fmt, ap);
1153     va_end(ap);
1154     return result;
1155 }
1156 #endif /* DEBUGGING */
1157
1158 #define DEBUG_RExC_seen()                                                   \
1159         DEBUG_OPTIMISE_MORE_r({                                             \
1160             Perl_re_printf( aTHX_ "RExC_seen: ");                           \
1161                                                                             \
1162             if (RExC_seen & REG_ZERO_LEN_SEEN)                              \
1163                 Perl_re_printf( aTHX_ "REG_ZERO_LEN_SEEN ");                \
1164                                                                             \
1165             if (RExC_seen & REG_LOOKBEHIND_SEEN)                            \
1166                 Perl_re_printf( aTHX_ "REG_LOOKBEHIND_SEEN ");              \
1167                                                                             \
1168             if (RExC_seen & REG_GPOS_SEEN)                                  \
1169                 Perl_re_printf( aTHX_ "REG_GPOS_SEEN ");                    \
1170                                                                             \
1171             if (RExC_seen & REG_RECURSE_SEEN)                               \
1172                 Perl_re_printf( aTHX_ "REG_RECURSE_SEEN ");                 \
1173                                                                             \
1174             if (RExC_seen & REG_TOP_LEVEL_BRANCHES_SEEN)                    \
1175                 Perl_re_printf( aTHX_ "REG_TOP_LEVEL_BRANCHES_SEEN ");      \
1176                                                                             \
1177             if (RExC_seen & REG_VERBARG_SEEN)                               \
1178                 Perl_re_printf( aTHX_ "REG_VERBARG_SEEN ");                 \
1179                                                                             \
1180             if (RExC_seen & REG_CUTGROUP_SEEN)                              \
1181                 Perl_re_printf( aTHX_ "REG_CUTGROUP_SEEN ");                \
1182                                                                             \
1183             if (RExC_seen & REG_RUN_ON_COMMENT_SEEN)                        \
1184                 Perl_re_printf( aTHX_ "REG_RUN_ON_COMMENT_SEEN ");          \
1185                                                                             \
1186             if (RExC_seen & REG_UNFOLDED_MULTI_SEEN)                        \
1187                 Perl_re_printf( aTHX_ "REG_UNFOLDED_MULTI_SEEN ");          \
1188                                                                             \
1189             if (RExC_seen & REG_UNBOUNDED_QUANTIFIER_SEEN)                  \
1190                 Perl_re_printf( aTHX_ "REG_UNBOUNDED_QUANTIFIER_SEEN ");    \
1191                                                                             \
1192             Perl_re_printf( aTHX_ "\n");                                    \
1193         });
1194
1195 #define DEBUG_SHOW_STUDY_FLAG(flags,flag) \
1196   if ((flags) & flag) Perl_re_printf( aTHX_  "%s ", #flag)
1197
1198
1199 #ifdef DEBUGGING
1200 static void
1201 S_debug_show_study_flags(pTHX_ U32 flags, const char *open_str,
1202                                     const char *close_str)
1203 {
1204     if (!flags)
1205         return;
1206
1207     Perl_re_printf( aTHX_  "%s", open_str);
1208     DEBUG_SHOW_STUDY_FLAG(flags, SF_BEFORE_SEOL);
1209     DEBUG_SHOW_STUDY_FLAG(flags, SF_BEFORE_MEOL);
1210     DEBUG_SHOW_STUDY_FLAG(flags, SF_IS_INF);
1211     DEBUG_SHOW_STUDY_FLAG(flags, SF_HAS_PAR);
1212     DEBUG_SHOW_STUDY_FLAG(flags, SF_IN_PAR);
1213     DEBUG_SHOW_STUDY_FLAG(flags, SF_HAS_EVAL);
1214     DEBUG_SHOW_STUDY_FLAG(flags, SCF_DO_SUBSTR);
1215     DEBUG_SHOW_STUDY_FLAG(flags, SCF_DO_STCLASS_AND);
1216     DEBUG_SHOW_STUDY_FLAG(flags, SCF_DO_STCLASS_OR);
1217     DEBUG_SHOW_STUDY_FLAG(flags, SCF_DO_STCLASS);
1218     DEBUG_SHOW_STUDY_FLAG(flags, SCF_WHILEM_VISITED_POS);
1219     DEBUG_SHOW_STUDY_FLAG(flags, SCF_TRIE_RESTUDY);
1220     DEBUG_SHOW_STUDY_FLAG(flags, SCF_SEEN_ACCEPT);
1221     DEBUG_SHOW_STUDY_FLAG(flags, SCF_TRIE_DOING_RESTUDY);
1222     DEBUG_SHOW_STUDY_FLAG(flags, SCF_IN_DEFINE);
1223     Perl_re_printf( aTHX_  "%s", close_str);
1224 }
1225
1226
1227 static void
1228 S_debug_studydata(pTHX_ const char *where, scan_data_t *data,
1229                     U32 depth, int is_inf)
1230 {
1231     DECLARE_AND_GET_RE_DEBUG_FLAGS;
1232
1233     DEBUG_OPTIMISE_MORE_r({
1234         if (!data)
1235             return;
1236         Perl_re_indentf(aTHX_  "%s: Pos:%" IVdf "/%" IVdf " Flags: 0x%" UVXf,
1237             depth,
1238             where,
1239             (IV)data->pos_min,
1240             (IV)data->pos_delta,
1241             (UV)data->flags
1242         );
1243
1244         S_debug_show_study_flags(aTHX_ data->flags," [","]");
1245
1246         Perl_re_printf( aTHX_
1247             " Whilem_c: %" IVdf " Lcp: %" IVdf " %s",
1248             (IV)data->whilem_c,
1249             (IV)(data->last_closep ? *((data)->last_closep) : -1),
1250             is_inf ? "INF " : ""
1251         );
1252
1253         if (data->last_found) {
1254             int i;
1255             Perl_re_printf(aTHX_
1256                 "Last:'%s' %" IVdf ":%" IVdf "/%" IVdf,
1257                     SvPVX_const(data->last_found),
1258                     (IV)data->last_end,
1259                     (IV)data->last_start_min,
1260                     (IV)data->last_start_max
1261             );
1262
1263             for (i = 0; i < 2; i++) {
1264                 Perl_re_printf(aTHX_
1265                     " %s%s: '%s' @ %" IVdf "/%" IVdf,
1266                     data->cur_is_floating == i ? "*" : "",
1267                     i ? "Float" : "Fixed",
1268                     SvPVX_const(data->substrs[i].str),
1269                     (IV)data->substrs[i].min_offset,
1270                     (IV)data->substrs[i].max_offset
1271                 );
1272                 S_debug_show_study_flags(aTHX_ data->substrs[i].flags," [","]");
1273             }
1274         }
1275
1276         Perl_re_printf( aTHX_ "\n");
1277     });
1278 }
1279
1280
1281 static void
1282 S_debug_peep(pTHX_ const char *str, const RExC_state_t *pRExC_state,
1283                 regnode *scan, U32 depth, U32 flags)
1284 {
1285     DECLARE_AND_GET_RE_DEBUG_FLAGS;
1286
1287     DEBUG_OPTIMISE_r({
1288         regnode *Next;
1289
1290         if (!scan)
1291             return;
1292         Next = regnext(scan);
1293         regprop(RExC_rx, RExC_mysv, scan, NULL, pRExC_state);
1294         Perl_re_indentf( aTHX_   "%s>%3d: %s (%d)",
1295             depth,
1296             str,
1297             REG_NODE_NUM(scan), SvPV_nolen_const(RExC_mysv),
1298             Next ? (REG_NODE_NUM(Next)) : 0 );
1299         S_debug_show_study_flags(aTHX_ flags," [ ","]");
1300         Perl_re_printf( aTHX_  "\n");
1301    });
1302 }
1303
1304
1305 #  define DEBUG_STUDYDATA(where, data, depth, is_inf) \
1306                     S_debug_studydata(aTHX_ where, data, depth, is_inf)
1307
1308 #  define DEBUG_PEEP(str, scan, depth, flags)   \
1309                     S_debug_peep(aTHX_ str, pRExC_state, scan, depth, flags)
1310
1311 #else
1312 #  define DEBUG_STUDYDATA(where, data, depth, is_inf) NOOP
1313 #  define DEBUG_PEEP(str, scan, depth, flags)         NOOP
1314 #endif
1315
1316
1317 /* =========================================================
1318  * BEGIN edit_distance stuff.
1319  *
1320  * This calculates how many single character changes of any type are needed to
1321  * transform a string into another one.  It is taken from version 3.1 of
1322  *
1323  * https://metacpan.org/pod/Text::Levenshtein::Damerau::XS
1324  */
1325
1326 /* Our unsorted dictionary linked list.   */
1327 /* Note we use UVs, not chars. */
1328
1329 struct dictionary{
1330   UV key;
1331   UV value;
1332   struct dictionary* next;
1333 };
1334 typedef struct dictionary item;
1335
1336
1337 PERL_STATIC_INLINE item*
1338 push(UV key, item* curr)
1339 {
1340     item* head;
1341     Newx(head, 1, item);
1342     head->key = key;
1343     head->value = 0;
1344     head->next = curr;
1345     return head;
1346 }
1347
1348
1349 PERL_STATIC_INLINE item*
1350 find(item* head, UV key)
1351 {
1352     item* iterator = head;
1353     while (iterator){
1354         if (iterator->key == key){
1355             return iterator;
1356         }
1357         iterator = iterator->next;
1358     }
1359
1360     return NULL;
1361 }
1362
1363 PERL_STATIC_INLINE item*
1364 uniquePush(item* head, UV key)
1365 {
1366     item* iterator = head;
1367
1368     while (iterator){
1369         if (iterator->key == key) {
1370             return head;
1371         }
1372         iterator = iterator->next;
1373     }
1374
1375     return push(key, head);
1376 }
1377
1378 PERL_STATIC_INLINE void
1379 dict_free(item* head)
1380 {
1381     item* iterator = head;
1382
1383     while (iterator) {
1384         item* temp = iterator;
1385         iterator = iterator->next;
1386         Safefree(temp);
1387     }
1388
1389     head = NULL;
1390 }
1391
1392 /* End of Dictionary Stuff */
1393
1394 /* All calculations/work are done here */
1395 STATIC int
1396 S_edit_distance(const UV* src,
1397                 const UV* tgt,
1398                 const STRLEN x,             /* length of src[] */
1399                 const STRLEN y,             /* length of tgt[] */
1400                 const SSize_t maxDistance
1401 )
1402 {
1403     item *head = NULL;
1404     UV swapCount, swapScore, targetCharCount, i, j;
1405     UV *scores;
1406     UV score_ceil = x + y;
1407
1408     PERL_ARGS_ASSERT_EDIT_DISTANCE;
1409
1410     /* intialize matrix start values */
1411     Newx(scores, ( (x + 2) * (y + 2)), UV);
1412     scores[0] = score_ceil;
1413     scores[1 * (y + 2) + 0] = score_ceil;
1414     scores[0 * (y + 2) + 1] = score_ceil;
1415     scores[1 * (y + 2) + 1] = 0;
1416     head = uniquePush(uniquePush(head, src[0]), tgt[0]);
1417
1418     /* work loops    */
1419     /* i = src index */
1420     /* j = tgt index */
1421     for (i=1;i<=x;i++) {
1422         if (i < x)
1423             head = uniquePush(head, src[i]);
1424         scores[(i+1) * (y + 2) + 1] = i;
1425         scores[(i+1) * (y + 2) + 0] = score_ceil;
1426         swapCount = 0;
1427
1428         for (j=1;j<=y;j++) {
1429             if (i == 1) {
1430                 if(j < y)
1431                 head = uniquePush(head, tgt[j]);
1432                 scores[1 * (y + 2) + (j + 1)] = j;
1433                 scores[0 * (y + 2) + (j + 1)] = score_ceil;
1434             }
1435
1436             targetCharCount = find(head, tgt[j-1])->value;
1437             swapScore = scores[targetCharCount * (y + 2) + swapCount] + i - targetCharCount - 1 + j - swapCount;
1438
1439             if (src[i-1] != tgt[j-1]){
1440                 scores[(i+1) * (y + 2) + (j + 1)] = MIN(swapScore,(MIN(scores[i * (y + 2) + j], MIN(scores[(i+1) * (y + 2) + j], scores[i * (y + 2) + (j + 1)])) + 1));
1441             }
1442             else {
1443                 swapCount = j;
1444                 scores[(i+1) * (y + 2) + (j + 1)] = MIN(scores[i * (y + 2) + j], swapScore);
1445             }
1446         }
1447
1448         find(head, src[i-1])->value = i;
1449     }
1450
1451     {
1452         IV score = scores[(x+1) * (y + 2) + (y + 1)];
1453         dict_free(head);
1454         Safefree(scores);
1455         return (maxDistance != 0 && maxDistance < score)?(-1):score;
1456     }
1457 }
1458
1459 /* END of edit_distance() stuff
1460  * ========================================================= */
1461
1462 /* Mark that we cannot extend a found fixed substring at this point.
1463    Update the longest found anchored substring or the longest found
1464    floating substrings if needed. */
1465
1466 STATIC void
1467 S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, scan_data_t *data,
1468                     SSize_t *minlenp, int is_inf)
1469 {
1470     const STRLEN l = CHR_SVLEN(data->last_found);
1471     SV * const longest_sv = data->substrs[data->cur_is_floating].str;
1472     const STRLEN old_l = CHR_SVLEN(longest_sv);
1473     DECLARE_AND_GET_RE_DEBUG_FLAGS;
1474
1475     PERL_ARGS_ASSERT_SCAN_COMMIT;
1476
1477     if ((l >= old_l) && ((l > old_l) || (data->flags & SF_BEFORE_EOL))) {
1478         const U8 i = data->cur_is_floating;
1479         SvSetMagicSV(longest_sv, data->last_found);
1480         data->substrs[i].min_offset = l ? data->last_start_min : data->pos_min;
1481
1482         if (!i) /* fixed */
1483             data->substrs[0].max_offset = data->substrs[0].min_offset;
1484         else { /* float */
1485             data->substrs[1].max_offset =
1486                       (is_inf)
1487                        ? OPTIMIZE_INFTY
1488                        : (l
1489                           ? data->last_start_max
1490                           /* temporary underflow guard for 5.32 */
1491                           : data->pos_delta < 0 ? OPTIMIZE_INFTY
1492                           : (data->pos_delta > OPTIMIZE_INFTY - data->pos_min
1493                                          ? OPTIMIZE_INFTY
1494                                          : data->pos_min + data->pos_delta));
1495         }
1496
1497         data->substrs[i].flags &= ~SF_BEFORE_EOL;
1498         data->substrs[i].flags |= data->flags & SF_BEFORE_EOL;
1499         data->substrs[i].minlenp = minlenp;
1500         data->substrs[i].lookbehind = 0;
1501     }
1502
1503     SvCUR_set(data->last_found, 0);
1504     {
1505         SV * const sv = data->last_found;
1506         if (SvUTF8(sv) && SvMAGICAL(sv)) {
1507             MAGIC * const mg = mg_find(sv, PERL_MAGIC_utf8);
1508             if (mg)
1509                 mg->mg_len = 0;
1510         }
1511     }
1512     data->last_end = -1;
1513     data->flags &= ~SF_BEFORE_EOL;
1514     DEBUG_STUDYDATA("commit", data, 0, is_inf);
1515 }
1516
1517 /* An SSC is just a regnode_charclass_posix with an extra field: the inversion
1518  * list that describes which code points it matches */
1519
1520 STATIC void
1521 S_ssc_anything(pTHX_ regnode_ssc *ssc)
1522 {
1523     /* Set the SSC 'ssc' to match an empty string or any code point */
1524
1525     PERL_ARGS_ASSERT_SSC_ANYTHING;
1526
1527     assert(is_ANYOF_SYNTHETIC(ssc));
1528
1529     /* mortalize so won't leak */
1530     ssc->invlist = sv_2mortal(_add_range_to_invlist(NULL, 0, UV_MAX));
1531     ANYOF_FLAGS(ssc) |= SSC_MATCHES_EMPTY_STRING;  /* Plus matches empty */
1532 }
1533
1534 STATIC int
1535 S_ssc_is_anything(const regnode_ssc *ssc)
1536 {
1537     /* Returns TRUE if the SSC 'ssc' can match the empty string and any code
1538      * point; FALSE otherwise.  Thus, this is used to see if using 'ssc' buys
1539      * us anything: if the function returns TRUE, 'ssc' hasn't been restricted
1540      * in any way, so there's no point in using it */
1541
1542     UV start, end;
1543     bool ret;
1544
1545     PERL_ARGS_ASSERT_SSC_IS_ANYTHING;
1546
1547     assert(is_ANYOF_SYNTHETIC(ssc));
1548
1549     if (! (ANYOF_FLAGS(ssc) & SSC_MATCHES_EMPTY_STRING)) {
1550         return FALSE;
1551     }
1552
1553     /* See if the list consists solely of the range 0 - Infinity */
1554     invlist_iterinit(ssc->invlist);
1555     ret = invlist_iternext(ssc->invlist, &start, &end)
1556           && start == 0
1557           && end == UV_MAX;
1558
1559     invlist_iterfinish(ssc->invlist);
1560
1561     if (ret) {
1562         return TRUE;
1563     }
1564
1565     /* If e.g., both \w and \W are set, matches everything */
1566     if (ANYOF_POSIXL_SSC_TEST_ANY_SET(ssc)) {
1567         int i;
1568         for (i = 0; i < ANYOF_POSIXL_MAX; i += 2) {
1569             if (ANYOF_POSIXL_TEST(ssc, i) && ANYOF_POSIXL_TEST(ssc, i+1)) {
1570                 return TRUE;
1571             }
1572         }
1573     }
1574
1575     return FALSE;
1576 }
1577
1578 STATIC void
1579 S_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc)
1580 {
1581     /* Initializes the SSC 'ssc'.  This includes setting it to match an empty
1582      * string, any code point, or any posix class under locale */
1583
1584     PERL_ARGS_ASSERT_SSC_INIT;
1585
1586     Zero(ssc, 1, regnode_ssc);
1587     set_ANYOF_SYNTHETIC(ssc);
1588     ARG_SET(ssc, ANYOF_ONLY_HAS_BITMAP);
1589     ssc_anything(ssc);
1590
1591     /* If any portion of the regex is to operate under locale rules that aren't
1592      * fully known at compile time, initialization includes it.  The reason
1593      * this isn't done for all regexes is that the optimizer was written under
1594      * the assumption that locale was all-or-nothing.  Given the complexity and
1595      * lack of documentation in the optimizer, and that there are inadequate
1596      * test cases for locale, many parts of it may not work properly, it is
1597      * safest to avoid locale unless necessary. */
1598     if (RExC_contains_locale) {
1599         ANYOF_POSIXL_SETALL(ssc);
1600     }
1601     else {
1602         ANYOF_POSIXL_ZERO(ssc);
1603     }
1604 }
1605
1606 STATIC int
1607 S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state,
1608                         const regnode_ssc *ssc)
1609 {
1610     /* Returns TRUE if the SSC 'ssc' is in its initial state with regard only
1611      * to the list of code points matched, and locale posix classes; hence does
1612      * not check its flags) */
1613
1614     UV start, end;
1615     bool ret;
1616
1617     PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT;
1618
1619     assert(is_ANYOF_SYNTHETIC(ssc));
1620
1621     invlist_iterinit(ssc->invlist);
1622     ret = invlist_iternext(ssc->invlist, &start, &end)
1623           && start == 0
1624           && end == UV_MAX;
1625
1626     invlist_iterfinish(ssc->invlist);
1627
1628     if (! ret) {
1629         return FALSE;
1630     }
1631
1632     if (RExC_contains_locale && ! ANYOF_POSIXL_SSC_TEST_ALL_SET(ssc)) {
1633         return FALSE;
1634     }
1635
1636     return TRUE;
1637 }
1638
1639 #define INVLIST_INDEX 0
1640 #define ONLY_LOCALE_MATCHES_INDEX 1
1641 #define DEFERRED_USER_DEFINED_INDEX 2
1642
1643 STATIC SV*
1644 S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state,
1645                                const regnode_charclass* const node)
1646 {
1647     /* Returns a mortal inversion list defining which code points are matched
1648      * by 'node', which is of type ANYOF.  Handles complementing the result if
1649      * appropriate.  If some code points aren't knowable at this time, the
1650      * returned list must, and will, contain every code point that is a
1651      * possibility. */
1652
1653     SV* invlist = NULL;
1654     SV* only_utf8_locale_invlist = NULL;
1655     unsigned int i;
1656     const U32 n = ARG(node);
1657     bool new_node_has_latin1 = FALSE;
1658     const U8 flags = (inRANGE(OP(node), ANYOFH, ANYOFRb))
1659                       ? 0
1660                       : ANYOF_FLAGS(node);
1661
1662     PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC;
1663
1664     /* Look at the data structure created by S_set_ANYOF_arg() */
1665     if (n != ANYOF_ONLY_HAS_BITMAP) {
1666         SV * const rv = MUTABLE_SV(RExC_rxi->data->data[n]);
1667         AV * const av = MUTABLE_AV(SvRV(rv));
1668         SV **const ary = AvARRAY(av);
1669         assert(RExC_rxi->data->what[n] == 's');
1670
1671         if (av_tindex_skip_len_mg(av) >= DEFERRED_USER_DEFINED_INDEX) {
1672
1673             /* Here there are things that won't be known until runtime -- we
1674              * have to assume it could be anything */
1675             invlist = sv_2mortal(_new_invlist(1));
1676             return _add_range_to_invlist(invlist, 0, UV_MAX);
1677         }
1678         else if (ary[INVLIST_INDEX]) {
1679
1680             /* Use the node's inversion list */
1681             invlist = sv_2mortal(invlist_clone(ary[INVLIST_INDEX], NULL));
1682         }
1683
1684         /* Get the code points valid only under UTF-8 locales */
1685         if (   (flags & ANYOFL_FOLD)
1686             &&  av_tindex_skip_len_mg(av) >= ONLY_LOCALE_MATCHES_INDEX)
1687         {
1688             only_utf8_locale_invlist = ary[ONLY_LOCALE_MATCHES_INDEX];
1689         }
1690     }
1691
1692     if (! invlist) {
1693         invlist = sv_2mortal(_new_invlist(0));
1694     }
1695
1696     /* An ANYOF node contains a bitmap for the first NUM_ANYOF_CODE_POINTS
1697      * code points, and an inversion list for the others, but if there are code
1698      * points that should match only conditionally on the target string being
1699      * UTF-8, those are placed in the inversion list, and not the bitmap.
1700      * Since there are circumstances under which they could match, they are
1701      * included in the SSC.  But if the ANYOF node is to be inverted, we have
1702      * to exclude them here, so that when we invert below, the end result
1703      * actually does include them.  (Think about "\xe0" =~ /[^\xc0]/di;).  We
1704      * have to do this here before we add the unconditionally matched code
1705      * points */
1706     if (flags & ANYOF_INVERT) {
1707         _invlist_intersection_complement_2nd(invlist,
1708                                              PL_UpperLatin1,
1709                                              &invlist);
1710     }
1711
1712     /* Add in the points from the bit map */
1713     if (! inRANGE(OP(node), ANYOFH, ANYOFRb)) {
1714         for (i = 0; i < NUM_ANYOF_CODE_POINTS; i++) {
1715             if (ANYOF_BITMAP_TEST(node, i)) {
1716                 unsigned int start = i++;
1717
1718                 for (;    i < NUM_ANYOF_CODE_POINTS
1719                        && ANYOF_BITMAP_TEST(node, i); ++i)
1720                 {
1721                     /* empty */
1722                 }
1723                 invlist = _add_range_to_invlist(invlist, start, i-1);
1724                 new_node_has_latin1 = TRUE;
1725             }
1726         }
1727     }
1728
1729     /* If this can match all upper Latin1 code points, have to add them
1730      * as well.  But don't add them if inverting, as when that gets done below,
1731      * it would exclude all these characters, including the ones it shouldn't
1732      * that were added just above */
1733     if (! (flags & ANYOF_INVERT) && OP(node) == ANYOFD
1734         && (flags & ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER))
1735     {
1736         _invlist_union(invlist, PL_UpperLatin1, &invlist);
1737     }
1738
1739     /* Similarly for these */
1740     if (flags & ANYOF_MATCHES_ALL_ABOVE_BITMAP) {
1741         _invlist_union_complement_2nd(invlist, PL_InBitmap, &invlist);
1742     }
1743
1744     if (flags & ANYOF_INVERT) {
1745         _invlist_invert(invlist);
1746     }
1747     else if (flags & ANYOFL_FOLD) {
1748         if (new_node_has_latin1) {
1749
1750             /* Under /li, any 0-255 could fold to any other 0-255, depending on
1751              * the locale.  We can skip this if there are no 0-255 at all. */
1752             _invlist_union(invlist, PL_Latin1, &invlist);
1753
1754             invlist = add_cp_to_invlist(invlist, LATIN_SMALL_LETTER_DOTLESS_I);
1755             invlist = add_cp_to_invlist(invlist, LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE);
1756         }
1757         else {
1758             if (_invlist_contains_cp(invlist, LATIN_SMALL_LETTER_DOTLESS_I)) {
1759                 invlist = add_cp_to_invlist(invlist, 'I');
1760             }
1761             if (_invlist_contains_cp(invlist,
1762                                         LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE))
1763             {
1764                 invlist = add_cp_to_invlist(invlist, 'i');
1765             }
1766         }
1767     }
1768
1769     /* Similarly add the UTF-8 locale possible matches.  These have to be
1770      * deferred until after the non-UTF-8 locale ones are taken care of just
1771      * above, or it leads to wrong results under ANYOF_INVERT */
1772     if (only_utf8_locale_invlist) {
1773         _invlist_union_maybe_complement_2nd(invlist,
1774                                             only_utf8_locale_invlist,
1775                                             flags & ANYOF_INVERT,
1776                                             &invlist);
1777     }
1778
1779     return invlist;
1780 }
1781
1782 /* These two functions currently do the exact same thing */
1783 #define ssc_init_zero           ssc_init
1784
1785 #define ssc_add_cp(ssc, cp)   ssc_add_range((ssc), (cp), (cp))
1786 #define ssc_match_all_cp(ssc) ssc_add_range(ssc, 0, UV_MAX)
1787
1788 /* 'AND' a given class with another one.  Can create false positives.  'ssc'
1789  * should not be inverted.  'and_with->flags & ANYOF_MATCHES_POSIXL' should be
1790  * 0 if 'and_with' is a regnode_charclass instead of a regnode_ssc. */
1791
1792 STATIC void
1793 S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc,
1794                 const regnode_charclass *and_with)
1795 {
1796     /* Accumulate into SSC 'ssc' its 'AND' with 'and_with', which is either
1797      * another SSC or a regular ANYOF class.  Can create false positives. */
1798
1799     SV* anded_cp_list;
1800     U8  and_with_flags = inRANGE(OP(and_with), ANYOFH, ANYOFRb)
1801                           ? 0
1802                           : ANYOF_FLAGS(and_with);
1803     U8  anded_flags;
1804
1805     PERL_ARGS_ASSERT_SSC_AND;
1806
1807     assert(is_ANYOF_SYNTHETIC(ssc));
1808
1809     /* 'and_with' is used as-is if it too is an SSC; otherwise have to extract
1810      * the code point inversion list and just the relevant flags */
1811     if (is_ANYOF_SYNTHETIC(and_with)) {
1812         anded_cp_list = ((regnode_ssc *)and_with)->invlist;
1813         anded_flags = and_with_flags;
1814
1815         /* XXX This is a kludge around what appears to be deficiencies in the
1816          * optimizer.  If we make S_ssc_anything() add in the WARN_SUPER flag,
1817          * there are paths through the optimizer where it doesn't get weeded
1818          * out when it should.  And if we don't make some extra provision for
1819          * it like the code just below, it doesn't get added when it should.
1820          * This solution is to add it only when AND'ing, which is here, and
1821          * only when what is being AND'ed is the pristine, original node
1822          * matching anything.  Thus it is like adding it to ssc_anything() but
1823          * only when the result is to be AND'ed.  Probably the same solution
1824          * could be adopted for the same problem we have with /l matching,
1825          * which is solved differently in S_ssc_init(), and that would lead to
1826          * fewer false positives than that solution has.  But if this solution
1827          * creates bugs, the consequences are only that a warning isn't raised
1828          * that should be; while the consequences for having /l bugs is
1829          * incorrect matches */
1830         if (ssc_is_anything((regnode_ssc *)and_with)) {
1831             anded_flags |= ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER;
1832         }
1833     }
1834     else {
1835         anded_cp_list = get_ANYOF_cp_list_for_ssc(pRExC_state, and_with);
1836         if (OP(and_with) == ANYOFD) {
1837             anded_flags = and_with_flags & ANYOF_COMMON_FLAGS;
1838         }
1839         else {
1840             anded_flags = and_with_flags
1841             &( ANYOF_COMMON_FLAGS
1842               |ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER
1843               |ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP);
1844             if (ANYOFL_UTF8_LOCALE_REQD(and_with_flags)) {
1845                 anded_flags &=
1846                     ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD;
1847             }
1848         }
1849     }
1850
1851     ANYOF_FLAGS(ssc) &= anded_flags;
1852
1853     /* Below, C1 is the list of code points in 'ssc'; P1, its posix classes.
1854      * C2 is the list of code points in 'and-with'; P2, its posix classes.
1855      * 'and_with' may be inverted.  When not inverted, we have the situation of
1856      * computing:
1857      *  (C1 | P1) & (C2 | P2)
1858      *                     =  (C1 & (C2 | P2)) | (P1 & (C2 | P2))
1859      *                     =  ((C1 & C2) | (C1 & P2)) | ((P1 & C2) | (P1 & P2))
1860      *                    <=  ((C1 & C2) |       P2)) | ( P1       | (P1 & P2))
1861      *                    <=  ((C1 & C2) | P1 | P2)
1862      * Alternatively, the last few steps could be:
1863      *                     =  ((C1 & C2) | (C1 & P2)) | ((P1 & C2) | (P1 & P2))
1864      *                    <=  ((C1 & C2) |  C1      ) | (      C2  | (P1 & P2))
1865      *                    <=  (C1 | C2 | (P1 & P2))
1866      * We favor the second approach if either P1 or P2 is non-empty.  This is
1867      * because these components are a barrier to doing optimizations, as what
1868      * they match cannot be known until the moment of matching as they are
1869      * dependent on the current locale, 'AND"ing them likely will reduce or
1870      * eliminate them.
1871      * But we can do better if we know that C1,P1 are in their initial state (a
1872      * frequent occurrence), each matching everything:
1873      *  (<everything>) & (C2 | P2) =  C2 | P2
1874      * Similarly, if C2,P2 are in their initial state (again a frequent
1875      * occurrence), the result is a no-op
1876      *  (C1 | P1) & (<everything>) =  C1 | P1
1877      *
1878      * Inverted, we have
1879      *  (C1 | P1) & ~(C2 | P2)  =  (C1 | P1) & (~C2 & ~P2)
1880      *                          =  (C1 & (~C2 & ~P2)) | (P1 & (~C2 & ~P2))
1881      *                         <=  (C1 & ~C2) | (P1 & ~P2)
1882      * */
1883
1884     if ((and_with_flags & ANYOF_INVERT)
1885         && ! is_ANYOF_SYNTHETIC(and_with))
1886     {
1887         unsigned int i;
1888
1889         ssc_intersection(ssc,
1890                          anded_cp_list,
1891                          FALSE /* Has already been inverted */
1892                          );
1893
1894         /* If either P1 or P2 is empty, the intersection will be also; can skip
1895          * the loop */
1896         if (! (and_with_flags & ANYOF_MATCHES_POSIXL)) {
1897             ANYOF_POSIXL_ZERO(ssc);
1898         }
1899         else if (ANYOF_POSIXL_SSC_TEST_ANY_SET(ssc)) {
1900
1901             /* Note that the Posix class component P from 'and_with' actually
1902              * looks like:
1903              *      P = Pa | Pb | ... | Pn
1904              * where each component is one posix class, such as in [\w\s].
1905              * Thus
1906              *      ~P = ~(Pa | Pb | ... | Pn)
1907              *         = ~Pa & ~Pb & ... & ~Pn
1908              *        <= ~Pa | ~Pb | ... | ~Pn
1909              * The last is something we can easily calculate, but unfortunately
1910              * is likely to have many false positives.  We could do better
1911              * in some (but certainly not all) instances if two classes in
1912              * P have known relationships.  For example
1913              *      :lower: <= :alpha: <= :alnum: <= \w <= :graph: <= :print:
1914              * So
1915              *      :lower: & :print: = :lower:
1916              * And similarly for classes that must be disjoint.  For example,
1917              * since \s and \w can have no elements in common based on rules in
1918              * the POSIX standard,
1919              *      \w & ^\S = nothing
1920              * Unfortunately, some vendor locales do not meet the Posix
1921              * standard, in particular almost everything by Microsoft.
1922              * The loop below just changes e.g., \w into \W and vice versa */
1923
1924             regnode_charclass_posixl temp;
1925             int add = 1;    /* To calculate the index of the complement */
1926
1927             Zero(&temp, 1, regnode_charclass_posixl);
1928             ANYOF_POSIXL_ZERO(&temp);
1929             for (i = 0; i < ANYOF_MAX; i++) {
1930                 assert(i % 2 != 0
1931                        || ! ANYOF_POSIXL_TEST((regnode_charclass_posixl*) and_with, i)
1932                        || ! ANYOF_POSIXL_TEST((regnode_charclass_posixl*) and_with, i + 1));
1933
1934                 if (ANYOF_POSIXL_TEST((regnode_charclass_posixl*) and_with, i)) {
1935                     ANYOF_POSIXL_SET(&temp, i + add);
1936                 }
1937                 add = 0 - add; /* 1 goes to -1; -1 goes to 1 */
1938             }
1939             ANYOF_POSIXL_AND(&temp, ssc);
1940
1941         } /* else ssc already has no posixes */
1942     } /* else: Not inverted.  This routine is a no-op if 'and_with' is an SSC
1943          in its initial state */
1944     else if (! is_ANYOF_SYNTHETIC(and_with)
1945              || ! ssc_is_cp_posixl_init(pRExC_state, (regnode_ssc *)and_with))
1946     {
1947         /* But if 'ssc' is in its initial state, the result is just 'and_with';
1948          * copy it over 'ssc' */
1949         if (ssc_is_cp_posixl_init(pRExC_state, ssc)) {
1950             if (is_ANYOF_SYNTHETIC(and_with)) {
1951                 StructCopy(and_with, ssc, regnode_ssc);
1952             }
1953             else {
1954                 ssc->invlist = anded_cp_list;
1955                 ANYOF_POSIXL_ZERO(ssc);
1956                 if (and_with_flags & ANYOF_MATCHES_POSIXL) {
1957                     ANYOF_POSIXL_OR((regnode_charclass_posixl*) and_with, ssc);
1958                 }
1959             }
1960         }
1961         else if (ANYOF_POSIXL_SSC_TEST_ANY_SET(ssc)
1962                  || (and_with_flags & ANYOF_MATCHES_POSIXL))
1963         {
1964             /* One or the other of P1, P2 is non-empty. */
1965             if (and_with_flags & ANYOF_MATCHES_POSIXL) {
1966                 ANYOF_POSIXL_AND((regnode_charclass_posixl*) and_with, ssc);
1967             }
1968             ssc_union(ssc, anded_cp_list, FALSE);
1969         }
1970         else { /* P1 = P2 = empty */
1971             ssc_intersection(ssc, anded_cp_list, FALSE);
1972         }
1973     }
1974 }
1975
1976 STATIC void
1977 S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc,
1978                const regnode_charclass *or_with)
1979 {
1980     /* Accumulate into SSC 'ssc' its 'OR' with 'or_with', which is either
1981      * another SSC or a regular ANYOF class.  Can create false positives if
1982      * 'or_with' is to be inverted. */
1983
1984     SV* ored_cp_list;
1985     U8 ored_flags;
1986     U8  or_with_flags = inRANGE(OP(or_with), ANYOFH, ANYOFRb)
1987                          ? 0
1988                          : ANYOF_FLAGS(or_with);
1989
1990     PERL_ARGS_ASSERT_SSC_OR;
1991
1992     assert(is_ANYOF_SYNTHETIC(ssc));
1993
1994     /* 'or_with' is used as-is if it too is an SSC; otherwise have to extract
1995      * the code point inversion list and just the relevant flags */
1996     if (is_ANYOF_SYNTHETIC(or_with)) {
1997         ored_cp_list = ((regnode_ssc*) or_with)->invlist;
1998         ored_flags = or_with_flags;
1999     }
2000     else {
2001         ored_cp_list = get_ANYOF_cp_list_for_ssc(pRExC_state, or_with);
2002         ored_flags = or_with_flags & ANYOF_COMMON_FLAGS;
2003         if (OP(or_with) != ANYOFD) {
2004             ored_flags
2005             |= or_with_flags
2006              & ( ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER
2007                 |ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP);
2008             if (ANYOFL_UTF8_LOCALE_REQD(or_with_flags)) {
2009                 ored_flags |=
2010                     ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD;
2011             }
2012         }
2013     }
2014
2015     ANYOF_FLAGS(ssc) |= ored_flags;
2016
2017     /* Below, C1 is the list of code points in 'ssc'; P1, its posix classes.
2018      * C2 is the list of code points in 'or-with'; P2, its posix classes.
2019      * 'or_with' may be inverted.  When not inverted, we have the simple
2020      * situation of computing:
2021      *  (C1 | P1) | (C2 | P2)  =  (C1 | C2) | (P1 | P2)
2022      * If P1|P2 yields a situation with both a class and its complement are
2023      * set, like having both \w and \W, this matches all code points, and we
2024      * can delete these from the P component of the ssc going forward.  XXX We
2025      * might be able to delete all the P components, but I (khw) am not certain
2026      * about this, and it is better to be safe.
2027      *
2028      * Inverted, we have
2029      *  (C1 | P1) | ~(C2 | P2)  =  (C1 | P1) | (~C2 & ~P2)
2030      *                         <=  (C1 | P1) | ~C2
2031      *                         <=  (C1 | ~C2) | P1
2032      * (which results in actually simpler code than the non-inverted case)
2033      * */
2034
2035     if ((or_with_flags & ANYOF_INVERT)
2036         && ! is_ANYOF_SYNTHETIC(or_with))
2037     {
2038         /* We ignore P2, leaving P1 going forward */
2039     }   /* else  Not inverted */
2040     else if (or_with_flags & ANYOF_MATCHES_POSIXL) {
2041         ANYOF_POSIXL_OR((regnode_charclass_posixl*)or_with, ssc);
2042         if (ANYOF_POSIXL_SSC_TEST_ANY_SET(ssc)) {
2043             unsigned int i;
2044             for (i = 0; i < ANYOF_MAX; i += 2) {
2045                 if (ANYOF_POSIXL_TEST(ssc, i) && ANYOF_POSIXL_TEST(ssc, i + 1))
2046                 {
2047                     ssc_match_all_cp(ssc);
2048                     ANYOF_POSIXL_CLEAR(ssc, i);
2049                     ANYOF_POSIXL_CLEAR(ssc, i+1);
2050                 }
2051             }
2052         }
2053     }
2054
2055     ssc_union(ssc,
2056               ored_cp_list,
2057               FALSE /* Already has been inverted */
2058               );
2059 }
2060
2061 STATIC void
2062 S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert2nd)
2063 {
2064     PERL_ARGS_ASSERT_SSC_UNION;
2065
2066     assert(is_ANYOF_SYNTHETIC(ssc));
2067
2068     _invlist_union_maybe_complement_2nd(ssc->invlist,
2069                                         invlist,
2070                                         invert2nd,
2071                                         &ssc->invlist);
2072 }
2073
2074 STATIC void
2075 S_ssc_intersection(pTHX_ regnode_ssc *ssc,
2076                          SV* const invlist,
2077                          const bool invert2nd)
2078 {
2079     PERL_ARGS_ASSERT_SSC_INTERSECTION;
2080
2081     assert(is_ANYOF_SYNTHETIC(ssc));
2082
2083     _invlist_intersection_maybe_complement_2nd(ssc->invlist,
2084                                                invlist,
2085                                                invert2nd,
2086                                                &ssc->invlist);
2087 }
2088
2089 STATIC void
2090 S_ssc_add_range(pTHX_ regnode_ssc *ssc, const UV start, const UV end)
2091 {
2092     PERL_ARGS_ASSERT_SSC_ADD_RANGE;
2093
2094     assert(is_ANYOF_SYNTHETIC(ssc));
2095
2096     ssc->invlist = _add_range_to_invlist(ssc->invlist, start, end);
2097 }
2098
2099 STATIC void
2100 S_ssc_cp_and(pTHX_ regnode_ssc *ssc, const UV cp)
2101 {
2102     /* AND just the single code point 'cp' into the SSC 'ssc' */
2103
2104     SV* cp_list = _new_invlist(2);
2105
2106     PERL_ARGS_ASSERT_SSC_CP_AND;
2107
2108     assert(is_ANYOF_SYNTHETIC(ssc));
2109
2110     cp_list = add_cp_to_invlist(cp_list, cp);
2111     ssc_intersection(ssc, cp_list,
2112                      FALSE /* Not inverted */
2113                      );
2114     SvREFCNT_dec_NN(cp_list);
2115 }
2116
2117 STATIC void
2118 S_ssc_clear_locale(regnode_ssc *ssc)
2119 {
2120     /* Set the SSC 'ssc' to not match any locale things */
2121     PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE;
2122
2123     assert(is_ANYOF_SYNTHETIC(ssc));
2124
2125     ANYOF_POSIXL_ZERO(ssc);
2126     ANYOF_FLAGS(ssc) &= ~ANYOF_LOCALE_FLAGS;
2127 }
2128
2129 STATIC bool
2130 S_is_ssc_worth_it(const RExC_state_t * pRExC_state, const regnode_ssc * ssc)
2131 {
2132     /* The synthetic start class is used to hopefully quickly winnow down
2133      * places where a pattern could start a match in the target string.  If it
2134      * doesn't really narrow things down that much, there isn't much point to
2135      * having the overhead of using it.  This function uses some very crude
2136      * heuristics to decide if to use the ssc or not.
2137      *
2138      * It returns TRUE if 'ssc' rules out more than half what it considers to
2139      * be the "likely" possible matches, but of course it doesn't know what the
2140      * actual things being matched are going to be; these are only guesses
2141      *
2142      * For /l matches, it assumes that the only likely matches are going to be
2143      *      in the 0-255 range, uniformly distributed, so half of that is 127
2144      * For /a and /d matches, it assumes that the likely matches will be just
2145      *      the ASCII range, so half of that is 63
2146      * For /u and there isn't anything matching above the Latin1 range, it
2147      *      assumes that that is the only range likely to be matched, and uses
2148      *      half that as the cut-off: 127.  If anything matches above Latin1,
2149      *      it assumes that all of Unicode could match (uniformly), except for
2150      *      non-Unicode code points and things in the General Category "Other"
2151      *      (unassigned, private use, surrogates, controls and formats).  This
2152      *      is a much large number. */
2153
2154     U32 count = 0;      /* Running total of number of code points matched by
2155                            'ssc' */
2156     UV start, end;      /* Start and end points of current range in inversion
2157                            XXX outdated.  UTF-8 locales are common, what about invert? list */
2158     const U32 max_code_points = (LOC)
2159                                 ?  256
2160                                 : ((  ! UNI_SEMANTICS
2161                                     ||  invlist_highest(ssc->invlist) < 256)
2162                                   ? 128
2163                                   : NON_OTHER_COUNT);
2164     const U32 max_match = max_code_points / 2;
2165
2166     PERL_ARGS_ASSERT_IS_SSC_WORTH_IT;
2167
2168     invlist_iterinit(ssc->invlist);
2169     while (invlist_iternext(ssc->invlist, &start, &end)) {
2170         if (start >= max_code_points) {
2171             break;
2172         }
2173         end = MIN(end, max_code_points - 1);
2174         count += end - start + 1;
2175         if (count >= max_match) {
2176             invlist_iterfinish(ssc->invlist);
2177             return FALSE;
2178         }
2179     }
2180
2181     return TRUE;
2182 }
2183
2184
2185 STATIC void
2186 S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc)
2187 {
2188     /* The inversion list in the SSC is marked mortal; now we need a more
2189      * permanent copy, which is stored the same way that is done in a regular
2190      * ANYOF node, with the first NUM_ANYOF_CODE_POINTS code points in a bit
2191      * map */
2192
2193     SV* invlist = invlist_clone(ssc->invlist, NULL);
2194
2195     PERL_ARGS_ASSERT_SSC_FINALIZE;
2196
2197     assert(is_ANYOF_SYNTHETIC(ssc));
2198
2199     /* The code in this file assumes that all but these flags aren't relevant
2200      * to the SSC, except SSC_MATCHES_EMPTY_STRING, which should be cleared
2201      * by the time we reach here */
2202     assert(! (ANYOF_FLAGS(ssc)
2203         & ~( ANYOF_COMMON_FLAGS
2204             |ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER
2205             |ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP)));
2206
2207     populate_ANYOF_from_invlist( (regnode *) ssc, &invlist);
2208
2209     set_ANYOF_arg(pRExC_state, (regnode *) ssc, invlist, NULL, NULL);
2210     SvREFCNT_dec(invlist);
2211
2212     /* Make sure is clone-safe */
2213     ssc->invlist = NULL;
2214
2215     if (ANYOF_POSIXL_SSC_TEST_ANY_SET(ssc)) {
2216         ANYOF_FLAGS(ssc) |= ANYOF_MATCHES_POSIXL;
2217         OP(ssc) = ANYOFPOSIXL;
2218     }
2219     else if (RExC_contains_locale) {
2220         OP(ssc) = ANYOFL;
2221     }
2222
2223     assert(! (ANYOF_FLAGS(ssc) & ANYOF_LOCALE_FLAGS) || RExC_contains_locale);
2224 }
2225
2226 #define TRIE_LIST_ITEM(state,idx) (trie->states[state].trans.list)[ idx ]
2227 #define TRIE_LIST_CUR(state)  ( TRIE_LIST_ITEM( state, 0 ).forid )
2228 #define TRIE_LIST_LEN(state) ( TRIE_LIST_ITEM( state, 0 ).newstate )
2229 #define TRIE_LIST_USED(idx)  ( trie->states[state].trans.list         \
2230                                ? (TRIE_LIST_CUR( idx ) - 1)           \
2231                                : 0 )
2232
2233
2234 #ifdef DEBUGGING
2235 /*
2236    dump_trie(trie,widecharmap,revcharmap)
2237    dump_trie_interim_list(trie,widecharmap,revcharmap,next_alloc)
2238    dump_trie_interim_table(trie,widecharmap,revcharmap,next_alloc)
2239
2240    These routines dump out a trie in a somewhat readable format.
2241    The _interim_ variants are used for debugging the interim
2242    tables that are used to generate the final compressed
2243    representation which is what dump_trie expects.
2244
2245    Part of the reason for their existence is to provide a form
2246    of documentation as to how the different representations function.
2247
2248 */
2249
2250 /*
2251   Dumps the final compressed table form of the trie to Perl_debug_log.
2252   Used for debugging make_trie().
2253 */
2254
2255 STATIC void
2256 S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap,
2257             AV *revcharmap, U32 depth)
2258 {
2259     U32 state;
2260     SV *sv=sv_newmortal();
2261     int colwidth= widecharmap ? 6 : 4;
2262     U16 word;
2263     DECLARE_AND_GET_RE_DEBUG_FLAGS;
2264
2265     PERL_ARGS_ASSERT_DUMP_TRIE;
2266
2267     Perl_re_indentf( aTHX_  "Char : %-6s%-6s%-4s ",
2268         depth+1, "Match","Base","Ofs" );
2269
2270     for( state = 0 ; state < trie->uniquecharcount ; state++ ) {
2271         SV ** const tmp = av_fetch( revcharmap, state, 0);
2272         if ( tmp ) {
2273             Perl_re_printf( aTHX_  "%*s",
2274                 colwidth,
2275                 pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), colwidth,
2276                             PL_colors[0], PL_colors[1],
2277                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
2278                             PERL_PV_ESCAPE_FIRSTCHAR
2279                 )
2280             );
2281         }
2282     }
2283     Perl_re_printf( aTHX_  "\n");
2284     Perl_re_indentf( aTHX_ "State|-----------------------", depth+1);
2285
2286     for( state = 0 ; state < trie->uniquecharcount ; state++ )
2287         Perl_re_printf( aTHX_  "%.*s", colwidth, "--------");
2288     Perl_re_printf( aTHX_  "\n");
2289
2290     for( state = 1 ; state < trie->statecount ; state++ ) {
2291         const U32 base = trie->states[ state ].trans.base;
2292
2293         Perl_re_indentf( aTHX_  "#%4" UVXf "|", depth+1, (UV)state);
2294
2295         if ( trie->states[ state ].wordnum ) {
2296             Perl_re_printf( aTHX_  " W%4X", trie->states[ state ].wordnum );
2297         } else {
2298             Perl_re_printf( aTHX_  "%6s", "" );
2299         }
2300
2301         Perl_re_printf( aTHX_  " @%4" UVXf " ", (UV)base );
2302
2303         if ( base ) {
2304             U32 ofs = 0;
2305
2306             while( ( base + ofs  < trie->uniquecharcount ) ||
2307                    ( base + ofs - trie->uniquecharcount < trie->lasttrans
2308                      && trie->trans[ base + ofs - trie->uniquecharcount ].check
2309                                                                     != state))
2310                     ofs++;
2311
2312             Perl_re_printf( aTHX_  "+%2" UVXf "[ ", (UV)ofs);
2313
2314             for ( ofs = 0 ; ofs < trie->uniquecharcount ; ofs++ ) {
2315                 if ( ( base + ofs >= trie->uniquecharcount )
2316                         && ( base + ofs - trie->uniquecharcount
2317                                                         < trie->lasttrans )
2318                         && trie->trans[ base + ofs
2319                                     - trie->uniquecharcount ].check == state )
2320                 {
2321                    Perl_re_printf( aTHX_  "%*" UVXf, colwidth,
2322                     (UV)trie->trans[ base + ofs - trie->uniquecharcount ].next
2323                    );
2324                 } else {
2325                     Perl_re_printf( aTHX_  "%*s", colwidth,"   ." );
2326                 }
2327             }
2328
2329             Perl_re_printf( aTHX_  "]");
2330
2331         }
2332         Perl_re_printf( aTHX_  "\n" );
2333     }
2334     Perl_re_indentf( aTHX_  "word_info N:(prev,len)=",
2335                                 depth);
2336     for (word=1; word <= trie->wordcount; word++) {
2337         Perl_re_printf( aTHX_  " %d:(%d,%d)",
2338             (int)word, (int)(trie->wordinfo[word].prev),
2339             (int)(trie->wordinfo[word].len));
2340     }
2341     Perl_re_printf( aTHX_  "\n" );
2342 }
2343 /*
2344   Dumps a fully constructed but uncompressed trie in list form.
2345   List tries normally only are used for construction when the number of
2346   possible chars (trie->uniquecharcount) is very high.
2347   Used for debugging make_trie().
2348 */
2349 STATIC void
2350 S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie,
2351                          HV *widecharmap, AV *revcharmap, U32 next_alloc,
2352                          U32 depth)
2353 {
2354     U32 state;
2355     SV *sv=sv_newmortal();
2356     int colwidth= widecharmap ? 6 : 4;
2357     DECLARE_AND_GET_RE_DEBUG_FLAGS;
2358
2359     PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST;
2360
2361     /* print out the table precompression.  */
2362     Perl_re_indentf( aTHX_  "State :Word | Transition Data\n",
2363             depth+1 );
2364     Perl_re_indentf( aTHX_  "%s",
2365             depth+1, "------:-----+-----------------\n" );
2366
2367     for( state=1 ; state < next_alloc ; state ++ ) {
2368         U16 charid;
2369
2370         Perl_re_indentf( aTHX_  " %4" UVXf " :",
2371             depth+1, (UV)state  );
2372         if ( ! trie->states[ state ].wordnum ) {
2373             Perl_re_printf( aTHX_  "%5s| ","");
2374         } else {
2375             Perl_re_printf( aTHX_  "W%4x| ",
2376                 trie->states[ state ].wordnum
2377             );
2378         }
2379         for( charid = 1 ; charid <= TRIE_LIST_USED( state ) ; charid++ ) {
2380             SV ** const tmp = av_fetch( revcharmap,
2381                                         TRIE_LIST_ITEM(state, charid).forid, 0);
2382             if ( tmp ) {
2383                 Perl_re_printf( aTHX_  "%*s:%3X=%4" UVXf " | ",
2384                     colwidth,
2385                     pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp),
2386                               colwidth,
2387                               PL_colors[0], PL_colors[1],
2388                               (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0)
2389                               | PERL_PV_ESCAPE_FIRSTCHAR
2390                     ) ,
2391                     TRIE_LIST_ITEM(state, charid).forid,
2392                     (UV)TRIE_LIST_ITEM(state, charid).newstate
2393                 );
2394                 if (!(charid % 10))
2395                     Perl_re_printf( aTHX_  "\n%*s| ",
2396                         (int)((depth * 2) + 14), "");
2397             }
2398         }
2399         Perl_re_printf( aTHX_  "\n");
2400     }
2401 }
2402
2403 /*
2404   Dumps a fully constructed but uncompressed trie in table form.
2405   This is the normal DFA style state transition table, with a few
2406   twists to facilitate compression later.
2407   Used for debugging make_trie().
2408 */
2409 STATIC void
2410 S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie,
2411                           HV *widecharmap, AV *revcharmap, U32 next_alloc,
2412                           U32 depth)
2413 {
2414     U32 state;
2415     U16 charid;
2416     SV *sv=sv_newmortal();
2417     int colwidth= widecharmap ? 6 : 4;
2418     DECLARE_AND_GET_RE_DEBUG_FLAGS;
2419
2420     PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE;
2421
2422     /*
2423        print out the table precompression so that we can do a visual check
2424        that they are identical.
2425      */
2426
2427     Perl_re_indentf( aTHX_  "Char : ", depth+1 );
2428
2429     for( charid = 0 ; charid < trie->uniquecharcount ; charid++ ) {
2430         SV ** const tmp = av_fetch( revcharmap, charid, 0);
2431         if ( tmp ) {
2432             Perl_re_printf( aTHX_  "%*s",
2433                 colwidth,
2434                 pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), colwidth,
2435                             PL_colors[0], PL_colors[1],
2436                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
2437                             PERL_PV_ESCAPE_FIRSTCHAR
2438                 )
2439             );
2440         }
2441     }
2442
2443     Perl_re_printf( aTHX_ "\n");
2444     Perl_re_indentf( aTHX_  "State+-", depth+1 );
2445
2446     for( charid=0 ; charid < trie->uniquecharcount ; charid++ ) {
2447         Perl_re_printf( aTHX_  "%.*s", colwidth,"--------");
2448     }
2449
2450     Perl_re_printf( aTHX_  "\n" );
2451
2452     for( state=1 ; state < next_alloc ; state += trie->uniquecharcount ) {
2453
2454         Perl_re_indentf( aTHX_  "%4" UVXf " : ",
2455             depth+1,
2456             (UV)TRIE_NODENUM( state ) );
2457
2458         for( charid = 0 ; charid < trie->uniquecharcount ; charid++ ) {
2459             UV v=(UV)SAFE_TRIE_NODENUM( trie->trans[ state + charid ].next );
2460             if (v)
2461                 Perl_re_printf( aTHX_  "%*" UVXf, colwidth, v );
2462             else
2463                 Perl_re_printf( aTHX_  "%*s", colwidth, "." );
2464         }
2465         if ( ! trie->states[ TRIE_NODENUM( state ) ].wordnum ) {
2466             Perl_re_printf( aTHX_  " (%4" UVXf ")\n",
2467                                             (UV)trie->trans[ state ].check );
2468         } else {
2469             Perl_re_printf( aTHX_  " (%4" UVXf ") W%4X\n",
2470                                             (UV)trie->trans[ state ].check,
2471             trie->states[ TRIE_NODENUM( state ) ].wordnum );
2472         }
2473     }
2474 }
2475
2476 #endif
2477
2478
2479 /* make_trie(startbranch,first,last,tail,word_count,flags,depth)
2480   startbranch: the first branch in the whole branch sequence
2481   first      : start branch of sequence of branch-exact nodes.
2482                May be the same as startbranch
2483   last       : Thing following the last branch.
2484                May be the same as tail.
2485   tail       : item following the branch sequence
2486   count      : words in the sequence
2487   flags      : currently the OP() type we will be building one of /EXACT(|F|FA|FU|FU_SS|L|FLU8)/
2488   depth      : indent depth
2489
2490 Inplace optimizes a sequence of 2 or more Branch-Exact nodes into a TRIE node.
2491
2492 A trie is an N'ary tree where the branches are determined by digital
2493 decomposition of the key. IE, at the root node you look up the 1st character and
2494 follow that branch repeat until you find the end of the branches. Nodes can be
2495 marked as "accepting" meaning they represent a complete word. Eg:
2496
2497   /he|she|his|hers/
2498
2499 would convert into the following structure. Numbers represent states, letters
2500 following numbers represent valid transitions on the letter from that state, if
2501 the number is in square brackets it represents an accepting state, otherwise it
2502 will be in parenthesis.
2503
2504       +-h->+-e->[3]-+-r->(8)-+-s->[9]
2505       |    |
2506       |   (2)
2507       |    |
2508      (1)   +-i->(6)-+-s->[7]
2509       |
2510       +-s->(3)-+-h->(4)-+-e->[5]
2511
2512       Accept Word Mapping: 3=>1 (he),5=>2 (she), 7=>3 (his), 9=>4 (hers)
2513
2514 This shows that when matching against the string 'hers' we will begin at state 1
2515 read 'h' and move to state 2, read 'e' and move to state 3 which is accepting,
2516 then read 'r' and go to state 8 followed by 's' which takes us to state 9 which
2517 is also accepting. Thus we know that we can match both 'he' and 'hers' with a
2518 single traverse. We store a mapping from accepting to state to which word was
2519 matched, and then when we have multiple possibilities we try to complete the
2520 rest of the regex in the order in which they occurred in the alternation.
2521
2522 The only prior NFA like behaviour that would be changed by the TRIE support is
2523 the silent ignoring of duplicate alternations which are of the form:
2524
2525  / (DUPE|DUPE) X? (?{ ... }) Y /x
2526
2527 Thus EVAL blocks following a trie may be called a different number of times with
2528 and without the optimisation. With the optimisations dupes will be silently
2529 ignored. This inconsistent behaviour of EVAL type nodes is well established as
2530 the following demonstrates:
2531
2532  'words'=~/(word|word|word)(?{ print $1 })[xyz]/
2533
2534 which prints out 'word' three times, but
2535
2536  'words'=~/(word|word|word)(?{ print $1 })S/
2537
2538 which doesnt print it out at all. This is due to other optimisations kicking in.
2539
2540 Example of what happens on a structural level:
2541
2542 The regexp /(ac|ad|ab)+/ will produce the following debug output:
2543
2544    1: CURLYM[1] {1,32767}(18)
2545    5:   BRANCH(8)
2546    6:     EXACT <ac>(16)
2547    8:   BRANCH(11)
2548    9:     EXACT <ad>(16)
2549   11:   BRANCH(14)
2550   12:     EXACT <ab>(16)
2551   16:   SUCCEED(0)
2552   17:   NOTHING(18)
2553   18: END(0)
2554
2555 This would be optimizable with startbranch=5, first=5, last=16, tail=16
2556 and should turn into:
2557
2558    1: CURLYM[1] {1,32767}(18)
2559    5:   TRIE(16)
2560         [Words:3 Chars Stored:6 Unique Chars:4 States:5 NCP:1]
2561           <ac>
2562           <ad>
2563           <ab>
2564   16:   SUCCEED(0)
2565   17:   NOTHING(18)
2566   18: END(0)
2567
2568 Cases where tail != last would be like /(?foo|bar)baz/:
2569
2570    1: BRANCH(4)
2571    2:   EXACT <foo>(8)
2572    4: BRANCH(7)
2573    5:   EXACT <bar>(8)
2574    7: TAIL(8)
2575    8: EXACT <baz>(10)
2576   10: END(0)
2577
2578 which would be optimizable with startbranch=1, first=1, last=7, tail=8
2579 and would end up looking like:
2580
2581     1: TRIE(8)
2582       [Words:2 Chars Stored:6 Unique Chars:5 States:7 NCP:1]
2583         <foo>
2584         <bar>
2585    7: TAIL(8)
2586    8: EXACT <baz>(10)
2587   10: END(0)
2588
2589     d = uvchr_to_utf8_flags(d, uv, 0);
2590
2591 is the recommended Unicode-aware way of saying
2592
2593     *(d++) = uv;
2594 */
2595
2596 #define TRIE_STORE_REVCHAR(val)                                            \
2597     STMT_START {                                                           \
2598         if (UTF) {                                                         \
2599             SV *zlopp = newSV(UTF8_MAXBYTES);                              \
2600             unsigned char *flrbbbbb = (unsigned char *) SvPVX(zlopp);      \
2601             unsigned char *const kapow = uvchr_to_utf8(flrbbbbb, val);     \
2602             *kapow = '\0';                                                 \
2603             SvCUR_set(zlopp, kapow - flrbbbbb);                            \
2604             SvPOK_on(zlopp);                                               \
2605             SvUTF8_on(zlopp);                                              \
2606             av_push(revcharmap, zlopp);                                    \
2607         } else {                                                           \
2608             char ooooff = (char)val;                                           \
2609             av_push(revcharmap, newSVpvn(&ooooff, 1));                     \
2610         }                                                                  \
2611         } STMT_END
2612
2613 /* This gets the next character from the input, folding it if not already
2614  * folded. */
2615 #define TRIE_READ_CHAR STMT_START {                                           \
2616     wordlen++;                                                                \
2617     if ( UTF ) {                                                              \
2618         /* if it is UTF then it is either already folded, or does not need    \
2619          * folding */                                                         \
2620         uvc = valid_utf8_to_uvchr( (const U8*) uc, &len);                     \
2621     }                                                                         \
2622     else if (folder == PL_fold_latin1) {                                      \
2623         /* This folder implies Unicode rules, which in the range expressible  \
2624          *  by not UTF is the lower case, with the two exceptions, one of     \
2625          *  which should have been taken care of before calling this */       \
2626         assert(*uc != LATIN_SMALL_LETTER_SHARP_S);                            \
2627         uvc = toLOWER_L1(*uc);                                                \
2628         if (UNLIKELY(uvc == MICRO_SIGN)) uvc = GREEK_SMALL_LETTER_MU;         \
2629         len = 1;                                                              \
2630     } else {                                                                  \
2631         /* raw data, will be folded later if needed */                        \
2632         uvc = (U32)*uc;                                                       \
2633         len = 1;                                                              \
2634     }                                                                         \
2635 } STMT_END
2636
2637
2638
2639 #define TRIE_LIST_PUSH(state,fid,ns) STMT_START {               \
2640     if ( TRIE_LIST_CUR( state ) >=TRIE_LIST_LEN( state ) ) {    \
2641         U32 ging = TRIE_LIST_LEN( state ) * 2;                  \
2642         Renew( trie->states[ state ].trans.list, ging, reg_trie_trans_le ); \
2643         TRIE_LIST_LEN( state ) = ging;                          \
2644     }                                                           \
2645     TRIE_LIST_ITEM( state, TRIE_LIST_CUR( state ) ).forid = fid;     \
2646     TRIE_LIST_ITEM( state, TRIE_LIST_CUR( state ) ).newstate = ns;   \
2647     TRIE_LIST_CUR( state )++;                                   \
2648 } STMT_END
2649
2650 #define TRIE_LIST_NEW(state) STMT_START {                       \
2651     Newx( trie->states[ state ].trans.list,                     \
2652         4, reg_trie_trans_le );                                 \
2653      TRIE_LIST_CUR( state ) = 1;                                \
2654      TRIE_LIST_LEN( state ) = 4;                                \
2655 } STMT_END
2656
2657 #define TRIE_HANDLE_WORD(state) STMT_START {                    \
2658     U16 dupe= trie->states[ state ].wordnum;                    \
2659     regnode * const noper_next = regnext( noper );              \
2660                                                                 \
2661     DEBUG_r({                                                   \
2662         /* store the word for dumping */                        \
2663         SV* tmp;                                                \
2664         if (OP(noper) != NOTHING)                               \
2665             tmp = newSVpvn_utf8(STRING(noper), STR_LEN(noper), UTF);    \
2666         else                                                    \
2667             tmp = newSVpvn_utf8( "", 0, UTF );                  \
2668         av_push( trie_words, tmp );                             \
2669     });                                                         \
2670                                                                 \
2671     curword++;                                                  \
2672     trie->wordinfo[curword].prev   = 0;                         \
2673     trie->wordinfo[curword].len    = wordlen;                   \
2674     trie->wordinfo[curword].accept = state;                     \
2675                                                                 \
2676     if ( noper_next < tail ) {                                  \
2677         if (!trie->jump)                                        \
2678             trie->jump = (U16 *) PerlMemShared_calloc( word_count + 1, \
2679                                                  sizeof(U16) ); \
2680         trie->jump[curword] = (U16)(noper_next - convert);      \
2681         if (!jumper)                                            \
2682             jumper = noper_next;                                \
2683         if (!nextbranch)                                        \
2684             nextbranch= regnext(cur);                           \
2685     }                                                           \
2686                                                                 \
2687     if ( dupe ) {                                               \
2688         /* It's a dupe. Pre-insert into the wordinfo[].prev   */\
2689         /* chain, so that when the bits of chain are later    */\
2690         /* linked together, the dups appear in the chain      */\
2691         trie->wordinfo[curword].prev = trie->wordinfo[dupe].prev; \
2692         trie->wordinfo[dupe].prev = curword;                    \
2693     } else {                                                    \
2694         /* we haven't inserted this word yet.                */ \
2695         trie->states[ state ].wordnum = curword;                \
2696     }                                                           \
2697 } STMT_END
2698
2699
2700 #define TRIE_TRANS_STATE(state,base,ucharcount,charid,special)          \
2701      ( ( base + charid >=  ucharcount                                   \
2702          && base + charid < ubound                                      \
2703          && state == trie->trans[ base - ucharcount + charid ].check    \
2704          && trie->trans[ base - ucharcount + charid ].next )            \
2705            ? trie->trans[ base - ucharcount + charid ].next             \
2706            : ( state==1 ? special : 0 )                                 \
2707       )
2708
2709 #define TRIE_BITMAP_SET_FOLDED(trie, uvc, folder)           \
2710 STMT_START {                                                \
2711     TRIE_BITMAP_SET(trie, uvc);                             \
2712     /* store the folded codepoint */                        \
2713     if ( folder )                                           \
2714         TRIE_BITMAP_SET(trie, folder[(U8) uvc ]);           \
2715                                                             \
2716     if ( !UTF ) {                                           \
2717         /* store first byte of utf8 representation of */    \
2718         /* variant codepoints */                            \
2719         if (! UVCHR_IS_INVARIANT(uvc)) {                    \
2720             TRIE_BITMAP_SET(trie, UTF8_TWO_BYTE_HI(uvc));   \
2721         }                                                   \
2722     }                                                       \
2723 } STMT_END
2724 #define MADE_TRIE       1
2725 #define MADE_JUMP_TRIE  2
2726 #define MADE_EXACT_TRIE 4
2727
2728 STATIC I32
2729 S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch,
2730                   regnode *first, regnode *last, regnode *tail,
2731                   U32 word_count, U32 flags, U32 depth)
2732 {
2733     /* first pass, loop through and scan words */
2734     reg_trie_data *trie;
2735     HV *widecharmap = NULL;
2736     AV *revcharmap = newAV();
2737     regnode *cur;
2738     STRLEN len = 0;
2739     UV uvc = 0;
2740     U16 curword = 0;
2741     U32 next_alloc = 0;
2742     regnode *jumper = NULL;
2743     regnode *nextbranch = NULL;
2744     regnode *convert = NULL;
2745     U32 *prev_states; /* temp array mapping each state to previous one */
2746     /* we just use folder as a flag in utf8 */
2747     const U8 * folder = NULL;
2748
2749     /* in the below add_data call we are storing either 'tu' or 'tuaa'
2750      * which stands for one trie structure, one hash, optionally followed
2751      * by two arrays */
2752 #ifdef DEBUGGING
2753     const U32 data_slot = add_data( pRExC_state, STR_WITH_LEN("tuaa"));
2754     AV *trie_words = NULL;
2755     /* along with revcharmap, this only used during construction but both are
2756      * useful during debugging so we store them in the struct when debugging.
2757      */
2758 #else
2759     const U32 data_slot = add_data( pRExC_state, STR_WITH_LEN("tu"));
2760     STRLEN trie_charcount=0;
2761 #endif
2762     SV *re_trie_maxbuff;
2763     DECLARE_AND_GET_RE_DEBUG_FLAGS;
2764
2765     PERL_ARGS_ASSERT_MAKE_TRIE;
2766 #ifndef DEBUGGING
2767     PERL_UNUSED_ARG(depth);
2768 #endif
2769
2770     switch (flags) {
2771         case EXACT: case EXACT_REQ8: case EXACTL: break;
2772         case EXACTFAA:
2773         case EXACTFUP:
2774         case EXACTFU:
2775         case EXACTFLU8: folder = PL_fold_latin1; break;
2776         case EXACTF:  folder = PL_fold; break;
2777         default: Perl_croak( aTHX_ "panic! In trie construction, unknown node type %u %s", (unsigned) flags, PL_reg_name[flags] );
2778     }
2779
2780     trie = (reg_trie_data *) PerlMemShared_calloc( 1, sizeof(reg_trie_data) );
2781     trie->refcount = 1;
2782     trie->startstate = 1;
2783     trie->wordcount = word_count;
2784     RExC_rxi->data->data[ data_slot ] = (void*)trie;
2785     trie->charmap = (U16 *) PerlMemShared_calloc( 256, sizeof(U16) );
2786     if (flags == EXACT || flags == EXACT_REQ8 || flags == EXACTL)
2787         trie->bitmap = (char *) PerlMemShared_calloc( ANYOF_BITMAP_SIZE, 1 );
2788     trie->wordinfo = (reg_trie_wordinfo *) PerlMemShared_calloc(
2789                        trie->wordcount+1, sizeof(reg_trie_wordinfo));
2790
2791     DEBUG_r({
2792         trie_words = newAV();
2793     });
2794
2795     re_trie_maxbuff = get_sv(RE_TRIE_MAXBUF_NAME, GV_ADD);
2796     assert(re_trie_maxbuff);
2797     if (!SvIOK(re_trie_maxbuff)) {
2798         sv_setiv(re_trie_maxbuff, RE_TRIE_MAXBUF_INIT);
2799     }
2800     DEBUG_TRIE_COMPILE_r({
2801         Perl_re_indentf( aTHX_
2802           "make_trie start==%d, first==%d, last==%d, tail==%d depth=%d\n",
2803           depth+1,
2804           REG_NODE_NUM(startbranch), REG_NODE_NUM(first),
2805           REG_NODE_NUM(last), REG_NODE_NUM(tail), (int)depth);
2806     });
2807
2808    /* Find the node we are going to overwrite */
2809     if ( first == startbranch && OP( last ) != BRANCH ) {
2810         /* whole branch chain */
2811         convert = first;
2812     } else {
2813         /* branch sub-chain */
2814         convert = NEXTOPER( first );
2815     }
2816
2817     /*  -- First loop and Setup --
2818
2819        We first traverse the branches and scan each word to determine if it
2820        contains widechars, and how many unique chars there are, this is
2821        important as we have to build a table with at least as many columns as we
2822        have unique chars.
2823
2824        We use an array of integers to represent the character codes 0..255
2825        (trie->charmap) and we use a an HV* to store Unicode characters. We use
2826        the native representation of the character value as the key and IV's for
2827        the coded index.
2828
2829        *TODO* If we keep track of how many times each character is used we can
2830        remap the columns so that the table compression later on is more
2831        efficient in terms of memory by ensuring the most common value is in the
2832        middle and the least common are on the outside.  IMO this would be better
2833        than a most to least common mapping as theres a decent chance the most
2834        common letter will share a node with the least common, meaning the node
2835        will not be compressible. With a middle is most common approach the worst
2836        case is when we have the least common nodes twice.
2837
2838      */
2839
2840     for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
2841         regnode *noper = NEXTOPER( cur );
2842         const U8 *uc;
2843         const U8 *e;
2844         int foldlen = 0;
2845         U32 wordlen      = 0;         /* required init */
2846         STRLEN minchars = 0;
2847         STRLEN maxchars = 0;
2848         bool set_bit = trie->bitmap ? 1 : 0; /*store the first char in the
2849                                                bitmap?*/
2850
2851         if (OP(noper) == NOTHING) {
2852             /* skip past a NOTHING at the start of an alternation
2853              * eg, /(?:)a|(?:b)/ should be the same as /a|b/
2854              *
2855              * If the next node is not something we are supposed to process
2856              * we will just ignore it due to the condition guarding the
2857              * next block.
2858              */
2859
2860             regnode *noper_next= regnext(noper);
2861             if (noper_next < tail)
2862                 noper= noper_next;
2863         }
2864
2865         if (    noper < tail
2866             && (    OP(noper) == flags
2867                 || (flags == EXACT && OP(noper) == EXACT_REQ8)
2868                 || (flags == EXACTFU && (   OP(noper) == EXACTFU_REQ8
2869                                          || OP(noper) == EXACTFUP))))
2870         {
2871             uc= (U8*)STRING(noper);
2872             e= uc + STR_LEN(noper);
2873         } else {
2874             trie->minlen= 0;
2875             continue;
2876         }
2877
2878
2879         if ( set_bit ) { /* bitmap only alloced when !(UTF&&Folding) */
2880             TRIE_BITMAP_SET(trie,*uc); /* store the raw first byte
2881                                           regardless of encoding */
2882             if (OP( noper ) == EXACTFUP) {
2883                 /* false positives are ok, so just set this */
2884                 TRIE_BITMAP_SET(trie, LATIN_SMALL_LETTER_SHARP_S);
2885             }
2886         }
2887
2888         for ( ; uc < e ; uc += len ) {  /* Look at each char in the current
2889                                            branch */
2890             TRIE_CHARCOUNT(trie)++;
2891             TRIE_READ_CHAR;
2892
2893             /* TRIE_READ_CHAR returns the current character, or its fold if /i
2894              * is in effect.  Under /i, this character can match itself, or
2895              * anything that folds to it.  If not under /i, it can match just
2896              * itself.  Most folds are 1-1, for example k, K, and KELVIN SIGN
2897              * all fold to k, and all are single characters.   But some folds
2898              * expand to more than one character, so for example LATIN SMALL
2899              * LIGATURE FFI folds to the three character sequence 'ffi'.  If
2900              * the string beginning at 'uc' is 'ffi', it could be matched by
2901              * three characters, or just by the one ligature character. (It
2902              * could also be matched by two characters: LATIN SMALL LIGATURE FF
2903              * followed by 'i', or by 'f' followed by LATIN SMALL LIGATURE FI).
2904              * (Of course 'I' and/or 'F' instead of 'i' and 'f' can also
2905              * match.)  The trie needs to know the minimum and maximum number
2906              * of characters that could match so that it can use size alone to
2907              * quickly reject many match attempts.  The max is simple: it is
2908              * the number of folded characters in this branch (since a fold is
2909              * never shorter than what folds to it. */
2910
2911             maxchars++;
2912
2913             /* And the min is equal to the max if not under /i (indicated by
2914              * 'folder' being NULL), or there are no multi-character folds.  If
2915              * there is a multi-character fold, the min is incremented just
2916              * once, for the character that folds to the sequence.  Each
2917              * character in the sequence needs to be added to the list below of
2918              * characters in the trie, but we count only the first towards the
2919              * min number of characters needed.  This is done through the
2920              * variable 'foldlen', which is returned by the macros that look
2921              * for these sequences as the number of bytes the sequence
2922              * occupies.  Each time through the loop, we decrement 'foldlen' by
2923              * how many bytes the current char occupies.  Only when it reaches
2924              * 0 do we increment 'minchars' or look for another multi-character
2925              * sequence. */
2926             if (folder == NULL) {
2927                 minchars++;
2928             }
2929             else if (foldlen > 0) {
2930                 foldlen -= (UTF) ? UTF8SKIP(uc) : 1;
2931             }
2932             else {
2933                 minchars++;
2934
2935                 /* See if *uc is the beginning of a multi-character fold.  If
2936                  * so, we decrement the length remaining to look at, to account
2937                  * for the current character this iteration.  (We can use 'uc'
2938                  * instead of the fold returned by TRIE_READ_CHAR because the
2939                  * macro is smart enough to account for any unfolded
2940                  * characters. */
2941                 if (UTF) {
2942                     if ((foldlen = is_MULTI_CHAR_FOLD_utf8_safe(uc, e))) {
2943                         foldlen -= UTF8SKIP(uc);
2944                     }
2945                 }
2946                 else if ((foldlen = is_MULTI_CHAR_FOLD_latin1_safe(uc, e))) {
2947                     foldlen--;
2948                 }
2949             }
2950
2951             /* The current character (and any potential folds) should be added
2952              * to the possible matching characters for this position in this
2953              * branch */
2954             if ( uvc < 256 ) {
2955                 if ( folder ) {
2956                     U8 folded= folder[ (U8) uvc ];
2957                     if ( !trie->charmap[ folded ] ) {
2958                         trie->charmap[ folded ]=( ++trie->uniquecharcount );
2959                         TRIE_STORE_REVCHAR( folded );
2960                     }
2961                 }
2962                 if ( !trie->charmap[ uvc ] ) {
2963                     trie->charmap[ uvc ]=( ++trie->uniquecharcount );
2964                     TRIE_STORE_REVCHAR( uvc );
2965                 }
2966                 if ( set_bit ) {
2967                     /* store the codepoint in the bitmap, and its folded
2968                      * equivalent. */
2969                     TRIE_BITMAP_SET_FOLDED(trie, uvc, folder);
2970                     set_bit = 0; /* We've done our bit :-) */
2971                 }
2972             } else {
2973
2974                 /* XXX We could come up with the list of code points that fold
2975                  * to this using PL_utf8_foldclosures, except not for
2976                  * multi-char folds, as there may be multiple combinations
2977                  * there that could work, which needs to wait until runtime to
2978                  * resolve (The comment about LIGATURE FFI above is such an
2979                  * example */
2980
2981                 SV** svpp;
2982                 if ( !widecharmap )
2983                     widecharmap = newHV();
2984
2985                 svpp = hv_fetch( widecharmap, (char*)&uvc, sizeof( UV ), 1 );
2986
2987                 if ( !svpp )
2988                     Perl_croak( aTHX_ "error creating/fetching widecharmap entry for 0x%" UVXf, uvc );
2989
2990                 if ( !SvTRUE( *svpp ) ) {
2991                     sv_setiv( *svpp, ++trie->uniquecharcount );
2992                     TRIE_STORE_REVCHAR(uvc);
2993                 }
2994             }
2995         } /* end loop through characters in this branch of the trie */
2996
2997         /* We take the min and max for this branch and combine to find the min
2998          * and max for all branches processed so far */
2999         if( cur == first ) {
3000             trie->minlen = minchars;
3001             trie->maxlen = maxchars;
3002         } else if (minchars < trie->minlen) {
3003             trie->minlen = minchars;
3004         } else if (maxchars > trie->maxlen) {
3005             trie->maxlen = maxchars;
3006         }
3007     } /* end first pass */
3008     DEBUG_TRIE_COMPILE_r(
3009         Perl_re_indentf( aTHX_
3010                 "TRIE(%s): W:%d C:%d Uq:%d Min:%d Max:%d\n",
3011                 depth+1,
3012                 ( widecharmap ? "UTF8" : "NATIVE" ), (int)word_count,
3013                 (int)TRIE_CHARCOUNT(trie), trie->uniquecharcount,
3014                 (int)trie->minlen, (int)trie->maxlen )
3015     );
3016
3017     /*
3018         We now know what we are dealing with in terms of unique chars and
3019         string sizes so we can calculate how much memory a naive
3020         representation using a flat table  will take. If it's over a reasonable
3021         limit (as specified by ${^RE_TRIE_MAXBUF}) we use a more memory
3022         conservative but potentially much slower representation using an array
3023         of lists.
3024
3025         At the end we convert both representations into the same compressed
3026         form that will be used in regexec.c for matching with. The latter
3027         is a form that cannot be used to construct with but has memory
3028         properties similar to the list form and access properties similar
3029         to the table form making it both suitable for fast searches and
3030         small enough that its feasable to store for the duration of a program.
3031
3032         See the comment in the code where the compressed table is produced
3033         inplace from the flat tabe representation for an explanation of how
3034         the compression works.
3035
3036     */
3037
3038
3039     Newx(prev_states, TRIE_CHARCOUNT(trie) + 2, U32);
3040     prev_states[1] = 0;
3041
3042     if ( (IV)( ( TRIE_CHARCOUNT(trie) + 1 ) * trie->uniquecharcount + 1)
3043                                                     > SvIV(re_trie_maxbuff) )
3044     {
3045         /*
3046             Second Pass -- Array Of Lists Representation
3047
3048             Each state will be represented by a list of charid:state records
3049             (reg_trie_trans_le) the first such element holds the CUR and LEN
3050             points of the allocated array. (See defines above).
3051
3052             We build the initial structure using the lists, and then convert
3053             it into the compressed table form which allows faster lookups
3054             (but cant be modified once converted).
3055         */
3056
3057         STRLEN transcount = 1;
3058
3059         DEBUG_TRIE_COMPILE_MORE_r( Perl_re_indentf( aTHX_  "Compiling trie using list compiler\n",
3060             depth+1));
3061
3062         trie->states = (reg_trie_state *)
3063             PerlMemShared_calloc( TRIE_CHARCOUNT(trie) + 2,
3064                                   sizeof(reg_trie_state) );
3065         TRIE_LIST_NEW(1);
3066         next_alloc = 2;
3067
3068         for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
3069
3070             regnode *noper   = NEXTOPER( cur );
3071             U32 state        = 1;         /* required init */
3072             U16 charid       = 0;         /* sanity init */
3073             U32 wordlen      = 0;         /* required init */
3074
3075             if (OP(noper) == NOTHING) {
3076                 regnode *noper_next= regnext(noper);
3077                 if (noper_next < tail)
3078                     noper= noper_next;
3079                 /* we will undo this assignment if noper does not
3080                  * point at a trieable type in the else clause of
3081                  * the following statement. */
3082             }
3083
3084             if (    noper < tail
3085                 && (    OP(noper) == flags
3086                     || (flags == EXACT && OP(noper) == EXACT_REQ8)
3087                     || (flags == EXACTFU && (   OP(noper) == EXACTFU_REQ8
3088                                              || OP(noper) == EXACTFUP))))
3089             {
3090                 const U8 *uc= (U8*)STRING(noper);
3091                 const U8 *e= uc + STR_LEN(noper);
3092
3093                 for ( ; uc < e ; uc += len ) {
3094
3095                     TRIE_READ_CHAR;
3096
3097                     if ( uvc < 256 ) {
3098                         charid = trie->charmap[ uvc ];
3099                     } else {
3100                         SV** const svpp = hv_fetch( widecharmap,
3101                                                     (char*)&uvc,
3102                                                     sizeof( UV ),
3103                                                     0);
3104                         if ( !svpp ) {
3105                             charid = 0;
3106                         } else {
3107                             charid=(U16)SvIV( *svpp );
3108                         }
3109                     }
3110                     /* charid is now 0 if we dont know the char read, or
3111                      * nonzero if we do */
3112                     if ( charid ) {
3113
3114                         U16 check;
3115                         U32 newstate = 0;
3116
3117                         charid--;
3118                         if ( !trie->states[ state ].trans.list ) {
3119                             TRIE_LIST_NEW( state );
3120                         }
3121                         for ( check = 1;
3122                               check <= TRIE_LIST_USED( state );
3123                               check++ )
3124                         {
3125                             if ( TRIE_LIST_ITEM( state, check ).forid
3126                                                                     == charid )
3127                             {
3128                                 newstate = TRIE_LIST_ITEM( state, check ).newstate;
3129                                 break;
3130                             }
3131                         }
3132                         if ( ! newstate ) {
3133                             newstate = next_alloc++;
3134                             prev_states[newstate] = state;
3135                             TRIE_LIST_PUSH( state, charid, newstate );
3136                             transcount++;
3137                         }
3138                         state = newstate;
3139                     } else {
3140                         Perl_croak( aTHX_ "panic! In trie construction, no char mapping for %" IVdf, uvc );
3141                     }
3142                 }
3143             } else {
3144                 /* If we end up here it is because we skipped past a NOTHING, but did not end up
3145                  * on a trieable type. So we need to reset noper back to point at the first regop
3146                  * in the branch before we call TRIE_HANDLE_WORD()
3147                 */
3148                 noper= NEXTOPER(cur);
3149             }
3150             TRIE_HANDLE_WORD(state);
3151
3152         } /* end second pass */
3153
3154         /* next alloc is the NEXT state to be allocated */
3155         trie->statecount = next_alloc;
3156         trie->states = (reg_trie_state *)
3157             PerlMemShared_realloc( trie->states,
3158                                    next_alloc
3159                                    * sizeof(reg_trie_state) );
3160
3161         /* and now dump it out before we compress it */
3162         DEBUG_TRIE_COMPILE_MORE_r(dump_trie_interim_list(trie, widecharmap,
3163                                                          revcharmap, next_alloc,
3164                                                          depth+1)
3165         );
3166
3167         trie->trans = (reg_trie_trans *)
3168             PerlMemShared_calloc( transcount, sizeof(reg_trie_trans) );
3169         {
3170             U32 state;
3171             U32 tp = 0;
3172             U32 zp = 0;
3173
3174
3175             for( state=1 ; state < next_alloc ; state ++ ) {
3176                 U32 base=0;
3177
3178                 /*
3179                 DEBUG_TRIE_COMPILE_MORE_r(
3180                     Perl_re_printf( aTHX_  "tp: %d zp: %d ",tp,zp)
3181                 );
3182                 */
3183
3184                 if (trie->states[state].trans.list) {
3185                     U16 minid=TRIE_LIST_ITEM( state, 1).forid;
3186                     U16 maxid=minid;
3187                     U16 idx;
3188
3189                     for( idx = 2 ; idx <= TRIE_LIST_USED( state ) ; idx++ ) {
3190                         const U16 forid = TRIE_LIST_ITEM( state, idx).forid;
3191                         if ( forid < minid ) {
3192                             minid=forid;
3193                         } else if ( forid > maxid ) {
3194                             maxid=forid;
3195                         }
3196                     }
3197                     if ( transcount < tp + maxid - minid + 1) {
3198                         transcount *= 2;
3199                         trie->trans = (reg_trie_trans *)
3200                             PerlMemShared_realloc( trie->trans,
3201                                                      transcount
3202                                                      * sizeof(reg_trie_trans) );
3203                         Zero( trie->trans + (transcount / 2),
3204                               transcount / 2,
3205                               reg_trie_trans );
3206                     }
3207                     base = trie->uniquecharcount + tp - minid;
3208                     if ( maxid == minid ) {
3209                         U32 set = 0;
3210                         for ( ; zp < tp ; zp++ ) {
3211                             if ( ! trie->trans[ zp ].next ) {
3212                                 base = trie->uniquecharcount + zp - minid;
3213                                 trie->trans[ zp ].next = TRIE_LIST_ITEM( state,
3214                                                                    1).newstate;
3215                                 trie->trans[ zp ].check = state;
3216                                 set = 1;
3217                                 break;
3218                             }
3219                         }
3220                         if ( !set ) {
3221                             trie->trans[ tp ].next = TRIE_LIST_ITEM( state,
3222                                                                    1).newstate;
3223                             trie->trans[ tp ].check = state;
3224                             tp++;
3225                             zp = tp;
3226                         }
3227                     } else {
3228                         for ( idx=1; idx <= TRIE_LIST_USED( state ) ; idx++ ) {
3229                             const U32 tid = base
3230                                            - trie->uniquecharcount
3231                                            + TRIE_LIST_ITEM( state, idx ).forid;
3232                             trie->trans[ tid ].next = TRIE_LIST_ITEM( state,
3233                                                                 idx ).newstate;
3234                             trie->trans[ tid ].check = state;
3235                         }
3236                         tp += ( maxid - minid + 1 );
3237                     }
3238                     Safefree(trie->states[ state ].trans.list);
3239                 }
3240                 /*
3241                 DEBUG_TRIE_COMPILE_MORE_r(
3242                     Perl_re_printf( aTHX_  " base: %d\n",base);
3243                 );
3244                 */
3245                 trie->states[ state ].trans.base=base;
3246             }
3247             trie->lasttrans = tp + 1;
3248         }
3249     } else {
3250         /*
3251            Second Pass -- Flat Table Representation.
3252
3253            we dont use the 0 slot of either trans[] or states[] so we add 1 to
3254            each.  We know that we will need Charcount+1 trans at most to store
3255            the data (one row per char at worst case) So we preallocate both
3256            structures assuming worst case.
3257
3258            We then construct the trie using only the .next slots of the entry
3259            structs.
3260
3261            We use the .check field of the first entry of the node temporarily
3262            to make compression both faster and easier by keeping track of how
3263            many non zero fields are in the node.
3264
3265            Since trans are numbered from 1 any 0 pointer in the table is a FAIL
3266            transition.
3267
3268            There are two terms at use here: state as a TRIE_NODEIDX() which is
3269            a number representing the first entry of the node, and state as a
3270            TRIE_NODENUM() which is the trans number. state 1 is TRIE_NODEIDX(1)
3271            and TRIE_NODENUM(1), state 2 is TRIE_NODEIDX(2) and TRIE_NODENUM(3)
3272            if there are 2 entrys per node. eg:
3273
3274              A B       A B
3275           1. 2 4    1. 3 7
3276           2. 0 3    3. 0 5
3277           3. 0 0    5. 0 0
3278           4. 0 0    7. 0 0
3279
3280            The table is internally in the right hand, idx form. However as we
3281            also have to deal with the states array which is indexed by nodenum
3282            we have to use TRIE_NODENUM() to convert.
3283
3284         */
3285         DEBUG_TRIE_COMPILE_MORE_r( Perl_re_indentf( aTHX_  "Compiling trie using table compiler\n",
3286             depth+1));
3287
3288         trie->trans = (reg_trie_trans *)
3289             PerlMemShared_calloc( ( TRIE_CHARCOUNT(trie) + 1 )
3290                                   * trie->uniquecharcount + 1,
3291                                   sizeof(reg_trie_trans) );
3292         trie->states = (reg_trie_state *)
3293             PerlMemShared_calloc( TRIE_CHARCOUNT(trie) + 2,
3294                                   sizeof(reg_trie_state) );
3295         next_alloc = trie->uniquecharcount + 1;
3296
3297
3298         for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
3299
3300             regnode *noper   = NEXTOPER( cur );
3301
3302             U32 state        = 1;         /* required init */
3303
3304             U16 charid       = 0;         /* sanity init */
3305             U32 accept_state = 0;         /* sanity init */
3306
3307             U32 wordlen      = 0;         /* required init */
3308
3309             if (OP(noper) == NOTHING) {
3310                 regnode *noper_next= regnext(noper);
3311                 if (noper_next < tail)
3312                     noper= noper_next;
3313                 /* we will undo this assignment if noper does not
3314                  * point at a trieable type in the else clause of
3315                  * the following statement. */
3316             }
3317
3318             if (    noper < tail
3319                 && (    OP(noper) == flags
3320                     || (flags == EXACT && OP(noper) == EXACT_REQ8)
3321                     || (flags == EXACTFU && (   OP(noper) == EXACTFU_REQ8
3322                                              || OP(noper) == EXACTFUP))))
3323             {
3324                 const U8 *uc= (U8*)STRING(noper);
3325                 const U8 *e= uc + STR_LEN(noper);
3326
3327                 for ( ; uc < e ; uc += len ) {
3328
3329                     TRIE_READ_CHAR;
3330
3331                     if ( uvc < 256 ) {
3332                         charid = trie->charmap[ uvc ];
3333                     } else {
3334                         SV* const * const svpp = hv_fetch( widecharmap,
3335                                                            (char*)&uvc,
3336                                                            sizeof( UV ),
3337                                                            0);
3338                         charid = svpp ? (U16)SvIV(*svpp) : 0;
3339                     }
3340                     if ( charid ) {
3341                         charid--;
3342                         if ( !trie->trans[ state + charid ].next ) {
3343                             trie->trans[ state + charid ].next = next_alloc;
3344                             trie->trans[ state ].check++;
3345                             prev_states[TRIE_NODENUM(next_alloc)]
3346                                     = TRIE_NODENUM(state);
3347                             next_alloc += trie->uniquecharcount;
3348                         }
3349                         state = trie->trans[ state + charid ].next;
3350                     } else {
3351                         Perl_croak( aTHX_ "panic! In trie construction, no char mapping for %" IVdf, uvc );
3352                     }
3353                     /* charid is now 0 if we dont know the char read, or
3354                      * nonzero if we do */
3355                 }
3356             } else {
3357                 /* If we end up here it is because we skipped past a NOTHING, but did not end up
3358                  * on a trieable type. So we need to reset noper back to point at the first regop
3359                  * in the branch before we call TRIE_HANDLE_WORD().
3360                 */
3361                 noper= NEXTOPER(cur);
3362             }
3363             accept_state = TRIE_NODENUM( state );
3364             TRIE_HANDLE_WORD(accept_state);
3365
3366         } /* end second pass */
3367
3368         /* and now dump it out before we compress it */
3369         DEBUG_TRIE_COMPILE_MORE_r(dump_trie_interim_table(trie, widecharmap,
3370                                                           revcharmap,
3371                                                           next_alloc, depth+1));
3372
3373         {
3374         /*
3375            * Inplace compress the table.*
3376
3377            For sparse data sets the table constructed by the trie algorithm will
3378            be mostly 0/FAIL transitions or to put it another way mostly empty.
3379            (Note that leaf nodes will not contain any transitions.)
3380
3381            This algorithm compresses the tables by eliminating most such
3382            transitions, at the cost of a modest bit of extra work during lookup:
3383
3384            - Each states[] entry contains a .base field which indicates the
3385            index in the state[] array wheres its transition data is stored.
3386
3387            - If .base is 0 there are no valid transitions from that node.
3388
3389            - If .base is nonzero then charid is added to it to find an entry in
3390            the trans array.
3391
3392            -If trans[states[state].base+charid].check!=state then the
3393            transition is taken to be a 0/Fail transition. Thus if there are fail
3394            transitions at the front of the node then the .base offset will point
3395            somewhere inside the previous nodes data (or maybe even into a node
3396            even earlier), but the .check field determines if the transition is
3397            valid.
3398
3399            XXX - wrong maybe?
3400            The following process inplace converts the table to the compressed
3401            table: We first do not compress the root node 1,and mark all its
3402            .check pointers as 1 and set its .base pointer as 1 as well. This
3403            allows us to do a DFA construction from the compressed table later,
3404            and ensures that any .base pointers we calculate later are greater
3405            than 0.
3406
3407            - We set 'pos' to indicate the first entry of the second node.
3408
3409            - We then iterate over the columns of the node, finding the first and
3410            last used entry at l and m. We then copy l..m into pos..(pos+m-l),
3411            and set the .check pointers accordingly, and advance pos
3412            appropriately and repreat for the next node. Note that when we copy
3413            the next pointers we have to convert them from the original
3414            NODEIDX form to NODENUM form as the former is not valid post
3415            compression.
3416
3417            - If a node has no transitions used we mark its base as 0 and do not
3418            advance the pos pointer.
3419
3420            - If a node only has one transition we use a second pointer into the
3421            structure to fill in allocated fail transitions from other states.
3422            This pointer is independent of the main pointer and scans forward
3423            looking for null transitions that are allocated to a state. When it
3424            finds one it writes the single transition into the "hole".  If the
3425            pointer doesnt find one the single transition is appended as normal.
3426
3427            - Once compressed we can Renew/realloc the structures to release the
3428            excess space.
3429
3430            See "Table-Compression Methods" in sec 3.9 of the Red Dragon,
3431            specifically Fig 3.47 and the associated pseudocode.
3432
3433            demq
3434         */
3435         const U32 laststate = TRIE_NODENUM( next_alloc );
3436         U32 state, charid;
3437         U32 pos = 0, zp=0;
3438         trie->statecount = laststate;
3439
3440         for ( state = 1 ; state < laststate ; state++ ) {
3441             U8 flag = 0;
3442             const U32 stateidx = TRIE_NODEIDX( state );
3443             const U32 o_used = trie->trans[ stateidx ].check;
3444             U32 used = trie->trans[ stateidx ].check;
3445             trie->trans[ stateidx ].check = 0;
3446
3447             for ( charid = 0;
3448                   used && charid < trie->uniquecharcount;
3449                   charid++ )
3450             {
3451                 if ( flag || trie->trans[ stateidx + charid ].next ) {
3452                     if ( trie->trans[ stateidx + charid ].next ) {
3453                         if (o_used == 1) {
3454                             for ( ; zp < pos ; zp++ ) {
3455                                 if ( ! trie->trans[ zp ].next ) {
3456                                     break;
3457                                 }
3458                             }
3459                             trie->states[ state ].trans.base
3460                                                     = zp
3461                                                       + trie->uniquecharcount
3462                                                       - charid ;
3463                             trie->trans[ zp ].next
3464                                 = SAFE_TRIE_NODENUM( trie->trans[ stateidx
3465                                                              + charid ].next );
3466                             trie->trans[ zp ].check = state;
3467                             if ( ++zp > pos ) pos = zp;
3468                             break;
3469                         }
3470                         used--;
3471                     }
3472                     if ( !flag ) {
3473                         flag = 1;
3474                         trie->states[ state ].trans.base
3475                                        = pos + trie->uniquecharcount - charid ;
3476                     }
3477                     trie->trans[ pos ].next
3478                         = SAFE_TRIE_NODENUM(
3479                                        trie->trans[ stateidx + charid ].next );
3480                     trie->trans[ pos ].check = state;
3481                     pos++;
3482                 }
3483             }
3484         }
3485         trie->lasttrans = pos + 1;
3486         trie->states = (reg_trie_state *)
3487             PerlMemShared_realloc( trie->states, laststate
3488                                    * sizeof(reg_trie_state) );
3489         DEBUG_TRIE_COMPILE_MORE_r(
3490             Perl_re_indentf( aTHX_  "Alloc: %d Orig: %" IVdf " elements, Final:%" IVdf ". Savings of %%%5.2f\n",
3491                 depth+1,
3492                 (int)( ( TRIE_CHARCOUNT(trie) + 1 ) * trie->uniquecharcount
3493                        + 1 ),
3494                 (IV)next_alloc,
3495                 (IV)pos,
3496                 ( ( next_alloc - pos ) * 100 ) / (double)next_alloc );
3497             );
3498
3499         } /* end table compress */
3500     }
3501     DEBUG_TRIE_COMPILE_MORE_r(
3502             Perl_re_indentf( aTHX_  "Statecount:%" UVxf " Lasttrans:%" UVxf "\n",
3503                 depth+1,
3504                 (UV)trie->statecount,
3505                 (UV)trie->lasttrans)
3506     );
3507     /* resize the trans array to remove unused space */
3508     trie->trans = (reg_trie_trans *)
3509         PerlMemShared_realloc( trie->trans, trie->lasttrans
3510                                * sizeof(reg_trie_trans) );
3511
3512     {   /* Modify the program and insert the new TRIE node */
3513         U8 nodetype =(U8)(flags & 0xFF);
3514         char *str=NULL;
3515
3516 #ifdef DEBUGGING
3517         regnode *optimize = NULL;
3518 #ifdef RE_TRACK_PATTERN_OFFSETS
3519
3520         U32 mjd_offset = 0;
3521         U32 mjd_nodelen = 0;
3522 #endif /* RE_TRACK_PATTERN_OFFSETS */
3523 #endif /* DEBUGGING */
3524         /*
3525            This means we convert either the first branch or the first Exact,
3526            depending on whether the thing following (in 'last') is a branch
3527            or not and whther first is the startbranch (ie is it a sub part of
3528            the alternation or is it the whole thing.)
3529            Assuming its a sub part we convert the EXACT otherwise we convert
3530            the whole branch sequence, including the first.
3531          */
3532         /* Find the node we are going to overwrite */
3533         if ( first != startbranch || OP( last ) == BRANCH ) {
3534             /* branch sub-chain */
3535             NEXT_OFF( first ) = (U16)(last - first);
3536 #ifdef RE_TRACK_PATTERN_OFFSETS
3537             DEBUG_r({
3538                 mjd_offset= Node_Offset((convert));
3539                 mjd_nodelen= Node_Length((convert));
3540             });
3541 #endif
3542             /* whole branch chain */
3543         }
3544 #ifdef RE_TRACK_PATTERN_OFFSETS
3545         else {
3546             DEBUG_r({
3547                 const  regnode *nop = NEXTOPER( convert );
3548                 mjd_offset= Node_Offset((nop));
3549                 mjd_nodelen= Node_Length((nop));
3550             });
3551         }
3552         DEBUG_OPTIMISE_r(
3553             Perl_re_indentf( aTHX_  "MJD offset:%" UVuf " MJD length:%" UVuf "\n",
3554                 depth+1,
3555                 (UV)mjd_offset, (UV)mjd_nodelen)
3556         );
3557 #endif
3558         /* But first we check to see if there is a common prefix we can
3559            split out as an EXACT and put in front of the TRIE node.  */
3560         trie->startstate= 1;
3561         if ( trie->bitmap && !widecharmap && !trie->jump  ) {
3562             /* we want to find the first state that has more than
3563              * one transition, if that state is not the first state
3564              * then we have a common prefix which we can remove.
3565              */
3566             U32 state;
3567             for ( state = 1 ; state < trie->statecount-1 ; state++ ) {
3568                 U32 ofs = 0;
3569                 I32 first_ofs = -1; /* keeps track of the ofs of the first
3570                                        transition, -1 means none */
3571                 U32 count = 0;
3572                 const U32 base = trie->states[ state ].trans.base;
3573
3574                 /* does this state terminate an alternation? */
3575                 if ( trie->states[state].wordnum )
3576                         count = 1;
3577
3578                 for ( ofs = 0 ; ofs < trie->uniquecharcount ; ofs++ ) {
3579                     if ( ( base + ofs >= trie->uniquecharcount ) &&
3580                          ( base + ofs - trie->uniquecharcount < trie->lasttrans ) &&
3581                          trie->trans[ base + ofs - trie->uniquecharcount ].check == state )
3582                     {
3583                         if ( ++count > 1 ) {
3584                             /* we have more than one transition */
3585                             SV **tmp;
3586                             U8 *ch;
3587                             /* if this is the first state there is no common prefix
3588                              * to extract, so we can exit */
3589                             if ( state == 1 ) break;
3590                             tmp = av_fetch( revcharmap, ofs, 0);
3591                             ch = (U8*)SvPV_nolen_const( *tmp );
3592
3593                             /* if we are on count 2 then we need to initialize the
3594                              * bitmap, and store the previous char if there was one
3595                              * in it*/
3596                             if ( count == 2 ) {
3597                                 /* clear the bitmap */
3598                                 Zero(trie->bitmap, ANYOF_BITMAP_SIZE, char);
3599                                 DEBUG_OPTIMISE_r(
3600                                     Perl_re_indentf( aTHX_  "New Start State=%" UVuf " Class: [",
3601                                         depth+1,
3602                                         (UV)state));
3603                                 if (first_ofs >= 0) {
3604                                     SV ** const tmp = av_fetch( revcharmap, first_ofs, 0);
3605                                     const U8 * const ch = (U8*)SvPV_nolen_const( *tmp );
3606
3607                                     TRIE_BITMAP_SET_FOLDED(trie,*ch, folder);
3608                                     DEBUG_OPTIMISE_r(
3609                                         Perl_re_printf( aTHX_  "%s", (char*)ch)
3610                                     );
3611                                 }
3612                             }
3613                             /* store the current firstchar in the bitmap */
3614                             TRIE_BITMAP_SET_FOLDED(trie,*ch, folder);
3615                             DEBUG_OPTIMISE_r(Perl_re_printf( aTHX_ "%s", ch));
3616                         }
3617                         first_ofs = ofs;
3618                     }
3619                 }
3620                 if ( count == 1 ) {
3621                     /* This state has only one transition, its transition is part
3622                      * of a common prefix - we need to concatenate the char it
3623                      * represents to what we have so far. */
3624                     SV **tmp = av_fetch( revcharmap, first_ofs, 0);
3625                     STRLEN len;
3626                     char *ch = SvPV( *tmp, len );
3627                     DEBUG_OPTIMISE_r({
3628                         SV *sv=sv_newmortal();
3629                         Perl_re_indentf( aTHX_  "Prefix State: %" UVuf " Ofs:%" UVuf " Char='%s'\n",
3630                             depth+1,
3631                             (UV)state, (UV)first_ofs,
3632                             pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), 6,
3633                                 PL_colors[0], PL_colors[1],
3634                                 (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
3635                                 PERL_PV_ESCAPE_FIRSTCHAR
3636                             )
3637                         );
3638                     });
3639                     if ( state==1 ) {
3640                         OP( convert ) = nodetype;
3641                         str=STRING(convert);
3642                         setSTR_LEN(convert, 0);
3643                     }
3644                     assert( ( STR_LEN(convert) + len ) < 256 );
3645                     setSTR_LEN(convert, (U8)(STR_LEN(convert) + len));
3646                     while (len--)
3647                         *str++ = *ch++;
3648                 } else {
3649 #ifdef DEBUGGING
3650                     if (state>1)
3651                         DEBUG_OPTIMISE_r(Perl_re_printf( aTHX_ "]\n"));
3652 #endif
3653                     break;
3654                 }
3655             }
3656             trie->prefixlen = (state-1);
3657             if (str) {
3658                 regnode *n = convert+NODE_SZ_STR(convert);
3659                 assert( NODE_SZ_STR(convert) <= U16_MAX );
3660                 NEXT_OFF(convert) = (U16)(NODE_SZ_STR(convert));
3661                 trie->startstate = state;
3662                 trie->minlen -= (state - 1);
3663                 trie->maxlen -= (state - 1);
3664 #ifdef DEBUGGING
3665                /* At least the UNICOS C compiler choked on this
3666                 * being argument to DEBUG_r(), so let's just have
3667                 * it right here. */
3668                if (
3669 #ifdef PERL_EXT_RE_BUILD
3670                    1
3671 #else
3672                    DEBUG_r_TEST
3673 #endif
3674                    ) {
3675                    regnode *fix = convert;
3676                    U32 word = trie->wordcount;
3677 #ifdef RE_TRACK_PATTERN_OFFSETS
3678                    mjd_nodelen++;
3679 #endif
3680                    Set_Node_Offset_Length(convert, mjd_offset, state - 1);
3681                    while( ++fix < n ) {
3682                        Set_Node_Offset_Length(fix, 0, 0);
3683                    }
3684                    while (word--) {
3685                        SV ** const tmp = av_fetch( trie_words, word, 0 );
3686                        if (tmp) {
3687                            if ( STR_LEN(convert) <= SvCUR(*tmp) )
3688                                sv_chop(*tmp, SvPV_nolen(*tmp) + STR_LEN(convert));
3689                            else
3690                                sv_chop(*tmp, SvPV_nolen(*tmp) + SvCUR(*tmp));
3691                        }
3692                    }
3693                }
3694 #endif
3695                 if (trie->maxlen) {
3696                     convert = n;
3697                 } else {
3698                     NEXT_OFF(convert) = (U16)(tail - convert);
3699                     DEBUG_r(optimize= n);
3700                 }
3701             }
3702         }
3703         if (!jumper)
3704             jumper = last;
3705         if ( trie->maxlen ) {
3706             NEXT_OFF( convert ) = (U16)(tail - convert);
3707             ARG_SET( convert, data_slot );
3708             /* Store the offset to the first unabsorbed branch in
3709                jump[0], which is otherwise unused by the jump logic.
3710                We use this when dumping a trie and during optimisation. */
3711             if (trie->jump)
3712                 trie->jump[0] = (U16)(nextbranch - convert);
3713
3714             /* If the start state is not accepting (meaning there is no empty string/NOTHING)
3715              *   and there is a bitmap
3716              *   and the first "jump target" node we found leaves enough room
3717              * then convert the TRIE node into a TRIEC node, with the bitmap
3718              * embedded inline in the opcode - this is hypothetically faster.
3719              */
3720             if ( !trie->states[trie->startstate].wordnum
3721                  && trie->bitmap
3722                  && ( (char *)jumper - (char *)convert) >= (int)sizeof(struct regnode_charclass) )
3723             {
3724                 OP( convert ) = TRIEC;
3725                 Copy(trie->bitmap, ((struct regnode_charclass *)convert)->bitmap, ANYOF_BITMAP_SIZE, char);
3726                 PerlMemShared_free(trie->bitmap);
3727                 trie->bitmap= NULL;
3728             } else
3729                 OP( convert ) = TRIE;
3730
3731             /* store the type in the flags */
3732             convert->flags = nodetype;
3733             DEBUG_r({
3734             optimize = convert
3735                       + NODE_STEP_REGNODE
3736                       + regarglen[ OP( convert ) ];
3737             });
3738             /* XXX We really should free up the resource in trie now,
3739                    as we won't use them - (which resources?) dmq */
3740         }
3741         /* needed for dumping*/
3742         DEBUG_r(if (optimize) {
3743             regnode *opt = convert;
3744
3745             while ( ++opt < optimize) {
3746                 Set_Node_Offset_Length(opt, 0, 0);
3747             }
3748             /*
3749                 Try to clean up some of the debris left after the
3750                 optimisation.
3751              */
3752             while( optimize < jumper ) {
3753                 Track_Code( mjd_nodelen += Node_Length((optimize)); );
3754                 OP( optimize ) = OPTIMIZED;
3755                 Set_Node_Offset_Length(optimize, 0, 0);
3756                 optimize++;
3757             }
3758             Set_Node_Offset_Length(convert, mjd_offset, mjd_nodelen);
3759         });
3760     } /* end node insert */
3761
3762     /*  Finish populating the prev field of the wordinfo array.  Walk back
3763      *  from each accept state until we find another accept state, and if
3764      *  so, point the first word's .prev field at the second word. If the
3765      *  second already has a .prev field set, stop now. This will be the
3766      *  case either if we've already processed that word's accept state,
3767      *  or that state had multiple words, and the overspill words were
3768      *  already linked up earlier.
3769      */
3770     {
3771         U16 word;
3772         U32 state;
3773         U16 prev;
3774
3775         for (word=1; word <= trie->wordcount; word++) {
3776             prev = 0;
3777             if (trie->wordinfo[word].prev)
3778                 continue;
3779             state = trie->wordinfo[word].accept;
3780             while (state) {
3781                 state = prev_states[state];
3782                 if (!state)
3783                     break;
3784                 prev = trie->states[state].wordnum;
3785                 if (prev)
3786                     break;
3787             }
3788             trie->wordinfo[word].prev = prev;
3789         }
3790         Safefree(prev_states);
3791     }
3792
3793
3794     /* and now dump out the compressed format */
3795     DEBUG_TRIE_COMPILE_r(dump_trie(trie, widecharmap, revcharmap, depth+1));
3796
3797     RExC_rxi->data->data[ data_slot + 1 ] = (void*)widecharmap;
3798 #ifdef DEBUGGING
3799     RExC_rxi->data->data[ data_slot + TRIE_WORDS_OFFSET ] = (void*)trie_words;
3800     RExC_rxi->data->data[ data_slot + 3 ] = (void*)revcharmap;
3801 #else
3802     SvREFCNT_dec_NN(revcharmap);
3803 #endif
3804     return trie->jump
3805            ? MADE_JUMP_TRIE
3806            : trie->startstate>1
3807              ? MADE_EXACT_TRIE
3808              : MADE_TRIE;
3809 }
3810
3811 STATIC regnode *
3812 S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth)
3813 {
3814 /* The Trie is constructed and compressed now so we can build a fail array if
3815  * it's needed
3816
3817    This is basically the Aho-Corasick algorithm. Its from exercise 3.31 and
3818    3.32 in the
3819    "Red Dragon" -- Compilers, principles, techniques, and tools. Aho, Sethi,
3820    Ullman 1985/88
3821    ISBN 0-201-10088-6
3822
3823    We find the fail state for each state in the trie, this state is the longest
3824    proper suffix of the current state's 'word' that is also a proper prefix of
3825    another word in our trie. State 1 represents the word '' and is thus the
3826    default fail state. This allows the DFA not to have to restart after its
3827    tried and failed a word at a given point, it simply continues as though it
3828    had been matching the other word in the first place.
3829    Consider
3830       'abcdgu'=~/abcdefg|cdgu/
3831    When we get to 'd' we are still matching the first word, we would encounter
3832    'g' which would fail, which would bring us to the state representing 'd' in
3833    the second word where we would try 'g' and succeed, proceeding to match
3834    'cdgu'.
3835  */
3836  /* add a fail transition */
3837     const U32 trie_offset = ARG(source);
3838     reg_trie_data *trie=(reg_trie_data *)RExC_rxi->data->data[trie_offset];
3839     U32 *q;
3840     const U32 ucharcount = trie->uniquecharcount;
3841     const U32 numstates = trie->statecount;
3842     const U32 ubound = trie->lasttrans + ucharcount;
3843     U32 q_read = 0;
3844     U32 q_write = 0;
3845     U32 charid;
3846     U32 base = trie->states[ 1 ].trans.base;
3847     U32 *fail;
3848     reg_ac_data *aho;
3849     const U32 data_slot = add_data( pRExC_state, STR_WITH_LEN("T"));
3850     regnode *stclass;
3851     DECLARE_AND_GET_RE_DEBUG_FLAGS;
3852
3853     PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE;
3854     PERL_UNUSED_CONTEXT;
3855 #ifndef DEBUGGING
3856     PERL_UNUSED_ARG(depth);
3857 #endif
3858
3859     if ( OP(source) == TRIE ) {
3860         struct regnode_1 *op = (struct regnode_1 *)
3861             PerlMemShared_calloc(1, sizeof(struct regnode_1));
3862         StructCopy(source, op, struct regnode_1);
3863         stclass = (regnode *)op;
3864     } else {
3865         struct regnode_charclass *op = (struct regnode_charclass *)
3866             PerlMemShared_calloc(1, sizeof(struct regnode_charclass));
3867         StructCopy(source, op, struct regnode_charclass);
3868         stclass = (regnode *)op;
3869     }
3870     OP(stclass)+=2; /* convert the TRIE type to its AHO-CORASICK equivalent */
3871
3872     ARG_SET( stclass, data_slot );
3873     aho = (reg_ac_data *) PerlMemShared_calloc( 1, sizeof(reg_ac_data) );
3874     RExC_rxi->data->data[ data_slot ] = (void*)aho;
3875     aho->trie=trie_offset;
3876     aho->states=(reg_trie_state *)PerlMemShared_malloc( numstates * sizeof(reg_trie_state) );
3877     Copy( trie->states, aho->states, numstates, reg_trie_state );
3878     Newx( q, numstates, U32);
3879     aho->fail = (U32 *) PerlMemShared_calloc( numstates, sizeof(U32) );
3880     aho->refcount = 1;
3881     fail = aho->fail;
3882     /* initialize fail[0..1] to be 1 so that we always have
3883        a valid final fail state */
3884     fail[ 0 ] = fail[ 1 ] = 1;
3885
3886     for ( charid = 0; charid < ucharcount ; charid++ ) {
3887         const U32 newstate = TRIE_TRANS_STATE( 1, base, ucharcount, charid, 0 );
3888         if ( newstate ) {
3889             q[ q_write ] = newstate;
3890             /* set to point at the root */
3891             fail[ q[ q_write++ ] ]=1;
3892         }
3893     }
3894     while ( q_read < q_write) {
3895         const U32 cur = q[ q_read++ % numstates ];
3896         base = trie->states[ cur ].trans.base;
3897
3898         for ( charid = 0 ; charid < ucharcount ; charid++ ) {
3899             const U32 ch_state = TRIE_TRANS_STATE( cur, base, ucharcount, charid, 1 );
3900             if (ch_state) {
3901                 U32 fail_state = cur;
3902                 U32 fail_base;
3903                 do {
3904                     fail_state = fail[ fail_state ];
3905                     fail_base = aho->states[ fail_state ].trans.base;
3906                 } while ( !TRIE_TRANS_STATE( fail_state, fail_base, ucharcount, charid, 1 ) );
3907
3908                 fail_state = TRIE_TRANS_STATE( fail_state, fail_base, ucharcount, charid, 1 );
3909                 fail[ ch_state ] = fail_state;
3910                 if ( !aho->states[ ch_state ].wordnum && aho->states[ fail_state ].wordnum )
3911                 {
3912                         aho->states[ ch_state ].wordnum =  aho->states[ fail_state ].wordnum;
3913                 }
3914                 q[ q_write++ % numstates] = ch_state;
3915             }
3916         }
3917     }
3918     /* restore fail[0..1] to 0 so that we "fall out" of the AC loop
3919        when we fail in state 1, this allows us to use the
3920        charclass scan to find a valid start char. This is based on the principle
3921        that theres a good chance the string being searched contains lots of stuff
3922        that cant be a start char.
3923      */
3924     fail[ 0 ] = fail[ 1 ] = 0;
3925     DEBUG_TRIE_COMPILE_r({
3926         Perl_re_indentf( aTHX_  "Stclass Failtable (%" UVuf " states): 0",
3927                       depth, (UV)numstates
3928         );
3929         for( q_read=1; q_read<numstates; q_read++ ) {
3930             Perl_re_printf( aTHX_  ", %" UVuf, (UV)fail[q_read]);
3931         }
3932         Perl_re_printf( aTHX_  "\n");
3933     });
3934     Safefree(q);
3935     /*RExC_seen |= REG_TRIEDFA_SEEN;*/
3936     return stclass;
3937 }
3938
3939
3940 /* The below joins as many adjacent EXACTish nodes as possible into a single
3941  * one.  The regop may be changed if the node(s) contain certain sequences that
3942  * require special handling.  The joining is only done if:
3943  * 1) there is room in the current conglomerated node to entirely contain the
3944  *    next one.
3945  * 2) they are compatible node types
3946  *
3947  * The adjacent nodes actually may be separated by NOTHING-kind nodes, and
3948  * these get optimized out
3949  *
3950  * XXX khw thinks this should be enhanced to fill EXACT (at least) nodes as full
3951  * as possible, even if that means splitting an existing node so that its first
3952  * part is moved to the preceeding node.  This would maximise the efficiency of
3953  * memEQ during matching.
3954  *
3955  * If a node is to match under /i (folded), the number of characters it matches
3956  * can be different than its character length if it contains a multi-character
3957  * fold.  *min_subtract is set to the total delta number of characters of the
3958  * input nodes.
3959  *
3960  * And *unfolded_multi_char is set to indicate whether or not the node contains
3961  * an unfolded multi-char fold.  This happens when it won't be known until
3962  * runtime whether the fold is valid or not; namely
3963  *  1) for EXACTF nodes that contain LATIN SMALL LETTER SHARP S, as only if the
3964  *      target string being matched against turns out to be UTF-8 is that fold
3965  *      valid; or
3966  *  2) for EXACTFL nodes whose folding rules depend on the locale in force at
3967  *      runtime.
3968  * (Multi-char folds whose components are all above the Latin1 range are not
3969  * run-time locale dependent, and have already been folded by the time this
3970  * function is called.)
3971  *
3972  * This is as good a place as any to discuss the design of handling these
3973  * multi-character fold sequences.  It's been wrong in Perl for a very long
3974  * time.  There are three code points in Unicode whose multi-character folds
3975  * were long ago discovered to mess things up.  The previous designs for
3976  * dealing with these involved assigning a special node for them.  This
3977  * approach doesn't always work, as evidenced by this example:
3978  *      "\xDFs" =~ /s\xDF/ui    # Used to fail before these patches
3979  * Both sides fold to "sss", but if the pattern is parsed to create a node that
3980  * would match just the \xDF, it won't be able to handle the case where a
3981  * successful match would have to cross the node's boundary.  The new approach
3982  * that hopefully generally solves the problem generates an EXACTFUP node
3983  * that is "sss" in this case.
3984  *
3985  * It turns out that there are problems with all multi-character folds, and not
3986  * just these three.  Now the code is general, for all such cases.  The
3987  * approach taken is:
3988  * 1)   This routine examines each EXACTFish node that could contain multi-
3989  *      character folded sequences.  Since a single character can fold into
3990  *      such a sequence, the minimum match length for this node is less than
3991  *      the number of characters in the node.  This routine returns in
3992  *      *min_subtract how many characters to subtract from the actual
3993  *      length of the string to get a real minimum match length; it is 0 if
3994  *      there are no multi-char foldeds.  This delta is used by the caller to
3995  *      adjust the min length of the match, and the delta between min and max,
3996  *      so that the optimizer doesn't reject these possibilities based on size
3997  *      constraints.
3998  *
3999  * 2)   For the sequence involving the LATIN SMALL LETTER SHARP S (U+00DF)
4000  *      under /u, we fold it to 'ss' in regatom(), and in this routine, after
4001  *      joining, we scan for occurrences of the sequence 'ss' in non-UTF-8
4002  *      EXACTFU nodes.  The node type of such nodes is then changed to
4003  *      EXACTFUP, indicating it is problematic, and needs careful handling.
4004  *      (The procedures in step 1) above are sufficient to handle this case in
4005  *      UTF-8 encoded nodes.)  The reason this is problematic is that this is
4006  *      the only case where there is a possible fold length change in non-UTF-8
4007  *      patterns.  By reserving a special node type for problematic cases, the
4008  *      far more common regular EXACTFU nodes can be processed faster.
4009  *      regexec.c takes advantage of this.
4010  *
4011  *      EXACTFUP has been created as a grab-bag for (hopefully uncommon)
4012  *      problematic cases.   These all only occur when the pattern is not
4013  *      UTF-8.  In addition to the 'ss' sequence where there is a possible fold
4014  *      length change, it handles the situation where the string cannot be
4015  *      entirely folded.  The strings in an EXACTFish node are folded as much
4016  *      as possible during compilation in regcomp.c.  This saves effort in
4017  *      regex matching.  By using an EXACTFUP node when it is not possible to
4018  *      fully fold at compile time, regexec.c can know that everything in an
4019  *      EXACTFU node is folded, so folding can be skipped at runtime.  The only
4020  *      case where folding in EXACTFU nodes can't be done at compile time is
4021  *      the presumably uncommon MICRO SIGN, when the pattern isn't UTF-8.  This
4022  *      is because its fold requires UTF-8 to represent.  Thus EXACTFUP nodes
4023  *      handle two very different cases.  Alternatively, there could have been
4024  *      a node type where there are length changes, one for unfolded, and one
4025  *      for both.  If yet another special case needed to be created, the number
4026  *      of required node types would have to go to 7.  khw figures that even
4027  *      though there are plenty of node types to spare, that the maintenance
4028  *      cost wasn't worth the small speedup of doing it that way, especially
4029  *      since he thinks the MICRO SIGN is rarely encountered in practice.
4030  *
4031  *      There are other cases where folding isn't done at compile time, but
4032  *      none of them are under /u, and hence not for EXACTFU nodes.  The folds
4033  *      in EXACTFL nodes aren't known until runtime, and vary as the locale
4034  *      changes.  Some folds in EXACTF depend on if the runtime target string
4035  *      is UTF-8 or not.  (regatom() will create an EXACTFU node even under /di
4036  *      when no fold in it depends on the UTF-8ness of the target string.)
4037  *
4038  * 3)   A problem remains for unfolded multi-char folds. (These occur when the
4039  *      validity of the fold won't be known until runtime, and so must remain
4040  *      unfolded for now.  This happens for the sharp s in EXACTF and EXACTFAA
4041  *      nodes when the pattern isn't in UTF-8.  (Note, BTW, that there cannot
4042  *      be an EXACTF node with a UTF-8 pattern.)  They also occur for various
4043  *      folds in EXACTFL nodes, regardless of the UTF-ness of the pattern.)
4044  *      The reason this is a problem is that the optimizer part of regexec.c
4045  *      (probably unwittingly, in Perl_regexec_flags()) makes an assumption
4046  *      that a character in the pattern corresponds to at most a single
4047  *      character in the target string.  (And I do mean character, and not byte
4048  *      here, unlike other parts of the documentation that have never been
4049  *      updated to account for multibyte Unicode.)  Sharp s in EXACTF and
4050  *      EXACTFL nodes can match the two character string 'ss'; in EXACTFAA
4051  *      nodes it can match "\x{17F}\x{17F}".  These, along with other ones in
4052  *      EXACTFL nodes, violate the assumption, and they are the only instances
4053  *      where it is violated.  I'm reluctant to try to change the assumption,
4054  *      as the code involved is impenetrable to me (khw), so instead the code
4055  *      here punts.  This routine examines EXACTFL nodes, and (when the pattern
4056  *      isn't UTF-8) EXACTF and EXACTFAA for such unfolded folds, and returns a
4057  *      boolean indicating whether or not the node contains such a fold.  When
4058  *      it is true, the caller sets a flag that later causes the optimizer in
4059  *      this file to not set values for the floating and fixed string lengths,
4060  *      and thus avoids the optimizer code in regexec.c that makes the invalid
4061  *      assumption.  Thus, there is no optimization based on string lengths for
4062  *      EXACTFL nodes that contain these few folds, nor for non-UTF8-pattern
4063  *      EXACTF and EXACTFAA nodes that contain the sharp s.  (The reason the
4064  *      assumption is wrong only in these cases is that all other non-UTF-8
4065  *      folds are 1-1; and, for UTF-8 patterns, we pre-fold all other folds to
4066  *      their expanded versions.  (Again, we can't prefold sharp s to 'ss' in
4067  *      EXACTF nodes because we don't know at compile time if it actually
4068  *      matches 'ss' or not.  For EXACTF nodes it will match iff the target
4069  *      string is in UTF-8.  This is in contrast to EXACTFU nodes, where it
4070  *      always matches; and EXACTFAA where it never does.  In an EXACTFAA node
4071  *      in a UTF-8 pattern, sharp s is folded to "\x{17F}\x{17F}, avoiding the
4072  *      problem; but in a non-UTF8 pattern, folding it to that above-Latin1
4073  *      string would require the pattern to be forced into UTF-8, the overhead
4074  *      of which we want to avoid.  Similarly the unfolded multi-char folds in
4075  *      EXACTFL nodes will match iff the locale at the time of match is a UTF-8
4076  *      locale.)
4077  *
4078  *      Similarly, the code that generates tries doesn't currently handle
4079  *      not-already-folded multi-char folds, and it looks like a pain to change
4080  *      that.  Therefore, trie generation of EXACTFAA nodes with the sharp s
4081  *      doesn't work.  Instead, such an EXACTFAA is turned into a new regnode,
4082  *      EXACTFAA_NO_TRIE, which the trie code knows not to handle.  Most people
4083  *      using /iaa matching will be doing so almost entirely with ASCII
4084  *      strings, so this should rarely be encountered in practice */
4085
4086 STATIC U32
4087 S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan,
4088                    UV *min_subtract, bool *unfolded_multi_char,
4089                    U32 flags, regnode *val, U32 depth)
4090 {
4091     /* Merge several consecutive EXACTish nodes into one. */
4092
4093     regnode *n = regnext(scan);
4094     U32 stringok = 1;
4095     regnode *next = scan + NODE_SZ_STR(scan);
4096     U32 merged = 0;
4097     U32 stopnow = 0;
4098 #ifdef DEBUGGING
4099     regnode *stop = scan;
4100     DECLARE_AND_GET_RE_DEBUG_FLAGS;
4101 #else
4102     PERL_UNUSED_ARG(depth);
4103 #endif
4104
4105     PERL_ARGS_ASSERT_JOIN_EXACT;
4106 #ifndef EXPERIMENTAL_INPLACESCAN
4107     PERL_UNUSED_ARG(flags);
4108     PERL_UNUSED_ARG(val);
4109 #endif
4110     DEBUG_PEEP("join", scan, depth, 0);
4111
4112     assert(PL_regkind[OP(scan)] == EXACT);
4113
4114     /* Look through the subsequent nodes in the chain.  Skip NOTHING, merge
4115      * EXACT ones that are mergeable to the current one. */
4116     while (    n
4117            && (    PL_regkind[OP(n)] == NOTHING
4118                || (stringok && PL_regkind[OP(n)] == EXACT))
4119            && NEXT_OFF(n)
4120            && NEXT_OFF(scan) + NEXT_OFF(n) < I16_MAX)
4121     {
4122
4123         if (OP(n) == TAIL || n > next)
4124             stringok = 0;
4125         if (PL_regkind[OP(n)] == NOTHING) {
4126             DEBUG_PEEP("skip:", n, depth, 0);
4127             NEXT_OFF(scan) += NEXT_OFF(n);
4128             next = n + NODE_STEP_REGNODE;
4129 #ifdef DEBUGGING
4130             if (stringok)
4131                 stop = n;
4132 #endif
4133             n = regnext(n);
4134         }
4135         else if (stringok) {
4136             const unsigned int oldl = STR_LEN(scan);
4137             regnode * const nnext = regnext(n);
4138
4139             /* XXX I (khw) kind of doubt that this works on platforms (should
4140              * Perl ever run on one) where U8_MAX is above 255 because of lots
4141              * of other assumptions */
4142             /* Don't join if the sum can't fit into a single node */
4143             if (oldl + STR_LEN(n) > U8_MAX)
4144                 break;
4145
4146             /* Joining something that requires UTF-8 with something that
4147              * doesn't, means the result requires UTF-8. */
4148             if (OP(scan) == EXACT && (OP(n) == EXACT_REQ8)) {
4149                 OP(scan) = EXACT_REQ8;
4150             }
4151             else if (OP(scan) == EXACT_REQ8 && (OP(n) == EXACT)) {
4152                 ;   /* join is compatible, no need to change OP */
4153             }
4154             else if ((OP(scan) == EXACTFU) && (OP(n) == EXACTFU_REQ8)) {
4155                 OP(scan) = EXACTFU_REQ8;
4156             }
4157             else if ((OP(scan) == EXACTFU_REQ8) && (OP(n) == EXACTFU)) {
4158                 ;   /* join is compatible, no need to change OP */
4159             }
4160             else if (OP(scan) == EXACTFU && OP(n) == EXACTFU) {
4161                 ;   /* join is compatible, no need to change OP */
4162             }
4163             else if (OP(scan) == EXACTFU && OP(n) == EXACTFU_S_EDGE) {
4164
4165                  /* Under /di, temporary EXACTFU_S_EDGE nodes are generated,
4166                   * which can join with EXACTFU ones.  We check for this case
4167                   * here.  These need to be resolved to either EXACTFU or
4168                   * EXACTF at joining time.  They have nothing in them that
4169                   * would forbid them from being the more desirable EXACTFU
4170                   * nodes except that they begin and/or end with a single [Ss].
4171                   * The reason this is problematic is because they could be
4172                   * joined in this loop with an adjacent node that ends and/or
4173                   * begins with [Ss] which would then form the sequence 'ss',
4174                   * which matches differently under /di than /ui, in which case
4175                   * EXACTFU can't be used.  If the 'ss' sequence doesn't get
4176                   * formed, the nodes get absorbed into any adjacent EXACTFU
4177                   * node.  And if the only adjacent node is EXACTF, they get
4178                   * absorbed into that, under the theory that a longer node is
4179                   * better than two shorter ones, even if one is EXACTFU.  Note
4180                   * that EXACTFU_REQ8 is generated only for UTF-8 patterns,
4181                   * and the EXACTFU_S_EDGE ones only for non-UTF-8.  */
4182
4183                 if (STRING(n)[STR_LEN(n)-1] == 's') {
4184
4185                     /* Here the joined node would end with 's'.  If the node
4186                      * following the combination is an EXACTF one, it's better to
4187                      * join this trailing edge 's' node with that one, leaving the
4188                      * current one in 'scan' be the more desirable EXACTFU */
4189                     if (OP(nnext) == EXACTF) {
4190                         break;
4191                     }
4192
4193                     OP(scan) = EXACTFU_S_EDGE;
4194
4195                 }   /* Otherwise, the beginning 's' of the 2nd node just
4196                        becomes an interior 's' in 'scan' */
4197             }
4198             else if (OP(scan) == EXACTF && OP(n) == EXACTF) {
4199                 ;   /* join is compatible, no need to change OP */
4200             }
4201             else if (OP(scan) == EXACTF && OP(n) == EXACTFU_S_EDGE) {
4202
4203                 /* EXACTF nodes are compatible for joining with EXACTFU_S_EDGE
4204                  * nodes.  But the latter nodes can be also joined with EXACTFU
4205                  * ones, and that is a better outcome, so if the node following
4206                  * 'n' is EXACTFU, quit now so that those two can be joined
4207                  * later */
4208                 if (OP(nnext) == EXACTFU) {
4209                     break;
4210                 }
4211
4212                 /* The join is compatible, and the combined node will be
4213                  * EXACTF.  (These don't care if they begin or end with 's' */
4214             }
4215             else if (OP(scan) == EXACTFU_S_EDGE && OP(n) == EXACTFU_S_EDGE) {
4216                 if (   STRING(scan)[STR_LEN(scan)-1] == 's'
4217                     && STRING(n)[0] == 's')
4218                 {
4219                     /* When combined, we have the sequence 'ss', which means we
4220                      * have to remain /di */
4221                     OP(scan) = EXACTF;
4222                 }
4223             }
4224             else if (OP(scan) == EXACTFU_S_EDGE && OP(n) == EXACTFU) {
4225                 if (STRING(n)[0] == 's') {
4226                     ;   /* Here the join is compatible and the combined node
4227                            starts with 's', no need to change OP */
4228                 }
4229                 else {  /* Now the trailing 's' is in the interior */
4230                     OP(scan) = EXACTFU;
4231                 }
4232             }
4233             else if (OP(scan) == EXACTFU_S_EDGE && OP(n) == EXACTF) {
4234
4235                 /* The join is compatible, and the combined node will be
4236                  * EXACTF.  (These don't care if they begin or end with 's' */
4237                 OP(scan) = EXACTF;
4238             }
4239             else if (OP(scan) != OP(n)) {
4240
4241                 /* The only other compatible joinings are the same node type */
4242                 break;
4243             }
4244
4245             DEBUG_PEEP("merg", n, depth, 0);
4246             merged++;
4247
4248             NEXT_OFF(scan) += NEXT_OFF(n);
4249             assert( ( STR_LEN(scan) + STR_LEN(n) ) < 256 );
4250             setSTR_LEN(scan, (U8)(STR_LEN(scan) + STR_LEN(n)));
4251             next = n + NODE_SZ_STR(n);
4252             /* Now we can overwrite *n : */
4253             Move(STRING(n), STRING(scan) + oldl, STR_LEN(n), char);
4254 #ifdef DEBUGGING
4255             stop = next - 1;
4256 #endif
4257             n = nnext;
4258             if (stopnow) break;
4259         }
4260
4261 #ifdef EXPERIMENTAL_INPLACESCAN
4262         if (flags && !NEXT_OFF(n)) {
4263             DEBUG_PEEP("atch", val, depth, 0);
4264             if (reg_off_by_arg[OP(n)]) {
4265                 ARG_SET(n, val - n);
4266             }
4267             else {
4268                 NEXT_OFF(n) = val - n;
4269             }
4270             stopnow = 1;
4271         }
4272 #endif
4273     }
4274
4275     /* This temporary node can now be turned into EXACTFU, and must, as
4276      * regexec.c doesn't handle it */
4277     if (OP(scan) == EXACTFU_S_EDGE) {
4278         OP(scan) = EXACTFU;
4279     }
4280
4281     *min_subtract = 0;
4282     *unfolded_multi_char = FALSE;
4283
4284     /* Here, all the adjacent mergeable EXACTish nodes have been merged.  We
4285      * can now analyze for sequences of problematic code points.  (Prior to
4286      * this final joining, sequences could have been split over boundaries, and
4287      * hence missed).  The sequences only happen in folding, hence for any
4288      * non-EXACT EXACTish node */
4289     if (OP(scan) != EXACT && OP(scan) != EXACT_REQ8 && OP(scan) != EXACTL) {
4290         U8* s0 = (U8*) STRING(scan);
4291         U8* s = s0;
4292         U8* s_end = s0 + STR_LEN(scan);
4293
4294         int total_count_delta = 0;  /* Total delta number of characters that
4295                                        multi-char folds expand to */
4296
4297         /* One pass is made over the node's string looking for all the
4298          * possibilities.  To avoid some tests in the loop, there are two main
4299          * cases, for UTF-8 patterns (which can't have EXACTF nodes) and
4300          * non-UTF-8 */
4301         if (UTF) {
4302             U8* folded = NULL;
4303
4304             if (OP(scan) == EXACTFL) {
4305                 U8 *d;
4306
4307                 /* An EXACTFL node would already have been changed to another
4308                  * node type unless there is at least one character in it that
4309                  * is problematic; likely a character whose fold definition
4310                  * won't be known until runtime, and so has yet to be folded.
4311                  * For all but the UTF-8 locale, folds are 1-1 in length, but
4312                  * to handle the UTF-8 case, we need to create a temporary
4313                  * folded copy using UTF-8 locale rules in order to analyze it.
4314                  * This is because our macros that look to see if a sequence is
4315                  * a multi-char fold assume everything is folded (otherwise the
4316                  * tests in those macros would be too complicated and slow).
4317                  * Note that here, the non-problematic folds will have already
4318                  * been done, so we can just copy such characters.  We actually
4319                  * don't completely fold the EXACTFL string.  We skip the
4320                  * unfolded multi-char folds, as that would just create work
4321                  * below to figure out the size they already are */
4322
4323                 Newx(folded, UTF8_MAX_FOLD_CHAR_EXPAND * STR_LEN(scan) + 1, U8);
4324                 d = folded;
4325                 while (s < s_end) {
4326                     STRLEN s_len = UTF8SKIP(s);
4327                     if (! is_PROBLEMATIC_LOCALE_FOLD_utf8(s)) {
4328                         Copy(s, d, s_len, U8);
4329                         d += s_len;
4330                     }
4331                     else if (is_FOLDS_TO_MULTI_utf8(s)) {
4332                         *unfolded_multi_char = TRUE;
4333                         Copy(s, d, s_len, U8);
4334                         d += s_len;
4335                     }
4336                     else if (isASCII(*s)) {
4337                         *(d++) = toFOLD(*s);
4338                     }
4339                     else {
4340                         STRLEN len;
4341                         _toFOLD_utf8_flags(s, s_end, d, &len, FOLD_FLAGS_FULL);
4342                         d += len;
4343                     }
4344                     s += s_len;
4345                 }
4346
4347                 /* Point the remainder of the routine to look at our temporary
4348                  * folded copy */
4349                 s = folded;
4350                 s_end = d;
4351             } /* End of creating folded copy of EXACTFL string */
4352
4353             /* Examine the string for a multi-character fold sequence.  UTF-8
4354              * patterns have all characters pre-folded by the time this code is
4355              * executed */
4356             while (s < s_end - 1) /* Can stop 1 before the end, as minimum
4357                                      length sequence we are looking for is 2 */
4358             {
4359                 int count = 0;  /* How many characters in a multi-char fold */
4360                 int len = is_MULTI_CHAR_FOLD_utf8_safe(s, s_end);
4361                 if (! len) {    /* Not a multi-char fold: get next char */
4362                     s += UTF8SKIP(s);
4363                     continue;
4364                 }
4365
4366                 { /* Here is a generic multi-char fold. */
4367                     U8* multi_end  = s + len;
4368
4369                     /* Count how many characters are in it.  In the case of
4370                      * /aa, no folds which contain ASCII code points are
4371                      * allowed, so check for those, and skip if found. */
4372                     if (OP(scan) != EXACTFAA && OP(scan) != EXACTFAA_NO_TRIE) {
4373                         count = utf8_length(s, multi_end);
4374                         s = multi_end;
4375                     }
4376                     else {
4377                         while (s < multi_end) {
4378                             if (isASCII(*s)) {
4379                                 s++;
4380                                 goto next_iteration;
4381                             }
4382                             else {
4383                                 s += UTF8SKIP(s);
4384                             }
4385                             count++;
4386                         }
4387                     }
4388                 }
4389
4390                 /* The delta is how long the sequence is minus 1 (1 is how long
4391                  * the character that folds to the sequence is) */
4392                 total_count_delta += count - 1;
4393               next_iteration: ;
4394             }
4395
4396             /* We created a temporary folded copy of the string in EXACTFL
4397              * nodes.  Therefore we need to be sure it doesn't go below zero,
4398              * as the real string could be shorter */
4399             if (OP(scan) == EXACTFL) {
4400                 int total_chars = utf8_length((U8*) STRING(scan),
4401                                            (U8*) STRING(scan) + STR_LEN(scan));
4402                 if (total_count_delta > total_chars) {
4403                     total_count_delta = total_chars;
4404                 }
4405             }
4406
4407             *min_subtract += total_count_delta;
4408             Safefree(folded);
4409         }
4410         else if (OP(scan) == EXACTFAA) {
4411
4412             /* Non-UTF-8 pattern, EXACTFAA node.  There can't be a multi-char
4413              * fold to the ASCII range (and there are no existing ones in the
4414              * upper latin1 range).  But, as outlined in the comments preceding
4415              * this function, we need to flag any occurrences of the sharp s.
4416              * This character forbids trie formation (because of added
4417              * complexity) */
4418 #if    UNICODE_MAJOR_VERSION > 3 /* no multifolds in early Unicode */   \
4419    || (UNICODE_MAJOR_VERSION == 3 && (   UNICODE_DOT_VERSION > 0)       \
4420                                       || UNICODE_DOT_DOT_VERSION > 0)
4421             while (s < s_end) {
4422                 if (*s == LATIN_SMALL_LETTER_SHARP_S) {
4423                     OP(scan) = EXACTFAA_NO_TRIE;
4424                     *unfolded_multi_char = TRUE;
4425                     break;
4426                 }
4427                 s++;
4428             }
4429         }
4430         else if (OP(scan) != EXACTFAA_NO_TRIE) {
4431
4432             /* Non-UTF-8 pattern, not EXACTFAA node.  Look for the multi-char
4433              * folds that are all Latin1.  As explained in the comments
4434              * preceding this function, we look also for the sharp s in EXACTF
4435              * and EXACTFL nodes; it can be in the final position.  Otherwise
4436              * we can stop looking 1 byte earlier because have to find at least
4437              * two characters for a multi-fold */
4438             const U8* upper = (OP(scan) == EXACTF || OP(scan) == EXACTFL)
4439                               ? s_end
4440                               : s_end -1;
4441
4442             while (s < upper) {
4443                 int len = is_MULTI_CHAR_FOLD_latin1_safe(s, s_end);
4444                 if (! len) {    /* Not a multi-char fold. */
4445                     if (*s == LATIN_SMALL_LETTER_SHARP_S
4446                         && (OP(scan) == EXACTF || OP(scan) == EXACTFL))
4447                     {
4448                         *unfolded_multi_char = TRUE;
4449                     }
4450                     s++;
4451                     continue;
4452                 }
4453
4454                 if (len == 2
4455                     && isALPHA_FOLD_EQ(*s, 's')
4456                     && isALPHA_FOLD_EQ(*(s+1), 's'))
4457                 {
4458
4459                     /* EXACTF nodes need to know that the minimum length
4460                      * changed so that a sharp s in the string can match this
4461                      * ss in the pattern, but they remain EXACTF nodes, as they
4462                      * won't match this unless the target string is in UTF-8,
4463                      * which we don't know until runtime.  EXACTFL nodes can't
4464                      * transform into EXACTFU nodes */
4465                     if (OP(scan) != EXACTF && OP(scan) != EXACTFL) {
4466                         OP(scan) = EXACTFUP;
4467                     }
4468                 }
4469
4470                 *min_subtract += len - 1;
4471                 s += len;
4472             }
4473 #endif
4474         }
4475     }
4476
4477 #ifdef DEBUGGING
4478     /* Allow dumping but overwriting the collection of skipped
4479      * ops and/or strings with fake optimized ops */
4480     n = scan + NODE_SZ_STR(scan);
4481     while (n <= stop) {
4482         OP(n) = OPTIMIZED;
4483         FLAGS(n) = 0;
4484         NEXT_OFF(n) = 0;
4485         n++;
4486     }
4487 #endif
4488     DEBUG_OPTIMISE_r(if (merged){DEBUG_PEEP("finl", scan, depth, 0);});
4489     return stopnow;
4490 }
4491
4492 /* REx optimizer.  Converts nodes into quicker variants "in place".
4493    Finds fixed substrings.  */
4494
4495 /* Stops at toplevel WHILEM as well as at "last". At end *scanp is set
4496    to the position after last scanned or to NULL. */
4497
4498 #define INIT_AND_WITHP \
4499     assert(!and_withp); \
4500     Newx(and_withp, 1, regnode_ssc); \
4501     SAVEFREEPV(and_withp)
4502
4503
4504 static void
4505 S_unwind_scan_frames(pTHX_ const void *p)
4506 {
4507     scan_frame *f= (scan_frame *)p;
4508     do {
4509         scan_frame *n= f->next_frame;
4510         Safefree(f);
4511         f= n;
4512     } while (f);
4513 }
4514
4515 /* Follow the next-chain of the current node and optimize away
4516    all the NOTHINGs from it.
4517  */
4518 STATIC void
4519 S_rck_elide_nothing(pTHX_ regnode *node)
4520 {
4521     PERL_ARGS_ASSERT_RCK_ELIDE_NOTHING;
4522
4523     if (OP(node) != CURLYX) {
4524         const int max = (reg_off_by_arg[OP(node)]
4525                         ? I32_MAX
4526                           /* I32 may be smaller than U16 on CRAYs! */
4527                         : (I32_MAX < U16_MAX ? I32_MAX : U16_MAX));
4528         int off = (reg_off_by_arg[OP(node)] ? ARG(node) : NEXT_OFF(node));
4529         int noff;
4530         regnode *n = node;
4531
4532         /* Skip NOTHING and LONGJMP. */
4533         while (
4534             (n = regnext(n))
4535             && (
4536                 (PL_regkind[OP(n)] == NOTHING && (noff = NEXT_OFF(n)))
4537                 || ((OP(n) == LONGJMP) && (noff = ARG(n)))
4538             )
4539             && off + noff < max
4540         ) {
4541             off += noff;
4542         }
4543         if (reg_off_by_arg[OP(node)])
4544             ARG(node) = off;
4545         else
4546             NEXT_OFF(node) = off;
4547     }
4548     return;
4549 }
4550
4551 /* the return from this sub is the minimum length that could possibly match */
4552 STATIC SSize_t
4553 S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
4554                         SSize_t *minlenp, SSize_t *deltap,
4555                         regnode *last,
4556                         scan_data_t *data,
4557                         I32 stopparen,
4558                         U32 recursed_depth,
4559                         regnode_ssc *and_withp,
4560                         U32 flags, U32 depth, bool was_mutate_ok)
4561                         /* scanp: Start here (read-write). */
4562                         /* deltap: Write maxlen-minlen here. */
4563                         /* last: Stop before this one. */
4564                         /* data: string data about the pattern */
4565                         /* stopparen: treat close N as END */
4566                         /* recursed: which subroutines have we recursed into */
4567                         /* and_withp: Valid if flags & SCF_DO_STCLASS_OR */
4568 {
4569     SSize_t final_minlen;
4570     /* There must be at least this number of characters to match */
4571     SSize_t min = 0;
4572     I32 pars = 0, code;
4573     regnode *scan = *scanp, *next;
4574     SSize_t delta = 0;
4575     int is_inf = (flags & SCF_DO_SUBSTR) && (data->flags & SF_IS_INF);
4576     int is_inf_internal = 0;            /* The studied chunk is infinite */
4577     I32 is_par = OP(scan) == OPEN ? ARG(scan) : 0;
4578     scan_data_t data_fake;
4579     SV *re_trie_maxbuff = NULL;
4580     regnode *first_non_open = scan;
4581     SSize_t stopmin = OPTIMIZE_INFTY;
4582     scan_frame *frame = NULL;
4583     DECLARE_AND_GET_RE_DEBUG_FLAGS;
4584
4585     PERL_ARGS_ASSERT_STUDY_CHUNK;
4586     RExC_study_started= 1;
4587
4588     Zero(&data_fake, 1, scan_data_t);
4589
4590     if ( depth == 0 ) {
4591         while (first_non_open && OP(first_non_open) == OPEN)
4592             first_non_open=regnext(first_non_open);
4593     }
4594
4595
4596   fake_study_recurse:
4597     DEBUG_r(
4598         RExC_study_chunk_recursed_count++;
4599     );
4600     DEBUG_OPTIMISE_MORE_r(
4601     {
4602         Perl_re_indentf( aTHX_  "study_chunk stopparen=%ld recursed_count=%lu depth=%lu recursed_depth=%lu scan=%p last=%p",
4603             depth, (long)stopparen,
4604             (unsigned long)RExC_study_chunk_recursed_count,
4605             (unsigned long)depth, (unsigned long)recursed_depth,
4606             scan,
4607             last);
4608         if (recursed_depth) {
4609             U32 i;
4610             U32 j;
4611             for ( j = 0 ; j < recursed_depth ; j++ ) {
4612                 for ( i = 0 ; i < (U32)RExC_total_parens ; i++ ) {
4613                     if (PAREN_TEST(j, i) && (!j || !PAREN_TEST(j - 1, i))) {
4614                         Perl_re_printf( aTHX_ " %d",(int)i);
4615                         break;
4616                     }
4617                 }
4618                 if ( j + 1 < recursed_depth ) {
4619                     Perl_re_printf( aTHX_  ",");
4620                 }
4621             }
4622         }
4623         Perl_re_printf( aTHX_ "\n");
4624     }
4625     );
4626     while ( scan && OP(scan) != END && scan < last ){
4627         UV min_subtract = 0;    /* How mmany chars to subtract from the minimum
4628                                    node length to get a real minimum (because
4629                                    the folded version may be shorter) */
4630         bool unfolded_multi_char = FALSE;
4631         /* avoid mutating ops if we are anywhere within the recursed or
4632          * enframed handling for a GOSUB: the outermost level will handle it.
4633          */
4634         bool mutate_ok = was_mutate_ok && !(frame && frame->in_gosub);
4635         /* Peephole optimizer: */
4636         DEBUG_STUDYDATA("Peep", data, depth, is_inf);
4637         DEBUG_PEEP("Peep", scan, depth, flags);
4638
4639
4640         /* The reason we do this here is that we need to deal with things like
4641          * /(?:f)(?:o)(?:o)/ which cant be dealt with by the normal EXACT
4642          * parsing code, as each (?:..) is handled by a different invocation of
4643          * reg() -- Yves
4644          */
4645         if (PL_regkind[OP(scan)] == EXACT
4646             && OP(scan) != LEXACT
4647             && OP(scan) != LEXACT_REQ8
4648             && mutate_ok
4649         ) {
4650             join_exact(pRExC_state, scan, &min_subtract, &unfolded_multi_char,
4651                     0, NULL, depth + 1);
4652         }
4653
4654         /* Follow the next-chain of the current node and optimize
4655            away all the NOTHINGs from it.
4656          */
4657         rck_elide_nothing(scan);
4658
4659         /* The principal pseudo-switch.  Cannot be a switch, since we look into
4660          * several different things.  */
4661         if ( OP(scan) == DEFINEP ) {
4662             SSize_t minlen = 0;
4663             SSize_t deltanext = 0;
4664             SSize_t fake_last_close = 0;
4665             I32 f = SCF_IN_DEFINE;
4666
4667             StructCopy(&zero_scan_data, &data_fake, scan_data_t);
4668             scan = regnext(scan);
4669             assert( OP(scan) == IFTHEN );
4670             DEBUG_PEEP("expect IFTHEN", scan, depth, flags);
4671
4672             data_fake.last_closep= &fake_last_close;
4673             minlen = *minlenp;
4674             next = regnext(scan);
4675             scan = NEXTOPER(NEXTOPER(scan));
4676             DEBUG_PEEP("scan", scan, depth, flags);
4677             DEBUG_PEEP("next", next, depth, flags);
4678
4679             /* we suppose the run is continuous, last=next...
4680              * NOTE we dont use the return here! */
4681             /* DEFINEP study_chunk() recursion */
4682             (void)study_chunk(pRExC_state, &scan, &minlen,
4683                               &deltanext, next, &data_fake, stopparen,
4684                               recursed_depth, NULL, f, depth+1, mutate_ok);
4685
4686             scan = next;
4687         } else
4688         if (
4689             OP(scan) == BRANCH  ||
4690             OP(scan) == BRANCHJ ||
4691             OP(scan) == IFTHEN
4692         ) {
4693             next = regnext(scan);
4694             code = OP(scan);
4695
4696             /* The op(next)==code check below is to see if we
4697              * have "BRANCH-BRANCH", "BRANCHJ-BRANCHJ", "IFTHEN-IFTHEN"
4698              * IFTHEN is special as it might not appear in pairs.
4699              * Not sure whether BRANCH-BRANCHJ is possible, regardless
4700              * we dont handle it cleanly. */
4701             if (OP(next) == code || code == IFTHEN) {
4702                 /* NOTE - There is similar code to this block below for
4703                  * handling TRIE nodes on a re-study.  If you change stuff here
4704                  * check there too. */
4705                 SSize_t max1 = 0, min1 = OPTIMIZE_INFTY, num = 0;
4706                 regnode_ssc accum;
4707                 regnode * const startbranch=scan;
4708
4709                 if (flags & SCF_DO_SUBSTR) {
4710                     /* Cannot merge strings after this. */
4711                     scan_commit(pRExC_state, data, minlenp, is_inf);
4712                 }
4713
4714                 if (flags & SCF_DO_STCLASS)
4715                     ssc_init_zero(pRExC_state, &accum);
4716
4717                 while (OP(scan) == code) {
4718                     SSize_t deltanext, minnext, fake;
4719                     I32 f = 0;
4720                     regnode_ssc this_class;
4721
4722                     DEBUG_PEEP("Branch", scan, depth, flags);
4723
4724                     num++;
4725                     StructCopy(&zero_scan_data, &data_fake, scan_data_t);
4726                     if (data) {
4727                         data_fake.whilem_c = data->whilem_c;
4728                         data_fake.last_closep = data->last_closep;
4729                     }
4730                     else
4731                         data_fake.last_closep = &fake;
4732
4733                     data_fake.pos_delta = delta;
4734                     next = regnext(scan);
4735
4736                     scan = NEXTOPER(scan); /* everything */
4737                     if (code != BRANCH)    /* everything but BRANCH */
4738                         scan = NEXTOPER(scan);
4739
4740                     if (flags & SCF_DO_STCLASS) {
4741                         ssc_init(pRExC_state, &this_class);
4742                         data_fake.start_class = &this_class;
4743                         f = SCF_DO_STCLASS_AND;
4744                     }
4745                     if (flags & SCF_WHILEM_VISITED_POS)
4746                         f |= SCF_WHILEM_VISITED_POS;
4747
4748                     /* we suppose the run is continuous, last=next...*/
4749                     /* recurse study_chunk() for each BRANCH in an alternation */
4750                     minnext = study_chunk(pRExC_state, &scan, minlenp,
4751                                       &deltanext, next, &data_fake, stopparen,
4752                                       recursed_depth, NULL, f, depth+1,
4753                                       mutate_ok);
4754
4755                     if (min1 > minnext)
4756                         min1 = minnext;
4757                     if (deltanext == OPTIMIZE_INFTY) {
4758                         is_inf = is_inf_internal = 1;
4759                         max1 = OPTIMIZE_INFTY;
4760                     } else if (max1 < minnext + deltanext)
4761                         max1 = minnext + deltanext;
4762                     scan = next;
4763                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
4764                         pars++;
4765                     if (data_fake.flags & SCF_SEEN_ACCEPT) {
4766                         if ( stopmin > minnext)
4767                             stopmin = min + min1;
4768                         flags &= ~SCF_DO_SUBSTR;
4769                         if (data)
4770                             data->flags |= SCF_SEEN_ACCEPT;
4771                     }
4772                     if (data) {
4773                         if (data_fake.flags & SF_HAS_EVAL)
4774                             data->flags |= SF_HAS_EVAL;
4775                         data->whilem_c = data_fake.whilem_c;
4776                     }
4777                     if (flags & SCF_DO_STCLASS)
4778                         ssc_or(pRExC_state, &accum, (regnode_charclass*)&this_class);
4779                 }
4780                 if (code == IFTHEN && num < 2) /* Empty ELSE branch */
4781                     min1 = 0;
4782                 if (flags & SCF_DO_SUBSTR) {
4783                     data->pos_min += min1;
4784                     if (data->pos_delta >= OPTIMIZE_INFTY - (max1 - min1))
4785                         data->pos_delta = OPTIMIZE_INFTY;
4786                     else
4787                         data->pos_delta += max1 - min1;
4788                     if (max1 != min1 || is_inf)
4789                         data->cur_is_floating = 1;
4790                 }
4791                 min += min1;
4792                 if (delta == OPTIMIZE_INFTY
4793                  || OPTIMIZE_INFTY - delta - (max1 - min1) < 0)
4794                     delta = OPTIMIZE_INFTY;
4795                 else
4796                     delta += max1 - min1;
4797                 if (flags & SCF_DO_STCLASS_OR) {
4798                     ssc_or(pRExC_state, data->start_class, (regnode_charclass*) &accum);
4799                     if (min1) {
4800                         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
4801                         flags &= ~SCF_DO_STCLASS;
4802                     }
4803                 }
4804                 else if (flags & SCF_DO_STCLASS_AND) {
4805                     if (min1) {
4806                         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) &accum);
4807                         flags &= ~SCF_DO_STCLASS;
4808                     }
4809                     else {
4810                         /* Switch to OR mode: cache the old value of
4811                          * data->start_class */
4812                         INIT_AND_WITHP;
4813                         StructCopy(data->start_class, and_withp, regnode_ssc);
4814                         flags &= ~SCF_DO_STCLASS_AND;
4815                         StructCopy(&accum, data->start_class, regnode_ssc);
4816                         flags |= SCF_DO_STCLASS_OR;
4817                     }
4818                 }
4819
4820                 if (PERL_ENABLE_TRIE_OPTIMISATION
4821                     && OP(startbranch) == BRANCH
4822                     && mutate_ok
4823                 ) {
4824                 /* demq.
4825
4826                    Assuming this was/is a branch we are dealing with: 'scan'
4827                    now points at the item that follows the branch sequence,
4828                    whatever it is. We now start at the beginning of the
4829                    sequence and look for subsequences of
4830
4831                    BRANCH->EXACT=>x1
4832                    BRANCH->EXACT=>x2
4833                    tail
4834
4835                    which would be constructed from a pattern like
4836                    /A|LIST|OF|WORDS/
4837
4838                    If we can find such a subsequence we need to turn the first
4839                    element into a trie and then add the subsequent branch exact
4840                    strings to the trie.
4841
4842                    We have two cases
4843
4844                      1. patterns where the whole set of branches can be
4845                         converted.
4846
4847                      2. patterns where only a subset can be converted.
4848
4849                    In case 1 we can replace the whole set with a single regop
4850                    for the trie. In case 2 we need to keep the start and end
4851                    branches so
4852
4853                      'BRANCH EXACT; BRANCH EXACT; BRANCH X'
4854                      becomes BRANCH TRIE; BRANCH X;
4855
4856                   There is an additional case, that being where there is a
4857                   common prefix, which gets split out into an EXACT like node
4858                   preceding the TRIE node.
4859
4860                   If x(1..n)==tail then we can do a simple trie, if not we make
4861                   a "jump" trie, such that when we match the appropriate word
4862                   we "jump" to the appropriate tail node. Essentially we turn
4863                   a nested if into a case structure of sorts.
4864
4865                 */
4866
4867                     int made=0;
4868                     if (!re_trie_maxbuff) {
4869                         re_trie_maxbuff = get_sv(RE_TRIE_MAXBUF_NAME, 1);
4870                         if (!SvIOK(re_trie_maxbuff))
4871                             sv_setiv(re_trie_maxbuff, RE_TRIE_MAXBUF_INIT);
4872                     }
4873                     if ( SvIV(re_trie_maxbuff)>=0  ) {
4874                         regnode *cur;
4875                         regnode *first = (regnode *)NULL;
4876                         regnode *prev = (regnode *)NULL;
4877                         regnode *tail = scan;
4878                         U8 trietype = 0;
4879                         U32 count=0;
4880
4881                         /* var tail is used because there may be a TAIL
4882                            regop in the way. Ie, the exacts will point to the
4883                            thing following the TAIL, but the last branch will
4884                            point at the TAIL. So we advance tail. If we
4885                            have nested (?:) we may have to move through several
4886                            tails.
4887                          */
4888
4889                         while ( OP( tail ) == TAIL ) {
4890                             /* this is the TAIL generated by (?:) */
4891                             tail = regnext( tail );
4892                         }
4893
4894
4895                         DEBUG_TRIE_COMPILE_r({
4896                             regprop(RExC_rx, RExC_mysv, tail, NULL, pRExC_state);
4897                             Perl_re_indentf( aTHX_  "%s %" UVuf ":%s\n",
4898                               depth+1,
4899                               "Looking for TRIE'able sequences. Tail node is ",
4900                               (UV) REGNODE_OFFSET(tail),
4901                               SvPV_nolen_const( RExC_mysv )
4902                             );
4903                         });
4904
4905                         /*
4906
4907                             Step through the branches
4908                                 cur represents each branch,
4909                                 noper is the first thing to be matched as part
4910                                       of that branch
4911                                 noper_next is the regnext() of that node.
4912
4913                             We normally handle a case like this
4914                             /FOO[xyz]|BAR[pqr]/ via a "jump trie" but we also
4915                             support building with NOJUMPTRIE, which restricts
4916                             the trie logic to structures like /FOO|BAR/.
4917
4918                             If noper is a trieable nodetype then the branch is
4919                             a possible optimization target. If we are building
4920                             under NOJUMPTRIE then we require that noper_next is
4921                             the same as scan (our current position in the regex
4922                             program).
4923
4924                             Once we have two or more consecutive such branches
4925                             we can create a trie of the EXACT's contents and
4926                             stitch it in place into the program.
4927
4928                             If the sequence represents all of the branches in
4929                             the alternation we replace the entire thing with a
4930                             single TRIE node.
4931
4932                             Otherwise when it is a subsequence we need to
4933                             stitch it in place and replace only the relevant
4934                             branches. This means the first branch has to remain
4935                             as it is used by the alternation logic, and its
4936                             next pointer, and needs to be repointed at the item
4937                             on the branch chain following the last branch we
4938                             have optimized away.
4939
4940                             This could be either a BRANCH, in which case the
4941                             subsequence is internal, or it could be the item
4942                             following the branch sequence in which case the
4943                             subsequence is at the end (which does not
4944                             necessarily mean the first node is the start of the
4945                             alternation).
4946
4947                             TRIE_TYPE(X) is a define which maps the optype to a
4948                             trietype.
4949
4950                                 optype          |  trietype
4951                                 ----------------+-----------
4952                                 NOTHING         | NOTHING
4953                                 EXACT           | EXACT
4954                                 EXACT_REQ8     | EXACT
4955                                 EXACTFU         | EXACTFU
4956                                 EXACTFU_REQ8   | EXACTFU
4957                                 EXACTFUP        | EXACTFU
4958                                 EXACTFAA        | EXACTFAA
4959                                 EXACTL          | EXACTL
4960                                 EXACTFLU8       | EXACTFLU8
4961
4962
4963                         */
4964 #define TRIE_TYPE(X) ( ( NOTHING == (X) )                                   \
4965                        ? NOTHING                                            \
4966                        : ( EXACT == (X) || EXACT_REQ8 == (X) )             \
4967                          ? EXACT                                            \
4968                          : (     EXACTFU == (X)                             \
4969                               || EXACTFU_REQ8 == (X)                       \
4970                               || EXACTFUP == (X) )                          \
4971                            ? EXACTFU                                        \
4972                            : ( EXACTFAA == (X) )                            \
4973                              ? EXACTFAA                                     \
4974                              : ( EXACTL == (X) )                            \
4975                                ? EXACTL                                     \
4976                                : ( EXACTFLU8 == (X) )                       \
4977                                  ? EXACTFLU8                                \
4978                                  : 0 )
4979
4980                         /* dont use tail as the end marker for this traverse */
4981                         for ( cur = startbranch ; cur != scan ; cur = regnext( cur ) ) {
4982                             regnode * const noper = NEXTOPER( cur );
4983                             U8 noper_type = OP( noper );
4984                             U8 noper_trietype = TRIE_TYPE( noper_type );
4985 #if defined(DEBUGGING) || defined(NOJUMPTRIE)
4986                             regnode * const noper_next = regnext( noper );
4987                             U8 noper_next_type = (noper_next && noper_next < tail) ? OP(noper_next) : 0;
4988                             U8 noper_next_trietype = (noper_next && noper_next < tail) ? TRIE_TYPE( noper_next_type ) :0;
4989 #endif
4990
4991                             DEBUG_TRIE_COMPILE_r({
4992                                 regprop(RExC_rx, RExC_mysv, cur, NULL, pRExC_state);
4993                                 Perl_re_indentf( aTHX_  "- %d:%s (%d)",
4994                                    depth+1,
4995                                    REG_NODE_NUM(cur), SvPV_nolen_const( RExC_mysv ), REG_NODE_NUM(cur) );
4996
4997                                 regprop(RExC_rx, RExC_mysv, noper, NULL, pRExC_state);
4998                                 Perl_re_printf( aTHX_  " -> %d:%s",
4999                                     REG_NODE_NUM(noper), SvPV_nolen_const(RExC_mysv));
5000
5001                                 if ( noper_next ) {
5002                                   regprop(RExC_rx, RExC_mysv, noper_next, NULL, pRExC_state);
5003                                   Perl_re_printf( aTHX_ "\t=> %d:%s\t",
5004                                     REG_NODE_NUM(noper_next), SvPV_nolen_const(RExC_mysv));
5005                                 }
5006                                 Perl_re_printf( aTHX_  "(First==%d,Last==%d,Cur==%d,tt==%s,ntt==%s,nntt==%s)\n",
5007                                    REG_NODE_NUM(first), REG_NODE_NUM(prev), REG_NODE_NUM(cur),
5008                                    PL_reg_name[trietype], PL_reg_name[noper_trietype], PL_reg_name[noper_next_trietype]
5009                                 );
5010                             });
5011
5012                             /* Is noper a trieable nodetype that can be merged
5013                              * with the current trie (if there is one)? */
5014                             if ( noper_trietype
5015                                   &&
5016                                   (
5017                                         ( noper_trietype == NOTHING )
5018                                         || ( trietype == NOTHING )
5019                                         || ( trietype == noper_trietype )
5020                                   )
5021 #ifdef NOJUMPTRIE
5022                                   && noper_next >= tail
5023 #endif
5024                                   && count < U16_MAX)
5025                             {
5026                                 /* Handle mergable triable node Either we are
5027                                  * the first node in a new trieable sequence,
5028                                  * in which case we do some bookkeeping,
5029                                  * otherwise we update the end pointer. */
5030                                 if ( !first ) {
5031                                     first = cur;
5032                                     if ( noper_trietype == NOTHING ) {
5033 #if !defined(DEBUGGING) && !defined(NOJUMPTRIE)
5034                                         regnode * const noper_next = regnext( noper );
5035                                         U8 noper_next_type = (noper_next && noper_next < tail) ? OP(noper_next) : 0;
5036                                         U8 noper_next_trietype = noper_next_type ? TRIE_TYPE( noper_next_type ) :0;
5037 #endif
5038
5039                                         if ( noper_next_trietype ) {
5040                                             trietype = noper_next_trietype;
5041                                         } else if (noper_next_type)  {
5042                                             /* a NOTHING regop is 1 regop wide.
5043                                              * We need at least two for a trie
5044                                              * so we can't merge this in */
5045                                             first = NULL;
5046                                         }
5047                                     } else {
5048                                         trietype = noper_trietype;
5049                                     }
5050                                 } else {
5051                                     if ( trietype == NOTHING )
5052                                         trietype = noper_trietype;
5053                                     prev = cur;
5054                                 }
5055                                 if (first)
5056                                     count++;
5057                             } /* end handle mergable triable node */
5058                             else {
5059                                 /* handle unmergable node -
5060                                  * noper may either be a triable node which can
5061                                  * not be tried together with the current trie,
5062                                  * or a non triable node */
5063                                 if ( prev ) {
5064                                     /* If last is set and trietype is not
5065                                      * NOTHING then we have found at least two
5066                                      * triable branch sequences in a row of a
5067                                      * similar trietype so we can turn them
5068                                      * into a trie. If/when we allow NOTHING to
5069                                      * start a trie sequence this condition
5070                                      * will be required, and it isn't expensive
5071                                      * so we leave it in for now. */
5072                                     if ( trietype && trietype != NOTHING )
5073                                         make_trie( pRExC_state,
5074                                                 startbranch, first, cur, tail,
5075                                                 count, trietype, depth+1 );
5076                                     prev = NULL; /* note: we clear/update
5077                                                     first, trietype etc below,
5078                                                     so we dont do it here */
5079                                 }
5080                                 if ( noper_trietype
5081 #ifdef NOJUMPTRIE
5082                                      && noper_next >= tail
5083 #endif
5084                                 ){
5085                                     /* noper is triable, so we can start a new
5086                                      * trie sequence */
5087                                     count = 1;
5088                                     first = cur;
5089                                     trietype = noper_trietype;
5090                                 } else if (first) {
5091                                     /* if we already saw a first but the
5092                                      * current node is not triable then we have
5093                                      * to reset the first information. */
5094                                     count = 0;
5095                                     first = NULL;
5096                                     trietype = 0;
5097                                 }
5098                             } /* end handle unmergable node */
5099                         } /* loop over branches */
5100                         DEBUG_TRIE_COMPILE_r({
5101                             regprop(RExC_rx, RExC_mysv, cur, NULL, pRExC_state);
5102                             Perl_re_indentf( aTHX_  "- %s (%d) <SCAN FINISHED> ",
5103                               depth+1, SvPV_nolen_const( RExC_mysv ), REG_NODE_NUM(cur));
5104                             Perl_re_printf( aTHX_  "(First==%d, Last==%d, Cur==%d, tt==%s)\n",
5105                                REG_NODE_NUM(first), REG_NODE_NUM(prev), REG_NODE_NUM(cur),
5106                                PL_reg_name[trietype]
5107                             );
5108
5109                         });
5110                         if ( prev && trietype ) {
5111                             if ( trietype != NOTHING ) {
5112                                 /* the last branch of the sequence was part of
5113                                  * a trie, so we have to construct it here
5114                                  * outside of the loop */
5115                                 made= make_trie( pRExC_state, startbranch,
5116                                                  first, scan, tail, count,
5117                                                  trietype, depth+1 );
5118 #ifdef TRIE_STUDY_OPT
5119                                 if ( ((made == MADE_EXACT_TRIE &&
5120                                      startbranch == first)
5121                                      || ( first_non_open == first )) &&
5122                                      depth==0 ) {
5123                                     flags |= SCF_TRIE_RESTUDY;
5124                                     if ( startbranch == first
5125                                          && scan >= tail )
5126                                     {
5127                                         RExC_seen &=~REG_TOP_LEVEL_BRANCHES_SEEN;
5128                                     }
5129                                 }
5130 #endif
5131                             } else {
5132                                 /* at this point we know whatever we have is a
5133                                  * NOTHING sequence/branch AND if 'startbranch'
5134                                  * is 'first' then we can turn the whole thing
5135                                  * into a NOTHING
5136                                  */
5137                                 if ( startbranch == first ) {
5138                                     regnode *opt;
5139                                     /* the entire thing is a NOTHING sequence,
5140                                      * something like this: (?:|) So we can
5141                                      * turn it into a plain NOTHING op. */
5142                                     DEBUG_TRIE_COMPILE_r({
5143                                         regprop(RExC_rx, RExC_mysv, cur, NULL, pRExC_state);
5144                                         Perl_re_indentf( aTHX_  "- %s (%d) <NOTHING BRANCH SEQUENCE>\n",
5145                                           depth+1,
5146                                           SvPV_nolen_const( RExC_mysv ), REG_NODE_NUM(cur));
5147
5148                                     });
5149                                     OP(startbranch)= NOTHING;
5150                                     NEXT_OFF(startbranch)= tail - startbranch;
5151                                     for ( opt= startbranch + 1; opt < tail ; opt++ )
5152                                         OP(opt)= OPTIMIZED;
5153                                 }
5154                             }
5155                         } /* end if ( prev) */
5156                     } /* TRIE_MAXBUF is non zero */
5157                 } /* do trie */
5158
5159             }
5160             else if ( code == BRANCHJ ) {  /* single branch is optimized. */
5161                 scan = NEXTOPER(NEXTOPER(scan));
5162             } else                      /* single branch is optimized. */
5163                 scan = NEXTOPER(scan);
5164             continue;
5165         } else if (OP(scan) == SUSPEND || OP(scan) == GOSUB) {
5166             I32 paren = 0;
5167             regnode *start = NULL;
5168             regnode *end = NULL;
5169             U32 my_recursed_depth= recursed_depth;
5170
5171             if (OP(scan) != SUSPEND) { /* GOSUB */
5172                 /* Do setup, note this code has side effects beyond
5173                  * the rest of this block. Specifically setting
5174                  * RExC_recurse[] must happen at least once during
5175                  * study_chunk(). */
5176                 paren = ARG(scan);
5177                 RExC_recurse[ARG2L(scan)] = scan;
5178                 start = REGNODE_p(RExC_open_parens[paren]);
5179                 end   = REGNODE_p(RExC_close_parens[paren]);
5180
5181                 /* NOTE we MUST always execute the above code, even
5182                  * if we do nothing with a GOSUB */
5183                 if (
5184                     ( flags & SCF_IN_DEFINE )
5185                     ||
5186                     (
5187                         (is_inf_internal || is_inf || (data && data->flags & SF_IS_INF))
5188                         &&
5189                         ( (flags & (SCF_DO_STCLASS | SCF_DO_SUBSTR)) == 0 )
5190                     )
5191                 ) {
5192                     /* no need to do anything here if we are in a define. */
5193                     /* or we are after some kind of infinite construct
5194                      * so we can skip recursing into this item.
5195                      * Since it is infinite we will not change the maxlen
5196                      * or delta, and if we miss something that might raise
5197                      * the minlen it will merely pessimise a little.
5198                      *
5199                      * Iow /(?(DEFINE)(?<foo>foo|food))a+(?&foo)/
5200                      * might result in a minlen of 1 and not of 4,
5201                      * but this doesn't make us mismatch, just try a bit
5202                      * harder than we should.
5203                      *
5204                      * However we must assume this GOSUB is infinite, to
5205                      * avoid wrongly applying other optimizations in the
5206                      * enclosing scope - see GH 18096, for example.
5207                      */
5208                     is_inf = is_inf_internal = 1;
5209                     scan= regnext(scan);
5210                     continue;
5211                 }
5212
5213                 if (
5214                     !recursed_depth
5215                     || !PAREN_TEST(recursed_depth - 1, paren)
5216                 ) {
5217                     /* it is quite possible that there are more efficient ways
5218                      * to do this. We maintain a bitmap per level of recursion
5219                      * of which patterns we have entered so we can detect if a
5220                      * pattern creates a possible infinite loop. When we
5221                      * recurse down a level we copy the previous levels bitmap
5222                      * down. When we are at recursion level 0 we zero the top
5223                      * level bitmap. It would be nice to implement a different
5224                      * more efficient way of doing this. In particular the top
5225                      * level bitmap may be unnecessary.
5226                      */
5227                     if (!recursed_depth) {
5228                         Zero(RExC_study_chunk_recursed, RExC_study_chunk_recursed_bytes, U8);
5229                     } else {
5230                         Copy(PAREN_OFFSET(recursed_depth - 1),
5231                              PAREN_OFFSET(recursed_depth),
5232                              RExC_study_chunk_recursed_bytes, U8);
5233                     }
5234                     /* we havent recursed into this paren yet, so recurse into it */
5235                     DEBUG_STUDYDATA("gosub-set", data, depth, is_inf);
5236                     PAREN_SET(recursed_depth, paren);
5237                     my_recursed_depth= recursed_depth + 1;
5238                 } else {
5239                     DEBUG_STUDYDATA("gosub-inf", data, depth, is_inf);
5240                     /* some form of infinite recursion, assume infinite length
5241                      * */
5242                     if (flags & SCF_DO_SUBSTR) {
5243                         scan_commit(pRExC_state, data, minlenp, is_inf);
5244                         data->cur_is_floating = 1;
5245                     }
5246                     is_inf = is_inf_internal = 1;
5247                     if (flags & SCF_DO_STCLASS_OR) /* Allow everything */
5248                         ssc_anything(data->start_class);
5249                     flags &= ~SCF_DO_STCLASS;
5250
5251                     start= NULL; /* reset start so we dont recurse later on. */
5252                 }
5253             } else {
5254                 paren = stopparen;
5255                 start = scan + 2;
5256                 end = regnext(scan);
5257             }
5258             if (start) {
5259                 scan_frame *newframe;
5260                 assert(end);
5261                 if (!RExC_frame_last) {
5262                     Newxz(newframe, 1, scan_frame);
5263                     SAVEDESTRUCTOR_X(S_unwind_scan_frames, newframe);
5264                     RExC_frame_head= newframe;
5265                     RExC_frame_count++;
5266                 } else if (!RExC_frame_last->next_frame) {
5267                     Newxz(newframe, 1, scan_frame);
5268                     RExC_frame_last->next_frame= newframe;
5269                     newframe->prev_frame= RExC_frame_last;
5270                     RExC_frame_count++;
5271                 } else {
5272                     newframe= RExC_frame_last->next_frame;
5273                 }
5274                 RExC_frame_last= newframe;
5275
5276                 newframe->next_regnode = regnext(scan);
5277                 newframe->last_regnode = last;
5278                 newframe->stopparen = stopparen;
5279                 newframe->prev_recursed_depth = recursed_depth;
5280                 newframe->this_prev_frame= frame;
5281                 newframe->in_gosub = (
5282                     (frame && frame->in_gosub) || OP(scan) == GOSUB
5283                 );
5284
5285                 DEBUG_STUDYDATA("frame-new", data, depth, is_inf);
5286                 DEBUG_PEEP("fnew", scan, depth, flags);
5287
5288                 frame = newframe;
5289                 scan =  start;
5290                 stopparen = paren;
5291                 last = end;
5292                 depth = depth + 1;
5293                 recursed_depth= my_recursed_depth;
5294
5295                 continue;
5296             }
5297         }
5298         else if (PL_regkind[OP(scan)] == EXACT && ! isEXACTFish(OP(scan))) {
5299             SSize_t bytelen = STR_LEN(scan), charlen;
5300             UV uc;
5301             assert(bytelen);
5302             if (UTF) {
5303                 const U8 * const s = (U8*)STRING(scan);
5304                 uc = utf8_to_uvchr_buf(s, s + bytelen, NULL);
5305                 charlen = utf8_length(s, s + bytelen);
5306             } else {
5307                 uc = *((U8*)STRING(scan));
5308                 charlen = bytelen;
5309             }
5310             min += charlen;
5311             if (flags & SCF_DO_SUBSTR) { /* Update longest substr. */
5312                 /* The code below prefers earlier match for fixed
5313                    offset, later match for variable offset.  */
5314                 if (data->last_end == -1) { /* Update the start info. */
5315                     data->last_start_min = data->pos_min;
5316                     data->last_start_max =
5317                         is_inf ? OPTIMIZE_INFTY
5318                         : (data->pos_delta > OPTIMIZE_INFTY - data->pos_min)
5319                             ? OPTIMIZE_INFTY : data->pos_min + data->pos_delta;
5320                 }
5321                 sv_catpvn(data->last_found, STRING(scan), bytelen);
5322                 if (UTF)
5323                     SvUTF8_on(data->last_found);
5324                 {
5325                     SV * const sv = data->last_found;
5326                     MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ?
5327                         mg_find(sv, PERL_MAGIC_utf8) : NULL;
5328                     if (mg && mg->mg_len >= 0)
5329                         mg->mg_len += charlen;
5330                 }
5331                 data->last_end = data->pos_min + charlen;
5332                 data->pos_min += charlen; /* As in the first entry. */
5333                 data->flags &= ~SF_BEFORE_EOL;
5334             }
5335
5336             /* ANDing the code point leaves at most it, and not in locale, and
5337              * can't match null string */
5338             if (flags & SCF_DO_STCLASS_AND) {
5339                 ssc_cp_and(data->start_class, uc);
5340                 ANYOF_FLAGS(data->start_class) &= ~SSC_MATCHES_EMPTY_STRING;
5341                 ssc_clear_locale(data->start_class);
5342             }
5343             else if (flags & SCF_DO_STCLASS_OR) {
5344                 ssc_add_cp(data->start_class, uc);
5345                 ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
5346
5347                 /* See commit msg 749e076fceedeb708a624933726e7989f2302f6a */
5348                 ANYOF_FLAGS(data->start_class) &= ~SSC_MATCHES_EMPTY_STRING;
5349             }
5350             flags &= ~SCF_DO_STCLASS;
5351         }
5352         else if (PL_regkind[OP(scan)] == EXACT) {
5353             /* But OP != EXACT!, so is EXACTFish */
5354             SSize_t bytelen = STR_LEN(scan), charlen;
5355             const U8 * s = (U8*)STRING(scan);
5356
5357             /* Replace a length 1 ASCII fold pair node with an ANYOFM node,
5358              * with the mask set to the complement of the bit that differs
5359              * between upper and lower case, and the lowest code point of the
5360              * pair (which the '&' forces) */
5361             if (     bytelen == 1
5362                 &&   isALPHA_A(*s)
5363                 &&  (         OP(scan) == EXACTFAA
5364                      || (     OP(scan) == EXACTFU
5365                          && ! HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(*s)))
5366                 &&   mutate_ok
5367             ) {
5368                 U8 mask = ~ ('A' ^ 'a'); /* These differ in just one bit */
5369
5370                 OP(scan) = ANYOFM;
5371                 ARG_SET(scan, *s & mask);
5372                 FLAGS(scan) = mask;
5373                 /* we're not EXACTFish any more, so restudy */
5374                 continue;
5375             }
5376
5377             /* Search for fixed substrings supports EXACT only. */
5378             if (flags & SCF_DO_SUBSTR) {
5379                 assert(data);
5380                 scan_commit(pRExC_state, data, minlenp, is_inf);
5381             }
5382             charlen = UTF ? (SSize_t) utf8_length(s, s + bytelen) : bytelen;
5383             if (unfolded_multi_char) {
5384                 RExC_seen |= REG_UNFOLDED_MULTI_SEEN;
5385             }
5386             min += charlen - min_subtract;
5387             assert (min >= 0);
5388             delta += min_subtract;
5389             if (flags & SCF_DO_SUBSTR) {
5390                 data->pos_min += charlen - min_subtract;
5391                 if (data->pos_min < 0) {
5392                     data->pos_min = 0;
5393                 }
5394                 data->pos_delta += min_subtract;
5395                 if (min_subtract) {
5396                     data->cur_is_floating = 1; /* float */
5397                 }
5398             }
5399
5400             if (flags & SCF_DO_STCLASS) {
5401                 SV* EXACTF_invlist = make_exactf_invlist(pRExC_state, scan);
5402
5403                 assert(EXACTF_invlist);
5404                 if (flags & SCF_DO_STCLASS_AND) {
5405                     if (OP(scan) != EXACTFL)
5406                         ssc_clear_locale(data->start_class);
5407                     ANYOF_FLAGS(data->start_class) &= ~SSC_MATCHES_EMPTY_STRING;
5408                     ANYOF_POSIXL_ZERO(data->start_class);
5409                     ssc_intersection(data->start_class, EXACTF_invlist, FALSE);
5410                 }
5411                 else {  /* SCF_DO_STCLASS_OR */
5412                     ssc_union(data->start_class, EXACTF_invlist, FALSE);
5413                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
5414
5415                     /* See commit msg 749e076fceedeb708a624933726e7989f2302f6a */
5416                     ANYOF_FLAGS(data->start_class) &= ~SSC_MATCHES_EMPTY_STRING;
5417                 }
5418                 flags &= ~SCF_DO_STCLASS;
5419                 SvREFCNT_dec(EXACTF_invlist);
5420             }
5421         }
5422         else if (REGNODE_VARIES(OP(scan))) {
5423             SSize_t mincount, maxcount, minnext, deltanext, pos_before = 0;
5424             I32 fl = 0, f = flags;
5425             regnode * const oscan = scan;
5426             regnode_ssc this_class;
5427             regnode_ssc *oclass = NULL;
5428             I32 next_is_eval = 0;
5429
5430             switch (PL_regkind[OP(scan)]) {
5431             case WHILEM:                /* End of (?:...)* . */
5432                 scan = NEXTOPER(scan);
5433                 goto finish;
5434             case PLUS:
5435                 if (flags & (SCF_DO_SUBSTR | SCF_DO_STCLASS)) {
5436                     next = NEXTOPER(scan);
5437                     if (   (     PL_regkind[OP(next)] == EXACT
5438                             && ! isEXACTFish(OP(next)))
5439                         || (flags & SCF_DO_STCLASS))
5440                     {
5441                         mincount = 1;
5442                         maxcount = REG_INFTY;
5443                         next = regnext(scan);
5444                         scan = NEXTOPER(scan);
5445                         goto do_curly;
5446                     }
5447                 }
5448                 if (flags & SCF_DO_SUBSTR)
5449                     data->pos_min++;
5450                 /* This will bypass the formal 'min += minnext * mincount'
5451                  * calculation in the do_curly path, so assumes min width
5452                  * of the PLUS payload is exactly one. */
5453                 min++;
5454                 /* FALLTHROUGH */
5455             case STAR:
5456                 next = NEXTOPER(scan);
5457
5458                 /* This temporary node can now be turned into EXACTFU, and
5459                  * must, as regexec.c doesn't handle it */
5460                 if (OP(next) == EXACTFU_S_EDGE && mutate_ok) {
5461                     OP(next) = EXACTFU;
5462                 }
5463
5464                 if (     STR_LEN(next) == 1
5465                     &&   isALPHA_A(* STRING(next))
5466                     && (         OP(next) == EXACTFAA
5467                         || (     OP(next) == EXACTFU
5468                             && ! HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(* STRING(next))))
5469                     &&   mutate_ok
5470                 ) {
5471                     /* These differ in just one bit */
5472                     U8 mask = ~ ('A' ^ 'a');
5473
5474                     assert(isALPHA_A(* STRING(next)));
5475
5476                     /* Then replace it by an ANYOFM node, with
5477                     * the mask set to the complement of the
5478                     * bit that differs between upper and lower
5479                     * case, and the lowest code point of the
5480                     * pair (which the '&' forces) */
5481                     OP(next) = ANYOFM;
5482                     ARG_SET(next, *STRING(next) & mask);
5483                     FLAGS(next) = mask;
5484                 }
5485
5486                 if (flags & SCF_DO_STCLASS) {
5487                     mincount = 0;
5488                     maxcount = REG_INFTY;
5489                     next = regnext(scan);
5490                     scan = NEXTOPER(scan);
5491                     goto do_curly;
5492                 }
5493                 if (flags & SCF_DO_SUBSTR) {
5494                     scan_commit(pRExC_state, data, minlenp, is_inf);
5495                     /* Cannot extend fixed substrings */
5496                     data->cur_is_floating = 1; /* float */
5497                 }
5498                 is_inf = is_inf_internal = 1;
5499                 scan = regnext(scan);
5500                 goto optimize_curly_tail;
5501             case CURLY:
5502                 if (stopparen>0 && (OP(scan)==CURLYN || OP(scan)==CURLYM)
5503                     && (scan->flags == stopparen))
5504                 {
5505                     mincount = 1;
5506                     maxcount = 1;
5507                 } else {
5508                     mincount = ARG1(scan);
5509                     maxcount = ARG2(scan);
5510                 }
5511                 next = regnext(scan);
5512                 if (OP(scan) == CURLYX) {
5513                     I32 lp = (data ? *(data->last_closep) : 0);
5514                     scan->flags = ((lp <= (I32)U8_MAX) ? (U8)lp : U8_MAX);
5515                 }
5516                 scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
5517                 next_is_eval = (OP(scan) == EVAL);
5518               do_curly:
5519                 if (flags & SCF_DO_SUBSTR) {
5520                     if (mincount == 0)
5521                         scan_commit(pRExC_state, data, minlenp, is_inf);
5522                     /* Cannot extend fixed substrings */
5523                     pos_before = data->pos_min;
5524                 }
5525                 if (data) {
5526                     fl = data->flags;
5527                     data->flags &= ~(SF_HAS_PAR|SF_IN_PAR|SF_HAS_EVAL);
5528                     if (is_inf)
5529                         data->flags |= SF_IS_INF;
5530                 }
5531                 if (flags & SCF_DO_STCLASS) {
5532                     ssc_init(pRExC_state, &this_class);
5533                     oclass = data->start_class;
5534                     data->start_class = &this_class;
5535                     f |= SCF_DO_STCLASS_AND;
5536                     f &= ~SCF_DO_STCLASS_OR;
5537                 }
5538                 /* Exclude from super-linear cache processing any {n,m}
5539                    regops for which the combination of input pos and regex
5540                    pos is not enough information to determine if a match
5541                    will be possible.
5542
5543                    For example, in the regex /foo(bar\s*){4,8}baz/ with the
5544                    regex pos at the \s*, the prospects for a match depend not
5545                    only on the input position but also on how many (bar\s*)
5546                    repeats into the {4,8} we are. */
5547                if ((mincount > 1) || (maxcount > 1 && maxcount != REG_INFTY))
5548                     f &= ~SCF_WHILEM_VISITED_POS;
5549
5550                 /* This will finish on WHILEM, setting scan, or on NULL: */
5551                 /* recurse study_chunk() on loop bodies */
5552                 minnext = study_chunk(pRExC_state, &scan, minlenp, &deltanext,
5553                                   last, data, stopparen, recursed_depth, NULL,
5554                                   (mincount == 0
5555                                    ? (f & ~SCF_DO_SUBSTR)
5556                                    : f)
5557                                   , depth+1, mutate_ok);
5558
5559                 if (flags & SCF_DO_STCLASS)
5560                     data->start_class = oclass;
5561                 if (mincount == 0 || minnext == 0) {
5562                     if (flags & SCF_DO_STCLASS_OR) {
5563                         ssc_or(pRExC_state, data->start_class, (regnode_charclass *) &this_class);
5564                     }
5565                     else if (flags & SCF_DO_STCLASS_AND) {
5566                         /* Switch to OR mode: cache the old value of
5567                          * data->start_class */
5568                         INIT_AND_WITHP;
5569                         StructCopy(data->start_class, and_withp, regnode_ssc);
5570                         flags &= ~SCF_DO_STCLASS_AND;
5571                         StructCopy(&this_class, data->start_class, regnode_ssc);
5572                         flags |= SCF_DO_STCLASS_OR;
5573                         ANYOF_FLAGS(data->start_class)
5574                                                 |= SSC_MATCHES_EMPTY_STRING;
5575                     }
5576                 } else {                /* Non-zero len */
5577                     if (flags & SCF_DO_STCLASS_OR) {
5578                         ssc_or(pRExC_state, data->start_class, (regnode_charclass *) &this_class);
5579                         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
5580                     }
5581                     else if (flags & SCF_DO_STCLASS_AND)
5582                         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) &this_class);
5583                     flags &= ~SCF_DO_STCLASS;
5584                 }
5585                 if (!scan)              /* It was not CURLYX, but CURLY. */
5586                     scan = next;
5587                 if (((flags & (SCF_TRIE_DOING_RESTUDY|SCF_DO_SUBSTR))==SCF_DO_SUBSTR)
5588                     /* ? quantifier ok, except for (?{ ... }) */
5589                     && (next_is_eval || !(mincount == 0 && maxcount == 1))
5590                     && (minnext == 0) && (deltanext == 0)
5591                     && data && !(data->flags & (SF_HAS_PAR|SF_IN_PAR))
5592                     && maxcount <= REG_INFTY/3) /* Complement check for big
5593                                                    count */
5594                 {
5595                     _WARN_HELPER(RExC_precomp_end, packWARN(WARN_REGEXP),
5596                         Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP),
5597                             "Quantifier unexpected on zero-length expression "
5598                             "in regex m/%" UTF8f "/",
5599                              UTF8fARG(UTF, RExC_precomp_end - RExC_precomp,
5600                                   RExC_precomp)));
5601                 }
5602
5603                 if ( ( minnext > 0 && mincount >= SSize_t_MAX / minnext )
5604                     || min >= SSize_t_MAX - minnext * mincount )
5605                 {
5606                     FAIL("Regexp out of space");
5607                 }
5608
5609                 min += minnext * mincount;
5610                 is_inf_internal |= deltanext == OPTIMIZE_INFTY
5611                          || (maxcount == REG_INFTY && minnext + deltanext > 0);
5612                 is_inf |= is_inf_internal;
5613                 if (is_inf) {
5614                     delta = OPTIMIZE_INFTY;
5615                 } else {
5616                     delta += (minnext + deltanext) * maxcount
5617                              - minnext * mincount;
5618                 }
5619                 /* Try powerful optimization CURLYX => CURLYN. */
5620                 if (  OP(oscan) == CURLYX && data
5621                       && data->flags & SF_IN_PAR
5622                       && !(data->flags & SF_HAS_EVAL)
5623                       && !deltanext && minnext == 1
5624                       && mutate_ok
5625                 ) {
5626                     /* Try to optimize to CURLYN.  */
5627                     regnode *nxt = NEXTOPER(oscan) + EXTRA_STEP_2ARGS;
5628                     regnode * const nxt1 = nxt;
5629 #ifdef DEBUGGING
5630                     regnode *nxt2;
5631 #endif
5632
5633                     /* Skip open. */
5634                     nxt = regnext(nxt);
5635                     if (!REGNODE_SIMPLE(OP(nxt))
5636                         && !(PL_regkind[OP(nxt)] == EXACT
5637                              && STR_LEN(nxt) == 1))
5638                         goto nogo;
5639 #ifdef DEBUGGING
5640                     nxt2 = nxt;
5641 #endif
5642                     nxt = regnext(nxt);
5643                     if (OP(nxt) != CLOSE)
5644                         goto nogo;
5645                     if (RExC_open_parens) {
5646
5647                         /*open->CURLYM*/
5648                         RExC_open_parens[ARG(nxt1)] = REGNODE_OFFSET(oscan);
5649
5650                         /*close->while*/
5651                         RExC_close_parens[ARG(nxt1)] = REGNODE_OFFSET(nxt) + 2;
5652                     }
5653                     /* Now we know that nxt2 is the only contents: */
5654                     oscan->flags = (U8)ARG(nxt);
5655                     OP(oscan) = CURLYN;
5656                     OP(nxt1) = NOTHING; /* was OPEN. */
5657
5658 #ifdef DEBUGGING
5659                     OP(nxt1 + 1) = OPTIMIZED; /* was count. */
5660                     NEXT_OFF(nxt1+ 1) = 0; /* just for consistency. */
5661                     NEXT_OFF(nxt2) = 0; /* just for consistency with CURLY. */
5662                     OP(nxt) = OPTIMIZED;        /* was CLOSE. */
5663                     OP(nxt + 1) = OPTIMIZED; /* was count. */
5664                     NEXT_OFF(nxt+ 1) = 0; /* just for consistency. */
5665 #endif
5666                 }
5667               nogo:
5668
5669                 /* Try optimization CURLYX => CURLYM. */
5670                 if (  OP(oscan) == CURLYX && data
5671                       && !(data->flags & SF_HAS_PAR)
5672                       && !(data->flags & SF_HAS_EVAL)
5673                       && !deltanext     /* atom is fixed width */
5674                       && minnext != 0   /* CURLYM can't handle zero width */
5675                          /* Nor characters whose fold at run-time may be
5676                           * multi-character */
5677                       && ! (RExC_seen & REG_UNFOLDED_MULTI_SEEN)
5678                       && mutate_ok
5679                 ) {
5680                     /* XXXX How to optimize if data == 0? */
5681                     /* Optimize to a simpler form.  */
5682                     regnode *nxt = NEXTOPER(oscan) + EXTRA_STEP_2ARGS; /* OPEN */
5683                     regnode *nxt2;
5684
5685                     OP(oscan) = CURLYM;
5686                     while ( (nxt2 = regnext(nxt)) /* skip over embedded stuff*/
5687                             && (OP(nxt2) != WHILEM))
5688                         nxt = nxt2;
5689                     OP(nxt2)  = SUCCEED; /* Whas WHILEM */
5690                     /* Need to optimize away parenths. */
5691                     if ((data->flags & SF_IN_PAR) && OP(nxt) == CLOSE) {
5692                         /* Set the parenth number.  */
5693                         regnode *nxt1 = NEXTOPER(oscan) + EXTRA_STEP_2ARGS; /* OPEN*/
5694
5695                         oscan->flags = (U8)ARG(nxt);
5696                         if (RExC_open_parens) {
5697                              /*open->CURLYM*/
5698                             RExC_open_parens[ARG(nxt1)] = REGNODE_OFFSET(oscan);
5699
5700                             /*close->NOTHING*/
5701                             RExC_close_parens[ARG(nxt1)] = REGNODE_OFFSET(nxt2)
5702                                                          + 1;
5703                         }
5704                         OP(nxt1) = OPTIMIZED;   /* was OPEN. */
5705                         OP(nxt) = OPTIMIZED;    /* was CLOSE. */
5706
5707 #ifdef DEBUGGING
5708                         OP(nxt1 + 1) = OPTIMIZED; /* was count. */
5709                         OP(nxt + 1) = OPTIMIZED; /* was count. */
5710                         NEXT_OFF(nxt1 + 1) = 0; /* just for consistency. */
5711                         NEXT_OFF(nxt + 1) = 0; /* just for consistency. */
5712 #endif
5713 #if 0
5714                         while ( nxt1 && (OP(nxt1) != WHILEM)) {
5715                             regnode *nnxt = regnext(nxt1);
5716                             if (nnxt == nxt) {
5717                                 if (reg_off_by_arg[OP(nxt1)])
5718                                     ARG_SET(nxt1, nxt2 - nxt1);
5719                                 else if (nxt2 - nxt1 < U16_MAX)
5720                                     NEXT_OFF(nxt1) = nxt2 - nxt1;
5721                                 else
5722                                     OP(nxt) = NOTHING;  /* Cannot beautify */
5723                             }
5724                             nxt1 = nnxt;
5725                         }
5726 #endif
5727                         /* Optimize again: */
5728                         /* recurse study_chunk() on optimised CURLYX => CURLYM */
5729                         study_chunk(pRExC_state, &nxt1, minlenp, &deltanext, nxt,
5730                                     NULL, stopparen, recursed_depth, NULL, 0,
5731                                     depth+1, mutate_ok);
5732                     }
5733                     else
5734                         oscan->flags = 0;
5735                 }
5736                 else if ((OP(oscan) == CURLYX)
5737                          && (flags & SCF_WHILEM_VISITED_POS)
5738                          /* See the comment on a similar expression above.
5739                             However, this time it's not a subexpression
5740                             we care about, but the expression itself. */
5741                          && (maxcount == REG_INFTY)
5742                          && data) {
5743                     /* This stays as CURLYX, we can put the count/of pair. */
5744                     /* Find WHILEM (as in regexec.c) */
5745                     regnode *nxt = oscan + NEXT_OFF(oscan);
5746
5747                     if (OP(PREVOPER(nxt)) == NOTHING) /* LONGJMP */
5748                         nxt += ARG(nxt);
5749                     nxt = PREVOPER(nxt);
5750                     if (nxt->flags & 0xf) {
5751                         /* we've already set whilem count on this node */
5752                     } else if (++data->whilem_c < 16) {
5753                         assert(data->whilem_c <= RExC_whilem_seen);
5754                         nxt->flags = (U8)(data->whilem_c
5755                             | (RExC_whilem_seen << 4)); /* On WHILEM */
5756                     }
5757                 }
5758                 if (data && fl & (SF_HAS_PAR|SF_IN_PAR))
5759                     pars++;
5760                 if (flags & SCF_DO_SUBSTR) {
5761                     SV *last_str = NULL;
5762                     STRLEN last_chrs = 0;
5763                     int counted = mincount != 0;
5764
5765                     if (data->last_end > 0 && mincount != 0) { /* Ends with a
5766                                                                   string. */
5767                         SSize_t b = pos_before >= data->last_start_min
5768                             ? pos_before : data->last_start_min;
5769                         STRLEN l;
5770                         const char * const s = SvPV_const(data->last_found, l);
5771                         SSize_t old = b - data->last_start_min;
5772                         assert(old >= 0);
5773
5774                         if (UTF)
5775                             old = utf8_hop_forward((U8*)s, old,
5776                                                (U8 *) SvEND(data->last_found))
5777                                 - (U8*)s;
5778                         l -= old;
5779                         /* Get the added string: */
5780                         last_str = newSVpvn_utf8(s  + old, l, UTF);
5781                         last_chrs = UTF ? utf8_length((U8*)(s + old),
5782                                             (U8*)(s + old + l)) : l;
5783                         if (deltanext == 0 && pos_before == b) {
5784                             /* What was added is a constant string */
5785                             if (mincount > 1) {
5786
5787                                 SvGROW(last_str, (mincount * l) + 1);
5788                                 repeatcpy(SvPVX(last_str) + l,
5789                                           SvPVX_const(last_str), l,
5790                                           mincount - 1);
5791                                 SvCUR_set(last_str, SvCUR(last_str) * mincount);
5792                                 /* Add additional parts. */
5793                                 SvCUR_set(data->last_found,
5794                                           SvCUR(data->last_found) - l);
5795                                 sv_catsv(data->last_found, last_str);
5796                                 {
5797                                     SV * sv = data->last_found;
5798                                     MAGIC *mg =
5799                                         SvUTF8(sv) && SvMAGICAL(sv) ?
5800                                         mg_find(sv, PERL_MAGIC_utf8) : NULL;
5801                                     if (mg && mg->mg_len >= 0)
5802                                         mg->mg_len += last_chrs * (mincount-1);
5803                                 }
5804                                 last_chrs *= mincount;
5805                                 data->last_end += l * (mincount - 1);
5806                             }
5807                         } else {
5808                             /* start offset must point into the last copy */
5809                             data->last_start_min += minnext * (mincount - 1);
5810                             data->last_start_max =
5811                               is_inf
5812                                ? OPTIMIZE_INFTY
5813                                : data->last_start_max +
5814                                  (maxcount - 1) * (minnext + data->pos_delta);
5815                         }
5816                     }
5817                     /* It is counted once already... */
5818                     data->pos_min += minnext * (mincount - counted);
5819 #if 0
5820 Perl_re_printf( aTHX_  "counted=%" UVuf " deltanext=%" UVuf
5821                               " OPTIMIZE_INFTY=%" UVuf " minnext=%" UVuf
5822                               " maxcount=%" UVuf " mincount=%" UVuf "\n",
5823     (UV)counted, (UV)deltanext, (UV)OPTIMIZE_INFTY, (UV)minnext, (UV)maxcount,
5824     (UV)mincount);
5825 if (deltanext != OPTIMIZE_INFTY)
5826 Perl_re_printf( aTHX_  "LHS=%" UVuf " RHS=%" UVuf "\n",
5827     (UV)(-counted * deltanext + (minnext + deltanext) * maxcount
5828           - minnext * mincount), (UV)(OPTIMIZE_INFTY - data->pos_delta));
5829 #endif
5830                     if (deltanext == OPTIMIZE_INFTY
5831                         || -counted * deltanext + (minnext + deltanext) * maxcount - minnext * mincount >= OPTIMIZE_INFTY - data->pos_delta)
5832                         data->pos_delta = OPTIMIZE_INFTY;
5833                     else
5834                         data->pos_delta += - counted * deltanext +
5835                         (minnext + deltanext) * maxcount - minnext * mincount;
5836                     if (mincount != maxcount) {
5837                          /* Cannot extend fixed substrings found inside
5838                             the group.  */
5839                         scan_commit(pRExC_state, data, minlenp, is_inf);
5840                         if (mincount && last_str) {
5841                             SV * const sv = data->last_found;
5842                             MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ?
5843                                 mg_find(sv, PERL_MAGIC_utf8) : NULL;
5844
5845                             if (mg)
5846                                 mg->mg_len = -1;
5847                             sv_setsv(sv, last_str);
5848                             data->last_end = data->pos_min;
5849                             data->last_start_min = data->pos_min - last_chrs;
5850                             data->last_start_max = is_inf
5851                                 ? OPTIMIZE_INFTY
5852                                 : data->pos_min + data->pos_delta - last_chrs;
5853                         }
5854                         data->cur_is_floating = 1; /* float */
5855                     }
5856                     SvREFCNT_dec(last_str);
5857                 }
5858                 if (data && (fl & SF_HAS_EVAL))
5859                     data->flags |= SF_HAS_EVAL;
5860               optimize_curly_tail:
5861                 rck_elide_nothing(oscan);
5862                 continue;
5863
5864             default:
5865                 Perl_croak(aTHX_ "panic: unexpected varying REx opcode %d",
5866                                                                     OP(scan));
5867             case REF:
5868             case CLUMP:
5869                 if (flags & SCF_DO_SUBSTR) {
5870                     /* Cannot expect anything... */
5871                     scan_commit(pRExC_state, data, minlenp, is_inf);
5872                     data->cur_is_floating = 1; /* float */
5873                 }
5874                 is_inf = is_inf_internal = 1;
5875                 if (flags & SCF_DO_STCLASS_OR) {
5876                     if (OP(scan) == CLUMP) {
5877                         /* Actually is any start char, but very few code points
5878                          * aren't start characters */
5879                         ssc_match_all_cp(data->start_class);
5880                     }
5881                     else {
5882                         ssc_anything(data->start_class);
5883                     }
5884                 }
5885                 flags &= ~SCF_DO_STCLASS;
5886                 break;
5887             }
5888         }
5889         else if (OP(scan) == LNBREAK) {
5890             if (flags & SCF_DO_STCLASS) {
5891                 if (flags & SCF_DO_STCLASS_AND) {
5892                     ssc_intersection(data->start_class,
5893                                     PL_XPosix_ptrs[_CC_VERTSPACE], FALSE);
5894                     ssc_clear_locale(data->start_class);
5895                     ANYOF_FLAGS(data->start_class)
5896                                                 &= ~SSC_MATCHES_EMPTY_STRING;
5897                 }
5898                 else if (flags & SCF_DO_STCLASS_OR) {
5899                     ssc_union(data->start_class,
5900                               PL_XPosix_ptrs[_CC_VERTSPACE],
5901                               FALSE);
5902                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
5903
5904                     /* See commit msg for
5905                      * 749e076fceedeb708a624933726e7989f2302f6a */
5906                     ANYOF_FLAGS(data->start_class)
5907                                                 &= ~SSC_MATCHES_EMPTY_STRING;
5908                 }
5909                 flags &= ~SCF_DO_STCLASS;
5910             }
5911             min++;
5912             if (delta != OPTIMIZE_INFTY)
5913                 delta++;    /* Because of the 2 char string cr-lf */
5914             if (flags & SCF_DO_SUBSTR) {
5915                 /* Cannot expect anything... */
5916                 scan_commit(pRExC_state, data, minlenp, is_inf);
5917                 data->pos_min += 1;
5918                 if (data->pos_delta != OPTIMIZE_INFTY) {
5919                     data->pos_delta += 1;
5920                 }
5921                 data->cur_is_floating = 1; /* float */
5922             }
5923         }
5924         else if (REGNODE_SIMPLE(OP(scan))) {
5925
5926             if (flags & SCF_DO_SUBSTR) {
5927                 scan_commit(pRExC_state, data, minlenp, is_inf);
5928                 data->pos_min++;
5929             }
5930             min++;
5931             if (flags & SCF_DO_STCLASS) {
5932                 bool invert = 0;
5933                 SV* my_invlist = NULL;
5934                 U8 namedclass;
5935
5936                 /* See commit msg 749e076fceedeb708a624933726e7989f2302f6a */
5937                 ANYOF_FLAGS(data->start_class) &= ~SSC_MATCHES_EMPTY_STRING;
5938
5939                 /* Some of the logic below assumes that switching
5940                    locale on will only add false positives. */
5941                 switch (OP(scan)) {
5942
5943                 default:
5944 #ifdef DEBUGGING
5945                    Perl_croak(aTHX_ "panic: unexpected simple REx opcode %d",
5946                                                                      OP(scan));
5947 #endif
5948                 case SANY:
5949                     if (flags & SCF_DO_STCLASS_OR) /* Allow everything */
5950                         ssc_match_all_cp(data->start_class);
5951                     break;
5952
5953                 case REG_ANY:
5954                     {
5955                         SV* REG_ANY_invlist = _new_invlist(2);
5956                         REG_ANY_invlist = add_cp_to_invlist(REG_ANY_invlist,
5957                                                             '\n');
5958                         if (flags & SCF_DO_STCLASS_OR) {
5959                             ssc_union(data->start_class,
5960                                       REG_ANY_invlist,
5961                                       TRUE /* TRUE => invert, hence all but \n
5962                                             */
5963                                       );
5964                         }
5965                         else if (flags & SCF_DO_STCLASS_AND) {
5966                             ssc_intersection(data->start_class,
5967                                              REG_ANY_invlist,
5968                                              TRUE  /* TRUE => invert */
5969                                              );
5970                             ssc_clear_locale(data->start_class);
5971                         }
5972                         SvREFCNT_dec_NN(REG_ANY_invlist);
5973                     }
5974                     break;
5975
5976                 case ANYOFD:
5977                 case ANYOFL:
5978                 case ANYOFPOSIXL:
5979                 case ANYOFH:
5980                 case ANYOFHb:
5981                 case ANYOFHr:
5982                 case ANYOFHs:
5983                 case ANYOF:
5984                     if (flags & SCF_DO_STCLASS_AND)
5985                         ssc_and(pRExC_state, data->start_class,
5986                                 (regnode_charclass *) scan);
5987                     else
5988                         ssc_or(pRExC_state, data->start_class,
5989                                                           (regnode_charclass *) scan);
5990                     break;
5991
5992                 case NANYOFM: /* NANYOFM already contains the inversion of the
5993                                  input ANYOF data, so, unlike things like
5994                                  NPOSIXA, don't change 'invert' to TRUE */
5995                     /* FALLTHROUGH */
5996                 case ANYOFM:
5997                   {
5998                     SV* cp_list = get_ANYOFM_contents(scan);
5999
6000                     if (flags & SCF_DO_STCLASS_OR) {
6001                         ssc_union(data->start_class, cp_list, invert);
6002                     }
6003                     else if (flags & SCF_DO_STCLASS_AND) {
6004                         ssc_intersection(data->start_class, cp_list, invert);
6005                     }
6006
6007                     SvREFCNT_dec_NN(cp_list);
6008                     break;
6009                   }
6010
6011                 case ANYOFR:
6012                 case ANYOFRb:
6013                   {
6014                     SV* cp_list = NULL;
6015
6016                     cp_list = _add_range_to_invlist(cp_list,
6017                                         ANYOFRbase(scan),
6018                                         ANYOFRbase(scan) + ANYOFRdelta(scan));
6019
6020                     if (flags & SCF_DO_STCLASS_OR) {
6021                         ssc_union(data->start_class, cp_list, invert);
6022                     }
6023                     else if (flags & SCF_DO_STCLASS_AND) {
6024                         ssc_intersection(data->start_class, cp_list, invert);
6025                     }
6026
6027                     SvREFCNT_dec_NN(cp_list);
6028                     break;
6029                   }
6030
6031                 case NPOSIXL:
6032                     invert = 1;
6033                     /* FALLTHROUGH */
6034
6035                 case POSIXL:
6036                     namedclass = classnum_to_namedclass(FLAGS(scan)) + invert;
6037                     if (flags & SCF_DO_STCLASS_AND) {
6038                         bool was_there = cBOOL(
6039                                           ANYOF_POSIXL_TEST(data->start_class,
6040                                                                  namedclass));
6041                         ANYOF_POSIXL_ZERO(data->start_class);
6042                         if (was_there) {    /* Do an AND */
6043                             ANYOF_POSIXL_SET(data->start_class, namedclass);
6044                         }
6045                         /* No individual code points can now match */
6046                         data->start_class->invlist
6047                                                 = sv_2mortal(_new_invlist(0));
6048                     }
6049                     else {
6050                         int complement = namedclass + ((invert) ? -1 : 1);
6051
6052                         assert(flags & SCF_DO_STCLASS_OR);
6053
6054                         /* If the complement of this class was already there,
6055                          * the result is that they match all code points,
6056                          * (\d + \D == everything).  Remove the classes from
6057                          * future consideration.  Locale is not relevant in
6058                          * this case */
6059                         if (ANYOF_POSIXL_TEST(data->start_class, complement)) {
6060                             ssc_match_all_cp(data->start_class);
6061                             ANYOF_POSIXL_CLEAR(data->start_class, namedclass);
6062                             ANYOF_POSIXL_CLEAR(data->start_class, complement);
6063                         }
6064                         else {  /* The usual case; just add this class to the
6065                                    existing set */
6066                             ANYOF_POSIXL_SET(data->start_class, namedclass);
6067                         }
6068                     }
6069                     break;
6070
6071                 case NPOSIXA:   /* For these, we always know the exact set of
6072                                    what's matched */
6073                     invert = 1;
6074                     /* FALLTHROUGH */
6075                 case POSIXA:
6076                     my_invlist = invlist_clone(PL_Posix_ptrs[FLAGS(scan)], NULL);
6077                     goto join_posix_and_ascii;
6078
6079                 case NPOSIXD:
6080                 case NPOSIXU:
6081                     invert = 1;
6082                     /* FALLTHROUGH */
6083                 case POSIXD:
6084                 case POSIXU:
6085                     my_invlist = invlist_clone(PL_XPosix_ptrs[FLAGS(scan)], NULL);
6086
6087                     /* NPOSIXD matches all upper Latin1 code points unless the
6088                      * target string being matched is UTF-8, which is
6089                      * unknowable until match time.  Since we are going to
6090                      * invert, we want to get rid of all of them so that the
6091                      * inversion will match all */
6092                     if (OP(scan) == NPOSIXD) {
6093                         _invlist_subtract(my_invlist, PL_UpperLatin1,
6094                                           &my_invlist);
6095                     }
6096
6097                   join_posix_and_ascii:
6098
6099                     if (flags & SCF_DO_STCLASS_AND) {
6100                         ssc_intersection(data->start_class, my_invlist, invert);
6101                         ssc_clear_locale(data->start_class);
6102                     }
6103                     else {
6104                         assert(flags & SCF_DO_STCLASS_OR);
6105                         ssc_union(data->start_class, my_invlist, invert);
6106                     }
6107                     SvREFCNT_dec(my_invlist);
6108                 }
6109                 if (flags & SCF_DO_STCLASS_OR)
6110                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
6111                 flags &= ~SCF_DO_STCLASS;
6112             }
6113         }
6114         else if (PL_regkind[OP(scan)] == EOL && flags & SCF_DO_SUBSTR) {
6115             data->flags |= (OP(scan) == MEOL
6116                             ? SF_BEFORE_MEOL
6117                             : SF_BEFORE_SEOL);
6118             scan_commit(pRExC_state, data, minlenp, is_inf);
6119
6120         }
6121         else if (  PL_regkind[OP(scan)] == BRANCHJ
6122                  /* Lookbehind, or need to calculate parens/evals/stclass: */
6123                    && (scan->flags || data || (flags & SCF_DO_STCLASS))
6124                    && (OP(scan) == IFMATCH || OP(scan) == UNLESSM))
6125         {
6126             if ( !PERL_ENABLE_POSITIVE_ASSERTION_STUDY
6127                 || OP(scan) == UNLESSM )
6128             {
6129                 /* Negative Lookahead/lookbehind
6130                    In this case we can't do fixed string optimisation.
6131                 */
6132
6133                 SSize_t deltanext, minnext, fake = 0;
6134                 regnode *nscan;
6135                 regnode_ssc intrnl;
6136                 int f = 0;
6137
6138                 StructCopy(&zero_scan_data, &data_fake, scan_data_t);
6139                 if (data) {
6140                     data_fake.whilem_c = data->whilem_c;
6141                     data_fake.last_closep = data->last_closep;
6142                 }
6143                 else
6144                     data_fake.last_closep = &fake;
6145                 data_fake.pos_delta = delta;
6146                 if ( flags & SCF_DO_STCLASS && !scan->flags
6147                      && OP(scan) == IFMATCH ) { /* Lookahead */
6148                     ssc_init(pRExC_state, &intrnl);
6149                     data_fake.start_class = &intrnl;
6150                     f |= SCF_DO_STCLASS_AND;
6151                 }
6152                 if (flags & SCF_WHILEM_VISITED_POS)
6153                     f |= SCF_WHILEM_VISITED_POS;
6154                 next = regnext(scan);
6155                 nscan = NEXTOPER(NEXTOPER(scan));
6156
6157                 /* recurse study_chunk() for lookahead body */
6158                 minnext = study_chunk(pRExC_state, &nscan, minlenp, &deltanext,
6159                                       last, &data_fake, stopparen,
6160                                       recursed_depth, NULL, f, depth+1,
6161                                       mutate_ok);
6162                 if (scan->flags) {
6163                     if (   deltanext < 0
6164                         || deltanext > (I32) U8_MAX
6165                         || minnext > (I32)U8_MAX
6166                         || minnext + deltanext > (I32)U8_MAX)
6167                     {
6168                         FAIL2("Lookbehind longer than %" UVuf " not implemented",
6169                               (UV)U8_MAX);
6170                     }
6171
6172                     /* The 'next_off' field has been repurposed to count the
6173                      * additional starting positions to try beyond the initial
6174                      * one.  (This leaves it at 0 for non-variable length
6175                      * matches to avoid breakage for those not using this
6176                      * extension) */
6177                     if (deltanext) {
6178                         scan->next_off = deltanext;
6179                         ckWARNexperimental(RExC_parse,
6180                             WARN_EXPERIMENTAL__VLB,
6181                             "Variable length lookbehind is experimental");
6182                     }
6183                     scan->flags = (U8)minnext + deltanext;
6184                 }
6185                 if (data) {
6186                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
6187                         pars++;
6188                     if (data_fake.flags & SF_HAS_EVAL)
6189                         data->flags |= SF_HAS_EVAL;
6190                     data->whilem_c = data_fake.whilem_c;
6191                 }
6192                 if (f & SCF_DO_STCLASS_AND) {
6193                     if (flags & SCF_DO_STCLASS_OR) {
6194                         /* OR before, AND after: ideally we would recurse with
6195                          * data_fake to get the AND applied by study of the
6196                          * remainder of the pattern, and then derecurse;
6197                          * *** HACK *** for now just treat as "no information".
6198                          * See [perl #56690].
6199                          */
6200                         ssc_init(pRExC_state, data->start_class);
6201                     }  else {
6202                         /* AND before and after: combine and continue.  These
6203                          * assertions are zero-length, so can match an EMPTY
6204                          * string */
6205                         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) &intrnl);
6206                         ANYOF_FLAGS(data->start_class)
6207                                                    |= SSC_MATCHES_EMPTY_STRING;
6208                     }
6209                 }
6210             }
6211 #if PERL_ENABLE_POSITIVE_ASSERTION_STUDY
6212             else {
6213                 /* Positive Lookahead/lookbehind
6214                    In this case we can do fixed string optimisation,
6215                    but we must be careful about it. Note in the case of
6216                    lookbehind the positions will be offset by the minimum
6217                    length of the pattern, something we won't know about
6218                    until after the recurse.
6219                 */
6220                 SSize_t deltanext, fake = 0;
6221                 regnode *nscan;
6222                 regnode_ssc intrnl;
6223                 int f = 0;
6224                 /* We use SAVEFREEPV so that when the full compile
6225                     is finished perl will clean up the allocated
6226                     minlens when it's all done. This way we don't
6227                     have to worry about freeing them when we know
6228                     they wont be used, which would be a pain.
6229                  */
6230                 SSize_t *minnextp;
6231                 Newx( minnextp, 1, SSize_t );
6232                 SAVEFREEPV(minnextp);
6233
6234                 if (data) {
6235                     StructCopy(data, &data_fake, scan_data_t);
6236                     if ((flags & SCF_DO_SUBSTR) && data->last_found) {
6237                         f |= SCF_DO_SUBSTR;
6238                         if (scan->flags)
6239                             scan_commit(pRExC_state, &data_fake, minlenp, is_inf);
6240                         data_fake.last_found=newSVsv(data->last_found);
6241                     }
6242                 }
6243                 else
6244                     data_fake.last_closep = &fake;
6245                 data_fake.flags = 0;
6246                 data_fake.substrs[0].flags = 0;
6247                 data_fake.substrs[1].flags = 0;
6248                 data_fake.pos_delta = delta;
6249                 if (is_inf)
6250                     data_fake.flags |= SF_IS_INF;
6251                 if ( flags & SCF_DO_STCLASS && !scan->flags
6252                      && OP(scan) == IFMATCH ) { /* Lookahead */
6253                     ssc_init(pRExC_state, &intrnl);
6254                     data_fake.start_class = &intrnl;
6255                     f |= SCF_DO_STCLASS_AND;
6256                 }
6257                 if (flags & SCF_WHILEM_VISITED_POS)
6258                     f |= SCF_WHILEM_VISITED_POS;
6259                 next = regnext(scan);
6260                 nscan = NEXTOPER(NEXTOPER(scan));
6261
6262                 /* positive lookahead study_chunk() recursion */
6263                 *minnextp = study_chunk(pRExC_state, &nscan, minnextp,
6264                                         &deltanext, last, &data_fake,
6265                                         stopparen, recursed_depth, NULL,
6266                                         f, depth+1, mutate_ok);
6267                 if (scan->flags) {
6268                     assert(0);  /* This code has never been tested since this
6269                                    is normally not compiled */
6270                     if (   deltanext < 0
6271                         || deltanext > (I32) U8_MAX
6272                         || *minnextp > (I32)U8_MAX
6273                         || *minnextp + deltanext > (I32)U8_MAX)
6274                     {
6275                         FAIL2("Lookbehind longer than %" UVuf " not implemented",
6276                               (UV)U8_MAX);
6277                     }
6278
6279                     if (deltanext) {
6280                         scan->next_off = deltanext;
6281                     }
6282                     scan->flags = (U8)*minnextp + deltanext;
6283                 }
6284
6285                 *minnextp += min;
6286
6287                 if (f & SCF_DO_STCLASS_AND) {
6288                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) &intrnl);
6289                     ANYOF_FLAGS(data->start_class) |= SSC_MATCHES_EMPTY_STRING;
6290                 }
6291                 if (data) {
6292                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
6293                         pars++;
6294                     if (data_fake.flags & SF_HAS_EVAL)
6295                         data->flags |= SF_HAS_EVAL;
6296                     data->whilem_c = data_fake.whilem_c;
6297                     if ((flags & SCF_DO_SUBSTR) && data_fake.last_found) {
6298                         int i;
6299                         if (RExC_rx->minlen<*minnextp)
6300                             RExC_rx->minlen=*minnextp;
6301                         scan_commit(pRExC_state, &data_fake, minnextp, is_inf);
6302                         SvREFCNT_dec_NN(data_fake.last_found);
6303
6304                         for (i = 0; i < 2; i++) {
6305                             if (data_fake.substrs[i].minlenp != minlenp) {
6306                                 data->substrs[i].min_offset =
6307                                             data_fake.substrs[i].min_offset;
6308                                 data->substrs[i].max_offset =
6309                                             data_fake.substrs[i].max_offset;
6310                                 data->substrs[i].minlenp =
6311                                             data_fake.substrs[i].minlenp;
6312                                 data->substrs[i].lookbehind += scan->flags;
6313                             }
6314                         }
6315                     }
6316                 }
6317             }
6318 #endif
6319         }
6320         else if (OP(scan) == OPEN) {
6321             if (stopparen != (I32)ARG(scan))
6322                 pars++;
6323         }
6324         else if (OP(scan) == CLOSE) {
6325             if (stopparen == (I32)ARG(scan)) {
6326                 break;
6327             }
6328             if ((I32)ARG(scan) == is_par) {
6329                 next = regnext(scan);
6330
6331                 if ( next && (OP(next) != WHILEM) && next < last)
6332                     is_par = 0;         /* Disable optimization */
6333             }
6334             if (data)
6335                 *(data->last_closep) = ARG(scan);
6336         }
6337         else if (OP(scan) == EVAL) {
6338                 if (data)
6339                     data->flags |= SF_HAS_EVAL;
6340         }
6341         else if ( PL_regkind[OP(scan)] == ENDLIKE ) {
6342             if (flags & SCF_DO_SUBSTR) {
6343                 scan_commit(pRExC_state, data, minlenp, is_inf);
6344                 flags &= ~SCF_DO_SUBSTR;
6345             }
6346             if (data && OP(scan)==ACCEPT) {
6347                 data->flags |= SCF_SEEN_ACCEPT;
6348                 if (stopmin > min)
6349                     stopmin = min;
6350             }
6351         }
6352         else if (OP(scan) == LOGICAL && scan->flags == 2) /* Embedded follows */
6353         {
6354                 if (flags & SCF_DO_SUBSTR) {
6355                     scan_commit(pRExC_state, data, minlenp, is_inf);
6356                     data->cur_is_floating = 1; /* float */
6357                 }
6358                 is_inf = is_inf_internal = 1;
6359                 if (flags & SCF_DO_STCLASS_OR) /* Allow everything */
6360                     ssc_anything(data->start_class);
6361                 flags &= ~SCF_DO_STCLASS;
6362         }
6363         else if (OP(scan) == GPOS) {
6364             if (!(RExC_rx->intflags & PREGf_GPOS_FLOAT) &&
6365                 !(delta || is_inf || (data && data->pos_delta)))
6366             {
6367                 if (!(RExC_rx->intflags & PREGf_ANCH) && (flags & SCF_DO_SUBSTR))
6368                     RExC_rx->intflags |= PREGf_ANCH_GPOS;
6369                 if (RExC_rx->gofs < (STRLEN)min)
6370                     RExC_rx->gofs = min;
6371             } else {
6372                 RExC_rx->intflags |= PREGf_GPOS_FLOAT;
6373                 RExC_rx->gofs = 0;
6374             }
6375         }
6376 #ifdef TRIE_STUDY_OPT
6377 #ifdef FULL_TRIE_STUDY
6378         else if (PL_regkind[OP(scan)] == TRIE) {
6379             /* NOTE - There is similar code to this block above for handling
6380                BRANCH nodes on the initial study.  If you change stuff here
6381                check there too. */
6382             regnode *trie_node= scan;
6383             regnode *tail= regnext(scan);
6384             reg_trie_data *trie = (reg_trie_data*)RExC_rxi->data->data[ ARG(scan) ];
6385             SSize_t max1 = 0, min1 = OPTIMIZE_INFTY;
6386             regnode_ssc accum;
6387
6388             if (flags & SCF_DO_SUBSTR) { /* XXXX Add !SUSPEND? */
6389                 /* Cannot merge strings after this. */
6390                 scan_commit(pRExC_state, data, minlenp, is_inf);
6391             }
6392             if (flags & SCF_DO_STCLASS)
6393                 ssc_init_zero(pRExC_state, &accum);
6394
6395             if (!trie->jump) {
6396                 min1= trie->minlen;
6397                 max1= trie->maxlen;
6398             } else {
6399                 const regnode *nextbranch= NULL;
6400                 U32 word;
6401
6402                 for ( word=1 ; word <= trie->wordcount ; word++)
6403                 {
6404                     SSize_t deltanext=0, minnext=0, f = 0, fake;
6405                     regnode_ssc this_class;
6406
6407                     StructCopy(&zero_scan_data, &data_fake, scan_data_t);
6408                     if (data) {
6409                         data_fake.whilem_c = data->whilem_c;
6410                         data_fake.last_closep = data->last_closep;
6411                     }
6412                     else
6413                         data_fake.last_closep = &fake;
6414                     data_fake.pos_delta = delta;
6415                     if (flags & SCF_DO_STCLASS) {
6416                         ssc_init(pRExC_state, &this_class);
6417                         data_fake.start_class = &this_class;
6418                         f = SCF_DO_STCLASS_AND;
6419                     }
6420                     if (flags & SCF_WHILEM_VISITED_POS)
6421                         f |= SCF_WHILEM_VISITED_POS;
6422
6423                     if (trie->jump[word]) {
6424                         if (!nextbranch)
6425                             nextbranch = trie_node + trie->jump[0];
6426                         scan= trie_node + trie->jump[word];
6427                         /* We go from the jump point to the branch that follows
6428                            it. Note this means we need the vestigal unused
6429                            branches even though they arent otherwise used. */
6430                         /* optimise study_chunk() for TRIE */
6431                         minnext = study_chunk(pRExC_state, &scan, minlenp,
6432                             &deltanext, (regnode *)nextbranch, &data_fake,
6433                             stopparen, recursed_depth, NULL, f, depth+1,
6434                             mutate_ok);
6435                     }
6436                     if (nextbranch && PL_regkind[OP(nextbranch)]==BRANCH)
6437                         nextbranch= regnext((regnode*)nextbranch);
6438
6439                     if (min1 > (SSize_t)(minnext + trie->minlen))
6440                         min1 = minnext + trie->minlen;
6441                     if (deltanext == OPTIMIZE_INFTY) {
6442                         is_inf = is_inf_internal = 1;
6443                         max1 = OPTIMIZE_INFTY;
6444                     } else if (max1 < (SSize_t)(minnext + deltanext + trie->maxlen))
6445                         max1 = minnext + deltanext + trie->maxlen;
6446
6447                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
6448                         pars++;
6449                     if (data_fake.flags & SCF_SEEN_ACCEPT) {
6450                         if ( stopmin > min + min1)
6451                             stopmin = min + min1;
6452                         flags &= ~SCF_DO_SUBSTR;
6453                         if (data)
6454                             data->flags |= SCF_SEEN_ACCEPT;
6455                     }
6456                     if (data) {
6457                         if (data_fake.flags & SF_HAS_EVAL)
6458                             data->flags |= SF_HAS_EVAL;
6459                         data->whilem_c = data_fake.whilem_c;
6460                     }
6461                     if (flags & SCF_DO_STCLASS)
6462                         ssc_or(pRExC_state, &accum, (regnode_charclass *) &this_class);
6463                 }
6464             }
6465             if (flags & SCF_DO_SUBSTR) {
6466                 data->pos_min += min1;
6467                 data->pos_delta += max1 - min1;
6468                 if (max1 != min1 || is_inf)
6469                     data->cur_is_floating = 1; /* float */
6470             }
6471             min += min1;
6472             if (delta != OPTIMIZE_INFTY) {
6473                 if (OPTIMIZE_INFTY - (max1 - min1) >= delta)
6474                     delta += max1 - min1;
6475                 else
6476                     delta = OPTIMIZE_INFTY;
6477             }
6478             if (flags & SCF_DO_STCLASS_OR) {
6479                 ssc_or(pRExC_state, data->start_class, (regnode_charclass *) &accum);
6480                 if (min1) {
6481                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
6482                     flags &= ~SCF_DO_STCLASS;
6483                 }
6484             }
6485             else if (flags & SCF_DO_STCLASS_AND) {
6486                 if (min1) {
6487                     ssc_and(pRExC_state, data->start_class, (regnode_charclass *) &accum);
6488                     flags &= ~SCF_DO_STCLASS;
6489                 }
6490                 else {
6491                     /* Switch to OR mode: cache the old value of
6492                      * data->start_class */
6493                     INIT_AND_WITHP;
6494                     StructCopy(data->start_class, and_withp, regnode_ssc);
6495                     flags &= ~SCF_DO_STCLASS_AND;
6496                     StructCopy(&accum, data->start_class, regnode_ssc);
6497                     flags |= SCF_DO_STCLASS_OR;
6498                 }
6499             }
6500             scan= tail;
6501             continue;
6502         }
6503 #else
6504         else if (PL_regkind[OP(scan)] == TRIE) {
6505             reg_trie_data *trie = (reg_trie_data*)RExC_rxi->data->data[ ARG(scan) ];
6506             U8*bang=NULL;
6507
6508             min += trie->minlen;
6509             delta += (trie->maxlen - trie->minlen);
6510             flags &= ~SCF_DO_STCLASS; /* xxx */
6511             if (flags & SCF_DO_SUBSTR) {
6512                 /* Cannot expect anything... */
6513                 scan_commit(pRExC_state, data, minlenp, is_inf);
6514                 data->pos_min += trie->minlen;
6515                 data->pos_delta += (trie->maxlen - trie->minlen);
6516                 if (trie->maxlen != trie->minlen)
6517                     data->cur_is_floating = 1; /* float */
6518             }
6519             if (trie->jump) /* no more substrings -- for now /grr*/
6520                flags &= ~SCF_DO_SUBSTR;
6521         }
6522         else if (OP(scan) == REGEX_SET) {
6523             Perl_croak(aTHX_ "panic: %s regnode should be resolved"
6524                              " before optimization", reg_name[REGEX_SET]);
6525         }
6526
6527 #endif /* old or new */
6528 #endif /* TRIE_STUDY_OPT */
6529
6530         /* Else: zero-length, ignore. */
6531         scan = regnext(scan);
6532     }
6533
6534   finish:
6535     if (frame) {
6536         /* we need to unwind recursion. */
6537         depth = depth - 1;
6538
6539         DEBUG_STUDYDATA("frame-end", data, depth, is_inf);
6540         DEBUG_PEEP("fend", scan, depth, flags);
6541
6542         /* restore previous context */
6543         last = frame->last_regnode;
6544         scan = frame->next_regnode;
6545         stopparen = frame->stopparen;
6546         recursed_depth = frame->prev_recursed_depth;
6547
6548         RExC_frame_last = frame->prev_frame;
6549         frame = frame->this_prev_frame;
6550         goto fake_study_recurse;
6551     }
6552
6553     assert(!frame);
6554     DEBUG_STUDYDATA("pre-fin", data, depth, is_inf);
6555
6556     *scanp = scan;
6557     *deltap = is_inf_internal ? OPTIMIZE_INFTY : delta;
6558
6559     if (flags & SCF_DO_SUBSTR && is_inf)
6560         data->pos_delta = OPTIMIZE_INFTY - data->pos_min;
6561     if (is_par > (I32)U8_MAX)
6562         is_par = 0;
6563     if (is_par && pars==1 && data) {
6564         data->flags |= SF_IN_PAR;
6565         data->flags &= ~SF_HAS_PAR;
6566     }
6567     else if (pars && data) {
6568         data->flags |= SF_HAS_PAR;
6569         data->flags &= ~SF_IN_PAR;
6570     }
6571     if (flags & SCF_DO_STCLASS_OR)
6572         ssc_and(pRExC_state, data->start_class, (regnode_charclass *) and_withp);
6573     if (flags & SCF_TRIE_RESTUDY)
6574         data->flags |=  SCF_TRIE_RESTUDY;
6575
6576     DEBUG_STUDYDATA("post-fin", data, depth, is_inf);
6577
6578     final_minlen = min < stopmin
6579             ? min : stopmin;
6580
6581     if (!(RExC_seen & REG_UNBOUNDED_QUANTIFIER_SEEN)) {
6582         if (final_minlen > OPTIMIZE_INFTY - delta)
6583             RExC_maxlen = OPTIMIZE_INFTY;
6584         else if (RExC_maxlen < final_minlen + delta)
6585             RExC_maxlen = final_minlen + delta;
6586     }
6587     return final_minlen;
6588 }
6589
6590 STATIC U32
6591 S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n)
6592 {
6593     U32 count = RExC_rxi->data ? RExC_rxi->data->count : 0;
6594
6595     PERL_ARGS_ASSERT_ADD_DATA;
6596
6597     Renewc(RExC_rxi->data,
6598            sizeof(*RExC_rxi->data) + sizeof(void*) * (count + n - 1),
6599            char, struct reg_data);
6600     if(count)
6601         Renew(RExC_rxi->data->what, count + n, U8);
6602     else
6603         Newx(RExC_rxi->data->what, n, U8);
6604     RExC_rxi->data->count = count + n;
6605     Copy(s, RExC_rxi->data->what + count, n, U8);
6606     return count;
6607 }
6608
6609 /*XXX: todo make this not included in a non debugging perl, but appears to be
6610  * used anyway there, in 'use re' */
6611 #ifndef PERL_IN_XSUB_RE
6612 void
6613 Perl_reginitcolors(pTHX)
6614 {
6615     const char * const s = PerlEnv_getenv("PERL_RE_COLORS");
6616     if (s) {
6617         char *t = savepv(s);
6618         int i = 0;
6619         PL_colors[0] = t;
6620         while (++i < 6) {
6621             t = strchr(t, '\t');
6622             if (t) {
6623                 *t = '\0';
6624                 PL_colors[i] = ++t;
6625             }
6626             else
6627                 PL_colors[i] = t = (char *)"";
6628         }
6629     } else {
6630         int i = 0;
6631         while (i < 6)
6632             PL_colors[i++] = (char *)"";
6633     }
6634     PL_colorset = 1;
6635 }
6636 #endif
6637
6638
6639 #ifdef TRIE_STUDY_OPT
6640 #define CHECK_RESTUDY_GOTO_butfirst(dOsomething)            \
6641     STMT_START {                                            \
6642         if (                                                \
6643               (data.flags & SCF_TRIE_RESTUDY)               \
6644               && ! restudied++                              \
6645         ) {                                                 \
6646             dOsomething;                                    \
6647             goto reStudy;                                   \
6648         }                                                   \
6649     } STMT_END
6650 #else
6651 #define CHECK_RESTUDY_GOTO_butfirst
6652 #endif
6653
6654 /*
6655  * pregcomp - compile a regular expression into internal code
6656  *
6657  * Decides which engine's compiler to call based on the hint currently in
6658  * scope
6659  */
6660
6661 #ifndef PERL_IN_XSUB_RE
6662
6663 /* return the currently in-scope regex engine (or the default if none)  */
6664
6665 regexp_engine const *
6666 Perl_current_re_engine(pTHX)
6667 {
6668     if (IN_PERL_COMPILETIME) {
6669         HV * const table = GvHV(PL_hintgv);
6670         SV **ptr;
6671
6672         if (!table || !(PL_hints & HINT_LOCALIZE_HH))
6673             return &PL_core_reg_engine;
6674         ptr = hv_fetchs(table, "regcomp", FALSE);
6675         if ( !(ptr && SvIOK(*ptr) && SvIV(*ptr)))
6676             return &PL_core_reg_engine;
6677         return INT2PTR(regexp_engine*, SvIV(*ptr));
6678     }
6679     else {
6680         SV *ptr;
6681         if (!PL_curcop->cop_hints_hash)
6682             return &PL_core_reg_engine;
6683         ptr = cop_hints_fetch_pvs(PL_curcop, "regcomp", 0);
6684         if ( !(ptr && SvIOK(ptr) && SvIV(ptr)))
6685             return &PL_core_reg_engine;
6686         return INT2PTR(regexp_engine*, SvIV(ptr));
6687     }
6688 }
6689
6690
6691 REGEXP *
6692 Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags)
6693 {
6694     regexp_engine const *eng = current_re_engine();
6695     DECLARE_AND_GET_RE_DEBUG_FLAGS;
6696
6697     PERL_ARGS_ASSERT_PREGCOMP;
6698
6699     /* Dispatch a request to compile a regexp to correct regexp engine. */
6700     DEBUG_COMPILE_r({
6701         Perl_re_printf( aTHX_  "Using engine %" UVxf "\n",
6702                         PTR2UV(eng));
6703     });
6704     return CALLREGCOMP_ENG(eng, pattern, flags);
6705 }
6706 #endif
6707
6708 /* public(ish) entry point for the perl core's own regex compiling code.
6709  * It's actually a wrapper for Perl_re_op_compile that only takes an SV
6710  * pattern rather than a list of OPs, and uses the internal engine rather
6711  * than the current one */
6712
6713 REGEXP *
6714 Perl_re_compile(pTHX_ SV * const pattern, U32 rx_flags)
6715 {
6716     SV *pat = pattern; /* defeat constness! */
6717
6718     PERL_ARGS_ASSERT_RE_COMPILE;
6719
6720     return Perl_re_op_compile(aTHX_ &pat, 1, NULL,
6721 #ifdef PERL_IN_XSUB_RE
6722                                 &my_reg_engine,
6723 #else
6724                                 &PL_core_reg_engine,
6725 #endif
6726                                 NULL, NULL, rx_flags, 0);
6727 }
6728
6729 static void
6730 S_free_codeblocks(pTHX_ struct reg_code_blocks *cbs)
6731 {
6732     int n;
6733
6734     if (--cbs->refcnt > 0)
6735         return;
6736     for (n = 0; n < cbs->count; n++) {
6737         REGEXP *rx = cbs->cb[n].src_regex;
6738         if (rx) {
6739             cbs->cb[n].src_regex = NULL;
6740             SvREFCNT_dec_NN(rx);
6741         }
6742     }
6743     Safefree(cbs->cb);
6744     Safefree(cbs);
6745 }
6746
6747
6748 static struct reg_code_blocks *
6749 S_alloc_code_blocks(pTHX_  int ncode)
6750 {
6751      struct reg_code_blocks *cbs;
6752     Newx(cbs, 1, struct reg_code_blocks);
6753     cbs->count = ncode;
6754     cbs->refcnt = 1;
6755     SAVEDESTRUCTOR_X(S_free_codeblocks, cbs);
6756     if (ncode)
6757         Newx(cbs->cb, ncode, struct reg_code_block);
6758     else
6759         cbs->cb = NULL;
6760     return cbs;
6761 }
6762
6763
6764 /* upgrade pattern pat_p of length plen_p to UTF8, and if there are code
6765  * blocks, recalculate the indices. Update pat_p and plen_p in-place to
6766  * point to the realloced string and length.
6767  *
6768  * This is essentially a copy of Perl_bytes_to_utf8() with the code index
6769  * stuff added */
6770
6771 static void
6772 S_pat_upgrade_to_utf8(pTHX_ RExC_state_t * const pRExC_state,
6773                     char **pat_p, STRLEN *plen_p, int num_code_blocks)
6774 {
6775     U8 *const src = (U8*)*pat_p;
6776     U8 *dst, *d;
6777     int n=0;
6778     STRLEN s = 0;
6779     bool do_end = 0;
6780     DECLARE_AND_GET_RE_DEBUG_FLAGS;
6781
6782     DEBUG_PARSE_r(Perl_re_printf( aTHX_
6783         "UTF8 mismatch! Converting to utf8 for resizing and compile\n"));
6784
6785     /* 1 for each byte + 1 for each byte that expands to two, + trailing NUL */
6786     Newx(dst, *plen_p + variant_under_utf8_count(src, src + *plen_p) + 1, U8);
6787     d = dst;
6788
6789     while (s < *plen_p) {
6790         append_utf8_from_native_byte(src[s], &d);
6791
6792         if (n < num_code_blocks) {
6793             assert(pRExC_state->code_blocks);
6794             if (!do_end && pRExC_state->code_blocks->cb[n].start == s) {
6795                 pRExC_state->code_blocks->cb[n].start = d - dst - 1;
6796                 assert(*(d - 1) == '(');
6797                 do_end = 1;
6798             }
6799             else if (do_end && pRExC_state->code_blocks->cb[n].end == s) {
6800                 pRExC_state->code_blocks->cb[n].end = d - dst - 1;
6801                 assert(*(d - 1) == ')');
6802                 do_end = 0;
6803                 n++;
6804             }
6805         }
6806         s++;
6807     }
6808     *d = '\0';
6809     *plen_p = d - dst;
6810     *pat_p = (char*) dst;
6811     SAVEFREEPV(*pat_p);
6812     RExC_orig_utf8 = RExC_utf8 = 1;
6813 }
6814
6815
6816
6817 /* S_concat_pat(): concatenate a list of args to the pattern string pat,
6818  * while recording any code block indices, and handling overloading,
6819  * nested qr// objects etc.  If pat is null, it will allocate a new
6820  * string, or just return the first arg, if there's only one.
6821  *
6822  * Returns the malloced/updated pat.
6823  * patternp and pat_count is the array of SVs to be concatted;
6824  * oplist is the optional list of ops that generated the SVs;
6825  * recompile_p is a pointer to a boolean that will be set if
6826  *   the regex will need to be recompiled.
6827  * delim, if non-null is an SV that will be inserted between each element
6828  */
6829
6830 static SV*
6831 S_concat_pat(pTHX_ RExC_state_t * const pRExC_state,
6832                 SV *pat, SV ** const patternp, int pat_count,
6833                 OP *oplist, bool *recompile_p, SV *delim)
6834 {
6835     SV **svp;
6836     int n = 0;
6837     bool use_delim = FALSE;
6838     bool alloced = FALSE;
6839
6840     /* if we know we have at least two args, create an empty string,
6841      * then concatenate args to that. For no args, return an empty string */
6842     if (!pat && pat_count != 1) {
6843         pat = newSVpvs("");
6844         SAVEFREESV(pat);
6845         alloced = TRUE;
6846     }
6847
6848     for (svp = patternp; svp < patternp + pat_count; svp++) {
6849         SV *sv;
6850         SV *rx  = NULL;
6851         STRLEN orig_patlen = 0;
6852         bool code = 0;
6853         SV *msv = use_delim ? delim : *svp;
6854         if (!msv) msv = &PL_sv_undef;
6855
6856         /* if we've got a delimiter, we go round the loop twice for each
6857          * svp slot (except the last), using the delimiter the second
6858          * time round */
6859         if (use_delim) {
6860             svp--;
6861             use_delim = FALSE;
6862         }
6863         else if (delim)
6864             use_delim = TRUE;
6865
6866         if (SvTYPE(msv) == SVt_PVAV) {
6867             /* we've encountered an interpolated array within
6868              * the pattern, e.g. /...@a..../. Expand the list of elements,
6869              * then recursively append elements.
6870              * The code in this block is based on S_pushav() */
6871
6872             AV *const av = (AV*)msv;
6873             const SSize_t maxarg = AvFILL(av) + 1;
6874             SV **array;
6875
6876             if (oplist) {
6877                 assert(oplist->op_type == OP_PADAV
6878                     || oplist->op_type == OP_RV2AV);
6879                 oplist = OpSIBLING(oplist);
6880             }
6881
6882             if (SvRMAGICAL(av)) {
6883                 SSize_t i;
6884
6885                 Newx(array, maxarg, SV*);
6886                 SAVEFREEPV(array);
6887                 for (i=0; i < maxarg; i++) {
6888                     SV ** const svp = av_fetch(av, i, FALSE);
6889                     array[i] = svp ? *svp : &PL_sv_undef;
6890                 }
6891             }
6892             else
6893                 array = AvARRAY(av);
6894
6895             pat = S_concat_pat(aTHX_ pRExC_state, pat,
6896                                 array, maxarg, NULL, recompile_p,
6897                                 /* $" */
6898                                 GvSV((gv_fetchpvs("\"", GV_ADDMULTI, SVt_PV))));
6899
6900             continue;
6901         }
6902
6903
6904         /* we make the assumption here that each op in the list of
6905          * op_siblings maps to one SV pushed onto the stack,
6906          * except for code blocks, with have both an OP_NULL and
6907          * an OP_CONST.
6908          * This allows us to match up the list of SVs against the
6909          * list of OPs to find the next code block.
6910          *
6911          * Note that       PUSHMARK PADSV PADSV ..
6912          * is optimised to
6913          *                 PADRANGE PADSV  PADSV  ..
6914          * so the alignment still works. */
6915
6916         if (oplist) {
6917             if (oplist->op_type == OP_NULL
6918                 && (oplist->op_flags & OPf_SPECIAL))
6919             {
6920                 assert(n < pRExC_state->code_blocks->count);
6921                 pRExC_state->code_blocks->cb[n].start = pat ? SvCUR(pat) : 0;
6922                 pRExC_state->code_blocks->cb[n].block = oplist;
6923                 pRExC_state->code_blocks->cb[n].src_regex = NULL;
6924                 n++;
6925                 code = 1;
6926                 oplist = OpSIBLING(oplist); /* skip CONST */
6927                 assert(oplist);
6928             }
6929             oplist = OpSIBLING(oplist);;
6930         }
6931
6932         /* apply magic and QR overloading to arg */
6933
6934         SvGETMAGIC(msv);
6935         if (SvROK(msv) && SvAMAGIC(msv)) {
6936             SV *sv = AMG_CALLunary(msv, regexp_amg);
6937             if (sv) {
6938                 if (SvROK(sv))
6939                     sv = SvRV(sv);
6940                 if (SvTYPE(sv) != SVt_REGEXP)
6941                     Perl_croak(aTHX_ "Overloaded qr did not return a REGEXP");
6942                 msv = sv;
6943             }
6944         }
6945
6946         /* try concatenation overload ... */
6947         if (pat && (SvAMAGIC(pat) || SvAMAGIC(msv)) &&
6948                 (sv = amagic_call(pat, msv, concat_amg, AMGf_assign)))
6949         {
6950             sv_setsv(pat, sv);
6951             /* overloading involved: all bets are off over literal
6952              * code. Pretend we haven't seen it */
6953             if (n)
6954                 pRExC_state->code_blocks->count -= n;
6955             n = 0;
6956         }
6957         else {
6958             /* ... or failing that, try "" overload */
6959             while (SvAMAGIC(msv)
6960                     && (sv = AMG_CALLunary(msv, string_amg))
6961                     && sv != msv
6962                     &&  !(   SvROK(msv)
6963                           && SvROK(sv)
6964                           && SvRV(msv) == SvRV(sv))
6965             ) {
6966                 msv = sv;
6967                 SvGETMAGIC(msv);
6968             }
6969             if (SvROK(msv) && SvTYPE(SvRV(msv)) == SVt_REGEXP)
6970                 msv = SvRV(msv);
6971
6972             if (pat) {
6973                 /* this is a partially unrolled
6974                  *     sv_catsv_nomg(pat, msv);
6975                  * that allows us to adjust code block indices if
6976                  * needed */
6977                 STRLEN dlen;
6978                 char *dst = SvPV_force_nomg(pat, dlen);
6979                 orig_patlen = dlen;
6980                 if (SvUTF8(msv) && !SvUTF8(pat)) {
6981                     S_pat_upgrade_to_utf8(aTHX_ pRExC_state, &dst, &dlen, n);
6982                     sv_setpvn(pat, dst, dlen);
6983                     SvUTF8_on(pat);
6984                 }
6985                 sv_catsv_nomg(pat, msv);
6986                 rx = msv;
6987             }
6988             else {
6989                 /* We have only one SV to process, but we need to verify
6990                  * it is properly null terminated or we will fail asserts
6991                  * later. In theory we probably shouldn't get such SV's,
6992                  * but if we do we should handle it gracefully. */
6993                 if ( SvTYPE(msv) != SVt_PV || (SvLEN(msv) > SvCUR(msv) && *(SvEND(msv)) == 0) || SvIsCOW_shared_hash(msv) ) {
6994                     /* not a string, or a string with a trailing null */
6995                     pat = msv;
6996                 } else {
6997                     /* a string with no trailing null, we need to copy it
6998                      * so it has a trailing null */
6999                     pat = sv_2mortal(newSVsv(msv));
7000                 }
7001             }
7002
7003             if (code)
7004                 pRExC_state->code_blocks->cb[n-1].end = SvCUR(pat)-1;
7005         }
7006
7007         /* extract any code blocks within any embedded qr//'s */
7008         if (rx && SvTYPE(rx) == SVt_REGEXP
7009             && RX_ENGINE((REGEXP*)rx)->op_comp)
7010         {
7011
7012             RXi_GET_DECL(ReANY((REGEXP *)rx), ri);
7013             if (ri->code_blocks && ri->code_blocks->count) {
7014                 int i;
7015                 /* the presence of an embedded qr// with code means
7016                  * we should always recompile: the text of the
7017                  * qr// may not have changed, but it may be a
7018                  * different closure than last time */
7019                 *recompile_p = 1;
7020                 if (pRExC_state->code_blocks) {
7021                     int new_count = pRExC_state->code_blocks->count
7022                             + ri->code_blocks->count;
7023                     Renew(pRExC_state->code_blocks->cb,
7024                             new_count, struct reg_code_block);
7025                     pRExC_state->code_blocks->count = new_count;
7026                 }
7027                 else
7028                     pRExC_state->code_blocks = S_alloc_code_blocks(aTHX_
7029                                                     ri->code_blocks->count);
7030
7031                 for (i=0; i < ri->code_blocks->count; i++) {
7032                     struct reg_code_block *src, *dst;
7033                     STRLEN offset =  orig_patlen
7034                         + ReANY((REGEXP *)rx)->pre_prefix;
7035                     assert(n < pRExC_state->code_blocks->count);
7036                     src = &ri->code_blocks->cb[i];
7037                     dst = &pRExC_state->code_blocks->cb[n];
7038                     dst->start      = src->start + offset;
7039                     dst->end        = src->end   + offset;
7040                     dst->block      = src->block;
7041                     dst->src_regex  = (REGEXP*) SvREFCNT_inc( (SV*)
7042                                             src->src_regex
7043                                                 ? src->src_regex
7044                                                 : (REGEXP*)rx);
7045                     n++;
7046                 }
7047             }
7048         }
7049     }
7050     /* avoid calling magic multiple times on a single element e.g. =~ $qr */
7051     if (alloced)
7052         SvSETMAGIC(pat);
7053
7054     return pat;
7055 }
7056
7057
7058
7059 /* see if there are any run-time code blocks in the pattern.
7060  * False positives are allowed */
7061
7062 static bool
7063 S_has_runtime_code(pTHX_ RExC_state_t * const pRExC_state,
7064                     char *pat, STRLEN plen)
7065 {
7066     int n = 0;
7067     STRLEN s;
7068
7069     PERL_UNUSED_CONTEXT;
7070
7071     for (s = 0; s < plen; s++) {
7072         if (   pRExC_state->code_blocks
7073             && n < pRExC_state->code_blocks->count
7074             && s == pRExC_state->code_blocks->cb[n].start)
7075         {
7076             s = pRExC_state->code_blocks->cb[n].end;
7077             n++;
7078             continue;
7079         }
7080         /* TODO ideally should handle [..], (#..), /#.../x to reduce false
7081          * positives here */
7082         if (pat[s] == '(' && s+2 <= plen && pat[s+1] == '?' &&
7083             (pat[s+2] == '{'
7084                 || (s + 2 <= plen && pat[s+2] == '?' && pat[s+3] == '{'))
7085         )
7086             return 1;
7087     }
7088     return 0;
7089 }
7090
7091 /* Handle run-time code blocks. We will already have compiled any direct
7092  * or indirect literal code blocks. Now, take the pattern 'pat' and make a
7093  * copy of it, but with any literal code blocks blanked out and
7094  * appropriate chars escaped; then feed it into
7095  *
7096  *    eval "qr'modified_pattern'"
7097  *
7098  * For example,
7099  *
7100  *       a\bc(?{"this was literal"})def'ghi\\jkl(?{"this is runtime"})mno
7101  *
7102  * becomes
7103  *
7104  *    qr'a\\bc_______________________def\'ghi\\\\jkl(?{"this is runtime"})mno'
7105  *
7106  * After eval_sv()-ing that, grab any new code blocks from the returned qr
7107  * and merge them with any code blocks of the original regexp.
7108  *
7109  * If the pat is non-UTF8, while the evalled qr is UTF8, don't merge;
7110  * instead, just save the qr and return FALSE; this tells our caller that
7111  * the original pattern needs upgrading to utf8.
7112  */
7113
7114 static bool
7115 S_compile_runtime_code(pTHX_ RExC_state_t * const pRExC_state,
7116     char *pat, STRLEN plen)
7117 {
7118     SV *qr;
7119
7120     DECLARE_AND_GET_RE_DEBUG_FLAGS;
7121
7122     if (pRExC_state->runtime_code_qr) {
7123         /* this is the second time we've been called; this should
7124          * only happen if the main pattern got upgraded to utf8
7125          * during compilation; re-use the qr we compiled first time
7126          * round (which should be utf8 too)
7127          */
7128         qr = pRExC_state->runtime_code_qr;
7129         pRExC_state->runtime_code_qr = NULL;
7130         assert(RExC_utf8 && SvUTF8(qr));
7131     }
7132     else {
7133         int n = 0;
7134         STRLEN s;
7135         char *p, *newpat;
7136         int newlen = plen + 7; /* allow for "qr''xx\0" extra chars */
7137         SV *sv, *qr_ref;
7138         dSP;
7139
7140         /* determine how many extra chars we need for ' and \ escaping */
7141         for (s = 0; s < plen; s++) {
7142             if (pat[s] == '\'' || pat[s] == '\\')
7143                 newlen++;
7144         }
7145
7146         Newx(newpat, newlen, char);
7147         p = newpat;
7148         *p++ = 'q'; *p++ = 'r'; *p++ = '\'';
7149
7150         for (s = 0; s < plen; s++) {
7151             if (   pRExC_state->code_blocks
7152                 && n < pRExC_state->code_blocks->count
7153                 && s == pRExC_state->code_blocks->cb[n].start)
7154             {
7155                 /* blank out literal code block so that they aren't
7156                  * recompiled: eg change from/to:
7157                  *     /(?{xyz})/
7158                  *     /(?=====)/
7159                  * and
7160                  *     /(??{xyz})/
7161                  *     /(?======)/
7162                  * and
7163                  *     /(?(?{xyz}))/
7164                  *     /(?(?=====))/
7165                 */
7166                 assert(pat[s]   == '(');
7167                 assert(pat[s+1] == '?');
7168                 *p++ = '(';
7169                 *p++ = '?';
7170                 s += 2;
7171                 while (s < pRExC_state->code_blocks->cb[n].end) {
7172                     *p++ = '=';
7173                     s++;
7174                 }
7175                 *p++ = ')';
7176                 n++;
7177                 continue;
7178             }
7179             if (pat[s] == '\'' || pat[s] == '\\')
7180                 *p++ = '\\';
7181             *p++ = pat[s];
7182         }
7183         *p++ = '\'';
7184         if (pRExC_state->pm_flags & RXf_PMf_EXTENDED) {
7185             *p++ = 'x';
7186             if (pRExC_state->pm_flags & RXf_PMf_EXTENDED_MORE) {
7187                 *p++ = 'x';
7188             }
7189         }
7190         *p++ = '\0';
7191         DEBUG_COMPILE_r({
7192             Perl_re_printf( aTHX_
7193                 "%sre-parsing pattern for runtime code:%s %s\n",
7194                 PL_colors[4], PL_colors[5], newpat);
7195         });
7196
7197         sv = newSVpvn_flags(newpat, p-newpat-1, RExC_utf8 ? SVf_UTF8 : 0);
7198         Safefree(newpat);
7199
7200         ENTER;
7201         SAVETMPS;
7202         save_re_context();
7203         PUSHSTACKi(PERLSI_REQUIRE);
7204         /* G_RE_REPARSING causes the toker to collapse \\ into \ when
7205          * parsing qr''; normally only q'' does this. It also alters
7206          * hints handling */
7207         eval_sv(sv, G_SCALAR|G_RE_REPARSING);
7208         SvREFCNT_dec_NN(sv);
7209         SPAGAIN;
7210         qr_ref = POPs;
7211         PUTBACK;
7212         {
7213             SV * const errsv = ERRSV;
7214             if (SvTRUE_NN(errsv))
7215                 /* use croak_sv ? */
7216                 Perl_croak_nocontext("%" SVf, SVfARG(errsv));
7217         }
7218         assert(SvROK(qr_ref));
7219         qr = SvRV(qr_ref);
7220         assert(SvTYPE(qr) == SVt_REGEXP && RX_ENGINE((REGEXP*)qr)->op_comp);
7221         /* the leaving below frees the tmp qr_ref.
7222          * Give qr a life of its own */
7223         SvREFCNT_inc(qr);
7224         POPSTACK;
7225         FREETMPS;
7226         LEAVE;
7227
7228     }
7229
7230     if (!RExC_utf8 && SvUTF8(qr)) {
7231         /* first time through; the pattern got upgraded; save the
7232          * qr for the next time through */
7233         assert(!pRExC_state->runtime_code_qr);
7234         pRExC_state->runtime_code_qr = qr;
7235         return 0;
7236     }
7237
7238
7239     /* extract any code blocks within the returned qr//  */
7240
7241
7242     /* merge the main (r1) and run-time (r2) code blocks into one */
7243     {
7244         RXi_GET_DECL(ReANY((REGEXP *)qr), r2);
7245         struct reg_code_block *new_block, *dst;
7246         RExC_state_t * const r1 = pRExC_state; /* convenient alias */
7247         int i1 = 0, i2 = 0;
7248         int r1c, r2c;
7249
7250         if (!r2->code_blocks || !r2->code_blocks->count) /* we guessed wrong */
7251         {
7252             SvREFCNT_dec_NN(qr);
7253             return 1;
7254         }
7255
7256         if (!r1->code_blocks)
7257             r1->code_blocks = S_alloc_code_blocks(aTHX_ 0);
7258
7259         r1c = r1->code_blocks->count;
7260         r2c = r2->code_blocks->count;
7261
7262         Newx(new_block, r1c + r2c, struct reg_code_block);
7263
7264         dst = new_block;
7265
7266         while (i1 < r1c || i2 < r2c) {
7267             struct reg_code_block *src;
7268             bool is_qr = 0;
7269
7270             if (i1 == r1c) {
7271                 src = &r2->code_blocks->cb[i2++];
7272                 is_qr = 1;
7273             }
7274             else if (i2 == r2c)
7275                 src = &r1->code_blocks->cb[i1++];
7276             else if (  r1->code_blocks->cb[i1].start
7277                      < r2->code_blocks->cb[i2].start)
7278             {
7279                 src = &r1->code_blocks->cb[i1++];
7280                 assert(src->end < r2->code_blocks->cb[i2].start);
7281             }
7282             else {
7283                 assert(  r1->code_blocks->cb[i1].start
7284                        > r2->code_blocks->cb[i2].start);
7285                 src = &r2->code_blocks->cb[i2++];
7286                 is_qr = 1;
7287                 assert(src->end < r1->code_blocks->cb[i1].start);
7288             }
7289
7290             assert(pat[src->start] == '(');
7291             assert(pat[src->end]   == ')');
7292             dst->start      = src->start;
7293             dst->end        = src->end;
7294             dst->block      = src->block;
7295             dst->src_regex  = is_qr ? (REGEXP*) SvREFCNT_inc( (SV*) qr)
7296                                     : src->src_regex;
7297             dst++;
7298         }
7299         r1->code_blocks->count += r2c;
7300         Safefree(r1->code_blocks->cb);
7301         r1->code_blocks->cb = new_block;
7302     }
7303
7304     SvREFCNT_dec_NN(qr);
7305     return 1;
7306 }
7307
7308
7309 STATIC bool
7310 S_setup_longest(pTHX_ RExC_state_t *pRExC_state,
7311                       struct reg_substr_datum  *rsd,
7312                       struct scan_data_substrs *sub,
7313                       STRLEN longest_length)
7314 {
7315     /* This is the common code for setting up the floating and fixed length
7316      * string data extracted from Perl_re_op_compile() below.  Returns a boolean
7317      * as to whether succeeded or not */
7318
7319     I32 t;
7320     SSize_t ml;
7321     bool eol  = cBOOL(sub->flags & SF_BEFORE_EOL);
7322     bool meol = cBOOL(sub->flags & SF_BEFORE_MEOL);
7323
7324     if (! (longest_length
7325            || (eol /* Can't have SEOL and MULTI */
7326                && (! meol || (RExC_flags & RXf_PMf_MULTILINE)))
7327           )
7328             /* See comments for join_exact for why REG_UNFOLDED_MULTI_SEEN */
7329         || (RExC_seen & REG_UNFOLDED_MULTI_SEEN))
7330     {
7331         return FALSE;
7332     }
7333
7334     /* copy the information about the longest from the reg_scan_data
7335         over to the program. */
7336     if (SvUTF8(sub->str)) {
7337         rsd->substr      = NULL;
7338         rsd->utf8_substr = sub->str;
7339     } else {
7340         rsd->substr      = sub->str;
7341         rsd->utf8_substr = NULL;
7342     }
7343     /* end_shift is how many chars that must be matched that
7344         follow this item. We calculate it ahead of time as once the
7345         lookbehind offset is added in we lose the ability to correctly
7346         calculate it.*/
7347     ml = sub->minlenp ? *(sub->minlenp) : (SSize_t)longest_length;
7348     rsd->end_shift = ml - sub->min_offset
7349         - longest_length
7350             /* XXX SvTAIL is always false here - did you mean FBMcf_TAIL
7351              * intead? - DAPM
7352             + (SvTAIL(sub->str) != 0)
7353             */
7354         + sub->lookbehind;
7355
7356     t = (eol/* Can't have SEOL and MULTI */
7357          && (! meol || (RExC_flags & RXf_PMf_MULTILINE)));
7358     fbm_compile(sub->str, t ? FBMcf_TAIL : 0);
7359
7360     return TRUE;
7361 }
7362
7363 STATIC void
7364 S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx)
7365 {
7366     /* Calculates and sets in the compiled pattern 'Rx' the string to compile,
7367      * properly wrapped with the right modifiers */
7368
7369     bool has_p     = ((RExC_rx->extflags & RXf_PMf_KEEPCOPY) == RXf_PMf_KEEPCOPY);
7370     bool has_charset = RExC_utf8 || (get_regex_charset(RExC_rx->extflags)
7371                                                 != REGEX_DEPENDS_CHARSET);
7372
7373     /* The caret is output if there are any defaults: if not all the STD
7374         * flags are set, or if no character set specifier is needed */
7375     bool has_default =
7376                 (((RExC_rx->extflags & RXf_PMf_STD_PMMOD) != RXf_PMf_STD_PMMOD)
7377                 || ! has_charset);
7378     bool has_runon = ((RExC_seen & REG_RUN_ON_COMMENT_SEEN)
7379                                                 == REG_RUN_ON_COMMENT_SEEN);
7380     U8 reganch = (U8)((RExC_rx->extflags & RXf_PMf_STD_PMMOD)
7381                         >> RXf_PMf_STD_PMMOD_SHIFT);
7382     const char *fptr = STD_PAT_MODS;        /*"msixxn"*/
7383     char *p;
7384     STRLEN pat_len = RExC_precomp_end - RExC_precomp;
7385
7386     /* We output all the necessary flags; we never output a minus, as all
7387         * those are defaults, so are
7388         * covered by the caret */
7389     const STRLEN wraplen = pat_len + has_p + has_runon
7390         + has_default       /* If needs a caret */
7391         + PL_bitcount[reganch] /* 1 char for each set standard flag */
7392
7393             /* If needs a character set specifier */
7394         + ((has_charset) ? MAX_CHARSET_NAME_LENGTH : 0)
7395         + (sizeof("(?:)") - 1);
7396
7397     PERL_ARGS_ASSERT_SET_REGEX_PV;
7398
7399     /* make sure PL_bitcount bounds not exceeded */
7400     STATIC_ASSERT_STMT(sizeof(STD_PAT_MODS) <= 8);
7401
7402     p = sv_grow(MUTABLE_SV(Rx), wraplen + 1); /* +1 for the ending NUL */
7403     SvPOK_on(Rx);
7404     if (RExC_utf8)
7405         SvFLAGS(Rx) |= SVf_UTF8;
7406     *p++='('; *p++='?';
7407
7408     /* If a default, cover it using the caret */
7409     if (has_default) {
7410         *p++= DEFAULT_PAT_MOD;
7411     }
7412     if (has_charset) {
7413         STRLEN len;
7414         const char* name;
7415
7416         name = get_regex_charset_name(RExC_rx->extflags, &len);
7417         if (strEQ(name, DEPENDS_PAT_MODS)) {  /* /d under UTF-8 => /u */
7418             assert(RExC_utf8);
7419             name = UNICODE_PAT_MODS;
7420             len = sizeof(UNICODE_PAT_MODS) - 1;
7421         }
7422         Copy(name, p, len, char);
7423         p += len;
7424     }
7425     if (has_p)
7426         *p++ = KEEPCOPY_PAT_MOD; /*'p'*/
7427     {
7428         char ch;
7429         while((ch = *fptr++)) {
7430             if(reganch & 1)
7431                 *p++ = ch;
7432             reganch >>= 1;
7433         }
7434     }
7435
7436     *p++ = ':';
7437     Copy(RExC_precomp, p, pat_len, char);
7438     assert ((RX_WRAPPED(Rx) - p) < 16);
7439     RExC_rx->pre_prefix = p - RX_WRAPPED(Rx);
7440     p += pat_len;
7441
7442     /* Adding a trailing \n causes this to compile properly:
7443             my $R = qr / A B C # D E/x; /($R)/
7444         Otherwise the parens are considered part of the comment */
7445     if (has_runon)
7446         *p++ = '\n';
7447     *p++ = ')';
7448     *p = 0;
7449     SvCUR_set(Rx, p - RX_WRAPPED(Rx));
7450 }
7451
7452 /*
7453  * Perl_re_op_compile - the perl internal RE engine's function to compile a
7454  * regular expression into internal code.
7455  * The pattern may be passed either as:
7456  *    a list of SVs (patternp plus pat_count)
7457  *    a list of OPs (expr)
7458  * If both are passed, the SV list is used, but the OP list indicates
7459  * which SVs are actually pre-compiled code blocks
7460  *
7461  * The SVs in the list have magic and qr overloading applied to them (and
7462  * the list may be modified in-place with replacement SVs in the latter
7463  * case).
7464  *
7465  * If the pattern hasn't changed from old_re, then old_re will be
7466  * returned.
7467  *
7468  * eng is the current engine. If that engine has an op_comp method, then
7469  * handle directly (i.e. we assume that op_comp was us); otherwise, just
7470  * do the initial concatenation of arguments and pass on to the external
7471  * engine.
7472  *
7473  * If is_bare_re is not null, set it to a boolean indicating whether the
7474  * arg list reduced (after overloading) to a single bare regex which has
7475  * been returned (i.e. /$qr/).
7476  *
7477  * orig_rx_flags contains RXf_* flags. See perlreapi.pod for more details.
7478  *
7479  * pm_flags contains the PMf_* flags, typically based on those from the
7480  * pm_flags field of the related PMOP. Currently we're only interested in
7481  * PMf_HAS_CV, PMf_IS_QR, PMf_USE_RE_EVAL, PMf_WILDCARD.
7482  *
7483  * For many years this code had an initial sizing pass that calculated
7484  * (sometimes incorrectly, leading to security holes) the size needed for the
7485  * compiled pattern.  That was changed by commit
7486  * 7c932d07cab18751bfc7515b4320436273a459e2 in 5.29, which reallocs the size, a
7487  * node at a time, as parsing goes along.  Patches welcome to fix any obsolete
7488  * references to this sizing pass.
7489  *
7490  * Now, an initial crude guess as to the size needed is made, based on the
7491  * length of the pattern.  Patches welcome to improve that guess.  That amount
7492  * of space is malloc'd and then immediately freed, and then clawed back node
7493  * by node.  This design is to minimze, to the extent possible, memory churn
7494  * when doing the reallocs.
7495  *
7496  * A separate parentheses counting pass may be needed in some cases.
7497  * (Previously the sizing pass did this.)  Patches welcome to reduce the number
7498  * of these cases.
7499  *
7500  * The existence of a sizing pass necessitated design decisions that are no
7501  * longer needed.  There are potential areas of simplification.
7502  *
7503  * Beware that the optimization-preparation code in here knows about some
7504  * of the structure of the compiled regexp.  [I'll say.]
7505  */
7506
7507 REGEXP *
7508 Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count,
7509                     OP *expr, const regexp_engine* eng, REGEXP *old_re,
7510                      bool *is_bare_re, const U32 orig_rx_flags, const U32 pm_flags)
7511 {
7512     REGEXP *Rx;         /* Capital 'R' means points to a REGEXP */
7513     STRLEN plen;
7514     char *exp;
7515     regnode *scan;
7516     I32 flags;
7517     SSize_t minlen = 0;
7518     U32 rx_flags;
7519     SV *pat;
7520     SV** new_patternp = patternp;
7521
7522     /* these are all flags - maybe they should be turned
7523      * into a single int with different bit masks */
7524     I32 sawlookahead = 0;
7525     I32 sawplus = 0;
7526     I32 sawopen = 0;
7527     I32 sawminmod = 0;
7528
7529     regex_charset initial_charset = get_regex_charset(orig_rx_flags);
7530     bool recompile = 0;
7531     bool runtime_code = 0;
7532     scan_data_t data;
7533     RExC_state_t RExC_state;
7534     RExC_state_t * const pRExC_state = &RExC_state;
7535 #ifdef TRIE_STUDY_OPT
7536     int restudied = 0;
7537     RExC_state_t copyRExC_state;
7538 #endif
7539     DECLARE_AND_GET_RE_DEBUG_FLAGS;
7540
7541     PERL_ARGS_ASSERT_RE_OP_COMPILE;
7542
7543     DEBUG_r(if (!PL_colorset) reginitcolors());
7544
7545
7546     pRExC_state->warn_text = NULL;
7547     pRExC_state->unlexed_names = NULL;
7548     pRExC_state->code_blocks = NULL;
7549
7550     if (is_bare_re)
7551         *is_bare_re = FALSE;
7552
7553     if (expr && (expr->op_type == OP_LIST ||
7554                 (expr->op_type == OP_NULL && expr->op_targ == OP_LIST))) {
7555         /* allocate code_blocks if needed */
7556         OP *o;
7557         int ncode = 0;
7558
7559         for (o = cLISTOPx(expr)->op_first; o; o = OpSIBLING(o))
7560             if (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL))
7561                 ncode++; /* count of DO blocks */
7562
7563         if (ncode)
7564             pRExC_state->code_blocks = S_alloc_code_blocks(aTHX_ ncode);
7565     }
7566
7567     if (!pat_count) {
7568         /* compile-time pattern with just OP_CONSTs and DO blocks */
7569
7570         int n;
7571         OP *o;
7572
7573         /* find how many CONSTs there are */
7574         assert(expr);
7575         n = 0;
7576         if (expr->op_type == OP_CONST)
7577             n = 1;
7578         else
7579             for (o = cLISTOPx(expr)->op_first; o; o = OpSIBLING(o)) {
7580                 if (o->op_type == OP_CONST)
7581                     n++;
7582             }
7583
7584         /* fake up an SV array */
7585
7586         assert(!new_patternp);
7587         Newx(new_patternp, n, SV*);
7588         SAVEFREEPV(new_patternp);
7589         pat_count = n;
7590
7591         n = 0;
7592         if (expr->op_type == OP_CONST)
7593             new_patternp[n] = cSVOPx_sv(expr);
7594         else
7595             for (o = cLISTOPx(expr)->op_first; o; o = OpSIBLING(o)) {
7596                 if (o->op_type == OP_CONST)
7597                     new_patternp[n++] = cSVOPo_sv;
7598             }
7599
7600     }
7601
7602     DEBUG_PARSE_r(Perl_re_printf( aTHX_
7603         "Assembling pattern from %d elements%s\n", pat_count,
7604             orig_rx_flags & RXf_SPLIT ? " for split" : ""));
7605
7606     /* set expr to the first arg op */
7607
7608     if (pRExC_state->code_blocks && pRExC_state->code_blocks->count
7609          && expr->op_type != OP_CONST)
7610     {
7611             expr = cLISTOPx(expr)->op_first;
7612             assert(   expr->op_type == OP_PUSHMARK
7613                    || (expr->op_type == OP_NULL && expr->op_targ == OP_PUSHMARK)
7614                    || expr->op_type == OP_PADRANGE);
7615             expr = OpSIBLING(expr);
7616     }
7617
7618     pat = S_concat_pat(aTHX_ pRExC_state, NULL, new_patternp, pat_count,
7619                         expr, &recompile, NULL);
7620
7621     /* handle bare (possibly after overloading) regex: foo =~ $re */
7622     {
7623         SV *re = pat;
7624         if (SvROK(re))
7625             re = SvRV(re);
7626         if (SvTYPE(re) == SVt_REGEXP) {
7627             if (is_bare_re)
7628                 *is_bare_re = TRUE;
7629             SvREFCNT_inc(re);
7630             DEBUG_PARSE_r(Perl_re_printf( aTHX_
7631                 "Precompiled pattern%s\n",
7632                     orig_rx_flags & RXf_SPLIT ? " for split" : ""));
7633
7634             return (REGEXP*)re;
7635         }
7636     }
7637
7638     exp = SvPV_nomg(pat, plen);
7639
7640     if (!eng->op_comp) {
7641         if ((SvUTF8(pat) && IN_BYTES)
7642                 || SvGMAGICAL(pat) || SvAMAGIC(pat))
7643         {
7644             /* make a temporary copy; either to convert to bytes,
7645              * or to avoid repeating get-magic / overloaded stringify */
7646             pat = newSVpvn_flags(exp, plen, SVs_TEMP |
7647                                         (IN_BYTES ? 0 : SvUTF8(pat)));
7648         }
7649         return CALLREGCOMP_ENG(eng, pat, orig_rx_flags);
7650     }
7651
7652     /* ignore the utf8ness if the pattern is 0 length */
7653     RExC_utf8 = RExC_orig_utf8 = (plen == 0 || IN_BYTES) ? 0 : SvUTF8(pat);
7654     RExC_uni_semantics = 0;
7655     RExC_contains_locale = 0;
7656     RExC_strict = cBOOL(pm_flags & RXf_PMf_STRICT);
7657     RExC_in_script_run = 0;
7658     RExC_study_started = 0;
7659     pRExC_state->runtime_code_qr = NULL;
7660     RExC_frame_head= NULL;
7661     RExC_frame_last= NULL;
7662     RExC_frame_count= 0;
7663     RExC_latest_warn_offset = 0;
7664     RExC_use_BRANCHJ = 0;
7665     RExC_warned_WARN_EXPERIMENTAL__VLB = 0;
7666     RExC_warned_WARN_EXPERIMENTAL__REGEX_SETS = 0;
7667     RExC_total_parens = 0;
7668     RExC_open_parens = NULL;
7669     RExC_close_parens = NULL;
7670     RExC_paren_names = NULL;
7671     RExC_size = 0;
7672     RExC_seen_d_op = FALSE;
7673 #ifdef DEBUGGING
7674     RExC_paren_name_list = NULL;
7675 #endif
7676
7677     DEBUG_r({
7678         RExC_mysv1= sv_newmortal();
7679         RExC_mysv2= sv_newmortal();
7680     });
7681
7682     DEBUG_COMPILE_r({
7683             SV *dsv= sv_newmortal();
7684             RE_PV_QUOTED_DECL(s, RExC_utf8, dsv, exp, plen, PL_dump_re_max_len);
7685             Perl_re_printf( aTHX_  "%sCompiling REx%s %s\n",
7686                           PL_colors[4], PL_colors[5], s);
7687         });
7688
7689     /* we jump here if we have to recompile, e.g., from upgrading the pattern
7690      * to utf8 */
7691
7692     if ((pm_flags & PMf_USE_RE_EVAL)
7693                 /* this second condition covers the non-regex literal case,
7694                  * i.e.  $foo =~ '(?{})'. */
7695                 || (IN_PERL_COMPILETIME && (PL_hints & HINT_RE_EVAL))
7696     )
7697         runtime_code = S_has_runtime_code(aTHX_ pRExC_state, exp, plen);
7698
7699   redo_parse:
7700     /* return old regex if pattern hasn't changed */
7701     /* XXX: note in the below we have to check the flags as well as the
7702      * pattern.
7703      *
7704      * Things get a touch tricky as we have to compare the utf8 flag
7705      * independently from the compile flags.  */
7706
7707     if (   old_re
7708         && !recompile
7709         && !!RX_UTF8(old_re) == !!RExC_utf8
7710         && ( RX_COMPFLAGS(old_re) == ( orig_rx_flags & RXf_PMf_FLAGCOPYMASK ) )
7711         && RX_PRECOMP(old_re)
7712         && RX_PRELEN(old_re) == plen
7713         && memEQ(RX_PRECOMP(old_re), exp, plen)
7714         && !runtime_code /* with runtime code, always recompile */ )
7715     {
7716         DEBUG_COMPILE_r({
7717             SV *dsv= sv_newmortal();
7718             RE_PV_QUOTED_DECL(s, RExC_utf8, dsv, exp, plen, PL_dump_re_max_len);
7719             Perl_re_printf( aTHX_  "%sSkipping recompilation of unchanged REx%s %s\n",
7720                           PL_colors[4], PL_colors[5], s);
7721         });
7722         return old_re;
7723     }
7724
7725     /* Allocate the pattern's SV */
7726     RExC_rx_sv = Rx = (REGEXP*) newSV_type(SVt_REGEXP);
7727     RExC_rx = ReANY(Rx);
7728     if ( RExC_rx == NULL )
7729         FAIL("Regexp out of space");
7730
7731     rx_flags = orig_rx_flags;
7732
7733     if (   toUSE_UNI_CHARSET_NOT_DEPENDS
7734         && initial_charset == REGEX_DEPENDS_CHARSET)
7735     {
7736
7737         /* Set to use unicode semantics if the pattern is in utf8 and has the
7738          * 'depends' charset specified, as it means unicode when utf8  */
7739         set_regex_charset(&rx_flags, REGEX_UNICODE_CHARSET);
7740         RExC_uni_semantics = 1;
7741     }
7742
7743     RExC_pm_flags = pm_flags;
7744
7745     if (runtime_code) {
7746         assert(TAINTING_get || !TAINT_get);
7747         if (TAINT_get)
7748             Perl_croak(aTHX_ "Eval-group in insecure regular expression");
7749
7750         if (!S_compile_runtime_code(aTHX_ pRExC_state, exp, plen)) {
7751             /* whoops, we have a non-utf8 pattern, whilst run-time code
7752              * got compiled as utf8. Try again with a utf8 pattern */
7753             S_pat_upgrade_to_utf8(aTHX_ pRExC_state, &exp, &plen,
7754                 pRExC_state->code_blocks ? pRExC_state->code_blocks->count : 0);
7755             goto redo_parse;
7756         }
7757     }
7758     assert(!pRExC_state->runtime_code_qr);
7759
7760     RExC_sawback = 0;
7761
7762     RExC_seen = 0;
7763     RExC_maxlen = 0;
7764     RExC_in_lookaround = 0;
7765     RExC_seen_zerolen = *exp == '^' ? -1 : 0;
7766     RExC_recode_x_to_native = 0;
7767     RExC_in_multi_char_class = 0;
7768
7769     RExC_start = RExC_copy_start_in_constructed = RExC_copy_start_in_input = RExC_precomp = exp;
7770     RExC_precomp_end = RExC_end = exp + plen;
7771     RExC_nestroot = 0;
7772     RExC_whilem_seen = 0;
7773     RExC_end_op = NULL;
7774     RExC_recurse = NULL;
7775     RExC_study_chunk_recursed = NULL;
7776     RExC_study_chunk_recursed_bytes= 0;
7777     RExC_recurse_count = 0;
7778     RExC_sets_depth = 0;
7779     pRExC_state->code_index = 0;
7780
7781     /* Initialize the string in the compiled pattern.  This is so that there is
7782      * something to output if necessary */
7783     set_regex_pv(pRExC_state, Rx);
7784
7785     DEBUG_PARSE_r({
7786         Perl_re_printf( aTHX_
7787             "Starting parse and generation\n");
7788         RExC_lastnum=0;
7789         RExC_lastparse=NULL;
7790     });
7791
7792     /* Allocate space and zero-initialize. Note, the two step process
7793        of zeroing when in debug mode, thus anything assigned has to
7794        happen after that */
7795     if (!  RExC_size) {
7796
7797         /* On the first pass of the parse, we guess how big this will be.  Then
7798          * we grow in one operation to that amount and then give it back.  As
7799          * we go along, we re-allocate what we need.
7800          *
7801          * XXX Currently the guess is essentially that the pattern will be an
7802          * EXACT node with one byte input, one byte output.  This is crude, and
7803          * better heuristics are welcome.
7804          *
7805          * On any subsequent passes, we guess what we actually computed in the
7806          * latest earlier pass.  Such a pass probably didn't complete so is
7807          * missing stuff.  We could improve those guesses by knowing where the
7808          * parse stopped, and use the length so far plus apply the above
7809          * assumption to what's left. */
7810         RExC_size = STR_SZ(RExC_end - RExC_start);
7811     }
7812
7813     Newxc(RExC_rxi, sizeof(regexp_internal) + RExC_size, char, regexp_internal);
7814     if ( RExC_rxi == NULL )
7815         FAIL("Regexp out of space");
7816
7817     Zero(RExC_rxi, sizeof(regexp_internal) + RExC_size, char);
7818     RXi_SET( RExC_rx, RExC_rxi );
7819
7820     /* We start from 0 (over from 0 in the case this is a reparse.  The first
7821      * node parsed will give back any excess memory we have allocated so far).
7822      * */
7823     RExC_size = 0;
7824
7825     /* non-zero initialization begins here */
7826     RExC_rx->engine= eng;
7827     RExC_rx->extflags = rx_flags;
7828     RXp_COMPFLAGS(RExC_rx) = orig_rx_flags & RXf_PMf_FLAGCOPYMASK;
7829
7830     if (pm_flags & PMf_IS_QR) {
7831         RExC_rxi->code_blocks = pRExC_state->code_blocks;
7832         if (RExC_rxi->code_blocks) {
7833             RExC_rxi->code_blocks->refcnt++;
7834         }
7835     }
7836
7837     RExC_rx->intflags = 0;
7838
7839     RExC_flags = rx_flags;      /* don't let top level (?i) bleed */
7840     RExC_parse = exp;
7841
7842     /* This NUL is guaranteed because the pattern comes from an SV*, and the sv
7843      * code makes sure the final byte is an uncounted NUL.  But should this
7844      * ever not be the case, lots of things could read beyond the end of the
7845      * buffer: loops like
7846      *      while(isFOO(*RExC_parse)) RExC_parse++;
7847      *      strchr(RExC_parse, "foo");
7848      * etc.  So it is worth noting. */
7849     assert(*RExC_end == '\0');
7850
7851     RExC_naughty = 0;
7852     RExC_npar = 1;
7853     RExC_parens_buf_size = 0;
7854     RExC_emit_start = RExC_rxi->program;
7855     pRExC_state->code_index = 0;
7856
7857     *((char*) RExC_emit_start) = (char) REG_MAGIC;
7858     RExC_emit = 1;
7859
7860     /* Do the parse */
7861     if (reg(pRExC_state, 0, &flags, 1)) {
7862
7863         /* Success!, But we may need to redo the parse knowing how many parens
7864          * there actually are */
7865         if (IN_PARENS_PASS) {
7866             flags |= RESTART_PARSE;
7867         }
7868
7869         /* We have that number in RExC_npar */
7870         RExC_total_parens = RExC_npar;
7871     }
7872     else if (! MUST_RESTART(flags)) {
7873         ReREFCNT_dec(Rx);
7874         Perl_croak(aTHX_ "panic: reg returned failure to re_op_compile, flags=%#" UVxf, (UV) flags);
7875     }
7876
7877     /* Here, we either have success, or we have to redo the parse for some reason */
7878     if (MUST_RESTART(flags)) {
7879
7880         /* It's possible to write a regexp in ascii that represents Unicode
7881         codepoints outside of the byte range, such as via \x{100}. If we
7882         detect such a sequence we have to convert the entire pattern to utf8
7883         and then recompile, as our sizing calculation will have been based
7884         on 1 byte == 1 character, but we will need to use utf8 to encode
7885         at least some part of the pattern, and therefore must convert the whole
7886         thing.
7887         -- dmq */
7888         if (flags & NEED_UTF8) {
7889
7890             /* We have stored the offset of the final warning output so far.
7891              * That must be adjusted.  Any variant characters between the start
7892              * of the pattern and this warning count for 2 bytes in the final,
7893              * so just add them again */
7894             if (UNLIKELY(RExC_latest_warn_offset > 0)) {
7895                 RExC_latest_warn_offset +=
7896                             variant_under_utf8_count((U8 *) exp, (U8 *) exp
7897                                                 + RExC_latest_warn_offset);
7898             }
7899             S_pat_upgrade_to_utf8(aTHX_ pRExC_state, &exp, &plen,
7900             pRExC_state->code_blocks ? pRExC_state->code_blocks->count : 0);
7901             DEBUG_PARSE_r(Perl_re_printf( aTHX_ "Need to redo parse after upgrade\n"));
7902         }
7903         else {
7904             DEBUG_PARSE_r(Perl_re_printf( aTHX_ "Need to redo parse\n"));
7905         }
7906
7907         if (ALL_PARENS_COUNTED) {
7908             /* Make enough room for all the known parens, and zero it */
7909             Renew(RExC_open_parens, RExC_total_parens, regnode_offset);
7910             Zero(RExC_open_parens, RExC_total_parens, regnode_offset);
7911             RExC_open_parens[0] = 1;    /* +1 for REG_MAGIC */
7912
7913             Renew(RExC_close_parens, RExC_total_parens, regnode_offset);
7914             Zero(RExC_close_parens, RExC_total_parens, regnode_offset);
7915         }
7916         else { /* Parse did not complete.  Reinitialize the parentheses
7917                   structures */
7918             RExC_total_parens = 0;
7919             if (RExC_open_parens) {
7920                 Safefree(RExC_open_parens);
7921                 RExC_open_parens = NULL;
7922             }
7923             if (RExC_close_parens) {
7924                 Safefree(RExC_close_parens);
7925                 RExC_close_parens = NULL;
7926             }
7927         }
7928
7929         /* Clean up what we did in this parse */
7930         SvREFCNT_dec_NN(RExC_rx_sv);
7931
7932         goto redo_parse;
7933     }
7934
7935     /* Here, we have successfully parsed and generated the pattern's program
7936      * for the regex engine.  We are ready to finish things up and look for
7937      * optimizations. */
7938
7939     /* Update the string to compile, with correct modifiers, etc */
7940     set_regex_pv(pRExC_state, Rx);
7941
7942     RExC_rx->nparens = RExC_total_parens - 1;
7943
7944     /* Uses the upper 4 bits of the FLAGS field, so keep within that size */
7945     if (RExC_whilem_seen > 15)
7946         RExC_whilem_seen = 15;
7947
7948     DEBUG_PARSE_r({
7949         Perl_re_printf( aTHX_
7950             "Required size %" IVdf " nodes\n", (IV)RExC_size);
7951         RExC_lastnum=0;
7952         RExC_lastparse=NULL;
7953     });
7954
7955 #ifdef RE_TRACK_PATTERN_OFFSETS
7956     DEBUG_OFFSETS_r(Perl_re_printf( aTHX_
7957                           "%s %" UVuf " bytes for offset annotations.\n",
7958                           RExC_offsets ? "Got" : "Couldn't get",
7959                           (UV)((RExC_offsets[0] * 2 + 1))));
7960     DEBUG_OFFSETS_r(if (RExC_offsets) {
7961         const STRLEN len = RExC_offsets[0];
7962         STRLEN i;
7963         DECLARE_AND_GET_RE_DEBUG_FLAGS;
7964         Perl_re_printf( aTHX_
7965                       "Offsets: [%" UVuf "]\n\t", (UV)RExC_offsets[0]);
7966         for (i = 1; i <= len; i++) {
7967             if (RExC_offsets[i*2-1] || RExC_offsets[i*2])
7968                 Perl_re_printf( aTHX_  "%" UVuf ":%" UVuf "[%" UVuf "] ",
7969                 (UV)i, (UV)RExC_offsets[i*2-1], (UV)RExC_offsets[i*2]);
7970         }
7971         Perl_re_printf( aTHX_  "\n");
7972     });
7973
7974 #else
7975     SetProgLen(RExC_rxi,RExC_size);
7976 #endif
7977
7978     DEBUG_DUMP_PRE_OPTIMIZE_r({
7979         SV * const sv = sv_newmortal();
7980         RXi_GET_DECL(RExC_rx, ri);
7981         DEBUG_RExC_seen();
7982         Perl_re_printf( aTHX_ "Program before optimization:\n");
7983
7984         (void)dumpuntil(RExC_rx, ri->program, ri->program + 1, NULL, NULL,
7985                         sv, 0, 0);
7986     });
7987
7988     DEBUG_OPTIMISE_r(
7989         Perl_re_printf( aTHX_  "Starting post parse optimization\n");
7990     );
7991
7992     /* XXXX To minimize changes to RE engine we always allocate
7993        3-units-long substrs field. */
7994     Newx(RExC_rx->substrs, 1, struct reg_substr_data);
7995     if (RExC_recurse_count) {
7996         Newx(RExC_recurse, RExC_recurse_count, regnode *);
7997         SAVEFREEPV(RExC_recurse);
7998     }
7999
8000     if (RExC_seen & REG_RECURSE_SEEN) {
8001         /* Note, RExC_total_parens is 1 + the number of parens in a pattern.
8002          * So its 1 if there are no parens. */
8003         RExC_study_chunk_recursed_bytes= (RExC_total_parens >> 3) +
8004                                          ((RExC_total_parens & 0x07) != 0);
8005         Newx(RExC_study_chunk_recursed,
8006              RExC_study_chunk_recursed_bytes * RExC_total_parens, U8);
8007         SAVEFREEPV(RExC_study_chunk_recursed);
8008     }
8009
8010   reStudy:
8011     RExC_rx->minlen = minlen = sawlookahead = sawplus = sawopen = sawminmod = 0;
8012     DEBUG_r(
8013         RExC_study_chunk_recursed_count= 0;
8014     );
8015     Zero(RExC_rx->substrs, 1, struct reg_substr_data);
8016     if (RExC_study_chunk_recursed) {
8017         Zero(RExC_study_chunk_recursed,
8018              RExC_study_chunk_recursed_bytes * RExC_total_parens, U8);
8019     }
8020
8021
8022 #ifdef TRIE_STUDY_OPT
8023     if (!restudied) {
8024         StructCopy(&zero_scan_data, &data, scan_data_t);
8025         copyRExC_state = RExC_state;
8026     } else {
8027         U32 seen=RExC_seen;
8028         DEBUG_OPTIMISE_r(Perl_re_printf( aTHX_ "Restudying\n"));
8029
8030         RExC_state = copyRExC_state;
8031         if (seen & REG_TOP_LEVEL_BRANCHES_SEEN)
8032             RExC_seen |= REG_TOP_LEVEL_BRANCHES_SEEN;
8033         else
8034             RExC_seen &= ~REG_TOP_LEVEL_BRANCHES_SEEN;
8035         StructCopy(&zero_scan_data, &data, scan_data_t);
8036     }
8037 #else
8038     StructCopy(&zero_scan_data, &data, scan_data_t);
8039 #endif
8040
8041     /* Dig out information for optimizations. */
8042     RExC_rx->extflags = RExC_flags; /* was pm_op */
8043     /*dmq: removed as part of de-PMOP: pm->op_pmflags = RExC_flags; */
8044
8045     if (UTF)
8046         SvUTF8_on(Rx);  /* Unicode in it? */
8047     RExC_rxi->regstclass = NULL;
8048     if (RExC_naughty >= TOO_NAUGHTY)    /* Probably an expensive pattern. */
8049         RExC_rx->intflags |= PREGf_NAUGHTY;
8050     scan = RExC_rxi->program + 1;               /* First BRANCH. */
8051
8052     /* testing for BRANCH here tells us whether there is "must appear"
8053        data in the pattern. If there is then we can use it for optimisations */
8054     if (!(RExC_seen & REG_TOP_LEVEL_BRANCHES_SEEN)) { /*  Only one top-level choice.
8055                                                   */
8056         SSize_t fake;
8057         STRLEN longest_length[2];
8058         regnode_ssc ch_class; /* pointed to by data */
8059         int stclass_flag;
8060         SSize_t last_close = 0; /* pointed to by data */
8061         regnode *first= scan;
8062         regnode *first_next= regnext(first);
8063         int i;
8064
8065         /*
8066          * Skip introductions and multiplicators >= 1
8067          * so that we can extract the 'meat' of the pattern that must
8068          * match in the large if() sequence following.
8069          * NOTE that EXACT is NOT covered here, as it is normally
8070          * picked up by the optimiser separately.
8071          *
8072          * This is unfortunate as the optimiser isnt handling lookahead
8073          * properly currently.
8074          *
8075          */
8076         while ((OP(first) == OPEN && (sawopen = 1)) ||
8077                /* An OR of *one* alternative - should not happen now. */
8078             (OP(first) == BRANCH && OP(first_next) != BRANCH) ||
8079             /* for now we can't handle lookbehind IFMATCH*/
8080             (OP(first) == IFMATCH && !first->flags && (sawlookahead = 1)) ||
8081             (OP(first) == PLUS) ||
8082             (OP(first) == MINMOD) ||
8083                /* An {n,m} with n>0 */
8084             (PL_regkind[OP(first)] == CURLY && ARG1(first) > 0) ||
8085             (OP(first) == NOTHING && PL_regkind[OP(first_next)] != END ))
8086         {
8087                 /*
8088                  * the only op that could be a regnode is PLUS, all the rest
8089                  * will be regnode_1 or regnode_2.
8090                  *
8091                  * (yves doesn't think this is true)
8092                  */
8093                 if (OP(first) == PLUS)
8094                     sawplus = 1;
8095                 else {
8096                     if (OP(first) == MINMOD)
8097                         sawminmod = 1;
8098                     first += regarglen[OP(first)];
8099                 }
8100                 first = NEXTOPER(first);
8101                 first_next= regnext(first);
8102         }
8103
8104         /* Starting-point info. */
8105       again:
8106         DEBUG_PEEP("first:", first, 0, 0);
8107         /* Ignore EXACT as we deal with it later. */
8108         if (PL_regkind[OP(first)] == EXACT) {
8109             if (! isEXACTFish(OP(first))) {
8110                 NOOP;   /* Empty, get anchored substr later. */
8111             }
8112             else
8113                 RExC_rxi->regstclass = first;
8114         }
8115 #ifdef TRIE_STCLASS
8116         else if (PL_regkind[OP(first)] == TRIE &&
8117                 ((reg_trie_data *)RExC_rxi->data->data[ ARG(first) ])->minlen>0)
8118         {
8119             /* this can happen only on restudy */
8120             RExC_rxi->regstclass = construct_ahocorasick_from_trie(pRExC_state, (regnode *)first, 0);
8121         }
8122 #endif
8123         else if (REGNODE_SIMPLE(OP(first)))
8124             RExC_rxi->regstclass = first;
8125         else if (PL_regkind[OP(first)] == BOUND ||
8126                  PL_regkind[OP(first)] == NBOUND)
8127             RExC_rxi->regstclass = first;
8128         else if (PL_regkind[OP(first)] == BOL) {
8129             RExC_rx->intflags |= (OP(first) == MBOL
8130                            ? PREGf_ANCH_MBOL
8131                            : PREGf_ANCH_SBOL);
8132             first = NEXTOPER(first);
8133             goto again;
8134         }
8135         else if (OP(first) == GPOS) {
8136             RExC_rx->intflags |= PREGf_ANCH_GPOS;
8137             first = NEXTOPER(first);
8138             goto again;
8139         }
8140         else if ((!sawopen || !RExC_sawback) &&
8141             !sawlookahead &&
8142             (OP(first) == STAR &&
8143             PL_regkind[OP(NEXTOPER(first))] == REG_ANY) &&
8144             !(RExC_rx->intflags & PREGf_ANCH) && !pRExC_state->code_blocks)
8145         {
8146             /* turn .* into ^.* with an implied $*=1 */
8147             const int type =
8148                 (OP(NEXTOPER(first)) == REG_ANY)
8149                     ? PREGf_ANCH_MBOL
8150                     : PREGf_ANCH_SBOL;
8151             RExC_rx->intflags |= (type | PREGf_IMPLICIT);
8152             first = NEXTOPER(first);
8153             goto again;
8154         }
8155         if (sawplus && !sawminmod && !sawlookahead
8156             && (!sawopen || !RExC_sawback)
8157             && !pRExC_state->code_blocks) /* May examine pos and $& */
8158             /* x+ must match at the 1st pos of run of x's */
8159             RExC_rx->intflags |= PREGf_SKIP;
8160
8161         /* Scan is after the zeroth branch, first is atomic matcher. */
8162 #ifdef TRIE_STUDY_OPT
8163         DEBUG_PARSE_r(
8164             if (!restudied)
8165                 Perl_re_printf( aTHX_  "first at %" IVdf "\n",
8166                               (IV)(first - scan + 1))
8167         );
8168 #else
8169         DEBUG_PARSE_r(
8170             Perl_re_printf( aTHX_  "first at %" IVdf "\n",
8171                 (IV)(first - scan + 1))
8172         );
8173 #endif
8174
8175
8176         /*
8177         * If there's something expensive in the r.e., find the
8178         * longest literal string that must appear and make it the
8179         * regmust.  Resolve ties in favor of later strings, since
8180         * the regstart check works with the beginning of the r.e.
8181         * and avoiding duplication strengthens checking.  Not a
8182         * strong reason, but sufficient in the absence of others.
8183         * [Now we resolve ties in favor of the earlier string if
8184         * it happens that c_offset_min has been invalidated, since the
8185         * earlier string may buy us something the later one won't.]
8186         */
8187
8188         data.substrs[0].str = newSVpvs("");
8189         data.substrs[1].str = newSVpvs("");
8190         data.last_found = newSVpvs("");
8191         data.cur_is_floating = 0; /* initially any found substring is fixed */
8192         ENTER_with_name("study_chunk");
8193         SAVEFREESV(data.substrs[0].str);
8194         SAVEFREESV(data.substrs[1].str);
8195         SAVEFREESV(data.last_found);
8196         first = scan;
8197         if (!RExC_rxi->regstclass) {
8198             ssc_init(pRExC_state, &ch_class);
8199             data.start_class = &ch_class;
8200             stclass_flag = SCF_DO_STCLASS_AND;
8201         } else                          /* XXXX Check for BOUND? */
8202             stclass_flag = 0;
8203         data.last_closep = &last_close;
8204
8205         DEBUG_RExC_seen();
8206         /*
8207          * MAIN ENTRY FOR study_chunk() FOR m/PATTERN/
8208          * (NO top level branches)
8209          */
8210         minlen = study_chunk(pRExC_state, &first, &minlen, &fake,
8211                              scan + RExC_size, /* Up to end */
8212             &data, -1, 0, NULL,
8213             SCF_DO_SUBSTR | SCF_WHILEM_VISITED_POS | stclass_flag
8214                           | (restudied ? SCF_TRIE_DOING_RESTUDY : 0),
8215             0, TRUE);
8216
8217
8218         CHECK_RESTUDY_GOTO_butfirst(LEAVE_with_name("study_chunk"));
8219
8220
8221         if ( RExC_total_parens == 1 && !data.cur_is_floating
8222              && data.last_start_min == 0 && data.last_end > 0
8223              && !RExC_seen_zerolen
8224              && !(RExC_seen & REG_VERBARG_SEEN)
8225              && !(RExC_seen & REG_GPOS_SEEN)
8226         ){
8227             RExC_rx->extflags |= RXf_CHECK_ALL;
8228         }
8229         scan_commit(pRExC_state, &data,&minlen, 0);
8230
8231
8232         /* XXX this is done in reverse order because that's the way the
8233          * code was before it was parameterised. Don't know whether it
8234          * actually needs doing in reverse order. DAPM */
8235         for (i = 1; i >= 0; i--) {
8236             longest_length[i] = CHR_SVLEN(data.substrs[i].str);
8237
8238             if (   !(   i
8239                      && SvCUR(data.substrs[0].str)  /* ok to leave SvCUR */
8240                      &&    data.substrs[0].min_offset
8241                         == data.substrs[1].min_offset
8242                      &&    SvCUR(data.substrs[0].str)
8243                         == SvCUR(data.substrs[1].str)
8244                     )
8245                 && S_setup_longest (aTHX_ pRExC_state,
8246                                         &(RExC_rx->substrs->data[i]),
8247                                         &(data.substrs[i]),
8248                                         longest_length[i]))
8249             {
8250                 RExC_rx->substrs->data[i].min_offset =
8251                         data.substrs[i].min_offset - data.substrs[i].lookbehind;
8252
8253                 RExC_rx->substrs->data[i].max_offset = data.substrs[i].max_offset;
8254                 /* Don't offset infinity */
8255                 if (data.substrs[i].max_offset < OPTIMIZE_INFTY)
8256                     RExC_rx->substrs->data[i].max_offset -= data.substrs[i].lookbehind;
8257                 SvREFCNT_inc_simple_void_NN(data.substrs[i].str);
8258             }
8259             else {
8260                 RExC_rx->substrs->data[i].substr      = NULL;
8261                 RExC_rx->substrs->data[i].utf8_substr = NULL;
8262                 longest_length[i] = 0;
8263             }
8264         }
8265
8266         LEAVE_with_name("study_chunk");
8267
8268         if (RExC_rxi->regstclass
8269             && (OP(RExC_rxi->regstclass) == REG_ANY || OP(RExC_rxi->regstclass) == SANY))
8270             RExC_rxi->regstclass = NULL;
8271
8272         if ((!(RExC_rx->substrs->data[0].substr || RExC_rx->substrs->data[0].utf8_substr)
8273               || RExC_rx->substrs->data[0].min_offset)
8274             && stclass_flag
8275             && ! (ANYOF_FLAGS(data.start_class) & SSC_MATCHES_EMPTY_STRING)
8276             && is_ssc_worth_it(pRExC_state, data.start_class))
8277         {
8278             const U32 n = add_data(pRExC_state, STR_WITH_LEN("f"));
8279
8280             ssc_finalize(pRExC_state, data.start_class);
8281
8282             Newx(RExC_rxi->data->data[n], 1, regnode_ssc);
8283             StructCopy(data.start_class,
8284                        (regnode_ssc*)RExC_rxi->data->data[n],
8285                        regnode_ssc);
8286             RExC_rxi->regstclass = (regnode*)RExC_rxi->data->data[n];
8287             RExC_rx->intflags &= ~PREGf_SKIP;   /* Used in find_byclass(). */
8288             DEBUG_COMPILE_r({ SV *sv = sv_newmortal();
8289                       regprop(RExC_rx, sv, (regnode*)data.start_class, NULL, pRExC_state);
8290                       Perl_re_printf( aTHX_
8291                                     "synthetic stclass \"%s\".\n",
8292                                     SvPVX_const(sv));});
8293             data.start_class = NULL;
8294         }
8295
8296         /* A temporary algorithm prefers floated substr to fixed one of
8297          * same length to dig more info. */
8298         i = (longest_length[0] <= longest_length[1]);
8299         RExC_rx->substrs->check_ix = i;
8300         RExC_rx->check_end_shift  = RExC_rx->substrs->data[i].end_shift;
8301         RExC_rx->check_substr     = RExC_rx->substrs->data[i].substr;
8302         RExC_rx->check_utf8       = RExC_rx->substrs->data[i].utf8_substr;
8303         RExC_rx->check_offset_min = RExC_rx->substrs->data[i].min_offset;
8304         RExC_rx->check_offset_max = RExC_rx->substrs->data[i].max_offset;
8305         if (!i && (RExC_rx->intflags & (PREGf_ANCH_SBOL|PREGf_ANCH_GPOS)))
8306             RExC_rx->intflags |= PREGf_NOSCAN;
8307
8308         if ((RExC_rx->check_substr || RExC_rx->check_utf8) ) {
8309             RExC_rx->extflags |= RXf_USE_INTUIT;
8310             if (SvTAIL(RExC_rx->check_substr ? RExC_rx->check_substr : RExC_rx->check_utf8))
8311                 RExC_rx->extflags |= RXf_INTUIT_TAIL;
8312         }
8313
8314         /* XXX Unneeded? dmq (shouldn't as this is handled elsewhere)
8315         if ( (STRLEN)minlen < longest_length[1] )
8316             minlen= longest_length[1];
8317         if ( (STRLEN)minlen < longest_length[0] )
8318             minlen= longest_length[0];
8319         */
8320     }
8321     else {
8322         /* Several toplevels. Best we can is to set minlen. */
8323         SSize_t fake;
8324         regnode_ssc ch_class;
8325         SSize_t last_close = 0;
8326
8327         DEBUG_PARSE_r(Perl_re_printf( aTHX_  "\nMulti Top Level\n"));
8328
8329         scan = RExC_rxi->program + 1;
8330         ssc_init(pRExC_state, &ch_class);
8331         data.start_class = &ch_class;
8332         data.last_closep = &last_close;
8333
8334         DEBUG_RExC_seen();
8335         /*
8336          * MAIN ENTRY FOR study_chunk() FOR m/P1|P2|.../
8337          * (patterns WITH top level branches)
8338          */
8339         minlen = study_chunk(pRExC_state,
8340             &scan, &minlen, &fake, scan + RExC_size, &data, -1, 0, NULL,
8341             SCF_DO_STCLASS_AND|SCF_WHILEM_VISITED_POS|(restudied
8342                                                       ? SCF_TRIE_DOING_RESTUDY
8343                                                       : 0),
8344             0, TRUE);
8345
8346         CHECK_RESTUDY_GOTO_butfirst(NOOP);
8347
8348         RExC_rx->check_substr = NULL;
8349         RExC_rx->check_utf8 = NULL;
8350         RExC_rx->substrs->data[0].substr      = NULL;
8351         RExC_rx->substrs->data[0].utf8_substr = NULL;
8352         RExC_rx->substrs->data[1].substr      = NULL;
8353         RExC_rx->substrs->data[1].utf8_substr = NULL;
8354
8355         if (! (ANYOF_FLAGS(data.start_class) & SSC_MATCHES_EMPTY_STRING)
8356             && is_ssc_worth_it(pRExC_state, data.start_class))
8357         {
8358             const U32 n = add_data(pRExC_state, STR_WITH_LEN("f"));
8359
8360             ssc_finalize(pRExC_state, data.start_class);
8361
8362             Newx(RExC_rxi->data->data[n], 1, regnode_ssc);
8363             StructCopy(data.start_class,
8364                        (regnode_ssc*)RExC_rxi->data->data[n],
8365                        regnode_ssc);
8366             RExC_rxi->regstclass = (regnode*)RExC_rxi->data->data[n];
8367             RExC_rx->intflags &= ~PREGf_SKIP;   /* Used in find_byclass(). */
8368             DEBUG_COMPILE_r({ SV* sv = sv_newmortal();
8369                       regprop(RExC_rx, sv, (regnode*)data.start_class, NULL, pRExC_state);
8370                       Perl_re_printf( aTHX_
8371                                     "synthetic stclass \"%s\".\n",
8372                                     SvPVX_const(sv));});
8373             data.start_class = NULL;
8374         }
8375     }
8376
8377     if (RExC_seen & REG_UNBOUNDED_QUANTIFIER_SEEN) {
8378         RExC_rx->extflags |= RXf_UNBOUNDED_QUANTIFIER_SEEN;
8379         RExC_rx->maxlen = REG_INFTY;
8380     }
8381     else {
8382         RExC_rx->maxlen = RExC_maxlen;
8383     }
8384
8385     /* Guard against an embedded (?=) or (?<=) with a longer minlen than
8386        the "real" pattern. */
8387     DEBUG_OPTIMISE_r({
8388         Perl_re_printf( aTHX_ "minlen: %" IVdf " RExC_rx->minlen:%" IVdf " maxlen:%" IVdf "\n",
8389                       (IV)minlen, (IV)RExC_rx->minlen, (IV)RExC_maxlen);
8390     });
8391     RExC_rx->minlenret = minlen;
8392     if (RExC_rx->minlen < minlen)
8393         RExC_rx->minlen = minlen;
8394
8395     if (RExC_seen & REG_RECURSE_SEEN ) {
8396         RExC_rx->intflags |= PREGf_RECURSE_SEEN;
8397         Newx(RExC_rx->recurse_locinput, RExC_rx->nparens + 1, char *);
8398     }
8399     if (RExC_seen & REG_GPOS_SEEN)
8400         RExC_rx->intflags |= PREGf_GPOS_SEEN;
8401     if (RExC_seen & REG_LOOKBEHIND_SEEN)
8402         RExC_rx->extflags |= RXf_NO_INPLACE_SUBST; /* inplace might break the
8403                                                 lookbehind */
8404     if (pRExC_state->code_blocks)
8405         RExC_rx->extflags |= RXf_EVAL_SEEN;
8406     if (RExC_seen & REG_VERBARG_SEEN)
8407     {
8408         RExC_rx->intflags |= PREGf_VERBARG_SEEN;
8409         RExC_rx->extflags |= RXf_NO_INPLACE_SUBST; /* don't understand this! Yves */
8410     }
8411     if (RExC_seen & REG_CUTGROUP_SEEN)
8412         RExC_rx->intflags |= PREGf_CUTGROUP_SEEN;
8413     if (pm_flags & PMf_USE_RE_EVAL)
8414         RExC_rx->intflags |= PREGf_USE_RE_EVAL;
8415     if (RExC_paren_names)
8416         RXp_PAREN_NAMES(RExC_rx) = MUTABLE_HV(SvREFCNT_inc(RExC_paren_names));
8417     else
8418         RXp_PAREN_NAMES(RExC_rx) = NULL;
8419
8420     /* If we have seen an anchor in our pattern then we set the extflag RXf_IS_ANCHORED
8421      * so it can be used in pp.c */
8422     if (RExC_rx->intflags & PREGf_ANCH)
8423         RExC_rx->extflags |= RXf_IS_ANCHORED;
8424
8425
8426     {
8427         /* this is used to identify "special" patterns that might result
8428          * in Perl NOT calling the regex engine and instead doing the match "itself",
8429          * particularly special cases in split//. By having the regex compiler
8430          * do this pattern matching at a regop level (instead of by inspecting the pattern)
8431          * we avoid weird issues with equivalent patterns resulting in different behavior,
8432          * AND we allow non Perl engines to get the same optimizations by the setting the
8433          * flags appropriately - Yves */
8434         regnode *first = RExC_rxi->program + 1;
8435         U8 fop = OP(first);
8436         regnode *next = regnext(first);
8437         U8 nop = OP(next);
8438
8439         if (PL_regkind[fop] == NOTHING && nop == END)
8440             RExC_rx->extflags |= RXf_NULL;
8441         else if ((fop == MBOL || (fop == SBOL && !first->flags)) && nop == END)
8442             /* when fop is SBOL first->flags will be true only when it was
8443              * produced by parsing /\A/, and not when parsing /^/. This is
8444              * very important for the split code as there we want to
8445              * treat /^/ as /^/m, but we do not want to treat /\A/ as /^/m.
8446              * See rt #122761 for more details. -- Yves */
8447             RExC_rx->extflags |= RXf_START_ONLY;
8448         else if (fop == PLUS
8449                  && PL_regkind[nop] == POSIXD && FLAGS(next) == _CC_SPACE
8450                  && nop == END)
8451             RExC_rx->extflags |= RXf_WHITE;
8452         else if ( RExC_rx->extflags & RXf_SPLIT
8453                   && (PL_regkind[fop] == EXACT && ! isEXACTFish(fop))
8454                   && STR_LEN(first) == 1
8455                   && *(STRING(first)) == ' '
8456                   && nop == END )
8457             RExC_rx->extflags |= (RXf_SKIPWHITE|RXf_WHITE);
8458
8459     }
8460
8461     if (RExC_contains_locale) {
8462         RXp_EXTFLAGS(RExC_rx) |= RXf_TAINTED;
8463     }
8464
8465 #ifdef DEBUGGING
8466     if (RExC_paren_names) {
8467         RExC_rxi->name_list_idx = add_data( pRExC_state, STR_WITH_LEN("a"));
8468         RExC_rxi->data->data[RExC_rxi->name_list_idx]
8469                                    = (void*)SvREFCNT_inc(RExC_paren_name_list);
8470     } else
8471 #endif
8472     RExC_rxi->name_list_idx = 0;
8473
8474     while ( RExC_recurse_count > 0 ) {
8475         const regnode *scan = RExC_recurse[ --RExC_recurse_count ];
8476         /*
8477          * This data structure is set up in study_chunk() and is used
8478          * to calculate the distance between a GOSUB regopcode and
8479          * the OPEN/CURLYM (CURLYM's are special and can act like OPEN's)
8480          * it refers to.
8481          *
8482          * If for some reason someone writes code that optimises
8483          * away a GOSUB opcode then the assert should be changed to
8484          * an if(scan) to guard the ARG2L_SET() - Yves
8485          *
8486          */
8487         assert(scan && OP(scan) == GOSUB);
8488         ARG2L_SET( scan, RExC_open_parens[ARG(scan)] - REGNODE_OFFSET(scan));
8489     }
8490
8491     Newxz(RExC_rx->offs, RExC_total_parens, regexp_paren_pair);
8492     /* assume we don't need to swap parens around before we match */
8493     DEBUG_TEST_r({
8494         Perl_re_printf( aTHX_ "study_chunk_recursed_count: %lu\n",
8495             (unsigned long)RExC_study_chunk_recursed_count);
8496     });
8497     DEBUG_DUMP_r({
8498         DEBUG_RExC_seen();
8499         Perl_re_printf( aTHX_ "Final program:\n");
8500         regdump(RExC_rx);
8501     });
8502
8503     if (RExC_open_parens) {
8504         Safefree(RExC_open_parens);
8505         RExC_open_parens = NULL;
8506     }
8507     if (RExC_close_parens) {
8508         Safefree(RExC_close_parens);
8509         RExC_close_parens = NULL;
8510     }
8511
8512 #ifdef USE_ITHREADS
8513     /* under ithreads the ?pat? PMf_USED flag on the pmop is simulated
8514      * by setting the regexp SV to readonly-only instead. If the
8515      * pattern's been recompiled, the USEDness should remain. */
8516     if (old_re && SvREADONLY(old_re))
8517         SvREADONLY_on(Rx);
8518 #endif
8519     return Rx;
8520 }
8521
8522
8523 SV*
8524 Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value,
8525                     const U32 flags)
8526 {
8527     PERL_ARGS_ASSERT_REG_NAMED_BUFF;
8528
8529     PERL_UNUSED_ARG(value);
8530
8531     if (flags & RXapif_FETCH) {
8532         return reg_named_buff_fetch(rx, key, flags);
8533     } else if (flags & (RXapif_STORE | RXapif_DELETE | RXapif_CLEAR)) {
8534         Perl_croak_no_modify();
8535         return NULL;
8536     } else if (flags & RXapif_EXISTS) {
8537         return reg_named_buff_exists(rx, key, flags)
8538             ? &PL_sv_yes
8539             : &PL_sv_no;
8540     } else if (flags & RXapif_REGNAMES) {
8541         return reg_named_buff_all(rx, flags);
8542     } else if (flags & (RXapif_SCALAR | RXapif_REGNAMES_COUNT)) {
8543         return reg_named_buff_scalar(rx, flags);
8544     } else {
8545         Perl_croak(aTHX_ "panic: Unknown flags %d in named_buff", (int)flags);
8546         return NULL;
8547     }
8548 }
8549
8550 SV*
8551 Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey,
8552                          const U32 flags)
8553 {
8554     PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER;
8555     PERL_UNUSED_ARG(lastkey);
8556
8557     if (flags & RXapif_FIRSTKEY)
8558         return reg_named_buff_firstkey(rx, flags);
8559     else if (flags & RXapif_NEXTKEY)
8560         return reg_named_buff_nextkey(rx, flags);
8561     else {
8562         Perl_croak(aTHX_ "panic: Unknown flags %d in named_buff_iter",
8563                                             (int)flags);
8564         return NULL;
8565     }
8566 }
8567
8568 SV*
8569 Perl_reg_named_buff_fetch(pTHX_ REGEXP * const r, SV * const namesv,
8570                           const U32 flags)
8571 {
8572     SV *ret;
8573     struct regexp *const rx = ReANY(r);
8574
8575     PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH;
8576
8577     if (rx && RXp_PAREN_NAMES(rx)) {
8578         HE *he_str = hv_fetch_ent( RXp_PAREN_NAMES(rx), namesv, 0, 0 );
8579         if (he_str) {
8580             IV i;
8581             SV* sv_dat=HeVAL(he_str);
8582             I32 *nums=(I32*)SvPVX(sv_dat);
8583             AV * const retarray = (flags & RXapif_ALL) ? newAV() : NULL;
8584             for ( i=0; i<SvIVX(sv_dat); i++ ) {
8585                 if ((I32)(rx->nparens) >= nums[i]
8586                     && rx->offs[nums[i]].start != -1
8587                     && rx->offs[nums[i]].end != -1)
8588                 {
8589                     ret = newSVpvs("");
8590                     CALLREG_NUMBUF_FETCH(r, nums[i], ret);
8591                     if (!retarray)
8592                         return ret;
8593                 } else {
8594                     if (retarray)
8595                         ret = newSVsv(&PL_sv_undef);
8596                 }
8597                 if (retarray)
8598                     av_push(retarray, ret);
8599             }
8600             if (retarray)
8601                 return newRV_noinc(MUTABLE_SV(retarray));
8602         }
8603     }
8604     return NULL;
8605 }
8606
8607 bool
8608 Perl_reg_named_buff_exists(pTHX_ REGEXP * const r, SV * const key,
8609                            const U32 flags)
8610 {
8611     struct regexp *const rx = ReANY(r);
8612
8613     PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS;
8614
8615     if (rx && RXp_PAREN_NAMES(rx)) {
8616         if (flags & RXapif_ALL) {
8617             return hv_exists_ent(RXp_PAREN_NAMES(rx), key, 0);
8618         } else {
8619             SV *sv = CALLREG_NAMED_BUFF_FETCH(r, key, flags);
8620             if (sv) {
8621                 SvREFCNT_dec_NN(sv);
8622                 return TRUE;
8623             } else {
8624                 return FALSE;
8625             }
8626         }
8627     } else {
8628         return FALSE;
8629     }
8630 }
8631
8632 SV*
8633 Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const r, const U32 flags)
8634 {
8635     struct regexp *const rx = ReANY(r);
8636
8637     PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY;
8638
8639     if ( rx && RXp_PAREN_NAMES(rx) ) {
8640         (void)hv_iterinit(RXp_PAREN_NAMES(rx));
8641
8642         return CALLREG_NAMED_BUFF_NEXTKEY(r, NULL, flags & ~RXapif_FIRSTKEY);
8643     } else {
8644         return FALSE;
8645     }
8646 }
8647
8648 SV*
8649 Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const r, const U32 flags)
8650 {
8651     struct regexp *const rx = ReANY(r);
8652     DECLARE_AND_GET_RE_DEBUG_FLAGS;
8653
8654     PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY;
8655
8656     if (rx && RXp_PAREN_NAMES(rx)) {
8657         HV *hv = RXp_PAREN_NAMES(rx);
8658         HE *temphe;
8659         while ( (temphe = hv_iternext_flags(hv, 0)) ) {
8660             IV i;
8661             IV parno = 0;
8662             SV* sv_dat = HeVAL(temphe);
8663             I32 *nums = (I32*)SvPVX(sv_dat);
8664             for ( i = 0; i < SvIVX(sv_dat); i++ ) {
8665                 if ((I32)(rx->lastparen) >= nums[i] &&
8666                     rx->offs[nums[i]].start != -1 &&
8667                     rx->offs[nums[i]].end != -1)
8668                 {
8669                     parno = nums[i];
8670                     break;
8671                 }
8672             }
8673             if (parno || flags & RXapif_ALL) {
8674                 return newSVhek(HeKEY_hek(temphe));
8675             }
8676         }
8677     }
8678     return NULL;
8679 }
8680
8681 SV*
8682 Perl_reg_named_buff_scalar(pTHX_ REGEXP * const r, const U32 flags)
8683 {
8684     SV *ret;
8685     AV *av;
8686     SSize_t length;
8687     struct regexp *const rx = ReANY(r);
8688
8689     PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR;
8690
8691     if (rx && RXp_PAREN_NAMES(rx)) {
8692         if (flags & (RXapif_ALL | RXapif_REGNAMES_COUNT)) {
8693             return newSViv(HvTOTALKEYS(RXp_PAREN_NAMES(rx)));
8694         } else if (flags & RXapif_ONE) {
8695             ret = CALLREG_NAMED_BUFF_ALL(r, (flags | RXapif_REGNAMES));
8696             av = MUTABLE_AV(SvRV(ret));
8697             length = av_count(av);
8698             SvREFCNT_dec_NN(ret);
8699             return newSViv(length);
8700         } else {
8701             Perl_croak(aTHX_ "panic: Unknown flags %d in named_buff_scalar",
8702                                                 (int)flags);
8703             return NULL;
8704         }
8705     }
8706     return &PL_sv_undef;
8707 }
8708
8709 SV*
8710 Perl_reg_named_buff_all(pTHX_ REGEXP * const r, const U32 flags)
8711 {
8712     struct regexp *const rx = ReANY(r);
8713     AV *av = newAV();
8714
8715     PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL;
8716
8717     if (rx && RXp_PAREN_NAMES(rx)) {
8718         HV *hv= RXp_PAREN_NAMES(rx);
8719         HE *temphe;
8720         (void)hv_iterinit(hv);
8721         while ( (temphe = hv_iternext_flags(hv, 0)) ) {
8722             IV i;
8723             IV parno = 0;
8724             SV* sv_dat = HeVAL(temphe);
8725             I32 *nums = (I32*)SvPVX(sv_dat);
8726             for ( i = 0; i < SvIVX(sv_dat); i++ ) {
8727                 if ((I32)(rx->lastparen) >= nums[i] &&
8728                     rx->offs[nums[i]].start != -1 &&
8729                     rx->offs[nums[i]].end != -1)
8730                 {
8731                     parno = nums[i];
8732                     break;
8733                 }
8734             }
8735             if (parno || flags & RXapif_ALL) {
8736                 av_push(av, newSVhek(HeKEY_hek(temphe)));
8737             }
8738         }
8739     }
8740
8741     return newRV_noinc(MUTABLE_SV(av));
8742 }
8743
8744 void
8745 Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const r, const I32 paren,
8746                              SV * const sv)
8747 {
8748     struct regexp *const rx = ReANY(r);
8749     char *s = NULL;
8750     SSize_t i = 0;
8751     SSize_t s1, t1;
8752     I32 n = paren;
8753
8754     PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH;
8755
8756     if (      n == RX_BUFF_IDX_CARET_PREMATCH
8757            || n == RX_BUFF_IDX_CARET_FULLMATCH
8758            || n == RX_BUFF_IDX_CARET_POSTMATCH
8759        )
8760     {
8761         bool keepcopy = cBOOL(rx->extflags & RXf_PMf_KEEPCOPY);
8762         if (!keepcopy) {
8763             /* on something like
8764              *    $r = qr/.../;
8765              *    /$qr/p;
8766              * the KEEPCOPY is set on the PMOP rather than the regex */
8767             if (PL_curpm && r == PM_GETRE(PL_curpm))
8768                  keepcopy = cBOOL(PL_curpm->op_pmflags & PMf_KEEPCOPY);
8769         }
8770         if (!keepcopy)
8771             goto ret_undef;
8772     }
8773
8774     if (!rx->subbeg)
8775         goto ret_undef;
8776
8777     if (n == RX_BUFF_IDX_CARET_FULLMATCH)
8778         /* no need to distinguish between them any more */
8779         n = RX_BUFF_IDX_FULLMATCH;
8780
8781     if ((n == RX_BUFF_IDX_PREMATCH || n == RX_BUFF_IDX_CARET_PREMATCH)
8782         && rx->offs[0].start != -1)
8783     {
8784         /* $`, ${^PREMATCH} */
8785         i = rx->offs[0].start;
8786         s = rx->subbeg;
8787     }
8788     else
8789     if ((n == RX_BUFF_IDX_POSTMATCH || n == RX_BUFF_IDX_CARET_POSTMATCH)
8790         && rx->offs[0].end != -1)
8791     {
8792         /* $', ${^POSTMATCH} */
8793         s = rx->subbeg - rx->suboffset + rx->offs[0].end;
8794         i = rx->sublen + rx->suboffset - rx->offs[0].end;
8795     }
8796     else
8797     if (inRANGE(n, 0, (I32)rx->nparens) &&
8798         (s1 = rx->offs[n].start) != -1  &&
8799         (t1 = rx->offs[n].end) != -1)
8800     {
8801         /* $&, ${^MATCH},  $1 ... */
8802         i = t1 - s1;
8803         s = rx->subbeg + s1 - rx->suboffset;
8804     } else {
8805         goto ret_undef;
8806     }
8807
8808     assert(s >= rx->subbeg);
8809     assert((STRLEN)rx->sublen >= (STRLEN)((s - rx->subbeg) + i) );
8810     if (i >= 0) {
8811 #ifdef NO_TAINT_SUPPORT
8812         sv_setpvn(sv, s, i);
8813 #else
8814         const int oldtainted = TAINT_get;
8815         TAINT_NOT;
8816         sv_setpvn(sv, s, i);
8817         TAINT_set(oldtainted);
8818 #endif
8819         if (RXp_MATCH_UTF8(rx))
8820             SvUTF8_on(sv);
8821         else
8822             SvUTF8_off(sv);
8823         if (TAINTING_get) {
8824             if (RXp_MATCH_TAINTED(rx)) {
8825                 if (SvTYPE(sv) >= SVt_PVMG) {
8826                     MAGIC* const mg = SvMAGIC(sv);
8827                     MAGIC* mgt;
8828                     TAINT;
8829                     SvMAGIC_set(sv, mg->mg_moremagic);
8830                     SvTAINT(sv);
8831                     if ((mgt = SvMAGIC(sv))) {
8832                         mg->mg_moremagic = mgt;
8833                         SvMAGIC_set(sv, mg);
8834                     }
8835                 } else {
8836                     TAINT;
8837                     SvTAINT(sv);
8838                 }
8839             } else
8840                 SvTAINTED_off(sv);
8841         }
8842     } else {
8843       ret_undef:
8844         sv_set_undef(sv);
8845         return;
8846     }
8847 }
8848
8849 void
8850 Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren,
8851                                                          SV const * const value)
8852 {
8853     PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE;
8854
8855     PERL_UNUSED_ARG(rx);
8856     PERL_UNUSED_ARG(paren);
8857     PERL_UNUSED_ARG(value);
8858
8859     if (!PL_localizing)
8860         Perl_croak_no_modify();
8861 }
8862
8863 I32
8864 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const r, const SV * const sv,
8865                               const I32 paren)
8866 {
8867     struct regexp *const rx = ReANY(r);
8868     I32 i;
8869     I32 s1, t1;
8870
8871     PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH;
8872
8873     if (   paren == RX_BUFF_IDX_CARET_PREMATCH
8874         || paren == RX_BUFF_IDX_CARET_FULLMATCH
8875         || paren == RX_BUFF_IDX_CARET_POSTMATCH
8876     )
8877     {
8878         bool keepcopy = cBOOL(rx->extflags & RXf_PMf_KEEPCOPY);
8879         if (!keepcopy) {
8880             /* on something like
8881              *    $r = qr/.../;
8882              *    /$qr/p;
8883              * the KEEPCOPY is set on the PMOP rather than the regex */
8884             if (PL_curpm && r == PM_GETRE(PL_curpm))
8885                  keepcopy = cBOOL(PL_curpm->op_pmflags & PMf_KEEPCOPY);
8886         }
8887         if (!keepcopy)
8888             goto warn_undef;
8889     }
8890
8891     /* Some of this code was originally in C<Perl_magic_len> in F<mg.c> */
8892     switch (paren) {
8893       case RX_BUFF_IDX_CARET_PREMATCH: /* ${^PREMATCH} */
8894       case RX_BUFF_IDX_PREMATCH:       /* $` */
8895         if (rx->offs[0].start != -1) {
8896                         i = rx->offs[0].start;
8897                         if (i > 0) {
8898                                 s1 = 0;
8899                                 t1 = i;
8900                                 goto getlen;
8901                         }
8902             }
8903         return 0;
8904
8905       case RX_BUFF_IDX_CARET_POSTMATCH: /* ${^POSTMATCH} */
8906       case RX_BUFF_IDX_POSTMATCH:       /* $' */
8907             if (rx->offs[0].end != -1) {
8908                         i = rx->sublen - rx->offs[0].end;
8909                         if (i > 0) {
8910                                 s1 = rx->offs[0].end;
8911                                 t1 = rx->sublen;
8912                                 goto getlen;
8913                         }
8914             }
8915         return 0;
8916
8917       default: /* $& / ${^MATCH}, $1, $2, ... */
8918             if (paren <= (I32)rx->nparens &&
8919             (s1 = rx->offs[paren].start) != -1 &&
8920             (t1 = rx->offs[paren].end) != -1)
8921             {
8922             i = t1 - s1;
8923             goto getlen;
8924         } else {
8925           warn_undef:
8926             if (ckWARN(WARN_UNINITIALIZED))
8927                 report_uninit((const SV *)sv);
8928             return 0;
8929         }
8930     }
8931   getlen:
8932     if (i > 0 && RXp_MATCH_UTF8(rx)) {
8933         const char * const s = rx->subbeg - rx->suboffset + s1;
8934         const U8 *ep;
8935         STRLEN el;
8936
8937         i = t1 - s1;
8938         if (is_utf8_string_loclen((U8*)s, i, &ep, &el))
8939             i = el;
8940     }
8941     return i;
8942 }
8943
8944 SV*
8945 Perl_reg_qr_package(pTHX_ REGEXP * const rx)
8946 {
8947     PERL_ARGS_ASSERT_REG_QR_PACKAGE;
8948         PERL_UNUSED_ARG(rx);
8949         if (0)
8950             return NULL;
8951         else
8952             return newSVpvs("Regexp");
8953 }
8954
8955 /* Scans the name of a named buffer from the pattern.
8956  * If flags is REG_RSN_RETURN_NULL returns null.
8957  * If flags is REG_RSN_RETURN_NAME returns an SV* containing the name
8958  * If flags is REG_RSN_RETURN_DATA returns the data SV* corresponding
8959  * to the parsed name as looked up in the RExC_paren_names hash.
8960  * If there is an error throws a vFAIL().. type exception.
8961  */
8962
8963 #define REG_RSN_RETURN_NULL    0
8964 #define REG_RSN_RETURN_NAME    1
8965 #define REG_RSN_RETURN_DATA    2
8966
8967 STATIC SV*
8968 S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags)
8969 {
8970     char *name_start = RExC_parse;
8971     SV* sv_name;
8972
8973     PERL_ARGS_ASSERT_REG_SCAN_NAME;
8974
8975     assert (RExC_parse <= RExC_end);
8976     if (RExC_parse == RExC_end) NOOP;
8977     else if (isIDFIRST_lazy_if_safe(RExC_parse, RExC_end, UTF)) {
8978          /* Note that the code here assumes well-formed UTF-8.  Skip IDFIRST by
8979           * using do...while */
8980         if (UTF)
8981             do {
8982                 RExC_parse += UTF8SKIP(RExC_parse);
8983             } while (   RExC_parse < RExC_end
8984                      && isWORDCHAR_utf8_safe((U8*)RExC_parse, (U8*) RExC_end));
8985         else
8986             do {
8987                 RExC_parse++;
8988             } while (RExC_parse < RExC_end && isWORDCHAR(*RExC_parse));
8989     } else {
8990         RExC_parse++; /* so the <- from the vFAIL is after the offending
8991                          character */
8992         vFAIL("Group name must start with a non-digit word character");
8993     }
8994     sv_name = newSVpvn_flags(name_start, (int)(RExC_parse - name_start),
8995                              SVs_TEMP | (UTF ? SVf_UTF8 : 0));
8996     if ( flags == REG_RSN_RETURN_NAME)
8997         return sv_name;
8998     else if (flags==REG_RSN_RETURN_DATA) {
8999         HE *he_str = NULL;
9000         SV *sv_dat = NULL;
9001         if ( ! sv_name )      /* should not happen*/
9002             Perl_croak(aTHX_ "panic: no svname in reg_scan_name");
9003         if (RExC_paren_names)
9004             he_str = hv_fetch_ent( RExC_paren_names, sv_name, 0, 0 );
9005         if ( he_str )
9006             sv_dat = HeVAL(he_str);
9007         if ( ! sv_dat ) {   /* Didn't find group */
9008
9009             /* It might be a forward reference; we can't fail until we
9010                 * know, by completing the parse to get all the groups, and
9011                 * then reparsing */
9012             if (ALL_PARENS_COUNTED)  {
9013                 vFAIL("Reference to nonexistent named group");
9014             }
9015             else {
9016                 REQUIRE_PARENS_PASS;
9017             }
9018         }
9019         return sv_dat;
9020     }
9021
9022     Perl_croak(aTHX_ "panic: bad flag %lx in reg_scan_name",
9023                      (unsigned long) flags);
9024 }
9025
9026 #define DEBUG_PARSE_MSG(funcname)     DEBUG_PARSE_r({           \
9027     if (RExC_lastparse!=RExC_parse) {                           \
9028         Perl_re_printf( aTHX_  "%s",                            \
9029             Perl_pv_pretty(aTHX_ RExC_mysv1, RExC_parse,        \
9030                 RExC_end - RExC_parse, 16,                      \
9031                 "", "",                                         \
9032                 PERL_PV_ESCAPE_UNI_DETECT |                     \
9033                 PERL_PV_PRETTY_ELLIPSES   |                     \
9034                 PERL_PV_PRETTY_LTGT       |                     \
9035                 PERL_PV_ESCAPE_RE         |                     \
9036                 PERL_PV_PRETTY_EXACTSIZE                        \
9037             )                                                   \
9038         );                                                      \
9039     } else                                                      \
9040         Perl_re_printf( aTHX_ "%16s","");                       \
9041                                                                 \
9042     if (RExC_lastnum!=RExC_emit)                                \
9043        Perl_re_printf( aTHX_ "|%4zu", RExC_emit);                \
9044     else                                                        \
9045        Perl_re_printf( aTHX_ "|%4s","");                        \
9046     Perl_re_printf( aTHX_ "|%*s%-4s",                           \
9047         (int)((depth*2)), "",                                   \
9048         (funcname)                                              \
9049     );                                                          \
9050     RExC_lastnum=RExC_emit;                                     \
9051     RExC_lastparse=RExC_parse;                                  \
9052 })
9053
9054
9055
9056 #define DEBUG_PARSE(funcname)     DEBUG_PARSE_r({           \
9057     DEBUG_PARSE_MSG((funcname));                            \
9058     Perl_re_printf( aTHX_ "%4s","\n");                                  \
9059 })
9060 #define DEBUG_PARSE_FMT(funcname,fmt,args)     DEBUG_PARSE_r({\
9061     DEBUG_PARSE_MSG((funcname));                            \
9062     Perl_re_printf( aTHX_ fmt "\n",args);                               \
9063 })
9064
9065 /* This section of code defines the inversion list object and its methods.  The
9066  * interfaces are highly subject to change, so as much as possible is static to
9067  * this file.  An inversion list is here implemented as a malloc'd C UV array
9068  * as an SVt_INVLIST scalar.
9069  *
9070  * An inversion list for Unicode is an array of code points, sorted by ordinal
9071  * number.  Each element gives the code point that begins a range that extends
9072  * up-to but not including the code point given by the next element.  The final
9073  * element gives the first code point of a range that extends to the platform's
9074  * infinity.  The even-numbered elements (invlist[0], invlist[2], invlist[4],
9075  * ...) give ranges whose code points are all in the inversion list.  We say
9076  * that those ranges are in the set.  The odd-numbered elements give ranges
9077  * whose code points are not in the inversion list, and hence not in the set.
9078  * Thus, element [0] is the first code point in the list.  Element [1]
9079  * is the first code point beyond that not in the list; and element [2] is the
9080  * first code point beyond that that is in the list.  In other words, the first
9081  * range is invlist[0]..(invlist[1]-1), and all code points in that range are
9082  * in the inversion list.  The second range is invlist[1]..(invlist[2]-1), and
9083  * all code points in that range are not in the inversion list.  The third
9084  * range invlist[2]..(invlist[3]-1) gives code points that are in the inversion
9085  * list, and so forth.  Thus every element whose index is divisible by two
9086  * gives the beginning of a range that is in the list, and every element whose
9087  * index is not divisible by two gives the beginning of a range not in the
9088  * list.  If the final element's index is divisible by two, the inversion list
9089  * extends to the platform's infinity; otherwise the highest code point in the
9090  * inversion list is the contents of that element minus 1.
9091  *
9092  * A range that contains just a single code point N will look like
9093  *  invlist[i]   == N
9094  *  invlist[i+1] == N+1
9095  *
9096  * If N is UV_MAX (the highest representable code point on the machine), N+1 is
9097  * impossible to represent, so element [i+1] is omitted.  The single element
9098  * inversion list
9099  *  invlist[0] == UV_MAX
9100  * contains just UV_MAX, but is interpreted as matching to infinity.
9101  *
9102  * Taking the complement (inverting) an inversion list is quite simple, if the
9103  * first element is 0, remove it; otherwise add a 0 element at the beginning.
9104  * This implementation reserves an element at the beginning of each inversion
9105  * list to always contain 0; there is an additional flag in the header which
9106  * indicates if the list begins at the 0, or is offset to begin at the next
9107  * element.  This means that the inversion list can be inverted without any
9108  * copying; just flip the flag.
9109  *
9110  * More about inversion lists can be found in "Unicode Demystified"
9111  * Chapter 13 by Richard Gillam, published by Addison-Wesley.
9112  *
9113  * The inversion list data structure is currently implemented as an SV pointing
9114  * to an array of UVs that the SV thinks are bytes.  This allows us to have an
9115  * array of UV whose memory management is automatically handled by the existing
9116  * facilities for SV's.
9117  *
9118  * Some of the methods should always be private to the implementation, and some
9119  * should eventually be made public */
9120
9121 /* The header definitions are in F<invlist_inline.h> */
9122
9123 #ifndef PERL_IN_XSUB_RE
9124
9125 PERL_STATIC_INLINE UV*
9126 S__invlist_array_init(SV* const invlist, const bool will_have_0)
9127 {
9128     /* Returns a pointer to the first element in the inversion list's array.
9129      * This is called upon initialization of an inversion list.  Where the
9130      * array begins depends on whether the list has the code point U+0000 in it
9131      * or not.  The other parameter tells it whether the code that follows this
9132      * call is about to put a 0 in the inversion list or not.  The first
9133      * element is either the element reserved for 0, if TRUE, or the element
9134      * after it, if FALSE */
9135
9136     bool* offset = get_invlist_offset_addr(invlist);
9137     UV* zero_addr = (UV *) SvPVX(invlist);
9138
9139     PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT;
9140
9141     /* Must be empty */
9142     assert(! _invlist_len(invlist));
9143
9144     *zero_addr = 0;
9145
9146     /* 1^1 = 0; 1^0 = 1 */
9147     *offset = 1 ^ will_have_0;
9148     return zero_addr + *offset;
9149 }
9150
9151 STATIC void
9152 S_invlist_replace_list_destroys_src(pTHX_ SV * dest, SV * src)
9153 {
9154     /* Replaces the inversion list in 'dest' with the one from 'src'.  It
9155      * steals the list from 'src', so 'src' is made to have a NULL list.  This
9156      * is similar to what SvSetMagicSV() would do, if it were implemented on
9157      * inversion lists, though this routine avoids a copy */
9158
9159     const UV src_len          = _invlist_len(src);
9160     const bool src_offset     = *get_invlist_offset_addr(src);
9161     const STRLEN src_byte_len = SvLEN(src);
9162     char * array              = SvPVX(src);
9163
9164     const int oldtainted = TAINT_get;
9165
9166     PERL_ARGS_ASSERT_INVLIST_REPLACE_LIST_DESTROYS_SRC;
9167
9168     assert(is_invlist(src));
9169     assert(is_invlist(dest));
9170     assert(! invlist_is_iterating(src));
9171     assert(SvCUR(src) == 0 || SvCUR(src) < SvLEN(src));
9172
9173     /* Make sure it ends in the right place with a NUL, as our inversion list
9174      * manipulations aren't careful to keep this true, but sv_usepvn_flags()
9175      * asserts it */
9176     array[src_byte_len - 1] = '\0';
9177
9178     TAINT_NOT;      /* Otherwise it breaks */
9179     sv_usepvn_flags(dest,
9180                     (char *) array,
9181                     src_byte_len - 1,
9182
9183                     /* This flag is documented to cause a copy to be avoided */
9184                     SV_HAS_TRAILING_NUL);
9185     TAINT_set(oldtainted);
9186     SvPV_set(src, 0);
9187     SvLEN_set(src, 0);
9188     SvCUR_set(src, 0);
9189
9190     /* Finish up copying over the other fields in an inversion list */
9191     *get_invlist_offset_addr(dest) = src_offset;
9192     invlist_set_len(dest, src_len, src_offset);
9193     *get_invlist_previous_index_addr(dest) = 0;
9194     invlist_iterfinish(dest);
9195 }
9196
9197 PERL_STATIC_INLINE IV*
9198 S_get_invlist_previous_index_addr(SV* invlist)
9199 {
9200     /* Return the address of the IV that is reserved to hold the cached index
9201      * */
9202     PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR;
9203
9204     assert(is_invlist(invlist));
9205
9206     return &(((XINVLIST*) SvANY(invlist))->prev_index);
9207 }
9208
9209 PERL_STATIC_INLINE IV
9210 S_invlist_previous_index(SV* const invlist)
9211 {
9212     /* Returns cached index of previous search */
9213
9214     PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX;
9215
9216     return *get_invlist_previous_index_addr(invlist);
9217 }
9218
9219 PERL_STATIC_INLINE void
9220 S_invlist_set_previous_index(SV* const invlist, const IV index)
9221 {
9222     /* Caches <index> for later retrieval */
9223
9224     PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX;
9225
9226     assert(index == 0 || index < (int) _invlist_len(invlist));
9227
9228     *get_invlist_previous_index_addr(invlist) = index;
9229 }
9230
9231 PERL_STATIC_INLINE void
9232 S_invlist_trim(SV* invlist)
9233 {
9234     /* Free the not currently-being-used space in an inversion list */
9235
9236     /* But don't free up the space needed for the 0 UV that is always at the
9237      * beginning of the list, nor the trailing NUL */
9238     const UV min_size = TO_INTERNAL_SIZE(1) + 1;
9239
9240     PERL_ARGS_ASSERT_INVLIST_TRIM;
9241
9242     assert(is_invlist(invlist));
9243
9244     SvPV_renew(invlist, MAX(min_size, SvCUR(invlist) + 1));
9245 }
9246
9247 PERL_STATIC_INLINE void
9248 S_invlist_clear(pTHX_ SV* invlist)    /* Empty the inversion list */
9249 {
9250     PERL_ARGS_ASSERT_INVLIST_CLEAR;
9251
9252     assert(is_invlist(invlist));
9253
9254     invlist_set_len(invlist, 0, 0);
9255     invlist_trim(invlist);
9256 }
9257
9258 #endif /* ifndef PERL_IN_XSUB_RE */
9259
9260 PERL_STATIC_INLINE bool
9261 S_invlist_is_iterating(SV* const invlist)
9262 {
9263     PERL_ARGS_ASSERT_INVLIST_IS_ITERATING;
9264
9265     return *(get_invlist_iter_addr(invlist)) < (STRLEN) UV_MAX;
9266 }
9267
9268 #ifndef PERL_IN_XSUB_RE
9269
9270 PERL_STATIC_INLINE UV
9271 S_invlist_max(SV* const invlist)
9272 {
9273     /* Returns the maximum number of elements storable in the inversion list's
9274      * array, without having to realloc() */
9275
9276     PERL_ARGS_ASSERT_INVLIST_MAX;
9277
9278     assert(is_invlist(invlist));
9279
9280     /* Assumes worst case, in which the 0 element is not counted in the
9281      * inversion list, so subtracts 1 for that */
9282     return SvLEN(invlist) == 0  /* This happens under _new_invlist_C_array */
9283            ? FROM_INTERNAL_SIZE(SvCUR(invlist)) - 1
9284            : FROM_INTERNAL_SIZE(SvLEN(invlist)) - 1;
9285 }
9286
9287 STATIC void
9288 S_initialize_invlist_guts(pTHX_ SV* invlist, const Size_t initial_size)
9289 {
9290     PERL_ARGS_ASSERT_INITIALIZE_INVLIST_GUTS;
9291
9292     /* First 1 is in case the zero element isn't in the list; second 1 is for
9293      * trailing NUL */
9294     SvGROW(invlist, TO_INTERNAL_SIZE(initial_size + 1) + 1);
9295     invlist_set_len(invlist, 0, 0);
9296
9297     /* Force iterinit() to be used to get iteration to work */
9298     invlist_iterfinish(invlist);
9299
9300     *get_invlist_previous_index_addr(invlist) = 0;
9301     SvPOK_on(invlist);  /* This allows B to extract the PV */
9302 }
9303
9304 SV*
9305 Perl__new_invlist(pTHX_ IV initial_size)
9306 {
9307
9308     /* Return a pointer to a newly constructed inversion list, with enough
9309      * space to store 'initial_size' elements.  If that number is negative, a
9310      * system default is used instead */
9311
9312     SV* new_list;
9313
9314     if (initial_size < 0) {
9315         initial_size = 10;
9316     }
9317
9318     new_list = newSV_type(SVt_INVLIST);
9319     initialize_invlist_guts(new_list, initial_size);
9320
9321     return new_list;
9322 }
9323
9324 SV*
9325 Perl__new_invlist_C_array(pTHX_ const UV* const list)
9326 {
9327     /* Return a pointer to a newly constructed inversion list, initialized to
9328      * point to <list>, which has to be in the exact correct inversion list
9329      * form, including internal fields.  Thus this is a dangerous routine that
9330      * should not be used in the wrong hands.  The passed in 'list' contains
9331      * several header fields at the beginning that are not part of the
9332      * inversion list body proper */
9333
9334     const STRLEN length = (STRLEN) list[0];
9335     const UV version_id =          list[1];
9336     const bool offset   =    cBOOL(list[2]);
9337 #define HEADER_LENGTH 3
9338     /* If any of the above changes in any way, you must change HEADER_LENGTH
9339      * (if appropriate) and regenerate INVLIST_VERSION_ID by running
9340      *      perl -E 'say int(rand 2**31-1)'
9341      */
9342 #define INVLIST_VERSION_ID 148565664 /* This is a combination of a version and
9343                                         data structure type, so that one being
9344                                         passed in can be validated to be an
9345                                         inversion list of the correct vintage.
9346                                        */
9347
9348     SV* invlist = newSV_type(SVt_INVLIST);
9349
9350     PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY;
9351
9352     if (version_id != INVLIST_VERSION_ID) {
9353         Perl_croak(aTHX_ "panic: Incorrect version for previously generated inversion list");
9354     }
9355
9356     /* The generated array passed in includes header elements that aren't part
9357      * of the list proper, so start it just after them */
9358     SvPV_set(invlist, (char *) (list + HEADER_LENGTH));
9359
9360     SvLEN_set(invlist, 0);  /* Means we own the contents, and the system
9361                                shouldn't touch it */
9362
9363     *(get_invlist_offset_addr(invlist)) = offset;
9364
9365     /* The 'length' passed to us is the physical number of elements in the
9366      * inversion list.  But if there is an offset the logical number is one
9367      * less than that */
9368     invlist_set_len(invlist, length  - offset, offset);
9369
9370     invlist_set_previous_index(invlist, 0);
9371
9372     /* Initialize the iteration pointer. */
9373     invlist_iterfinish(invlist);
9374
9375     SvREADONLY_on(invlist);
9376     SvPOK_on(invlist);
9377
9378     return invlist;
9379 }
9380
9381 STATIC void
9382 S__append_range_to_invlist(pTHX_ SV* const invlist,
9383                                  const UV start, const UV end)
9384 {
9385    /* Subject to change or removal.  Append the range from 'start' to 'end' at
9386     * the end of the inversion list.  The range must be above any existing
9387     * ones. */
9388
9389     UV* array;
9390     UV max = invlist_max(invlist);
9391     UV len = _invlist_len(invlist);
9392     bool offset;
9393
9394     PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST;
9395
9396     if (len == 0) { /* Empty lists must be initialized */
9397         offset = start != 0;
9398         array = _invlist_array_init(invlist, ! offset);
9399     }
9400     else {
9401         /* Here, the existing list is non-empty. The current max entry in the
9402          * list is generally the first value not in the set, except when the
9403          * set extends to the end of permissible values, in which case it is
9404          * the first entry in that final set, and so this call is an attempt to
9405          * append out-of-order */
9406
9407         UV final_element = len - 1;
9408         array = invlist_array(invlist);
9409         if (   array[final_element] > start
9410             || ELEMENT_RANGE_MATCHES_INVLIST(final_element))
9411         {
9412             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",
9413                      array[final_element], start,
9414                      ELEMENT_RANGE_MATCHES_INVLIST(final_element) ? 't' : 'f');
9415         }
9416
9417         /* Here, it is a legal append.  If the new range begins 1 above the end
9418          * of the range below it, it is extending the range below it, so the
9419          * new first value not in the set is one greater than the newly
9420          * extended range.  */
9421         offset = *get_invlist_offset_addr(invlist);
9422         if (array[final_element] == start) {
9423             if (end != UV_MAX) {
9424                 array[final_element] = end + 1;
9425             }
9426             else {
9427                 /* But if the end is the maximum representable on the machine,
9428                  * assume that infinity was actually what was meant.  Just let
9429                  * the range that this would extend to have no end */
9430                 invlist_set_len(invlist, len - 1, offset);
9431             }
9432             return;
9433         }
9434     }
9435
9436     /* Here the new range doesn't extend any existing set.  Add it */
9437
9438     len += 2;   /* Includes an element each for the start and end of range */
9439
9440     /* If wll overflow the existing space, extend, which may cause the array to
9441      * be moved */
9442     if (max < len) {
9443         invlist_extend(invlist, len);
9444
9445         /* Have to set len here to avoid assert failure in invlist_array() */
9446         invlist_set_len(invlist, len, offset);
9447
9448         array = invlist_array(invlist);
9449     }
9450     else {
9451         invlist_set_len(invlist, len, offset);
9452     }
9453
9454     /* The next item on the list starts the range, the one after that is
9455      * one past the new range.  */
9456     array[len - 2] = start;
9457     if (end != UV_MAX) {
9458         array[len - 1] = end + 1;
9459     }
9460     else {
9461         /* But if the end is the maximum representable on the machine, just let
9462          * the range have no end */
9463         invlist_set_len(invlist, len - 1, offset);
9464     }
9465 }
9466
9467 SSize_t
9468 Perl__invlist_search(SV* const invlist, const UV cp)
9469 {
9470     /* Searches the inversion list for the entry that contains the input code
9471      * point <cp>.  If <cp> is not in the list, -1 is returned.  Otherwise, the
9472      * return value is the index into the list's array of the range that
9473      * contains <cp>, that is, 'i' such that
9474      *  array[i] <= cp < array[i+1]
9475      */
9476
9477     IV low = 0;
9478     IV mid;
9479     IV high = _invlist_len(invlist);
9480     const IV highest_element = high - 1;
9481     const UV* array;
9482
9483     PERL_ARGS_ASSERT__INVLIST_SEARCH;
9484
9485     /* If list is empty, return failure. */
9486     if (high == 0) {
9487         return -1;
9488     }
9489
9490     /* (We can't get the array unless we know the list is non-empty) */
9491     array = invlist_array(invlist);
9492
9493     mid = invlist_previous_index(invlist);
9494     assert(mid >=0);
9495     if (mid > highest_element) {
9496         mid = highest_element;
9497     }
9498
9499     /* <mid> contains the cache of the result of the previous call to this
9500      * function (0 the first time).  See if this call is for the same result,
9501      * or if it is for mid-1.  This is under the theory that calls to this
9502      * function will often be for related code points that are near each other.
9503      * And benchmarks show that caching gives better results.  We also test
9504      * here if the code point is within the bounds of the list.  These tests
9505      * replace others that would have had to be made anyway to make sure that
9506      * the array bounds were not exceeded, and these give us extra information
9507      * at the same time */
9508     if (cp >= array[mid]) {
9509         if (cp >= array[highest_element]) {
9510             return highest_element;
9511         }
9512
9513         /* Here, array[mid] <= cp < array[highest_element].  This means that
9514          * the final element is not the answer, so can exclude it; it also
9515          * means that <mid> is not the final element, so can refer to 'mid + 1'
9516          * safely */
9517         if (cp < array[mid + 1]) {
9518             return mid;
9519         }
9520         high--;
9521         low = mid + 1;
9522     }
9523     else { /* cp < aray[mid] */
9524         if (cp < array[0]) { /* Fail if outside the array */
9525             return -1;
9526         }
9527         high = mid;
9528         if (cp >= array[mid - 1]) {
9529             goto found_entry;
9530         }
9531     }
9532
9533     /* Binary search.  What we are looking for is <i> such that
9534      *  array[i] <= cp < array[i+1]
9535      * The loop below converges on the i+1.  Note that there may not be an
9536      * (i+1)th element in the array, and things work nonetheless */
9537     while (low < high) {
9538         mid = (low + high) / 2;
9539         assert(mid <= highest_element);
9540         if (array[mid] <= cp) { /* cp >= array[mid] */
9541             low = mid + 1;
9542
9543             /* We could do this extra test to exit the loop early.
9544             if (cp < array[low]) {
9545                 return mid;
9546             }
9547             */
9548         }
9549         else { /* cp < array[mid] */
9550             high = mid;
9551         }
9552     }
9553
9554   found_entry:
9555     high--;
9556     invlist_set_previous_index(invlist, high);
9557     return high;
9558 }
9559
9560 void
9561 Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b,
9562                                          const bool complement_b, SV** output)
9563 {
9564     /* Take the union of two inversion lists and point '*output' to it.  On
9565      * input, '*output' MUST POINT TO NULL OR TO AN SV* INVERSION LIST (possibly
9566      * even 'a' or 'b').  If to an inversion list, the contents of the original
9567      * list will be replaced by the union.  The first list, 'a', may be
9568      * NULL, in which case a copy of the second list is placed in '*output'.
9569      * If 'complement_b' is TRUE, the union is taken of the complement
9570      * (inversion) of 'b' instead of b itself.
9571      *
9572      * The basis for this comes from "Unicode Demystified" Chapter 13 by
9573      * Richard Gillam, published by Addison-Wesley, and explained at some
9574      * length there.  The preface says to incorporate its examples into your
9575      * code at your own risk.
9576      *
9577      * The algorithm is like a merge sort. */
9578
9579     const UV* array_a;    /* a's array */
9580     const UV* array_b;
9581     UV len_a;       /* length of a's array */
9582     UV len_b;
9583
9584     SV* u;                      /* the resulting union */
9585     UV* array_u;
9586     UV len_u = 0;
9587
9588     UV i_a = 0;             /* current index into a's array */
9589     UV i_b = 0;
9590     UV i_u = 0;
9591
9592     /* running count, as explained in the algorithm source book; items are
9593      * stopped accumulating and are output when the count changes to/from 0.
9594      * The count is incremented when we start a range that's in an input's set,
9595      * and decremented when we start a range that's not in a set.  So this
9596      * variable can be 0, 1, or 2.  When it is 0 neither input is in their set,
9597      * and hence nothing goes into the union; 1, just one of the inputs is in
9598      * its set (and its current range gets added to the union); and 2 when both
9599      * inputs are in their sets.  */
9600     UV count = 0;
9601
9602     PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND;
9603     assert(a != b);
9604     assert(*output == NULL || is_invlist(*output));
9605
9606     len_b = _invlist_len(b);
9607     if (len_b == 0) {
9608
9609         /* Here, 'b' is empty, hence it's complement is all possible code
9610          * points.  So if the union includes the complement of 'b', it includes
9611          * everything, and we need not even look at 'a'.  It's easiest to
9612          * create a new inversion list that matches everything.  */
9613         if (complement_b) {
9614             SV* everything = _add_range_to_invlist(NULL, 0, UV_MAX);
9615
9616             if (*output == NULL) { /* If the output didn't exist, just point it
9617                                       at the new list */
9618                 *output = everything;
9619             }
9620             else { /* Otherwise, replace its contents with the new list */
9621                 invlist_replace_list_destroys_src(*output, everything);
9622                 SvREFCNT_dec_NN(everything);
9623             }
9624
9625             return;
9626         }
9627
9628         /* Here, we don't want the complement of 'b', and since 'b' is empty,
9629          * the union will come entirely from 'a'.  If 'a' is NULL or empty, the
9630          * output will be empty */
9631
9632         if (a == NULL || _invlist_len(a) == 0) {
9633             if (*output == NULL) {
9634                 *output = _new_invlist(0);
9635             }
9636             else {
9637                 invlist_clear(*output);
9638             }
9639             return;
9640         }
9641
9642         /* Here, 'a' is not empty, but 'b' is, so 'a' entirely determines the
9643          * union.  We can just return a copy of 'a' if '*output' doesn't point
9644          * to an existing list */
9645         if (*output == NULL) {
9646             *output = invlist_clone(a, NULL);
9647             return;
9648         }
9649
9650         /* If the output is to overwrite 'a', we have a no-op, as it's
9651          * already in 'a' */
9652         if (*output == a) {
9653             return;
9654         }
9655
9656         /* Here, '*output' is to be overwritten by 'a' */
9657         u = invlist_clone(a, NULL);
9658         invlist_replace_list_destroys_src(*output, u);
9659         SvREFCNT_dec_NN(u);
9660
9661         return;
9662     }
9663
9664     /* Here 'b' is not empty.  See about 'a' */
9665
9666     if (a == NULL || ((len_a = _invlist_len(a)) == 0)) {
9667
9668         /* Here, 'a' is empty (and b is not).  That means the union will come
9669          * entirely from 'b'.  If '*output' is NULL, we can directly return a
9670          * clone of 'b'.  Otherwise, we replace the contents of '*output' with
9671          * the clone */
9672
9673         SV ** dest = (*output == NULL) ? output : &u;
9674         *dest = invlist_clone(b, NULL);
9675         if (complement_b) {
9676             _invlist_invert(*dest);
9677         }
9678
9679         if (dest == &u) {
9680             invlist_replace_list_destroys_src(*output, u);
9681             SvREFCNT_dec_NN(u);
9682         }
9683
9684         return;
9685     }
9686
9687     /* Here both lists exist and are non-empty */
9688     array_a = invlist_array(a);
9689     array_b = invlist_array(b);
9690
9691     /* If are to take the union of 'a' with the complement of b, set it
9692      * up so are looking at b's complement. */
9693     if (complement_b) {
9694
9695         /* To complement, we invert: if the first element is 0, remove it.  To
9696          * do this, we just pretend the array starts one later */
9697         if (array_b[0] == 0) {
9698             array_b++;
9699             len_b--;
9700         }
9701         else {
9702
9703             /* But if the first element is not zero, we pretend the list starts
9704              * at the 0 that is always stored immediately before the array. */
9705             array_b--;
9706             len_b++;
9707         }
9708     }
9709
9710     /* Size the union for the worst case: that the sets are completely
9711      * disjoint */
9712     u = _new_invlist(len_a + len_b);
9713
9714     /* Will contain U+0000 if either component does */
9715     array_u = _invlist_array_init(u, (    len_a > 0 && array_a[0] == 0)
9716                                       || (len_b > 0 && array_b[0] == 0));
9717
9718     /* Go through each input list item by item, stopping when have exhausted
9719      * one of them */
9720     while (i_a < len_a && i_b < len_b) {
9721         UV cp;      /* The element to potentially add to the union's array */
9722         bool cp_in_set;   /* is it in the input list's set or not */
9723
9724         /* We need to take one or the other of the two inputs for the union.
9725          * Since we are merging two sorted lists, we take the smaller of the
9726          * next items.  In case of a tie, we take first the one that is in its
9727          * set.  If we first took the one not in its set, it would decrement
9728          * the count, possibly to 0 which would cause it to be output as ending
9729          * the range, and the next time through we would take the same number,
9730          * and output it again as beginning the next range.  By doing it the
9731          * opposite way, there is no possibility that the count will be
9732          * momentarily decremented to 0, and thus the two adjoining ranges will
9733          * be seamlessly merged.  (In a tie and both are in the set or both not
9734          * in the set, it doesn't matter which we take first.) */
9735         if (       array_a[i_a] < array_b[i_b]
9736             || (   array_a[i_a] == array_b[i_b]
9737                 && ELEMENT_RANGE_MATCHES_INVLIST(i_a)))
9738         {
9739             cp_in_set = ELEMENT_RANGE_MATCHES_INVLIST(i_a);
9740             cp = array_a[i_a++];
9741         }
9742         else {
9743             cp_in_set = ELEMENT_RANGE_MATCHES_INVLIST(i_b);
9744             cp = array_b[i_b++];
9745         }
9746
9747         /* Here, have chosen which of the two inputs to look at.  Only output
9748          * if the running count changes to/from 0, which marks the
9749          * beginning/end of a range that's in the set */
9750         if (cp_in_set) {
9751             if (count == 0) {
9752                 array_u[i_u++] = cp;
9753             }
9754             count++;
9755         }
9756         else {
9757             count--;
9758             if (count == 0) {
9759                 array_u[i_u++] = cp;
9760             }
9761         }
9762     }
9763
9764
9765     /* The loop above increments the index into exactly one of the input lists
9766      * each iteration, and ends when either index gets to its list end.  That
9767      * means the other index is lower than its end, and so something is
9768      * remaining in that one.  We decrement 'count', as explained below, if
9769      * that list is in its set.  (i_a and i_b each currently index the element
9770      * beyond the one we care about.) */
9771     if (   (i_a != len_a && PREV_RANGE_MATCHES_INVLIST(i_a))
9772         || (i_b != len_b && PREV_RANGE_MATCHES_INVLIST(i_b)))
9773     {
9774         count--;
9775     }
9776
9777     /* Above we decremented 'count' if the list that had unexamined elements in
9778      * it was in its set.  This has made it so that 'count' being non-zero
9779      * means there isn't anything left to output; and 'count' equal to 0 means
9780      * that what is left to output is precisely that which is left in the
9781      * non-exhausted input list.
9782      *
9783      * To see why, note first that the exhausted input obviously has nothing
9784      * left to add to the union.  If it was in its set at its end, that means
9785      * the set extends from here to the platform's infinity, and hence so does
9786      * the union and the non-exhausted set is irrelevant.  The exhausted set
9787      * also contributed 1 to 'count'.  If 'count' was 2, it got decremented to
9788      * 1, but if it was 1, the non-exhausted set wasn't in its set, and so
9789      * 'count' remains at 1.  This is consistent with the decremented 'count'
9790      * != 0 meaning there's nothing left to add to the union.
9791      *
9792      * But if the exhausted input wasn't in its set, it contributed 0 to
9793      * 'count', and the rest of the union will be whatever the other input is.
9794      * If 'count' was 0, neither list was in its set, and 'count' remains 0;
9795      * otherwise it gets decremented to 0.  This is consistent with 'count'
9796      * == 0 meaning the remainder of the union is whatever is left in the
9797      * non-exhausted list. */
9798     if (count != 0) {
9799         len_u = i_u;
9800     }
9801     else {
9802         IV copy_count = len_a - i_a;
9803         if (copy_count > 0) {   /* The non-exhausted input is 'a' */
9804             Copy(array_a + i_a, array_u + i_u, copy_count, UV);
9805         }
9806         else { /* The non-exhausted input is b */
9807             copy_count = len_b - i_b;
9808             Copy(array_b + i_b, array_u + i_u, copy_count, UV);
9809         }
9810         len_u = i_u + copy_count;
9811     }
9812
9813     /* Set the result to the final length, which can change the pointer to
9814      * array_u, so re-find it.  (Note that it is unlikely that this will
9815      * change, as we are shrinking the space, not enlarging it) */
9816     if (len_u != _invlist_len(u)) {
9817         invlist_set_len(u, len_u, *get_invlist_offset_addr(u));
9818         invlist_trim(u);
9819         array_u = invlist_array(u);
9820     }
9821
9822     if (*output == NULL) {  /* Simply return the new inversion list */
9823         *output = u;
9824     }
9825     else {
9826         /* Otherwise, overwrite the inversion list that was in '*output'.  We
9827          * could instead free '*output', and then set it to 'u', but experience
9828          * has shown [perl #127392] that if the input is a mortal, we can get a
9829          * huge build-up of these during regex compilation before they get
9830          * freed. */
9831         invlist_replace_list_destroys_src(*output, u);
9832         SvREFCNT_dec_NN(u);
9833     }
9834
9835     return;
9836 }
9837
9838 void
9839 Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b,
9840                                                const bool complement_b, SV** i)
9841 {
9842     /* Take the intersection of two inversion lists and point '*i' to it.  On
9843      * input, '*i' MUST POINT TO NULL OR TO AN SV* INVERSION LIST (possibly
9844      * even 'a' or 'b').  If to an inversion list, the contents of the original
9845      * list will be replaced by the intersection.  The first list, 'a', may be
9846      * NULL, in which case '*i' will be an empty list.  If 'complement_b' is
9847      * TRUE, the result will be the intersection of 'a' and the complement (or
9848      * inversion) of 'b' instead of 'b' directly.
9849      *
9850      * The basis for this comes from "Unicode Demystified" Chapter 13 by
9851      * Richard Gillam, published by Addison-Wesley, and explained at some
9852      * length there.  The preface says to incorporate its examples into your
9853      * code at your own risk.  In fact, it had bugs
9854      *
9855      * The algorithm is like a merge sort, and is essentially the same as the
9856      * union above
9857      */
9858
9859     const UV* array_a;          /* a's array */
9860     const UV* array_b;
9861     UV len_a;   /* length of a's array */
9862     UV len_b;
9863
9864     SV* r;                   /* the resulting intersection */
9865     UV* array_r;
9866     UV len_r = 0;
9867
9868     UV i_a = 0;             /* current index into a's array */
9869     UV i_b = 0;
9870     UV i_r = 0;
9871
9872     /* running count of how many of the two inputs are postitioned at ranges
9873      * that are in their sets.  As explained in the algorithm source book,
9874      * items are stopped accumulating and are output when the count changes
9875      * to/from 2.  The count is incremented when we start a range that's in an
9876      * input's set, and decremented when we start a range that's not in a set.
9877      * Only when it is 2 are we in the intersection. */
9878     UV count = 0;
9879
9880     PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND;
9881     assert(a != b);
9882     assert(*i == NULL || is_invlist(*i));
9883
9884     /* Special case if either one is empty */
9885     len_a = (a == NULL) ? 0 : _invlist_len(a);
9886     if ((len_a == 0) || ((len_b = _invlist_len(b)) == 0)) {
9887         if (len_a != 0 && complement_b) {
9888
9889             /* Here, 'a' is not empty, therefore from the enclosing 'if', 'b'
9890              * must be empty.  Here, also we are using 'b's complement, which
9891              * hence must be every possible code point.  Thus the intersection
9892              * is simply 'a'. */
9893
9894             if (*i == a) {  /* No-op */
9895                 return;
9896             }
9897
9898             if (*i == NULL) {
9899                 *i = invlist_clone(a, NULL);
9900                 return;
9901             }
9902
9903             r = invlist_clone(a, NULL);
9904             invlist_replace_list_destroys_src(*i, r);
9905             SvREFCNT_dec_NN(r);
9906             return;
9907         }
9908
9909         /* Here, 'a' or 'b' is empty and not using the complement of 'b'.  The
9910          * intersection must be empty */
9911         if (*i == NULL) {
9912             *i = _new_invlist(0);
9913             return;
9914         }
9915
9916         invlist_clear(*i);
9917         return;
9918     }
9919
9920     /* Here both lists exist and are non-empty */
9921     array_a = invlist_array(a);
9922     array_b = invlist_array(b);
9923
9924     /* If are to take the intersection of 'a' with the complement of b, set it
9925      * up so are looking at b's complement. */
9926     if (complement_b) {
9927
9928         /* To complement, we invert: if the first element is 0, remove it.  To
9929          * do this, we just pretend the array starts one later */
9930         if (array_b[0] == 0) {
9931             array_b++;
9932             len_b--;
9933         }
9934         else {
9935
9936             /* But if the first element is not zero, we pretend the list starts
9937              * at the 0 that is always stored immediately before the array. */
9938             array_b--;
9939             len_b++;
9940         }
9941     }
9942
9943     /* Size the intersection for the worst case: that the intersection ends up
9944      * fragmenting everything to be completely disjoint */
9945     r= _new_invlist(len_a + len_b);
9946
9947     /* Will contain U+0000 iff both components do */
9948     array_r = _invlist_array_init(r,    len_a > 0 && array_a[0] == 0
9949                                      && len_b > 0 && array_b[0] == 0);
9950
9951     /* Go through each list item by item, stopping when have exhausted one of
9952      * them */
9953     while (i_a < len_a && i_b < len_b) {
9954         UV cp;      /* The element to potentially add to the intersection's
9955                        array */
9956         bool cp_in_set; /* Is it in the input list's set or not */
9957
9958         /* We need to take one or the other of the two inputs for the
9959          * intersection.  Since we are merging two sorted lists, we take the
9960          * smaller of the next items.  In case of a tie, we take first the one
9961          * that is not in its set (a difference from the union algorithm).  If
9962          * we first took the one in its set, it would increment the count,
9963          * possibly to 2 which would cause it to be output as starting a range
9964          * in the intersection, and the next time through we would take that
9965          * same number, and output it again as ending the set.  By doing the
9966          * opposite of this, there is no possibility that the count will be
9967          * momentarily incremented to 2.  (In a tie and both are in the set or
9968          * both not in the set, it doesn't matter which we take first.) */
9969         if (       array_a[i_a] < array_b[i_b]
9970             || (   array_a[i_a] == array_b[i_b]
9971                 && ! ELEMENT_RANGE_MATCHES_INVLIST(i_a)))
9972         {
9973             cp_in_set = ELEMENT_RANGE_MATCHES_INVLIST(i_a);
9974             cp = array_a[i_a++];
9975         }
9976         else {
9977             cp_in_set = ELEMENT_RANGE_MATCHES_INVLIST(i_b);
9978             cp= array_b[i_b++];
9979         }
9980
9981         /* Here, have chosen which of the two inputs to look at.  Only output
9982          * if the running count changes to/from 2, which marks the
9983          * beginning/end of a range that's in the intersection */
9984         if (cp_in_set) {
9985             count++;
9986             if (count == 2) {
9987                 array_r[i_r++] = cp;
9988             }
9989         }
9990         else {
9991             if (count == 2) {
9992                 array_r[i_r++] = cp;
9993             }
9994             count--;
9995         }
9996
9997     }
9998
9999     /* The loop above increments the index into exactly one of the input lists
10000      * each iteration, and ends when either index gets to its list end.  That
10001      * means the other index is lower than its end, and so something is
10002      * remaining in that one.  We increment 'count', as explained below, if the
10003      * exhausted list was in its set.  (i_a and i_b each currently index the
10004      * element beyond the one we care about.) */
10005     if (   (i_a == len_a && PREV_RANGE_MATCHES_INVLIST(i_a))
10006         || (i_b == len_b && PREV_RANGE_MATCHES_INVLIST(i_b)))
10007     {
10008         count++;
10009     }
10010
10011     /* Above we incremented 'count' if the exhausted list was in its set.  This
10012      * has made it so that 'count' being below 2 means there is nothing left to
10013      * output; otheriwse what's left to add to the intersection is precisely
10014      * that which is left in the non-exhausted input list.
10015      *
10016      * To see why, note first that the exhausted input obviously has nothing
10017      * left to affect the intersection.  If it was in its set at its end, that
10018      * means the set extends from here to the platform's infinity, and hence
10019      * anything in the non-exhausted's list will be in the intersection, and
10020      * anything not in it won't be.  Hence, the rest of the intersection is
10021      * precisely what's in the non-exhausted list  The exhausted set also
10022      * contributed 1 to 'count', meaning 'count' was at least 1.  Incrementing
10023      * it means 'count' is now at least 2.  This is consistent with the
10024      * incremented 'count' being >= 2 means to add the non-exhausted list to
10025      * the intersection.
10026      *
10027      * But if the exhausted input wasn't in its set, it contributed 0 to
10028      * 'count', and the intersection can't include anything further; the
10029      * non-exhausted set is irrelevant.  'count' was at most 1, and doesn't get
10030      * incremented.  This is consistent with 'count' being < 2 meaning nothing
10031      * further to add to the intersection. */
10032     if (count < 2) { /* Nothing left to put in the intersection. */
10033         len_r = i_r;
10034     }
10035     else { /* copy the non-exhausted list, unchanged. */
10036         IV copy_count = len_a - i_a;
10037         if (copy_count > 0) {   /* a is the one with stuff left */
10038             Copy(array_a + i_a, array_r + i_r, copy_count, UV);
10039         }
10040         else {  /* b is the one with stuff left */
10041             copy_count = len_b - i_b;
10042             Copy(array_b + i_b, array_r + i_r, copy_count, UV);
10043         }
10044         len_r = i_r + copy_count;
10045     }
10046
10047     /* Set the result to the final length, which can change the pointer to
10048      * array_r, so re-find it.  (Note that it is unlikely that this will
10049      * change, as we are shrinking the space, not enlarging it) */
10050     if (len_r != _invlist_len(r)) {
10051         invlist_set_len(r, len_r, *get_invlist_offset_addr(r));
10052         invlist_trim(r);
10053         array_r = invlist_array(r);
10054     }
10055
10056     if (*i == NULL) { /* Simply return the calculated intersection */
10057         *i = r;
10058     }
10059     else { /* Otherwise, replace the existing inversion list in '*i'.  We could
10060               instead free '*i', and then set it to 'r', but experience has
10061               shown [perl #127392] that if the input is a mortal, we can get a
10062               huge build-up of these during regex compilation before they get
10063               freed. */
10064         if (len_r) {
10065             invlist_replace_list_destroys_src(*i, r);
10066         }
10067         else {
10068             invlist_clear(*i);
10069         }
10070         SvREFCNT_dec_NN(r);
10071     }
10072
10073     return;
10074 }
10075
10076 SV*
10077 Perl__add_range_to_invlist(pTHX_ SV* invlist, UV start, UV end)
10078 {
10079     /* Add the range from 'start' to 'end' inclusive to the inversion list's
10080      * set.  A pointer to the inversion list is returned.  This may actually be
10081      * a new list, in which case the passed in one has been destroyed.  The
10082      * passed-in inversion list can be NULL, in which case a new one is created
10083      * with just the one range in it.  The new list is not necessarily
10084      * NUL-terminated.  Space is not freed if the inversion list shrinks as a
10085      * result of this function.  The gain would not be large, and in many
10086      * cases, this is called multiple times on a single inversion list, so
10087      * anything freed may almost immediately be needed again.
10088      *
10089      * This used to mostly call the 'union' routine, but that is much more
10090      * heavyweight than really needed for a single range addition */
10091
10092     UV* array;              /* The array implementing the inversion list */
10093     UV len;                 /* How many elements in 'array' */
10094     SSize_t i_s;            /* index into the invlist array where 'start'
10095                                should go */
10096     SSize_t i_e = 0;        /* And the index where 'end' should go */
10097     UV cur_highest;         /* The highest code point in the inversion list
10098                                upon entry to this function */
10099
10100     /* This range becomes the whole inversion list if none already existed */
10101     if (invlist == NULL) {
10102         invlist = _new_invlist(2);
10103         _append_range_to_invlist(invlist, start, end);
10104         return invlist;
10105     }
10106
10107     /* Likewise, if the inversion list is currently empty */
10108     len = _invlist_len(invlist);
10109     if (len == 0) {
10110         _append_range_to_invlist(invlist, start, end);
10111         return invlist;
10112     }
10113
10114     /* Starting here, we have to know the internals of the list */
10115     array = invlist_array(invlist);
10116
10117     /* If the new range ends higher than the current highest ... */
10118     cur_highest = invlist_highest(invlist);
10119     if (end > cur_highest) {
10120
10121         /* If the whole range is higher, we can just append it */
10122         if (start > cur_highest) {
10123             _append_range_to_invlist(invlist, start, end);
10124             return invlist;
10125         }
10126
10127         /* Otherwise, add the portion that is higher ... */
10128         _append_range_to_invlist(invlist, cur_highest + 1, end);
10129
10130         /* ... and continue on below to handle the rest.  As a result of the
10131          * above append, we know that the index of the end of the range is the
10132          * final even numbered one of the array.  Recall that the final element
10133          * always starts a range that extends to infinity.  If that range is in
10134          * the set (meaning the set goes from here to infinity), it will be an
10135          * even index, but if it isn't in the set, it's odd, and the final
10136          * range in the set is one less, which is even. */
10137         if (end == UV_MAX) {
10138             i_e = len;
10139         }
10140         else {
10141             i_e = len - 2;
10142         }
10143     }
10144
10145     /* We have dealt with appending, now see about prepending.  If the new
10146      * range starts lower than the current lowest ... */
10147     if (start < array[0]) {
10148
10149         /* Adding something which has 0 in it is somewhat tricky, and uncommon.
10150          * Let the union code handle it, rather than having to know the
10151          * trickiness in two code places.  */
10152         if (UNLIKELY(start == 0)) {
10153             SV* range_invlist;
10154
10155             range_invlist = _new_invlist(2);
10156             _append_range_to_invlist(range_invlist, start, end);
10157
10158             _invlist_union(invlist, range_invlist, &invlist);
10159
10160             SvREFCNT_dec_NN(range_invlist);
10161
10162             return invlist;
10163         }
10164
10165         /* If the whole new range comes before the first entry, and doesn't
10166          * extend it, we have to insert it as an additional range */
10167         if (end < array[0] - 1) {
10168             i_s = i_e = -1;
10169             goto splice_in_new_range;
10170         }
10171
10172         /* Here the new range adjoins the existing first range, extending it
10173          * downwards. */
10174         array[0] = start;
10175
10176         /* And continue on below to handle the rest.  We know that the index of
10177          * the beginning of the range is the first one of the array */
10178         i_s = 0;
10179     }
10180     else { /* Not prepending any part of the new range to the existing list.
10181             * Find where in the list it should go.  This finds i_s, such that:
10182             *     invlist[i_s] <= start < array[i_s+1]
10183             */
10184         i_s = _invlist_search(invlist, start);
10185     }
10186
10187     /* At this point, any extending before the beginning of the inversion list
10188      * and/or after the end has been done.  This has made it so that, in the
10189      * code below, each endpoint of the new range is either in a range that is
10190      * in the set, or is in a gap between two ranges that are.  This means we
10191      * don't have to worry about exceeding the array bounds.
10192      *
10193      * Find where in the list the new range ends (but we can skip this if we
10194      * have already determined what it is, or if it will be the same as i_s,
10195      * which we already have computed) */
10196     if (i_e == 0) {
10197         i_e = (start == end)
10198               ? i_s
10199               : _invlist_search(invlist, end);
10200     }
10201
10202     /* Here generally invlist[i_e] <= end < array[i_e+1].  But if invlist[i_e]
10203      * is a range that goes to infinity there is no element at invlist[i_e+1],
10204      * so only the first relation holds. */
10205
10206     if ( ! ELEMENT_RANGE_MATCHES_INVLIST(i_s)) {
10207
10208         /* Here, the ranges on either side of the beginning of the new range
10209          * are in the set, and this range starts in the gap between them.
10210          *
10211          * The new range extends the range above it downwards if the new range
10212          * ends at or above that range's start */
10213         const bool extends_the_range_above = (   end == UV_MAX
10214                                               || end + 1 >= array[i_s+1]);
10215
10216         /* The new range extends the range below it upwards if it begins just
10217          * after where that range ends */
10218         if (start == array[i_s]) {
10219
10220             /* If the new range fills the entire gap between the other ranges,
10221              * they will get merged together.  Other ranges may also get
10222              * merged, depending on how many of them the new range spans.  In
10223              * the general case, we do the merge later, just once, after we
10224              * figure out how many to merge.  But in the case where the new
10225              * range exactly spans just this one gap (possibly extending into
10226              * the one above), we do the merge here, and an early exit.  This
10227              * is done here to avoid having to special case later. */
10228             if (i_e - i_s <= 1) {
10229
10230                 /* If i_e - i_s == 1, it means that the new range terminates
10231                  * within the range above, and hence 'extends_the_range_above'
10232                  * must be true.  (If the range above it extends to infinity,
10233                  * 'i_s+2' will be above the array's limit, but 'len-i_s-2'
10234                  * will be 0, so no harm done.) */
10235                 if (extends_the_range_above) {
10236                     Move(array + i_s + 2, array + i_s, len - i_s - 2, UV);
10237                     invlist_set_len(invlist,
10238                                     len - 2,
10239                                     *(get_invlist_offset_addr(invlist)));
10240                     return invlist;
10241                 }
10242
10243                 /* Here, i_e must == i_s.  We keep them in sync, as they apply
10244                  * to the same range, and below we are about to decrement i_s
10245                  * */
10246                 i_e--;
10247             }
10248
10249             /* Here, the new range is adjacent to the one below.  (It may also
10250              * span beyond the range above, but that will get resolved later.)
10251              * Extend the range below to include this one. */
10252             array[i_s] = (end == UV_MAX) ? UV_MAX : end + 1;
10253             i_s--;
10254             start = array[i_s];
10255         }
10256         else if (extends_the_range_above) {
10257
10258             /* Here the new range only extends the range above it, but not the
10259              * one below.  It merges with the one above.  Again, we keep i_e
10260              * and i_s in sync if they point to the same range */
10261             if (i_e == i_s) {
10262                 i_e++;
10263             }
10264             i_s++;
10265             array[i_s] = start;
10266         }
10267     }
10268
10269     /* Here, we've dealt with the new range start extending any adjoining
10270      * existing ranges.
10271      *
10272      * If the new range extends to infinity, it is now the final one,
10273      * regardless of what was there before */
10274     if (UNLIKELY(end == UV_MAX)) {
10275         invlist_set_len(invlist, i_s + 1, *(get_invlist_offset_addr(invlist)));
10276         return invlist;
10277     }
10278
10279     /* If i_e started as == i_s, it has also been dealt with,
10280      * and been updated to the new i_s, which will fail the following if */
10281     if (! ELEMENT_RANGE_MATCHES_INVLIST(i_e)) {
10282
10283         /* Here, the ranges on either side of the end of the new range are in
10284          * the set, and this range ends in the gap between them.
10285          *
10286          * If this range is adjacent to (hence extends) the range above it, it
10287          * becomes part of that range; likewise if it extends the range below,
10288          * it becomes part of that range */
10289         if (end + 1 == array[i_e+1]) {
10290             i_e++;
10291             array[i_e] = start;
10292         }
10293         else if (start <= array[i_e]) {
10294             array[i_e] = end + 1;
10295             i_e--;
10296         }
10297     }
10298
10299     if (i_s == i_e) {
10300
10301         /* If the range fits entirely in an existing range (as possibly already
10302          * extended above), it doesn't add anything new */
10303         if (ELEMENT_RANGE_MATCHES_INVLIST(i_s)) {
10304             return invlist;
10305         }
10306
10307         /* Here, no part of the range is in the list.  Must add it.  It will
10308          * occupy 2 more slots */
10309       splice_in_new_range:
10310
10311         invlist_extend(invlist, len + 2);
10312         array = invlist_array(invlist);
10313         /* Move the rest of the array down two slots. Don't include any
10314          * trailing NUL */
10315         Move(array + i_e + 1, array + i_e + 3, len - i_e - 1, UV);
10316
10317         /* Do the actual splice */
10318         array[i_e+1] = start;
10319         array[i_e+2] = end + 1;
10320         invlist_set_len(invlist, len + 2, *(get_invlist_offset_addr(invlist)));
10321         return invlist;
10322     }
10323
10324     /* Here the new range crossed the boundaries of a pre-existing range.  The
10325      * code above has adjusted things so that both ends are in ranges that are
10326      * in the set.  This means everything in between must also be in the set.
10327      * Just squash things together */
10328     Move(array + i_e + 1, array + i_s + 1, len - i_e - 1, UV);
10329     invlist_set_len(invlist,
10330                     len - i_e + i_s,
10331                     *(get_invlist_offset_addr(invlist)));
10332
10333     return invlist;
10334 }
10335
10336 SV*
10337 Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0,
10338                                  UV** other_elements_ptr)
10339 {
10340     /* Create and return an inversion list whose contents are to be populated
10341      * by the caller.  The caller gives the number of elements (in 'size') and
10342      * the very first element ('element0').  This function will set
10343      * '*other_elements_ptr' to an array of UVs, where the remaining elements
10344      * are to be placed.
10345      *
10346      * Obviously there is some trust involved that the caller will properly
10347      * fill in the other elements of the array.
10348      *
10349      * (The first element needs to be passed in, as the underlying code does
10350      * things differently depending on whether it is zero or non-zero) */
10351
10352     SV* invlist = _new_invlist(size);
10353     bool offset;
10354
10355     PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST;
10356
10357     invlist = add_cp_to_invlist(invlist, element0);
10358     offset = *get_invlist_offset_addr(invlist);
10359
10360     invlist_set_len(invlist, size, offset);
10361     *other_elements_ptr = invlist_array(invlist) + 1;
10362     return invlist;
10363 }
10364
10365 #endif
10366
10367 #ifndef PERL_IN_XSUB_RE
10368 void
10369 Perl__invlist_invert(pTHX_ SV* const invlist)
10370 {
10371     /* Complement the input inversion list.  This adds a 0 if the list didn't
10372      * have a zero; removes it otherwise.  As described above, the data
10373      * structure is set up so that this is very efficient */
10374
10375     PERL_ARGS_ASSERT__INVLIST_INVERT;
10376
10377     assert(! invlist_is_iterating(invlist));
10378
10379     /* The inverse of matching nothing is matching everything */
10380     if (_invlist_len(invlist) == 0) {
10381         _append_range_to_invlist(invlist, 0, UV_MAX);
10382         return;
10383     }
10384
10385     *get_invlist_offset_addr(invlist) = ! *get_invlist_offset_addr(invlist);
10386 }
10387
10388 SV*
10389 Perl_invlist_clone(pTHX_ SV* const invlist, SV* new_invlist)
10390 {
10391     /* Return a new inversion list that is a copy of the input one, which is
10392      * unchanged.  The new list will not be mortal even if the old one was. */
10393
10394     const STRLEN nominal_length = _invlist_len(invlist);
10395     const STRLEN physical_length = SvCUR(invlist);
10396     const bool offset = *(get_invlist_offset_addr(invlist));
10397
10398     PERL_ARGS_ASSERT_INVLIST_CLONE;
10399
10400     if (new_invlist == NULL) {
10401         new_invlist = _new_invlist(nominal_length);
10402     }
10403     else {
10404         sv_upgrade(new_invlist, SVt_INVLIST);
10405         initialize_invlist_guts(new_invlist, nominal_length);
10406     }
10407
10408     *(get_invlist_offset_addr(new_invlist)) = offset;
10409     invlist_set_len(new_invlist, nominal_length, offset);
10410     Copy(SvPVX(invlist), SvPVX(new_invlist), physical_length, char);
10411
10412     return new_invlist;
10413 }
10414
10415 #endif
10416
10417 PERL_STATIC_INLINE UV
10418 S_invlist_lowest(SV* const invlist)
10419 {
10420     /* Returns the lowest code point that matches an inversion list.  This API
10421      * has an ambiguity, as it returns 0 under either the lowest is actually
10422      * 0, or if the list is empty.  If this distinction matters to you, check
10423      * for emptiness before calling this function */
10424
10425     UV len = _invlist_len(invlist);
10426     UV *array;
10427
10428     PERL_ARGS_ASSERT_INVLIST_LOWEST;
10429
10430     if (len == 0) {
10431         return 0;
10432     }
10433
10434     array = invlist_array(invlist);
10435
10436     return array[0];
10437 }
10438
10439 STATIC SV *
10440 S_invlist_contents(pTHX_ SV* const invlist, const bool traditional_style)
10441 {
10442     /* Get the contents of an inversion list into a string SV so that they can
10443      * be printed out.  If 'traditional_style' is TRUE, it uses the format
10444      * traditionally done for debug tracing; otherwise it uses a format
10445      * suitable for just copying to the output, with blanks between ranges and
10446      * a dash between range components */
10447
10448     UV start, end;
10449     SV* output;
10450     const char intra_range_delimiter = (traditional_style ? '\t' : '-');
10451     const char inter_range_delimiter = (traditional_style ? '\n' : ' ');
10452
10453     if (traditional_style) {
10454         output = newSVpvs("\n");
10455     }
10456     else {
10457         output = newSVpvs("");
10458     }
10459
10460     PERL_ARGS_ASSERT_INVLIST_CONTENTS;
10461
10462     assert(! invlist_is_iterating(invlist));
10463
10464     invlist_iterinit(invlist);
10465     while (invlist_iternext(invlist, &start, &end)) {
10466         if (end == UV_MAX) {
10467             Perl_sv_catpvf(aTHX_ output, "%04" UVXf "%cINFTY%c",
10468                                           start, intra_range_delimiter,
10469                                                  inter_range_delimiter);
10470         }
10471         else if (end != start) {
10472             Perl_sv_catpvf(aTHX_ output, "%04" UVXf "%c%04" UVXf "%c",
10473                                           start,
10474                                                    intra_range_delimiter,
10475                                                   end, inter_range_delimiter);
10476         }
10477         else {
10478             Perl_sv_catpvf(aTHX_ output, "%04" UVXf "%c",
10479                                           start, inter_range_delimiter);
10480         }
10481     }
10482
10483     if (SvCUR(output) && ! traditional_style) {/* Get rid of trailing blank */
10484         SvCUR_set(output, SvCUR(output) - 1);
10485     }
10486
10487     return output;
10488 }
10489
10490 #ifndef PERL_IN_XSUB_RE
10491 void
10492 Perl__invlist_dump(pTHX_ PerlIO *file, I32 level,
10493                          const char * const indent, SV* const invlist)
10494 {
10495     /* Designed to be called only by do_sv_dump().  Dumps out the ranges of the
10496      * inversion list 'invlist' to 'file' at 'level'  Each line is prefixed by
10497      * the string 'indent'.  The output looks like this:
10498          [0] 0x000A .. 0x000D
10499          [2] 0x0085
10500          [4] 0x2028 .. 0x2029
10501          [6] 0x3104 .. INFTY
10502      * This means that the first range of code points matched by the list are
10503      * 0xA through 0xD; the second range contains only the single code point
10504      * 0x85, etc.  An inversion list is an array of UVs.  Two array elements
10505      * are used to define each range (except if the final range extends to
10506      * infinity, only a single element is needed).  The array index of the
10507      * first element for the corresponding range is given in brackets. */
10508
10509     UV start, end;
10510     STRLEN count = 0;
10511
10512     PERL_ARGS_ASSERT__INVLIST_DUMP;
10513
10514     if (invlist_is_iterating(invlist)) {
10515         Perl_dump_indent(aTHX_ level, file,
10516              "%sCan't dump inversion list because is in middle of iterating\n",
10517              indent);
10518         return;
10519     }
10520
10521     invlist_iterinit(invlist);
10522     while (invlist_iternext(invlist, &start, &end)) {
10523         if (end == UV_MAX) {
10524             Perl_dump_indent(aTHX_ level, file,
10525                                        "%s[%" UVuf "] 0x%04" UVXf " .. INFTY\n",
10526                                    indent, (UV)count, start);
10527         }
10528         else if (end != start) {
10529             Perl_dump_indent(aTHX_ level, file,
10530                                     "%s[%" UVuf "] 0x%04" UVXf " .. 0x%04" UVXf "\n",
10531                                 indent, (UV)count, start,         end);
10532         }
10533         else {
10534             Perl_dump_indent(aTHX_ level, file, "%s[%" UVuf "] 0x%04" UVXf "\n",
10535                                             indent, (UV)count, start);
10536         }
10537         count += 2;
10538     }
10539 }
10540
10541 #endif
10542
10543 #if defined(PERL_ARGS_ASSERT__INVLISTEQ) && !defined(PERL_IN_XSUB_RE)
10544 bool
10545 Perl__invlistEQ(pTHX_ SV* const a, SV* const b, const bool complement_b)
10546 {
10547     /* Return a boolean as to if the two passed in inversion lists are
10548      * identical.  The final argument, if TRUE, says to take the complement of
10549      * the second inversion list before doing the comparison */
10550
10551     const UV len_a = _invlist_len(a);
10552     UV len_b = _invlist_len(b);
10553
10554     const UV* array_a = NULL;
10555     const UV* array_b = NULL;
10556
10557     PERL_ARGS_ASSERT__INVLISTEQ;
10558
10559     /* This code avoids accessing the arrays unless it knows the length is
10560      * non-zero */
10561
10562     if (len_a == 0) {
10563         if (len_b == 0) {
10564             return ! complement_b;
10565         }
10566     }
10567     else {
10568         array_a = invlist_array(a);
10569     }
10570
10571     if (len_b != 0) {
10572         array_b = invlist_array(b);
10573     }
10574
10575     /* If are to compare 'a' with the complement of b, set it
10576      * up so are looking at b's complement. */
10577     if (complement_b) {
10578
10579         /* The complement of nothing is everything, so <a> would have to have
10580          * just one element, starting at zero (ending at infinity) */
10581         if (len_b == 0) {
10582             return (len_a == 1 && array_a[0] == 0);
10583         }
10584         if (array_b[0] == 0) {
10585
10586             /* Otherwise, to complement, we invert.  Here, the first element is
10587              * 0, just remove it.  To do this, we just pretend the array starts
10588              * one later */
10589
10590             array_b++;
10591             len_b--;
10592         }
10593         else {
10594
10595             /* But if the first element is not zero, we pretend the list starts
10596              * at the 0 that is always stored immediately before the array. */
10597             array_b--;
10598             len_b++;
10599         }
10600     }
10601
10602     return    len_a == len_b
10603            && memEQ(array_a, array_b, len_a * sizeof(array_a[0]));
10604
10605 }
10606 #endif
10607
10608 /*
10609  * As best we can, determine the characters that can match the start of
10610  * the given EXACTF-ish node.  This is for use in creating ssc nodes, so there
10611  * can be false positive matches
10612  *
10613  * Returns the invlist as a new SV*; it is the caller's responsibility to
10614  * call SvREFCNT_dec() when done with it.
10615  */
10616 STATIC SV*
10617 S_make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node)
10618 {
10619     const U8 * s = (U8*)STRING(node);
10620     SSize_t bytelen = STR_LEN(node);
10621     UV uc;
10622     /* Start out big enough for 2 separate code points */
10623     SV* invlist = _new_invlist(4);
10624
10625     PERL_ARGS_ASSERT_MAKE_EXACTF_INVLIST;
10626
10627     if (! UTF) {
10628         uc = *s;
10629
10630         /* We punt and assume can match anything if the node begins
10631          * with a multi-character fold.  Things are complicated.  For
10632          * example, /ffi/i could match any of:
10633          *  "\N{LATIN SMALL LIGATURE FFI}"
10634          *  "\N{LATIN SMALL LIGATURE FF}I"
10635          *  "F\N{LATIN SMALL LIGATURE FI}"
10636          *  plus several other things; and making sure we have all the
10637          *  possibilities is hard. */
10638         if (is_MULTI_CHAR_FOLD_latin1_safe(s, s + bytelen)) {
10639             invlist = _add_range_to_invlist(invlist, 0, UV_MAX);
10640         }
10641         else {
10642             /* Any Latin1 range character can potentially match any
10643              * other depending on the locale, and in Turkic locales, U+130 and
10644              * U+131 */
10645             if (OP(node) == EXACTFL) {
10646                 _invlist_union(invlist, PL_Latin1, &invlist);
10647                 invlist = add_cp_to_invlist(invlist,
10648                                                 LATIN_SMALL_LETTER_DOTLESS_I);
10649                 invlist = add_cp_to_invlist(invlist,
10650                                         LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE);
10651             }
10652             else {
10653                 /* But otherwise, it matches at least itself.  We can
10654                  * quickly tell if it has a distinct fold, and if so,
10655                  * it matches that as well */
10656                 invlist = add_cp_to_invlist(invlist, uc);
10657                 if (IS_IN_SOME_FOLD_L1(uc))
10658                     invlist = add_cp_to_invlist(invlist, PL_fold_latin1[uc]);
10659             }
10660
10661             /* Some characters match above-Latin1 ones under /i.  This
10662              * is true of EXACTFL ones when the locale is UTF-8 */
10663             if (HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(uc)
10664                 && (! isASCII(uc) || ! inRANGE(OP(node), EXACTFAA,
10665                                                          EXACTFAA_NO_TRIE)))
10666             {
10667                 add_above_Latin1_folds(pRExC_state, (U8) uc, &invlist);
10668             }
10669         }
10670     }
10671     else {  /* Pattern is UTF-8 */
10672         U8 folded[UTF8_MAX_FOLD_CHAR_EXPAND * UTF8_MAXBYTES_CASE + 1] = { '\0' };
10673         const U8* e = s + bytelen;
10674         IV fc;
10675
10676         fc = uc = utf8_to_uvchr_buf(s, s + bytelen, NULL);
10677
10678         /* The only code points that aren't folded in a UTF EXACTFish
10679          * node are the problematic ones in EXACTFL nodes */
10680         if (OP(node) == EXACTFL && is_PROBLEMATIC_LOCALE_FOLDEDS_START_cp(uc)) {
10681             /* We need to check for the possibility that this EXACTFL
10682              * node begins with a multi-char fold.  Therefore we fold
10683              * the first few characters of it so that we can make that
10684              * check */
10685             U8 *d = folded;
10686             int i;
10687
10688             fc = -1;
10689             for (i = 0; i < UTF8_MAX_FOLD_CHAR_EXPAND && s < e; i++) {
10690                 if (isASCII(*s)) {
10691                     *(d++) = (U8) toFOLD(*s);
10692                     if (fc < 0) {       /* Save the first fold */
10693                         fc = *(d-1);
10694                     }
10695                     s++;
10696                 }
10697                 else {
10698                     STRLEN len;
10699                     UV fold = toFOLD_utf8_safe(s, e, d, &len);
10700                     if (fc < 0) {       /* Save the first fold */
10701                         fc = fold;
10702                     }
10703                     d += len;
10704                     s += UTF8SKIP(s);
10705                 }
10706             }
10707
10708             /* And set up so the code below that looks in this folded
10709              * buffer instead of the node's string */
10710             e = d;
10711             s = folded;
10712         }
10713
10714         /* When we reach here 's' points to the fold of the first
10715          * character(s) of the node; and 'e' points to far enough along
10716          * the folded string to be just past any possible multi-char
10717          * fold.
10718          *
10719          * Like the non-UTF case above, we punt if the node begins with a
10720          * multi-char fold  */
10721
10722         if (is_MULTI_CHAR_FOLD_utf8_safe(s, e)) {
10723             invlist = _add_range_to_invlist(invlist, 0, UV_MAX);
10724         }
10725         else {  /* Single char fold */
10726             unsigned int k;
10727             U32 first_fold;
10728             const U32 * remaining_folds;
10729             Size_t folds_count;
10730
10731             /* It matches itself */
10732             invlist = add_cp_to_invlist(invlist, fc);
10733
10734             /* ... plus all the things that fold to it, which are found in
10735              * PL_utf8_foldclosures */
10736             folds_count = _inverse_folds(fc, &first_fold,
10737                                                 &remaining_folds);
10738             for (k = 0; k < folds_count; k++) {
10739                 UV c = (k == 0) ? first_fold : remaining_folds[k-1];
10740
10741                 /* /aa doesn't allow folds between ASCII and non- */
10742                 if (   inRANGE(OP(node), EXACTFAA, EXACTFAA_NO_TRIE)
10743                     && isASCII(c) != isASCII(fc))
10744                 {
10745                     continue;
10746                 }
10747
10748                 invlist = add_cp_to_invlist(invlist, c);
10749             }
10750
10751             if (OP(node) == EXACTFL) {
10752
10753                 /* If either [iI] are present in an EXACTFL node the above code
10754                  * should have added its normal case pair, but under a Turkish
10755                  * locale they could match instead the case pairs from it.  Add
10756                  * those as potential matches as well */
10757                 if (isALPHA_FOLD_EQ(fc, 'I')) {
10758                     invlist = add_cp_to_invlist(invlist,
10759                                                 LATIN_SMALL_LETTER_DOTLESS_I);
10760                     invlist = add_cp_to_invlist(invlist,
10761                                         LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE);
10762                 }
10763                 else if (fc == LATIN_SMALL_LETTER_DOTLESS_I) {
10764                     invlist = add_cp_to_invlist(invlist, 'I');
10765                 }
10766                 else if (fc == LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE) {
10767                     invlist = add_cp_to_invlist(invlist, 'i');
10768                 }
10769             }
10770         }
10771     }
10772
10773     return invlist;
10774 }
10775
10776 #undef HEADER_LENGTH
10777 #undef TO_INTERNAL_SIZE
10778 #undef FROM_INTERNAL_SIZE
10779 #undef INVLIST_VERSION_ID
10780
10781 /* End of inversion list object */
10782
10783 STATIC void
10784 S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state)
10785 {
10786     /* This parses the flags that are in either the '(?foo)' or '(?foo:bar)'
10787      * constructs, and updates RExC_flags with them.  On input, RExC_parse
10788      * should point to the first flag; it is updated on output to point to the
10789      * final ')' or ':'.  There needs to be at least one flag, or this will
10790      * abort */
10791
10792     /* for (?g), (?gc), and (?o) warnings; warning
10793        about (?c) will warn about (?g) -- japhy    */
10794
10795 #define WASTED_O  0x01
10796 #define WASTED_G  0x02
10797 #define WASTED_C  0x04
10798 #define WASTED_GC (WASTED_G|WASTED_C)
10799     I32 wastedflags = 0x00;
10800     U32 posflags = 0, negflags = 0;
10801     U32 *flagsp = &posflags;
10802     char has_charset_modifier = '\0';
10803     regex_charset cs;
10804     bool has_use_defaults = FALSE;
10805     const char* const seqstart = RExC_parse - 1; /* Point to the '?' */
10806     int x_mod_count = 0;
10807
10808     PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS;
10809
10810     /* '^' as an initial flag sets certain defaults */
10811     if (UCHARAT(RExC_parse) == '^') {
10812         RExC_parse++;
10813         has_use_defaults = TRUE;
10814         STD_PMMOD_FLAGS_CLEAR(&RExC_flags);
10815         cs = (toUSE_UNI_CHARSET_NOT_DEPENDS)
10816              ? REGEX_UNICODE_CHARSET
10817              : REGEX_DEPENDS_CHARSET;
10818         set_regex_charset(&RExC_flags, cs);
10819     }
10820     else {
10821         cs = get_regex_charset(RExC_flags);
10822         if (   cs == REGEX_DEPENDS_CHARSET
10823             && (toUSE_UNI_CHARSET_NOT_DEPENDS))
10824         {
10825             cs = REGEX_UNICODE_CHARSET;
10826         }
10827     }
10828
10829     while (RExC_parse < RExC_end) {
10830         /* && memCHRs("iogcmsx", *RExC_parse) */
10831         /* (?g), (?gc) and (?o) are useless here
10832            and must be globally applied -- japhy */
10833         if ((RExC_pm_flags & PMf_WILDCARD)) {
10834             if (flagsp == & negflags) {
10835                 if (*RExC_parse == 'm') {
10836                     RExC_parse++;
10837                     /* diag_listed_as: Use of %s is not allowed in Unicode
10838                        property wildcard subpatterns in regex; marked by <--
10839                        HERE in m/%s/ */
10840                     vFAIL("Use of modifier '-m' is not allowed in Unicode"
10841                           " property wildcard subpatterns");
10842                 }
10843             }
10844             else {
10845                 if (*RExC_parse == 's') {
10846                     goto modifier_illegal_in_wildcard;
10847                 }
10848             }
10849         }
10850
10851         switch (*RExC_parse) {
10852
10853             /* Code for the imsxn flags */
10854             CASE_STD_PMMOD_FLAGS_PARSE_SET(flagsp, x_mod_count);
10855
10856             case LOCALE_PAT_MOD:
10857                 if (has_charset_modifier) {
10858                     goto excess_modifier;
10859                 }
10860                 else if (flagsp == &negflags) {
10861                     goto neg_modifier;
10862                 }
10863                 cs = REGEX_LOCALE_CHARSET;
10864                 has_charset_modifier = LOCALE_PAT_MOD;
10865                 break;
10866             case UNICODE_PAT_MOD:
10867                 if (has_charset_modifier) {
10868                     goto excess_modifier;
10869                 }
10870                 else if (flagsp == &negflags) {
10871                     goto neg_modifier;
10872                 }
10873                 cs = REGEX_UNICODE_CHARSET;
10874                 has_charset_modifier = UNICODE_PAT_MOD;
10875                 break;
10876             case ASCII_RESTRICT_PAT_MOD:
10877                 if (flagsp == &negflags) {
10878                     goto neg_modifier;
10879                 }
10880                 if (has_charset_modifier) {
10881                     if (cs != REGEX_ASCII_RESTRICTED_CHARSET) {
10882                         goto excess_modifier;
10883                     }
10884                     /* Doubled modifier implies more restricted */
10885                     cs = REGEX_ASCII_MORE_RESTRICTED_CHARSET;
10886                 }
10887                 else {
10888                     cs = REGEX_ASCII_RESTRICTED_CHARSET;
10889                 }
10890                 has_charset_modifier = ASCII_RESTRICT_PAT_MOD;
10891                 break;
10892             case DEPENDS_PAT_MOD:
10893                 if (has_use_defaults) {
10894                     goto fail_modifiers;
10895                 }
10896                 else if (flagsp == &negflags) {
10897                     goto neg_modifier;
10898                 }
10899                 else if (has_charset_modifier) {
10900                     goto excess_modifier;
10901                 }
10902
10903                 /* The dual charset means unicode semantics if the
10904                  * pattern (or target, not known until runtime) are
10905                  * utf8, or something in the pattern indicates unicode
10906                  * semantics */
10907                 cs = (toUSE_UNI_CHARSET_NOT_DEPENDS)
10908                      ? REGEX_UNICODE_CHARSET
10909                      : REGEX_DEPENDS_CHARSET;
10910                 has_charset_modifier = DEPENDS_PAT_MOD;
10911                 break;
10912               excess_modifier:
10913                 RExC_parse++;
10914                 if (has_charset_modifier == ASCII_RESTRICT_PAT_MOD) {
10915                     vFAIL2("Regexp modifier \"%c\" may appear a maximum of twice", ASCII_RESTRICT_PAT_MOD);
10916                 }
10917                 else if (has_charset_modifier == *(RExC_parse - 1)) {
10918                     vFAIL2("Regexp modifier \"%c\" may not appear twice",
10919                                         *(RExC_parse - 1));
10920                 }
10921                 else {
10922                     vFAIL3("Regexp modifiers \"%c\" and \"%c\" are mutually exclusive", has_charset_modifier, *(RExC_parse - 1));
10923                 }
10924                 NOT_REACHED; /*NOTREACHED*/
10925               neg_modifier:
10926                 RExC_parse++;
10927                 vFAIL2("Regexp modifier \"%c\" may not appear after the \"-\"",
10928                                     *(RExC_parse - 1));
10929                 NOT_REACHED; /*NOTREACHED*/
10930             case GLOBAL_PAT_MOD: /* 'g' */
10931                 if (RExC_pm_flags & PMf_WILDCARD) {
10932                     goto modifier_illegal_in_wildcard;
10933                 }
10934                 /*FALLTHROUGH*/
10935             case ONCE_PAT_MOD: /* 'o' */
10936                 if (ckWARN(WARN_REGEXP)) {
10937                     const I32 wflagbit = *RExC_parse == 'o'
10938                                          ? WASTED_O
10939                                          : WASTED_G;
10940                     if (! (wastedflags & wflagbit) ) {
10941                         wastedflags |= wflagbit;
10942                         /* diag_listed_as: Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in m/%s/ */
10943                         vWARN5(
10944                             RExC_parse + 1,
10945                             "Useless (%s%c) - %suse /%c modifier",
10946                             flagsp == &negflags ? "?-" : "?",
10947                             *RExC_parse,
10948                             flagsp == &negflags ? "don't " : "",
10949                             *RExC_parse
10950                         );
10951                     }
10952                 }
10953                 break;
10954
10955             case CONTINUE_PAT_MOD: /* 'c' */
10956                 if (RExC_pm_flags & PMf_WILDCARD) {
10957                     goto modifier_illegal_in_wildcard;
10958                 }
10959                 if (ckWARN(WARN_REGEXP)) {
10960                     if (! (wastedflags & WASTED_C) ) {
10961                         wastedflags |= WASTED_GC;
10962                         /* diag_listed_as: Useless (?-%s) - don't use /%s modifier in regex; marked by <-- HERE in m/%s/ */
10963                         vWARN3(
10964                             RExC_parse + 1,
10965                             "Useless (%sc) - %suse /gc modifier",
10966                             flagsp == &negflags ? "?-" : "?",
10967                             flagsp == &negflags ? "don't " : ""
10968                         );
10969                     }
10970                 }
10971                 break;
10972             case KEEPCOPY_PAT_MOD: /* 'p' */
10973                 if (RExC_pm_flags & PMf_WILDCARD) {
10974                     goto modifier_illegal_in_wildcard;
10975                 }
10976                 if (flagsp == &negflags) {
10977                     ckWARNreg(RExC_parse + 1,"Useless use of (?-p)");
10978                 } else {
10979                     *flagsp |= RXf_PMf_KEEPCOPY;
10980                 }
10981                 break;
10982             case '-':
10983                 /* A flag is a default iff it is following a minus, so
10984                  * if there is a minus, it means will be trying to
10985                  * re-specify a default which is an error */
10986                 if (has_use_defaults || flagsp == &negflags) {
10987                     goto fail_modifiers;
10988                 }
10989                 flagsp = &negflags;
10990                 wastedflags = 0;  /* reset so (?g-c) warns twice */
10991                 x_mod_count = 0;
10992                 break;
10993             case ':':
10994             case ')':
10995
10996                 if (  (RExC_pm_flags & PMf_WILDCARD)
10997                     && cs != REGEX_ASCII_MORE_RESTRICTED_CHARSET)
10998                 {
10999                     RExC_parse++;
11000                     /* diag_listed_as: Use of %s is not allowed in Unicode
11001                        property wildcard subpatterns in regex; marked by <--
11002                        HERE in m/%s/ */
11003                     vFAIL2("Use of modifier '%c' is not allowed in Unicode"
11004                            " property wildcard subpatterns",
11005                            has_charset_modifier);
11006                 }
11007
11008                 if ((posflags & (RXf_PMf_EXTENDED|RXf_PMf_EXTENDED_MORE)) == RXf_PMf_EXTENDED) {
11009                     negflags |= RXf_PMf_EXTENDED_MORE;
11010                 }
11011                 RExC_flags |= posflags;
11012
11013                 if (negflags & RXf_PMf_EXTENDED) {
11014                     negflags |= RXf_PMf_EXTENDED_MORE;
11015                 }
11016                 RExC_flags &= ~negflags;
11017                 set_regex_charset(&RExC_flags, cs);
11018
11019                 return;
11020             default:
11021               fail_modifiers:
11022                 RExC_parse += SKIP_IF_CHAR(RExC_parse, RExC_end);
11023                 /* diag_listed_as: Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/ */
11024                 vFAIL2utf8f("Sequence (%" UTF8f "...) not recognized",
11025                       UTF8fARG(UTF, RExC_parse-seqstart, seqstart));
11026                 NOT_REACHED; /*NOTREACHED*/
11027         }
11028
11029         RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;
11030     }
11031
11032     vFAIL("Sequence (?... not terminated");
11033
11034   modifier_illegal_in_wildcard:
11035     RExC_parse++;
11036     /* diag_listed_as: Use of %s is not allowed in Unicode property wildcard
11037        subpatterns in regex; marked by <-- HERE in m/%s/ */
11038     vFAIL2("Use of modifier '%c' is not allowed in Unicode property wildcard"
11039            " subpatterns", *(RExC_parse - 1));
11040 }
11041
11042 /*
11043  - reg - regular expression, i.e. main body or parenthesized thing
11044  *
11045  * Caller must absorb opening parenthesis.
11046  *
11047  * Combining parenthesis handling with the base level of regular expression
11048  * is a trifle forced, but the need to tie the tails of the branches to what
11049  * follows makes it hard to avoid.
11050  */
11051 #define REGTAIL(x,y,z) regtail((x),(y),(z),depth+1)
11052 #ifdef DEBUGGING
11053 #define REGTAIL_STUDY(x,y,z) regtail_study((x),(y),(z),depth+1)
11054 #else
11055 #define REGTAIL_STUDY(x,y,z) regtail((x),(y),(z),depth+1)
11056 #endif
11057
11058 STATIC regnode_offset
11059 S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state,
11060                              I32 *flagp,
11061                              char * parse_start,
11062                              char ch
11063                       )
11064 {
11065     regnode_offset ret;
11066     char* name_start = RExC_parse;
11067     U32 num = 0;
11068     SV *sv_dat = reg_scan_name(pRExC_state, REG_RSN_RETURN_DATA);
11069     DECLARE_AND_GET_RE_DEBUG_FLAGS;
11070
11071     PERL_ARGS_ASSERT_HANDLE_NAMED_BACKREF;
11072
11073     if (RExC_parse == name_start || *RExC_parse != ch) {
11074         /* diag_listed_as: Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/ */
11075         vFAIL2("Sequence %.3s... not terminated", parse_start);
11076     }
11077
11078     if (sv_dat) {
11079         num = add_data( pRExC_state, STR_WITH_LEN("S"));
11080         RExC_rxi->data->data[num]=(void*)sv_dat;
11081         SvREFCNT_inc_simple_void_NN(sv_dat);
11082     }
11083     RExC_sawback = 1;
11084     ret = reganode(pRExC_state,
11085                    ((! FOLD)
11086                      ? REFN
11087                      : (ASCII_FOLD_RESTRICTED)
11088                        ? REFFAN
11089                        : (AT_LEAST_UNI_SEMANTICS)
11090                          ? REFFUN
11091                          : (LOC)
11092                            ? REFFLN
11093                            : REFFN),
11094                     num);
11095     *flagp |= HASWIDTH;
11096
11097     Set_Node_Offset(REGNODE_p(ret), parse_start+1);
11098     Set_Node_Cur_Length(REGNODE_p(ret), parse_start);
11099
11100     nextchar(pRExC_state);
11101     return ret;
11102 }
11103
11104 /* On success, returns the offset at which any next node should be placed into
11105  * the regex engine program being compiled.
11106  *
11107  * Returns 0 otherwise, with *flagp set to indicate why:
11108  *  TRYAGAIN        at the end of (?) that only sets flags.
11109  *  RESTART_PARSE   if the parse needs to be restarted, or'd with
11110  *                  NEED_UTF8 if the pattern needs to be upgraded to UTF-8.
11111  *  Otherwise would only return 0 if regbranch() returns 0, which cannot
11112  *  happen.  */
11113 STATIC regnode_offset
11114 S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth)
11115     /* paren: Parenthesized? 0=top; 1,2=inside '(': changed to letter.
11116      * 2 is like 1, but indicates that nextchar() has been called to advance
11117      * RExC_parse beyond the '('.  Things like '(?' are indivisible tokens, and
11118      * this flag alerts us to the need to check for that */
11119 {
11120     regnode_offset ret = 0;    /* Will be the head of the group. */
11121     regnode_offset br;
11122     regnode_offset lastbr;
11123     regnode_offset ender = 0;
11124     I32 parno = 0;
11125     I32 flags;
11126     U32 oregflags = RExC_flags;
11127     bool have_branch = 0;
11128     bool is_open = 0;
11129     I32 freeze_paren = 0;
11130     I32 after_freeze = 0;
11131     I32 num; /* numeric backreferences */
11132     SV * max_open;  /* Max number of unclosed parens */
11133     I32 was_in_lookaround = RExC_in_lookaround;
11134
11135     char * parse_start = RExC_parse; /* MJD */
11136     char * const oregcomp_parse = RExC_parse;
11137
11138     DECLARE_AND_GET_RE_DEBUG_FLAGS;
11139
11140     PERL_ARGS_ASSERT_REG;
11141     DEBUG_PARSE("reg ");
11142
11143     max_open = get_sv(RE_COMPILE_RECURSION_LIMIT, GV_ADD);
11144     assert(max_open);
11145     if (!SvIOK(max_open)) {
11146         sv_setiv(max_open, RE_COMPILE_RECURSION_INIT);
11147     }
11148     if (depth > 4 * (UV) SvIV(max_open)) { /* We increase depth by 4 for each
11149                                               open paren */
11150         vFAIL("Too many nested open parens");
11151     }
11152
11153     *flagp = 0;                         /* Initialize. */
11154
11155     /* Having this true makes it feasible to have a lot fewer tests for the
11156      * parse pointer being in scope.  For example, we can write
11157      *      while(isFOO(*RExC_parse)) RExC_parse++;
11158      * instead of
11159      *      while(RExC_parse < RExC_end && isFOO(*RExC_parse)) RExC_parse++;
11160      */
11161     assert(*RExC_end == '\0');
11162
11163     /* Make an OPEN node, if parenthesized. */
11164     if (paren) {
11165
11166         /* Under /x, space and comments can be gobbled up between the '(' and
11167          * here (if paren ==2).  The forms '(*VERB' and '(?...' disallow such
11168          * intervening space, as the sequence is a token, and a token should be
11169          * indivisible */
11170         bool has_intervening_patws = (paren == 2)
11171                                   && *(RExC_parse - 1) != '(';
11172
11173         if (RExC_parse >= RExC_end) {
11174             vFAIL("Unmatched (");
11175         }
11176
11177         if (paren == 'r') {     /* Atomic script run */
11178             paren = '>';
11179             goto parse_rest;
11180         }
11181         else if ( *RExC_parse == '*') { /* (*VERB:ARG), (*construct:...) */
11182             char *start_verb = RExC_parse + 1;
11183             STRLEN verb_len;
11184             char *start_arg = NULL;
11185             unsigned char op = 0;
11186             int arg_required = 0;
11187             int internal_argval = -1; /* if >-1 we are not allowed an argument*/
11188             bool has_upper = FALSE;
11189
11190             if (has_intervening_patws) {
11191                 RExC_parse++;   /* past the '*' */
11192
11193                 /* For strict backwards compatibility, don't change the message
11194                  * now that we also have lowercase operands */
11195                 if (isUPPER(*RExC_parse)) {
11196                     vFAIL("In '(*VERB...)', the '(' and '*' must be adjacent");
11197                 }
11198                 else {
11199                     vFAIL("In '(*...)', the '(' and '*' must be adjacent");
11200                 }
11201             }
11202             while (RExC_parse < RExC_end && *RExC_parse != ')' ) {
11203                 if ( *RExC_parse == ':' ) {
11204                     start_arg = RExC_parse + 1;
11205                     break;
11206                 }
11207                 else if (! UTF) {
11208                     if (isUPPER(*RExC_parse)) {
11209                         has_upper = TRUE;
11210                     }
11211                     RExC_parse++;
11212                 }
11213                 else {
11214                     RExC_parse += UTF8SKIP(RExC_parse);
11215                 }
11216             }
11217             verb_len = RExC_parse - start_verb;
11218             if ( start_arg ) {
11219                 if (RExC_parse >= RExC_end) {
11220                     goto unterminated_verb_pattern;
11221                 }
11222
11223                 RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;
11224                 while ( RExC_parse < RExC_end && *RExC_parse != ')' ) {
11225                     RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;
11226                 }
11227                 if ( RExC_parse >= RExC_end || *RExC_parse != ')' ) {
11228                   unterminated_verb_pattern:
11229                     if (has_upper) {
11230                         vFAIL("Unterminated verb pattern argument");
11231                     }
11232                     else {
11233                         vFAIL("Unterminated '(*...' argument");
11234                     }
11235                 }
11236             } else {
11237                 if ( RExC_parse >= RExC_end || *RExC_parse != ')' ) {
11238                     if (has_upper) {
11239                         vFAIL("Unterminated verb pattern");
11240                     }
11241                     else {
11242                         vFAIL("Unterminated '(*...' construct");
11243                     }
11244                 }
11245             }
11246
11247             /* Here, we know that RExC_parse < RExC_end */
11248
11249             switch ( *start_verb ) {
11250             case 'A':  /* (*ACCEPT) */
11251                 if ( memEQs(start_verb, verb_len,"ACCEPT") ) {
11252                     op = ACCEPT;
11253                     internal_argval = RExC_nestroot;
11254                 }
11255                 break;
11256             case 'C':  /* (*COMMIT) */
11257                 if ( memEQs(start_verb, verb_len,"COMMIT") )
11258                     op = COMMIT;
11259                 break;
11260             case 'F':  /* (*FAIL) */
11261                 if ( verb_len==1 || memEQs(start_verb, verb_len,"FAIL") ) {
11262                     op = OPFAIL;
11263                 }
11264                 break;
11265             case ':':  /* (*:NAME) */
11266             case 'M':  /* (*MARK:NAME) */
11267                 if ( verb_len==0 || memEQs(start_verb, verb_len,"MARK") ) {
11268                     op = MARKPOINT;
11269                     arg_required = 1;
11270                 }
11271                 break;
11272             case 'P':  /* (*PRUNE) */
11273                 if ( memEQs(start_verb, verb_len,"PRUNE") )
11274                     op = PRUNE;
11275                 break;
11276             case 'S':   /* (*SKIP) */
11277                 if ( memEQs(start_verb, verb_len,"SKIP") )
11278                     op = SKIP;
11279                 break;
11280             case 'T':  /* (*THEN) */
11281                 /* [19:06] <TimToady> :: is then */
11282                 if ( memEQs(start_verb, verb_len,"THEN") ) {
11283                     op = CUTGROUP;
11284                     RExC_seen |= REG_CUTGROUP_SEEN;
11285                 }
11286                 break;
11287             case 'a':
11288                 if (   memEQs(start_verb, verb_len, "asr")
11289                     || memEQs(start_verb, verb_len, "atomic_script_run"))
11290                 {
11291                     paren = 'r';        /* Mnemonic: recursed run */
11292                     goto script_run;
11293                 }
11294                 else if (memEQs(start_verb, verb_len, "atomic")) {
11295                     paren = 't';    /* AtOMIC */
11296                     goto alpha_assertions;
11297                 }
11298                 break;
11299             case 'p':
11300                 if (   memEQs(start_verb, verb_len, "plb")
11301                     || memEQs(start_verb, verb_len, "positive_lookbehind"))
11302                 {
11303                     paren = 'b';
11304                     goto lookbehind_alpha_assertions;
11305                 }
11306                 else if (   memEQs(start_verb, verb_len, "pla")
11307                          || memEQs(start_verb, verb_len, "positive_lookahead"))
11308                 {
11309                     paren = 'a';
11310                     goto alpha_assertions;
11311                 }
11312                 break;
11313             case 'n':
11314                 if (   memEQs(start_verb, verb_len, "nlb")
11315                     || memEQs(start_verb, verb_len, "negative_lookbehind"))
11316                 {
11317                     paren = 'B';
11318                     goto lookbehind_alpha_assertions;
11319                 }
11320                 else if (   memEQs(start_verb, verb_len, "nla")
11321                          || memEQs(start_verb, verb_len, "negative_lookahead"))
11322                 {
11323                     paren = 'A';
11324                     goto alpha_assertions;
11325                 }
11326                 break;
11327             case 's':
11328                 if (   memEQs(start_verb, verb_len, "sr")
11329                     || memEQs(start_verb, verb_len, "script_run"))
11330                 {
11331                     regnode_offset atomic;
11332
11333                     paren = 's';
11334
11335                    script_run:
11336
11337                     /* This indicates Unicode rules. */
11338                     REQUIRE_UNI_RULES(flagp, 0);
11339
11340                     if (! start_arg) {
11341                         goto no_colon;
11342                     }
11343
11344                     RExC_parse = start_arg;
11345
11346                     if (RExC_in_script_run) {
11347
11348                         /*  Nested script runs are treated as no-ops, because
11349                          *  if the nested one fails, the outer one must as
11350                          *  well.  It could fail sooner, and avoid (??{} with
11351                          *  side effects, but that is explicitly documented as
11352                          *  undefined behavior. */
11353
11354                         ret = 0;
11355
11356                         if (paren == 's') {
11357                             paren = ':';
11358                             goto parse_rest;
11359                         }
11360
11361                         /* But, the atomic part of a nested atomic script run
11362                          * isn't a no-op, but can be treated just like a '(?>'
11363                          * */
11364                         paren = '>';
11365                         goto parse_rest;
11366                     }
11367
11368                     if (paren == 's') {
11369                         /* Here, we're starting a new regular script run */
11370                         ret = reg_node(pRExC_state, SROPEN);
11371                         RExC_in_script_run = 1;
11372                         is_open = 1;
11373                         goto parse_rest;
11374                     }
11375
11376                     /* Here, we are starting an atomic script run.  This is
11377                      * handled by recursing to deal with the atomic portion
11378                      * separately, enclosed in SROPEN ... SRCLOSE nodes */
11379
11380                     ret = reg_node(pRExC_state, SROPEN);
11381
11382                     RExC_in_script_run = 1;
11383
11384                     atomic = reg(pRExC_state, 'r', &flags, depth);
11385                     if (flags & (RESTART_PARSE|NEED_UTF8)) {
11386                         *flagp = flags & (RESTART_PARSE|NEED_UTF8);
11387                         return 0;
11388                     }
11389
11390                     if (! REGTAIL(pRExC_state, ret, atomic)) {
11391                         REQUIRE_BRANCHJ(flagp, 0);
11392                     }
11393
11394                     if (! REGTAIL(pRExC_state, atomic, reg_node(pRExC_state,
11395                                                                 SRCLOSE)))
11396                     {
11397                         REQUIRE_BRANCHJ(flagp, 0);
11398                     }
11399
11400                     RExC_in_script_run = 0;
11401                     return ret;
11402                 }
11403
11404                 break;
11405
11406             lookbehind_alpha_assertions:
11407                 RExC_seen |= REG_LOOKBEHIND_SEEN;
11408                 /*FALLTHROUGH*/
11409
11410             alpha_assertions:
11411
11412                 RExC_in_lookaround++;
11413                 RExC_seen_zerolen++;
11414
11415                 if (! start_arg) {
11416                     goto no_colon;
11417                 }
11418
11419                 /* An empty negative lookahead assertion simply is failure */
11420                 if (paren == 'A' && RExC_parse == start_arg) {
11421                     ret=reganode(pRExC_state, OPFAIL, 0);
11422                     nextchar(pRExC_state);
11423                     return ret;
11424                 }
11425
11426                 RExC_parse = start_arg;
11427                 goto parse_rest;
11428
11429               no_colon:
11430                 vFAIL2utf8f(
11431                 "'(*%" UTF8f "' requires a terminating ':'",
11432                 UTF8fARG(UTF, verb_len, start_verb));
11433                 NOT_REACHED; /*NOTREACHED*/
11434
11435             } /* End of switch */
11436             if ( ! op ) {
11437                 RExC_parse += UTF
11438                               ? UTF8_SAFE_SKIP(RExC_parse, RExC_end)
11439                               : 1;
11440                 if (has_upper || verb_len == 0) {
11441                     vFAIL2utf8f(
11442                     "Unknown verb pattern '%" UTF8f "'",
11443                     UTF8fARG(UTF, verb_len, start_verb));
11444                 }
11445                 else {
11446                     vFAIL2utf8f(
11447                     "Unknown '(*...)' construct '%" UTF8f "'",
11448                     UTF8fARG(UTF, verb_len, start_verb));
11449                 }
11450             }
11451             if ( RExC_parse == start_arg ) {
11452                 start_arg = NULL;
11453             }
11454             if ( arg_required && !start_arg ) {
11455                 vFAIL3("Verb pattern '%.*s' has a mandatory argument",
11456                     (int) verb_len, start_verb);
11457             }
11458             if (internal_argval == -1) {
11459                 ret = reganode(pRExC_state, op, 0);
11460             } else {
11461                 ret = reg2Lanode(pRExC_state, op, 0, internal_argval);
11462             }
11463             RExC_seen |= REG_VERBARG_SEEN;
11464             if (start_arg) {
11465                 SV *sv = newSVpvn( start_arg,
11466                                     RExC_parse - start_arg);
11467                 ARG(REGNODE_p(ret)) = add_data( pRExC_state,
11468                                         STR_WITH_LEN("S"));
11469                 RExC_rxi->data->data[ARG(REGNODE_p(ret))]=(void*)sv;
11470                 FLAGS(REGNODE_p(ret)) = 1;
11471             } else {
11472                 FLAGS(REGNODE_p(ret)) = 0;
11473             }
11474             if ( internal_argval != -1 )
11475                 ARG2L_SET(REGNODE_p(ret), internal_argval);
11476             nextchar(pRExC_state);
11477             return ret;
11478         }
11479         else if (*RExC_parse == '?') { /* (?...) */
11480             bool is_logical = 0;
11481             const char * const seqstart = RExC_parse;
11482             const char * endptr;
11483             const char non_existent_group_msg[]
11484                                             = "Reference to nonexistent group";
11485             const char impossible_group[] = "Invalid reference to group";
11486
11487             if (has_intervening_patws) {
11488                 RExC_parse++;
11489                 vFAIL("In '(?...)', the '(' and '?' must be adjacent");
11490             }
11491
11492             RExC_parse++;           /* past the '?' */
11493             paren = *RExC_parse;    /* might be a trailing NUL, if not
11494                                        well-formed */
11495             RExC_parse += UTF ? UTF8SKIP(RExC_parse) : 1;
11496             if (RExC_parse > RExC_end) {
11497                 paren = '\0';
11498             }
11499             ret = 0;                    /* For look-ahead/behind. */
11500             switch (paren) {
11501
11502             case 'P':   /* (?P...) variants for those used to PCRE/Python */
11503                 paren = *RExC_parse;
11504                 if ( paren == '<') {    /* (?P<...>) named capture */
11505                     RExC_parse++;
11506                     if (RExC_parse >= RExC_end) {
11507                         vFAIL("Sequence (?P<... not terminated");
11508                     }
11509                     goto named_capture;
11510                 }
11511                 else if (paren == '>') {   /* (?P>name) named recursion */
11512                     RExC_parse++;
11513                     if (RExC_parse >= RExC_end) {
11514                         vFAIL("Sequence (?P>... not terminated");
11515                     }
11516                     goto named_recursion;
11517                 }
11518                 else if (paren == '=') {   /* (?P=...)  named backref */
11519                     RExC_parse++;
11520                     return handle_named_backref(pRExC_state, flagp,
11521                                                 parse_start, ')');
11522                 }
11523                 RExC_parse += SKIP_IF_CHAR(RExC_parse, RExC_end);
11524                 /* diag_listed_as: Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/ */
11525                 vFAIL3("Sequence (%.*s...) not recognized",
11526                                 (int) (RExC_parse - seqstart), seqstart);
11527                 NOT_REACHED; /*NOTREACHED*/
11528             case '<':           /* (?<...) */
11529                 /* If you want to support (?<*...), first reconcile with GH #17363 */
11530                 if (*RExC_parse == '!')
11531                     paren = ',';
11532                 else if (*RExC_parse != '=')
11533               named_capture:
11534                 {               /* (?<...>) */
11535                     char *name_start;
11536                     SV *svname;
11537                     paren= '>';
11538                 /* FALLTHROUGH */
11539             case '\'':          /* (?'...') */
11540                     name_start = RExC_parse;
11541                     svname = reg_scan_name(pRExC_state, REG_RSN_RETURN_NAME);
11542                     if (   RExC_parse == name_start
11543                         || RExC_parse >= RExC_end
11544                         || *RExC_parse != paren)
11545                     {
11546                         vFAIL2("Sequence (?%c... not terminated",
11547                             paren=='>' ? '<' : (char) paren);
11548                     }
11549                     {
11550                         HE *he_str;
11551                         SV *sv_dat = NULL;
11552                         if (!svname) /* shouldn't happen */
11553                             Perl_croak(aTHX_
11554                                 "panic: reg_scan_name returned NULL");
11555                         if (!RExC_paren_names) {
11556                             RExC_paren_names= newHV();
11557                             sv_2mortal(MUTABLE_SV(RExC_paren_names));
11558 #ifdef DEBUGGING
11559                             RExC_paren_name_list= newAV();
11560                             sv_2mortal(MUTABLE_SV(RExC_paren_name_list));
11561 #endif
11562                         }
11563                         he_str = hv_fetch_ent( RExC_paren_names, svname, 1, 0 );
11564                         if ( he_str )
11565                             sv_dat = HeVAL(he_str);
11566                         if ( ! sv_dat ) {
11567                             /* croak baby croak */
11568                             Perl_croak(aTHX_
11569                                 "panic: paren_name hash element allocation failed");
11570                         } else if ( SvPOK(sv_dat) ) {
11571                             /* (?|...) can mean we have dupes so scan to check
11572                                its already been stored. Maybe a flag indicating
11573                                we are inside such a construct would be useful,
11574                                but the arrays are likely to be quite small, so
11575                                for now we punt -- dmq */
11576                             IV count = SvIV(sv_dat);
11577                             I32 *pv = (I32*)SvPVX(sv_dat);
11578                             IV i;
11579                             for ( i = 0 ; i < count ; i++ ) {
11580                                 if ( pv[i] == RExC_npar ) {
11581                                     count = 0;
11582                                     break;
11583                                 }
11584                             }
11585                             if ( count ) {
11586                                 pv = (I32*)SvGROW(sv_dat,
11587                                                 SvCUR(sv_dat) + sizeof(I32)+1);
11588                                 SvCUR_set(sv_dat, SvCUR(sv_dat) + sizeof(I32));
11589                                 pv[count] = RExC_npar;
11590                                 SvIV_set(sv_dat, SvIVX(sv_dat) + 1);
11591                             }
11592                         } else {
11593                             (void)SvUPGRADE(sv_dat, SVt_PVNV);
11594                             sv_setpvn(sv_dat, (char *)&(RExC_npar),
11595                                                                 sizeof(I32));
11596                             SvIOK_on(sv_dat);
11597                             SvIV_set(sv_dat, 1);
11598                         }
11599 #ifdef DEBUGGING
11600                         /* Yes this does cause a memory leak in debugging Perls
11601                          * */
11602                         if (!av_store(RExC_paren_name_list,
11603                                       RExC_npar, SvREFCNT_inc_NN(svname)))
11604                             SvREFCNT_dec_NN(svname);
11605 #endif
11606
11607                         /*sv_dump(sv_dat);*/
11608                     }
11609                     nextchar(pRExC_state);
11610                     paren = 1;
11611                     goto capturing_parens;
11612                 }
11613
11614                 RExC_seen |= REG_LOOKBEHIND_SEEN;
11615                 RExC_in_lookaround++;
11616                 RExC_parse++;
11617                 if (RExC_parse >= RExC_end) {
11618                     vFAIL("Sequence (?... not terminated");
11619                 }
11620                 RExC_seen_zerolen++;
11621                 break;
11622             case '=':           /* (?=...) */
11623                 RExC_seen_zerolen++;
11624                 RExC_in_lookaround++;
11625                 break;
11626             case '!':           /* (?!...) */
11627                 RExC_seen_zerolen++;
11628                 /* check if we're really just a "FAIL" assertion */
11629                 skip_to_be_ignored_text(pRExC_state, &RExC_parse,
11630                                         FALSE /* Don't force to /x */ );
11631                 if (*RExC_parse == ')') {
11632                     ret=reganode(pRExC_state, OPFAIL, 0);
11633                     nextchar(pRExC_state);
11634                     return ret;
11635                 }
11636                 RExC_in_lookaround++;
11637                 break;
11638             case '|':           /* (?|...) */
11639                 /* branch reset, behave like a (?:...) except that
11640                    buffers in alternations share the same numbers */
11641                 paren = ':';
11642                 after_freeze = freeze_paren = RExC_npar;
11643
11644                 /* XXX This construct currently requires an extra pass.
11645                  * Investigation would be required to see if that could be
11646                  * changed */
11647                 REQUIRE_PARENS_PASS;
11648                 break;
11649             case ':':           /* (?:...) */
11650             case '>':           /* (?>...) */
11651                 break;
11652             case '$':           /* (?$...) */
11653             case '@':           /* (?@...) */
11654                 vFAIL2("Sequence (?%c...) not implemented", (int)paren);
11655                 break;
11656             case '0' :           /* (?0) */
11657             case 'R' :           /* (?R) */
11658                 if (RExC_parse == RExC_end || *RExC_parse != ')')
11659                     FAIL("Sequence (?R) not terminated");
11660                 num = 0;
11661                 RExC_seen |= REG_RECURSE_SEEN;
11662
11663                 /* XXX These constructs currently require an extra pass.
11664                  * It probably could be changed */
11665                 REQUIRE_PARENS_PASS;
11666
11667                 *flagp |= POSTPONED;
11668                 goto gen_recurse_regop;
11669                 /*notreached*/
11670             /* named and numeric backreferences */
11671             case '&':            /* (?&NAME) */
11672                 parse_start = RExC_parse - 1;
11673               named_recursion:
11674                 {
11675                     SV *sv_dat = reg_scan_name(pRExC_state,
11676                                                REG_RSN_RETURN_DATA);
11677                    num = sv_dat ? *((I32 *)SvPVX(sv_dat)) : 0;
11678                 }
11679                 if (RExC_parse >= RExC_end || *RExC_parse != ')')
11680                     vFAIL("Sequence (?&... not terminated");
11681                 goto gen_recurse_regop;
11682                 /* NOTREACHED */
11683             case '+':
11684                 if (! inRANGE(RExC_parse[0], '1', '9')) {
11685                     RExC_parse++;
11686                     vFAIL("Illegal pattern");
11687                 }
11688                 goto parse_recursion;
11689                 /* NOTREACHED*/
11690             case '-': /* (?-1) */
11691                 if (! inRANGE(RExC_parse[0], '1', '9')) {
11692                     RExC_parse--; /* rewind to let it be handled later */
11693                     goto parse_flags;
11694                 }
11695                 /* FALLTHROUGH */
11696             case '1': case '2': case '3': case '4': /* (?1) */
11697             case '5': case '6': case '7': case '8': case '9':
11698                 RExC_parse = (char *) seqstart + 1;  /* Point to the digit */
11699               parse_recursion:
11700                 {
11701                     bool is_neg = FALSE;
11702                     UV unum;
11703                     parse_start = RExC_parse - 1; /* MJD */
11704                     if (*RExC_parse == '-') {
11705                         RExC_parse++;
11706                         is_neg = TRUE;
11707                     }
11708                     endptr = RExC_end;
11709                     if (grok_atoUV(RExC_parse, &unum, &endptr)
11710                         && unum <= I32_MAX
11711                     ) {
11712                         num = (I32)unum;
11713                         RExC_parse = (char*)endptr;
11714                     }
11715                     else {  /* Overflow, or something like that.  Position
11716                                beyond all digits for the message */
11717                         while (RExC_parse < RExC_end && isDIGIT(*RExC_parse))  {
11718                             RExC_parse++;
11719                         }
11720                         vFAIL(impossible_group);
11721                     }
11722                     if (is_neg) {
11723                         /* -num is always representable on 1 and 2's complement
11724                          * machines */
11725                         num = -num;
11726                     }
11727                 }
11728                 if (*RExC_parse!=')')
11729                     vFAIL("Expecting close bracket");
11730
11731               gen_recurse_regop:
11732                 if (paren == '-' || paren == '+') {
11733
11734                     /* Don't overflow */
11735                     if (UNLIKELY(I32_MAX - RExC_npar < num)) {
11736                         RExC_parse++;
11737                         vFAIL(impossible_group);
11738                     }
11739
11740                     /*
11741                     Diagram of capture buffer numbering.
11742                     Top line is the normal capture buffer numbers
11743                     Bottom line is the negative indexing as from
11744                     the X (the (?-2))
11745
11746                         1 2    3 4 5 X   Y      6 7
11747                        /(a(x)y)(a(b(c(?+2)d)e)f)(g(h))/
11748                        /(a(x)y)(a(b(c(?-2)d)e)f)(g(h))/
11749                     -   5 4    3 2 1 X   Y      x x
11750
11751                     Resolve to absolute group.  Recall that RExC_npar is +1 of
11752                     the actual parenthesis group number.  For lookahead, we
11753                     have to compensate for that.  Using the above example, when
11754                     we get to Y in the parse, num is 2 and RExC_npar is 6.  We
11755                     want 7 for +2, and 4 for -2.
11756                     */
11757                     if ( paren == '+' ) {
11758                         num--;
11759                     }
11760
11761                     num += RExC_npar;
11762
11763                     if (paren == '-' && num < 1) {
11764                         RExC_parse++;
11765                         vFAIL(non_existent_group_msg);
11766                     }
11767                 }
11768
11769                 if (num >= RExC_npar) {
11770
11771                     /* It might be a forward reference; we can't fail until we
11772                      * know, by completing the parse to get all the groups, and
11773                      * then reparsing */
11774                     if (ALL_PARENS_COUNTED)  {
11775                         if (num >= RExC_total_parens) {
11776                             RExC_parse++;
11777                             vFAIL(non_existent_group_msg);
11778                         }
11779                     }
11780                     else {
11781                         REQUIRE_PARENS_PASS;
11782                     }
11783                 }
11784
11785                 /* We keep track how many GOSUB items we have produced.
11786                    To start off the ARG2L() of the GOSUB holds its "id",
11787                    which is used later in conjunction with RExC_recurse
11788                    to calculate the offset we need to jump for the GOSUB,
11789                    which it will store in the final representation.
11790                    We have to defer the actual calculation until much later
11791                    as the regop may move.
11792                  */
11793                 ret = reg2Lanode(pRExC_state, GOSUB, num, RExC_recurse_count);
11794                 RExC_recurse_count++;
11795                 DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_
11796                     "%*s%*s Recurse #%" UVuf " to %" IVdf "\n",
11797                             22, "|    |", (int)(depth * 2 + 1), "",
11798                             (UV)ARG(REGNODE_p(ret)),
11799                             (IV)ARG2L(REGNODE_p(ret))));
11800                 RExC_seen |= REG_RECURSE_SEEN;
11801
11802                 Set_Node_Length(REGNODE_p(ret),
11803                                 1 + regarglen[OP(REGNODE_p(ret))]); /* MJD */
11804                 Set_Node_Offset(REGNODE_p(ret), parse_start); /* MJD */
11805
11806                 *flagp |= POSTPONED;
11807                 assert(*RExC_parse == ')');
11808                 nextchar(pRExC_state);
11809                 return ret;
11810
11811             /* NOTREACHED */
11812
11813             case '?':           /* (??...) */
11814                 is_logical = 1;
11815                 if (*RExC_parse != '{') {
11816                     RExC_parse += SKIP_IF_CHAR(RExC_parse, RExC_end);
11817                     /* diag_listed_as: Sequence (?%s...) not recognized in regex; marked by <-- HERE in m/%s/ */
11818                     vFAIL2utf8f(
11819                         "Sequence (%" UTF8f "...) not recognized",
11820                         UTF8fARG(UTF, RExC_parse-seqstart, seqstart));
11821                     NOT_REACHED; /*NOTREACHED*/
11822                 }
11823                 *flagp |= POSTPONED;
11824                 paren = '{';
11825                 RExC_parse++;
11826                 /* FALLTHROUGH */
11827             case '{':           /* (?{...}) */
11828             {
11829                 U32 n = 0;
11830                 struct reg_code_block *cb;
11831                 OP * o;
11832
11833                 RExC_seen_zerolen++;
11834
11835                 if (   !pRExC_state->code_blocks
11836                     || pRExC_state->code_index
11837                                         >= pRExC_state->code_blocks->count
11838                     || pRExC_state->code_blocks->cb[pRExC_state->code_index].start
11839                         != (STRLEN)((RExC_parse -3 - (is_logical ? 1 : 0))
11840                             - RExC_start)
11841                 ) {
11842                     if (RExC_pm_flags & PMf_USE_RE_EVAL)
11843                         FAIL("panic: Sequence (?{...}): no code block found\n");
11844                     FAIL("Eval-group not allowed at runtime, use re 'eval'");
11845                 }
11846                 /* this is a pre-compiled code block (?{...}) */
11847                 cb = &pRExC_state->code_blocks->cb[pRExC_state->code_index];
11848                 RExC_parse = RExC_start + cb->end;
11849                 o = cb->block;
11850                 if (cb->src_regex) {
11851                     n = add_data(pRExC_state, STR_WITH_LEN("rl"));
11852                     RExC_rxi->data->data[n] =
11853                         (void*)SvREFCNT_inc((SV*)cb->src_regex);
11854                     RExC_rxi->data->data[n+1] = (void*)o;
11855                 }
11856                 else {
11857                     n = add_data(pRExC_state,
11858                             (RExC_pm_flags & PMf_HAS_CV) ? "L" : "l", 1);
11859                     RExC_rxi->data->data[n] = (void*)o;
11860                 }
11861                 pRExC_state->code_index++;
11862                 nextchar(pRExC_state);
11863
11864                 if (is_logical) {
11865                     regnode_offset eval;
11866                     ret = reg_node(pRExC_state, LOGICAL);
11867
11868                     eval = reg2Lanode(pRExC_state, EVAL,
11869                                        n,
11870
11871                                        /* for later propagation into (??{})
11872                                         * return value */
11873                                        RExC_flags & RXf_PMf_COMPILETIME
11874                                       );
11875                     FLAGS(REGNODE_p(ret)) = 2;
11876                     if (! REGTAIL(pRExC_state, ret, eval)) {
11877                         REQUIRE_BRANCHJ(flagp, 0);
11878                     }
11879                     /* deal with the length of this later - MJD */
11880                     return ret;
11881                 }
11882                 ret = reg2Lanode(pRExC_state, EVAL, n, 0);
11883                 Set_Node_Length(REGNODE_p(ret), RExC_parse - parse_start + 1);
11884                 Set_Node_Offset(REGNODE_p(ret), parse_start);
11885                 return ret;
11886             }
11887             case '(':           /* (?(?{...})...) and (?(?=...)...) */
11888             {
11889                 int is_define= 0;
11890                 const int DEFINE_len = sizeof("DEFINE") - 1;
11891                 if (    RExC_parse < RExC_end - 1
11892                     && (   (       RExC_parse[0] == '?'        /* (?(?...)) */
11893                             && (   RExC_parse[1] == '='
11894                                 || RExC_parse[1] == '!'
11895                                 || RExC_parse[1] == '<'
11896                                 || RExC_parse[1] == '{'))
11897                         || (       RExC_parse[0] == '*'        /* (?(*...)) */
11898                             && (   memBEGINs(RExC_parse + 1,
11899                                          (Size_t) (RExC_end - (RExC_parse + 1)),
11900                                          "pla:")
11901                                 || memBEGINs(RExC_parse + 1,
11902                                          (Size_t) (RExC_end - (RExC_parse + 1)),
11903                                          "plb:")
11904                                 || memBEGINs(RExC_parse + 1,
11905                                          (Size_t) (RExC_end - (RExC_parse + 1)),
11906                                          "nla:")
11907                                 || memBEGINs(RExC_parse + 1,
11908                                          (Size_t) (RExC_end - (RExC_parse + 1)),
11909                                          "nlb:")
11910                                 || memBEGINs(RExC_parse + 1,
11911                                          (Size_t) (RExC_end - (RExC_parse + 1)),
11912                                          "positive_lookahead:")
11913                                 || memBEGINs(RExC_parse + 1,
11914                                          (Size_t) (RExC_end - (RExC_parse + 1)),
11915                                          "positive_lookbehind:")
11916                                 || memBEGINs(RExC_parse + 1,
11917                                          (Size_t) (RExC_end - (RExC_parse + 1)),
11918                                          "negative_lookahead:")
11919                                 || memBEGINs(RExC_parse + 1,
11920                                          (Size_t) (RExC_end - (RExC_parse + 1)),
11921                                          "negative_lookbehind:"))))
11922                 ) { /* Lookahead or eval. */
11923                     I32 flag;
11924                     regnode_offset tail;
11925
11926                     ret = reg_node(pRExC_state, LOGICAL);
11927                     FLAGS(REGNODE_p(ret)) = 1;
11928
11929                     tail = reg(pRExC_state, 1, &flag, depth+1);
11930                     RETURN_FAIL_ON_RESTART(flag, flagp);
11931                     if (! REGTAIL(pRExC_state, ret, tail)) {
11932                         REQUIRE_BRANCHJ(flagp, 0);
11933                     }
11934                     goto insert_if;
11935                 }
11936                 else if (   RExC_parse[0] == '<'     /* (?(<NAME>)...) */
11937                          || RExC_parse[0] == '\'' ) /* (?('NAME')...) */
11938                 {
11939                     char ch = RExC_parse[0] == '<' ? '>' : '\'';
11940                     char *name_start= RExC_parse++;
11941                     U32 num = 0;
11942                     SV *sv_dat=reg_scan_name(pRExC_state, REG_RSN_RETURN_DATA);
11943                     if (   RExC_parse == name_start
11944                         || RExC_parse >= RExC_end
11945                         || *RExC_parse != ch)
11946                     {
11947                         vFAIL2("Sequence (?(%c... not terminated",
11948                             (ch == '>' ? '<' : ch));
11949                     }
11950                     RExC_parse++;
11951                     if (sv_dat) {
11952                         num = add_data( pRExC_state, STR_WITH_LEN("S"));
11953                         RExC_rxi->data->data[num]=(void*)sv_dat;
11954                         SvREFCNT_inc_simple_void_NN(sv_dat);
11955                     }
11956                     ret = reganode(pRExC_state, GROUPPN, num);
11957                     goto insert_if_check_paren;
11958                 }
11959                 else if (memBEGINs(RExC_parse,
11960                                    (STRLEN) (RExC_end - RExC_parse),
11961                                    "DEFINE"))
11962                 {
11963                     ret = reganode(pRExC_state, DEFINEP, 0);
11964                     RExC_parse += DEFINE_len;
11965                     is_define = 1;
11966                     goto insert_if_check_paren;
11967                 }
11968                 else if (RExC_parse[0] == 'R') {
11969                     RExC_parse++;
11970                     /* parno == 0 => /(?(R)YES|NO)/  "in any form of recursion OR eval"
11971                      * parno == 1 => /(?(R0)YES|NO)/ "in GOSUB (?0) / (?R)"
11972                      * parno == 2 => /(?(R1)YES|NO)/ "in GOSUB (?1) (parno-1)"
11973                      */
11974                     parno = 0;
11975                     if (RExC_parse[0] == '0') {
11976                         parno = 1;
11977                         RExC_parse++;
11978                     }
11979                     else if (inRANGE(RExC_parse[0], '1', '9')) {
11980                         UV uv;
11981                         endptr = RExC_end;
11982                         if (grok_atoUV(RExC_parse, &uv, &endptr)
11983                             && uv <= I32_MAX
11984                         ) {
11985                             parno = (I32)uv + 1;
11986                             RExC_parse = (char*)endptr;
11987                         }
11988                         /* else "Switch condition not recognized" below */
11989                     } else if (RExC_parse[0] == '&') {
11990                         SV *sv_dat;
11991                         RExC_parse++;
11992                         sv_dat = reg_scan_name(pRExC_state,
11993                                                REG_RSN_RETURN_DATA);
11994                         if (sv_dat)
11995                             parno = 1 + *((I32 *)SvPVX(sv_dat));
11996                     }
11997                     ret = reganode(pRExC_state, INSUBP, parno);
11998                     goto insert_if_check_paren;
11999                 }
12000                 else if (inRANGE(RExC_parse[0], '1', '9')) {
12001                     /* (?(1)...) */
12002                     char c;
12003                     UV uv;
12004                     endptr = RExC_end;
12005                     if (grok_atoUV(RExC_parse, &uv, &endptr)
12006                         && uv <= I32_MAX
12007                     ) {
12008                         parno = (I32)uv;
12009                         RExC_parse = (char*)endptr;
12010                     }
12011                     else {
12012                         vFAIL("panic: grok_atoUV returned FALSE");
12013                     }
12014                     ret = reganode(pRExC_state, GROUPP, parno);
12015
12016                  insert_if_check_paren:
12017                     if (UCHARAT(RExC_parse) != ')') {
12018                         RExC_parse += UTF
12019                                       ? UTF8_SAFE_SKIP(RExC_parse, RExC_end)
12020                                       : 1;
12021                         vFAIL("Switch condition not recognized");
12022                     }
12023                     nextchar(pRExC_state);
12024                   insert_if:
12025                     if (! REGTAIL(pRExC_state, ret, reganode(pRExC_state,
12026                                                              IFTHEN, 0)))
12027                     {
12028                         REQUIRE_BRANCHJ(flagp, 0);
12029                     }
12030                     br = regbranch(pRExC_state, &flags, 1, depth+1);
12031                     if (br == 0) {
12032                         RETURN_FAIL_ON_RESTART(flags,flagp);
12033                         FAIL2("panic: regbranch returned failure, flags=%#" UVxf,
12034                               (UV) flags);
12035                     } else
12036                     if (! REGTAIL(pRExC_state, br, reganode(pRExC_state,
12037                                                              LONGJMP, 0)))
12038                     {
12039                         REQUIRE_BRANCHJ(flagp, 0);
12040                     }
12041                     c = UCHARAT(RExC_parse);
12042                     nextchar(pRExC_state);
12043                     if (flags&HASWIDTH)
12044                         *flagp |= HASWIDTH;
12045                     if (c == '|') {
12046                         if (is_define)
12047                             vFAIL("(?(DEFINE)....) does not allow branches");
12048
12049                         /* Fake one for optimizer.  */
12050                         lastbr = reganode(pRExC_state, IFTHEN, 0);
12051
12052                         if (!regbranch(pRExC_state, &flags, 1, depth+1)) {
12053                             RETURN_FAIL_ON_RESTART(flags, flagp);
12054                             FAIL2("panic: regbranch returned failure, flags=%#" UVxf,
12055                                   (UV) flags);
12056                         }
12057                         if (! REGTAIL(pRExC_state, ret, lastbr)) {
12058                             REQUIRE_BRANCHJ(flagp, 0);
12059                         }
12060                         if (flags&HASWIDTH)
12061                             *flagp |= HASWIDTH;
12062                         c = UCHARAT(RExC_parse);
12063                         nextchar(pRExC_state);
12064                     }
12065                     else
12066                         lastbr = 0;
12067                     if (c != ')') {
12068                         if (RExC_parse >= RExC_end)
12069                             vFAIL("Switch (?(condition)... not terminated");
12070                         else
12071                             vFAIL("Switch (?(condition)... contains too many branches");
12072                     }
12073                     ender = reg_node(pRExC_state, TAIL);
12074                     if (! REGTAIL(pRExC_state, br, ender)) {
12075                         REQUIRE_BRANCHJ(flagp, 0);
12076                     }
12077                     if (lastbr) {
12078                         if (! REGTAIL(pRExC_state, lastbr, ender)) {
12079                             REQUIRE_BRANCHJ(flagp, 0);
12080                         }
12081                         if (! REGTAIL(pRExC_state,
12082                                       REGNODE_OFFSET(
12083                                                  NEXTOPER(
12084                                                  NEXTOPER(REGNODE_p(lastbr)))),
12085                                       ender))
12086                         {
12087                             REQUIRE_BRANCHJ(flagp, 0);
12088                         }
12089                     }
12090                     else
12091                         if (! REGTAIL(pRExC_state, ret, ender)) {
12092                             REQUIRE_BRANCHJ(flagp, 0);
12093                         }
12094 #if 0  /* Removing this doesn't cause failures in the test suite -- khw */
12095                     RExC_size++; /* XXX WHY do we need this?!!
12096                                     For large programs it seems to be required
12097                                     but I can't figure out why. -- dmq*/
12098 #endif
12099                     return ret;
12100                 }
12101                 RExC_parse += UTF
12102                               ? UTF8_SAFE_SKIP(RExC_parse, RExC_end)
12103                               : 1;
12104                 vFAIL("Unknown switch condition (?(...))");
12105             }
12106             case '[':           /* (?[ ... ]) */
12107                 return handle_regex_sets(pRExC_state, NULL, flagp, depth+1,
12108                                          oregcomp_parse);
12109             case 0: /* A NUL */
12110                 RExC_parse--; /* for vFAIL to print correctly */
12111                 vFAIL("Sequence (? incomplete");
12112                 break;
12113
12114             case ')':
12115                 if (RExC_strict) {  /* [perl #132851] */
12116                     ckWARNreg(RExC_parse, "Empty (?) without any modifiers");
12117                 }
12118                 /* FALLTHROUGH */
12119             case '*': /* If you want to support (?*...), first reconcile with GH #17363 */
12120             /* FALLTHROUGH */
12121             default: /* e.g., (?i) */
12122                 RExC_parse = (char *) seqstart + 1;
12123               parse_flags:
12124                 parse_lparen_question_flags(pRExC_state);
12125                 if (UCHARAT(RExC_parse) != ':') {
12126                     if (RExC_parse < RExC_end)
12127                         nextchar(pRExC_state);
12128                     *flagp = TRYAGAIN;
12129                     return 0;
12130                 }
12131                 paren = ':';
12132                 nextchar(pRExC_state);
12133                 ret = 0;
12134                 goto parse_rest;
12135             } /* end switch */
12136         }
12137         else if (!(RExC_flags & RXf_PMf_NOCAPTURE)) {   /* (...) */
12138           capturing_parens:
12139             parno = RExC_npar;
12140             RExC_npar++;
12141             if (! ALL_PARENS_COUNTED) {
12142                 /* If we are in our first pass through (and maybe only pass),
12143                  * we  need to allocate memory for the capturing parentheses
12144                  * data structures.
12145                  */
12146
12147                 if (!RExC_parens_buf_size) {
12148                     /* first guess at number of parens we might encounter */
12149                     RExC_parens_buf_size = 10;
12150
12151                     /* setup RExC_open_parens, which holds the address of each
12152                      * OPEN tag, and to make things simpler for the 0 index the
12153                      * start of the program - this is used later for offsets */
12154                     Newxz(RExC_open_parens, RExC_parens_buf_size,
12155                             regnode_offset);
12156                     RExC_open_parens[0] = 1;    /* +1 for REG_MAGIC */
12157
12158                     /* setup RExC_close_parens, which holds the address of each
12159                      * CLOSE tag, and to make things simpler for the 0 index
12160                      * the end of the program - this is used later for offsets
12161                      * */
12162                     Newxz(RExC_close_parens, RExC_parens_buf_size,
12163                             regnode_offset);
12164                     /* we dont know where end op starts yet, so we dont need to
12165                      * set RExC_close_parens[0] like we do RExC_open_parens[0]
12166                      * above */
12167                 }
12168                 else if (RExC_npar > RExC_parens_buf_size) {
12169                     I32 old_size = RExC_parens_buf_size;
12170
12171                     RExC_parens_buf_size *= 2;
12172
12173                     Renew(RExC_open_parens, RExC_parens_buf_size,
12174                             regnode_offset);
12175                     Zero(RExC_open_parens + old_size,
12176                             RExC_parens_buf_size - old_size, regnode_offset);
12177
12178                     Renew(RExC_close_parens, RExC_parens_buf_size,
12179                             regnode_offset);
12180                     Zero(RExC_close_parens + old_size,
12181                             RExC_parens_buf_size - old_size, regnode_offset);
12182                 }
12183             }
12184
12185             ret = reganode(pRExC_state, OPEN, parno);
12186             if (!RExC_nestroot)
12187                 RExC_nestroot = parno;
12188             if (RExC_open_parens && !RExC_open_parens[parno])
12189             {
12190                 DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_
12191                     "%*s%*s Setting open paren #%" IVdf " to %zu\n",
12192                     22, "|    |", (int)(depth * 2 + 1), "",
12193                     (IV)parno, ret));
12194                 RExC_open_parens[parno]= ret;
12195             }
12196
12197             Set_Node_Length(REGNODE_p(ret), 1); /* MJD */
12198             Set_Node_Offset(REGNODE_p(ret), RExC_parse); /* MJD */
12199             is_open = 1;
12200         } else {
12201             /* with RXf_PMf_NOCAPTURE treat (...) as (?:...) */
12202             paren = ':';
12203             ret = 0;
12204         }
12205     }
12206     else                        /* ! paren */
12207         ret = 0;
12208
12209    parse_rest:
12210     /* Pick up the branches, linking them together. */
12211     parse_start = RExC_parse;   /* MJD */
12212     br = regbranch(pRExC_state, &flags, 1, depth+1);
12213
12214     /*     branch_len = (paren != 0); */
12215
12216     if (br == 0) {
12217         RETURN_FAIL_ON_RESTART(flags, flagp);
12218         FAIL2("panic: regbranch returned failure, flags=%#" UVxf, (UV) flags);
12219     }
12220     if (*RExC_parse == '|') {
12221         if (RExC_use_BRANCHJ) {
12222             reginsert(pRExC_state, BRANCHJ, br, depth+1);
12223         }
12224         else {                  /* MJD */
12225             reginsert(pRExC_state, BRANCH, br, depth+1);
12226             Set_Node_Length(REGNODE_p(br), paren != 0);
12227             Set_Node_Offset_To_R(br, parse_start-RExC_start);
12228         }
12229         have_branch = 1;
12230     }
12231     else if (paren == ':') {
12232         *flagp |= flags&SIMPLE;
12233     }
12234     if (is_open) {                              /* Starts with OPEN. */
12235         if (! REGTAIL(pRExC_state, ret, br)) {  /* OPEN -> first. */
12236             REQUIRE_BRANCHJ(flagp, 0);
12237         }
12238     }
12239     else if (paren != '?')              /* Not Conditional */
12240         ret = br;
12241     *flagp |= flags & (HASWIDTH | POSTPONED);
12242     lastbr = br;
12243     while (*RExC_parse == '|') {
12244         if (RExC_use_BRANCHJ) {
12245             bool shut_gcc_up;
12246
12247             ender = reganode(pRExC_state, LONGJMP, 0);
12248
12249             /* Append to the previous. */
12250             shut_gcc_up = REGTAIL(pRExC_state,
12251                          REGNODE_OFFSET(NEXTOPER(NEXTOPER(REGNODE_p(lastbr)))),
12252                          ender);
12253             PERL_UNUSED_VAR(shut_gcc_up);
12254         }
12255         nextchar(pRExC_state);
12256         if (freeze_paren) {
12257             if (RExC_npar > after_freeze)
12258                 after_freeze = RExC_npar;
12259             RExC_npar = freeze_paren;
12260         }
12261         br = regbranch(pRExC_state, &flags, 0, depth+1);
12262
12263         if (br == 0) {
12264             RETURN_FAIL_ON_RESTART(flags, flagp);
12265             FAIL2("panic: regbranch returned failure, flags=%#" UVxf, (UV) flags);
12266         }
12267         if (!  REGTAIL(pRExC_state, lastbr, br)) {  /* BRANCH -> BRANCH. */
12268             REQUIRE_BRANCHJ(flagp, 0);
12269         }
12270         lastbr = br;
12271         *flagp |= flags & (HASWIDTH | POSTPONED);
12272     }
12273
12274     if (have_branch || paren != ':') {
12275         regnode * br;
12276
12277         /* Make a closing node, and hook it on the end. */
12278         switch (paren) {
12279         case ':':
12280             ender = reg_node(pRExC_state, TAIL);
12281             break;
12282         case 1: case 2:
12283             ender = reganode(pRExC_state, CLOSE, parno);
12284             if ( RExC_close_parens ) {
12285                 DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_
12286                         "%*s%*s Setting close paren #%" IVdf " to %zu\n",
12287                         22, "|    |", (int)(depth * 2 + 1), "",
12288                         (IV)parno, ender));
12289                 RExC_close_parens[parno]= ender;
12290                 if (RExC_nestroot == parno)
12291                     RExC_nestroot = 0;
12292             }
12293             Set_Node_Offset(REGNODE_p(ender), RExC_parse+1); /* MJD */
12294             Set_Node_Length(REGNODE_p(ender), 1); /* MJD */
12295             break;
12296         case 's':
12297             ender = reg_node(pRExC_state, SRCLOSE);
12298             RExC_in_script_run = 0;
12299             break;
12300         case '<':
12301         case 'a':
12302         case 'A':
12303         case 'b':
12304         case 'B':
12305         case ',':
12306         case '=':
12307         case '!':
12308             *flagp &= ~HASWIDTH;
12309             /* FALLTHROUGH */
12310         case 't':   /* aTomic */
12311         case '>':
12312             ender = reg_node(pRExC_state, SUCCEED);
12313             break;
12314         case 0:
12315             ender = reg_node(pRExC_state, END);
12316             assert(!RExC_end_op); /* there can only be one! */
12317             RExC_end_op = REGNODE_p(ender);
12318             if (RExC_close_parens) {
12319                 DEBUG_OPTIMISE_MORE_r(Perl_re_printf( aTHX_
12320                     "%*s%*s Setting close paren #0 (END) to %zu\n",
12321                     22, "|    |", (int)(depth * 2 + 1), "",
12322                     ender));
12323
12324                 RExC_close_parens[0]= ender;
12325             }
12326             break;
12327         }
12328         DEBUG_PARSE_r({
12329             DEBUG_PARSE_MSG("lsbr");
12330             regprop(RExC_rx, RExC_mysv1, REGNODE_p(lastbr), NULL, pRExC_state);
12331             regprop(RExC_rx, RExC_mysv2, REGNODE_p(ender), NULL, pRExC_state);
12332             Perl_re_printf( aTHX_  "~ tying lastbr %s (%" IVdf ") to ender %s (%" IVdf ") offset %" IVdf "\n",
12333                           SvPV_nolen_const(RExC_mysv1),
12334                           (IV)lastbr,
12335                           SvPV_nolen_const(RExC_mysv2),
12336                           (IV)ender,
12337                           (IV)(ender - lastbr)
12338             );
12339         });
12340         if (! REGTAIL(pRExC_state, lastbr, ender)) {
12341             REQUIRE_BRANCHJ(flagp, 0);
12342         }
12343
12344         if (have_branch) {
12345             char is_nothing= 1;
12346             if (depth==1)
12347                 RExC_seen |= REG_TOP_LEVEL_BRANCHES_SEEN;
12348
12349             /* Hook the tails of the branches to the closing node. */
12350             for (br = REGNODE_p(ret); br; br = regnext(br)) {
12351                 const U8 op = PL_regkind[OP(br)];
12352                 if (op == BRANCH) {
12353                     if (! REGTAIL_STUDY(pRExC_state,
12354                                         REGNODE_OFFSET(NEXTOPER(br)),
12355                                         ender))
12356                     {
12357                         REQUIRE_BRANCHJ(flagp, 0);
12358                     }
12359                     if ( OP(NEXTOPER(br)) != NOTHING
12360                          || regnext(NEXTOPER(br)) != REGNODE_p(ender))
12361                         is_nothing= 0;
12362                 }
12363                 else if (op == BRANCHJ) {
12364                     bool shut_gcc_up = REGTAIL_STUDY(pRExC_state,
12365                                         REGNODE_OFFSET(NEXTOPER(NEXTOPER(br))),
12366                                         ender);
12367                     PERL_UNUSED_VAR(shut_gcc_up);
12368                     /* for now we always disable this optimisation * /
12369                     if ( OP(NEXTOPER(NEXTOPER(br))) != NOTHING
12370                          || regnext(NEXTOPER(NEXTOPER(br))) != REGNODE_p(ender))
12371                     */
12372                         is_nothing= 0;
12373                 }
12374             }
12375             if (is_nothing) {
12376                 regnode * ret_as_regnode = REGNODE_p(ret);
12377                 br= PL_regkind[OP(ret_as_regnode)] != BRANCH
12378                                ? regnext(ret_as_regnode)
12379                                : ret_as_regnode;
12380                 DEBUG_PARSE_r({
12381                     DEBUG_PARSE_MSG("NADA");
12382                     regprop(RExC_rx, RExC_mysv1, ret_as_regnode,
12383                                      NULL, pRExC_state);
12384                     regprop(RExC_rx, RExC_mysv2, REGNODE_p(ender),
12385                                      NULL, pRExC_state);
12386                     Perl_re_printf( aTHX_  "~ converting ret %s (%" IVdf ") to ender %s (%" IVdf ") offset %" IVdf "\n",
12387                                   SvPV_nolen_const(RExC_mysv1),
12388                                   (IV)REG_NODE_NUM(ret_as_regnode),
12389                                   SvPV_nolen_const(RExC_mysv2),
12390                                   (IV)ender,
12391                                   (IV)(ender - ret)
12392                     );
12393                 });
12394                 OP(br)= NOTHING;
12395                 if (OP(REGNODE_p(ender)) == TAIL) {
12396                     NEXT_OFF(br)= 0;
12397                     RExC_emit= REGNODE_OFFSET(br) + 1;
12398                 } else {
12399                     regnode *opt;
12400                     for ( opt= br + 1; opt < REGNODE_p(ender) ; opt++ )
12401                         OP(opt)= OPTIMIZED;
12402                     NEXT_OFF(br)= REGNODE_p(ender) - br;
12403                 }
12404             }
12405         }
12406     }
12407
12408     {
12409         const char *p;
12410          /* Even/odd or x=don't care: 010101x10x */
12411         static const char parens[] = "=!aA<,>Bbt";
12412          /* flag below is set to 0 up through 'A'; 1 for larger */
12413
12414         if (paren && (p = strchr(parens, paren))) {
12415             U8 node = ((p - parens) % 2) ? UNLESSM : IFMATCH;
12416             int flag = (p - parens) > 3;
12417
12418             if (paren == '>' || paren == 't') {
12419                 node = SUSPEND, flag = 0;
12420             }
12421
12422             reginsert(pRExC_state, node, ret, depth+1);
12423             Set_Node_Cur_Length(REGNODE_p(ret), parse_start);
12424             Set_Node_Offset(REGNODE_p(ret), parse_start + 1);
12425             FLAGS(REGNODE_p(ret)) = flag;
12426             if (! REGTAIL_STUDY(pRExC_state, ret, reg_node(pRExC_state, TAIL)))
12427             {
12428                 REQUIRE_BRANCHJ(flagp, 0);
12429             }
12430         }
12431     }
12432
12433     /* Check for proper termination. */
12434     if (paren) {
12435         /* restore original flags, but keep (?p) and, if we've encountered
12436          * something in the parse that changes /d rules into /u, keep the /u */
12437         RExC_flags = oregflags | (RExC_flags & RXf_PMf_KEEPCOPY);
12438         if (DEPENDS_SEMANTICS && toUSE_UNI_CHARSET_NOT_DEPENDS) {
12439             set_regex_charset(&RExC_flags, REGEX_UNICODE_CHARSET);
12440         }
12441         if (RExC_parse >= RExC_end || UCHARAT(RExC_parse) != ')') {
12442             RExC_parse = oregcomp_parse;
12443             vFAIL("Unmatched (");
12444         }
12445         nextchar(pRExC_state);
12446     }
12447     else if (!paren && RExC_parse < RExC_end) {
12448         if (*RExC_parse == ')') {
12449             RExC_parse++;
12450             vFAIL("Unmatched )");
12451         }
12452         else
12453             FAIL("Junk on end of regexp");      /* "Can't happen". */
12454         NOT_REACHED; /* NOTREACHED */
12455     }
12456
12457     if (after_freeze > RExC_npar)
12458         RExC_npar = after_freeze;
12459
12460     RExC_in_lookaround = was_in_lookaround;
12461
12462     return(ret);
12463 }
12464
12465 /*
12466  - regbranch - one alternative of an | operator
12467  *
12468  * Implements the concatenation operator.
12469  *
12470  * On success, returns the offset at which any next node should be placed into
12471  * the regex engine program being compiled.
12472  *
12473  * Returns 0 otherwise, setting flagp to RESTART_PARSE if the parse needs
12474  * to be restarted, or'd with NEED_UTF8 if the pattern needs to be upgraded to
12475  * UTF-8
12476  */
12477 STATIC regnode_offset
12478 S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth)
12479 {
12480     regnode_offset ret;
12481     regnode_offset chain = 0;
12482     regnode_offset latest;
12483     I32 flags = 0, c = 0;
12484     DECLARE_AND_GET_RE_DEBUG_FLAGS;
12485
12486     PERL_ARGS_ASSERT_REGBRANCH;
12487
12488     DEBUG_PARSE("brnc");
12489
12490     if (first)
12491         ret = 0;
12492     else {
12493         if (RExC_use_BRANCHJ)
12494             ret = reganode(pRExC_state, BRANCHJ, 0);
12495         else {
12496             ret = reg_node(pRExC_state, BRANCH);
12497             Set_Node_Length(REGNODE_p(ret), 1);
12498         }
12499     }
12500
12501     *flagp = 0;                 /* Initialize. */
12502
12503     skip_to_be_ignored_text(pRExC_state, &RExC_parse,
12504                             FALSE /* Don't force to /x */ );
12505     while (RExC_parse < RExC_end && *RExC_parse != '|' && *RExC_parse != ')') {
12506         flags &= ~TRYAGAIN;
12507         latest = regpiece(pRExC_state, &flags, depth+1);
12508         if (latest == 0) {
12509             if (flags & TRYAGAIN)
12510                 continue;
12511             RETURN_FAIL_ON_RESTART(flags, flagp);
12512             FAIL2("panic: regpiece returned failure, flags=%#" UVxf, (UV) flags);
12513         }
12514         else if (ret == 0)
12515             ret = latest;
12516         *flagp |= flags&(HASWIDTH|POSTPONED);
12517         if (chain != 0) {
12518             /* FIXME adding one for every branch after the first is probably
12519              * excessive now we have TRIE support. (hv) */
12520             MARK_NAUGHTY(1);
12521             if (! REGTAIL(pRExC_state, chain, latest)) {
12522                 /* XXX We could just redo this branch, but figuring out what
12523                  * bookkeeping needs to be reset is a pain, and it's likely
12524                  * that other branches that goto END will also be too large */
12525                 REQUIRE_BRANCHJ(flagp, 0);
12526             }
12527         }
12528         chain = latest;
12529         c++;
12530     }
12531     if (chain == 0) {   /* Loop ran zero times. */
12532         chain = reg_node(pRExC_state, NOTHING);
12533         if (ret == 0)
12534             ret = chain;
12535     }
12536     if (c == 1) {
12537         *flagp |= flags&SIMPLE;
12538     }
12539
12540     return ret;
12541 }
12542
12543 /*
12544  - regcurly - a little FSA that accepts {\d+,?\d*}
12545     Pulled from reg.c.
12546  */
12547 bool
12548 Perl_regcurly(const char *s)
12549 {
12550     PERL_ARGS_ASSERT_REGCURLY;
12551
12552     if (*s++ != '{')
12553         return FALSE;
12554     if (!isDIGIT(*s))
12555         return FALSE;
12556     while (isDIGIT(*s))
12557         s++;
12558     if (*s == ',') {
12559         s++;
12560         while (isDIGIT(*s))
12561             s++;
12562     }
12563
12564     return *s == '}';
12565 }
12566
12567 /*
12568  - regpiece - something followed by possible quantifier * + ? {n,m}
12569  *
12570  * Note that the branching code sequences used for ? and the general cases
12571  * of * and + are somewhat optimized:  they use the same NOTHING node as
12572  * both the endmarker for their branch list and the body of the last branch.
12573  * It might seem that this node could be dispensed with entirely, but the
12574  * endmarker role is not redundant.
12575  *
12576  * On success, returns the offset at which any next node should be placed into
12577  * the regex engine program being compiled.
12578  *
12579  * Returns 0 otherwise, with *flagp set to indicate why:
12580  *  TRYAGAIN        if regatom() returns 0 with TRYAGAIN.
12581  *  RESTART_PARSE   if the parse needs to be restarted, or'd with
12582  *                  NEED_UTF8 if the pattern needs to be upgraded to UTF-8.
12583  */
12584 STATIC regnode_offset
12585 S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
12586 {
12587     regnode_offset ret;
12588     char op;
12589     char *next;
12590     I32 flags;
12591     const char * const origparse = RExC_parse;
12592     I32 min;
12593     I32 max = REG_INFTY;
12594 #ifdef RE_TRACK_PATTERN_OFFSETS
12595     char *parse_start;
12596 #endif
12597     const char *maxpos = NULL;
12598     UV uv;
12599
12600     /* Save the original in case we change the emitted regop to a FAIL. */
12601     const regnode_offset orig_emit = RExC_emit;
12602
12603     DECLARE_AND_GET_RE_DEBUG_FLAGS;
12604
12605     PERL_ARGS_ASSERT_REGPIECE;
12606
12607     DEBUG_PARSE("piec");
12608
12609     ret = regatom(pRExC_state, &flags, depth+1);
12610     if (ret == 0) {
12611         RETURN_FAIL_ON_RESTART_OR_FLAGS(flags, flagp, TRYAGAIN);
12612         FAIL2("panic: regatom returned failure, flags=%#" UVxf, (UV) flags);
12613     }
12614
12615 #ifdef RE_TRACK_PATTERN_OFFSETS
12616     parse_start = RExC_parse;
12617 #endif
12618
12619     op = *RExC_parse;
12620     switch (op) {
12621
12622       case '*':
12623         nextchar(pRExC_state);
12624         min = 0;
12625         break;
12626
12627       case '+':
12628         nextchar(pRExC_state);
12629         min = 1;
12630         break;
12631
12632       case '?':
12633         nextchar(pRExC_state);
12634         min = 0; max = 1;
12635         break;
12636
12637       case '{':  /* A '{' may or may not indicate a quantifier; call regcurly()
12638                     to determine which */
12639         if (regcurly(RExC_parse)) {
12640             const char* endptr;
12641
12642             /* Here is a quantifier, parse for min and max values */
12643             maxpos = NULL;
12644             next = RExC_parse + 1;
12645             while (isDIGIT(*next) || *next == ',') {
12646                 if (*next == ',') {
12647                     if (maxpos)
12648                         break;
12649                     else
12650                         maxpos = next;
12651                 }
12652                 next++;
12653             }
12654
12655             assert(*next == '}');
12656
12657             if (!maxpos)
12658                 maxpos = next;
12659             RExC_parse++;
12660             if (isDIGIT(*RExC_parse)) {
12661                 endptr = RExC_end;
12662                 if (!grok_atoUV(RExC_parse, &uv, &endptr))
12663                     vFAIL("Invalid quantifier in {,}");
12664                 if (uv >= REG_INFTY)
12665                     vFAIL2("Quantifier in {,} bigger than %d", REG_INFTY - 1);
12666                 min = (I32)uv;
12667             } else {
12668                 min = 0;
12669             }
12670             if (*maxpos == ',')
12671                 maxpos++;
12672             else
12673                 maxpos = RExC_parse;
12674             if (isDIGIT(*maxpos)) {
12675                 endptr = RExC_end;
12676                 if (!grok_atoUV(maxpos, &uv, &endptr))
12677                     vFAIL("Invalid quantifier in {,}");
12678                 if (uv >= REG_INFTY)
12679                     vFAIL2("Quantifier in {,} bigger than %d", REG_INFTY - 1);
12680                 max = (I32)uv;
12681             } else {
12682                 max = REG_INFTY;            /* meaning "infinity" */
12683             }
12684
12685             RExC_parse = next;
12686             nextchar(pRExC_state);
12687             if (max < min) {    /* If can't match, warn and optimize to fail
12688                                    unconditionally */
12689                 reginsert(pRExC_state, OPFAIL, orig_emit, depth+1);
12690                 ckWARNreg(RExC_parse, "Quantifier {n,m} with n > m can't match");
12691                 NEXT_OFF(REGNODE_p(orig_emit)) =
12692                                     regarglen[OPFAIL] + NODE_STEP_REGNODE;
12693                 return ret;
12694             }
12695             else if (min == max && *RExC_parse == '?')
12696             {
12697                 ckWARN2reg(RExC_parse + 1,
12698                            "Useless use of greediness modifier '%c'",
12699                            *RExC_parse);
12700             }
12701
12702             break;
12703         } /* End of is regcurly() */
12704
12705         /* Here was a '{', but what followed it didn't form a quantifier. */
12706         /* FALLTHROUGH */
12707
12708       default:
12709         *flagp = flags;
12710         return(ret);
12711         NOT_REACHED; /*NOTREACHED*/
12712     }
12713
12714     /* Here we have a quantifier, and have calculated 'min' and 'max'.
12715      *
12716      * Check and possibly adjust a zero width operand */
12717     if (! (flags & (HASWIDTH|POSTPONED))) {
12718         if (max > REG_INFTY/3) {
12719             if (origparse[0] == '\\' && origparse[1] == 'K') {
12720                 vFAIL2utf8f(
12721                            "%" UTF8f " is forbidden - matches null string"
12722                            " many times",
12723                            UTF8fARG(UTF, (RExC_parse >= origparse
12724                                          ? RExC_parse - origparse
12725                                          : 0),
12726                            origparse));
12727             } else {
12728                 ckWARN2reg(RExC_parse,
12729                            "%" UTF8f " matches null string many times",
12730                            UTF8fARG(UTF, (RExC_parse >= origparse
12731                                          ? RExC_parse - origparse
12732                                          : 0),
12733                            origparse));
12734             }
12735         }
12736
12737         /* There's no point in trying to match something 0 length more than
12738          * once except for extra side effects, which we don't have here since
12739          * not POSTPONED */
12740         if (max > 1) {
12741             max = 1;
12742             if (min > max) {
12743                 min = max;
12744             }
12745         }
12746     }
12747
12748     /* If this is a code block pass it up */
12749     *flagp |= (flags & POSTPONED);
12750
12751     if (max > 0) {
12752         *flagp |= (flags & HASWIDTH);
12753         if (max == REG_INFTY)
12754             RExC_seen |= REG_UNBOUNDED_QUANTIFIER_SEEN;
12755     }
12756
12757     /* 'SIMPLE' operands don't require full generality */
12758     if ((flags&SIMPLE)) {
12759         if (max == REG_INFTY) {
12760             if (min == 0) {
12761                 if (UNLIKELY(RExC_pm_flags & PMf_WILDCARD)) {
12762                     goto min0_maxINF_wildcard_forbidden;
12763                 }
12764
12765                 reginsert(pRExC_state, STAR, ret, depth+1);
12766                 MARK_NAUGHTY(4);
12767                 goto done_main_op;
12768             }
12769             else if (min == 1) {
12770                 reginsert(pRExC_state, PLUS, ret, depth+1);
12771                 MARK_NAUGHTY(3);
12772                 goto done_main_op;
12773             }
12774         }
12775
12776         /* Here, SIMPLE, but not the '*' and '+' special cases */
12777
12778         MARK_NAUGHTY_EXP(2, 2);
12779         reginsert(pRExC_state, CURLY, ret, depth+1);
12780         Set_Node_Offset(REGNODE_p(ret), parse_start+1); /* MJD */
12781         Set_Node_Cur_Length(REGNODE_p(ret), parse_start);
12782     }
12783     else {  /* not SIMPLE */
12784         const regnode_offset w = reg_node(pRExC_state, WHILEM);
12785
12786         FLAGS(REGNODE_p(w)) = 0;
12787         if (!  REGTAIL(pRExC_state, ret, w)) {
12788             REQUIRE_BRANCHJ(flagp, 0);
12789         }
12790         if (RExC_use_BRANCHJ) {
12791             reginsert(pRExC_state, LONGJMP, ret, depth+1);
12792             reginsert(pRExC_state, NOTHING, ret, depth+1);
12793             NEXT_OFF(REGNODE_p(ret)) = 3;        /* Go over LONGJMP. */
12794         }
12795         reginsert(pRExC_state, CURLYX, ret, depth+1);
12796                         /* MJD hk */
12797         Set_Node_Offset(REGNODE_p(ret), parse_start+1);
12798         Set_Node_Length(REGNODE_p(ret),
12799                         op == '{' ? (RExC_parse - parse_start) : 1);
12800
12801         if (RExC_use_BRANCHJ)
12802             NEXT_OFF(REGNODE_p(ret)) = 3;   /* Go over NOTHING to
12803                                                LONGJMP. */
12804         if (! REGTAIL(pRExC_state, ret, reg_node(pRExC_state,
12805                                                   NOTHING)))
12806         {
12807             REQUIRE_BRANCHJ(flagp, 0);
12808         }
12809         RExC_whilem_seen++;
12810         MARK_NAUGHTY_EXP(1, 4);     /* compound interest */
12811     }
12812
12813     /* Finish up the CURLY/CURLYX case */
12814     FLAGS(REGNODE_p(ret)) = 0;
12815
12816     ARG1_SET(REGNODE_p(ret), (U16)min);
12817     ARG2_SET(REGNODE_p(ret), (U16)max);
12818
12819   done_main_op:
12820
12821     /* Process any greediness modifiers */
12822     if (*RExC_parse == '?') {
12823         nextchar(pRExC_state);
12824         reginsert(pRExC_state, MINMOD, ret, depth+1);
12825         if (! REGTAIL(pRExC_state, ret, ret + NODE_STEP_REGNODE)) {
12826             REQUIRE_BRANCHJ(flagp, 0);
12827         }
12828     }
12829     else if (*RExC_parse == '+') {
12830         regnode_offset ender;
12831         nextchar(pRExC_state);
12832         ender = reg_node(pRExC_state, SUCCEED);
12833         if (! REGTAIL(pRExC_state, ret, ender)) {
12834             REQUIRE_BRANCHJ(flagp, 0);
12835         }
12836         reginsert(pRExC_state, SUSPEND, ret, depth+1);
12837         ender = reg_node(pRExC_state, TAIL);
12838         if (! REGTAIL(pRExC_state, ret, ender)) {
12839             REQUIRE_BRANCHJ(flagp, 0);
12840         }
12841     }
12842
12843     /* Forbid extra quantifiers */
12844     if (ISMULT2(RExC_parse)) {
12845         RExC_parse++;
12846         vFAIL("Nested quantifiers");
12847     }
12848
12849     return(ret);
12850
12851   min0_maxINF_wildcard_forbidden:
12852
12853     /* Here we are in a wildcard match, and the minimum match length is 0, and
12854      * the max could be infinity.  This is currently forbidden.  The only
12855      * reason is to make it harder to write patterns that take a long long time
12856      * to halt, and because the use of this construct isn't necessary in
12857      * matching Unicode property values */
12858     RExC_parse++;
12859     /* diag_listed_as: Use of %s is not allowed in Unicode property wildcard
12860        subpatterns in regex; marked by <-- HERE in m/%s/
12861      */
12862     vFAIL("Use of quantifier '*' is not allowed in Unicode property wildcard"
12863           " subpatterns");
12864
12865     /* Note, don't need to worry about the input being '{0,}', as a '}' isn't
12866      * legal at all in wildcards, so can't get this far */
12867
12868     NOT_REACHED; /*NOTREACHED*/
12869 }
12870
12871 STATIC bool
12872 S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state,
12873                 regnode_offset * node_p,
12874                 UV * code_point_p,
12875                 int * cp_count,
12876                 I32 * flagp,
12877                 const bool strict,
12878                 const U32 depth
12879     )
12880 {
12881  /* This routine teases apart the various meanings of \N and returns
12882   * accordingly.  The input parameters constrain which meaning(s) is/are valid
12883   * in the current context.
12884   *
12885   * Exactly one of <node_p> and <code_point_p> must be non-NULL.
12886   *
12887   * If <code_point_p> is not NULL, the context is expecting the result to be a
12888   * single code point.  If this \N instance turns out to a single code point,
12889   * the function returns TRUE and sets *code_point_p to that code point.
12890   *
12891   * If <node_p> is not NULL, the context is expecting the result to be one of
12892   * the things representable by a regnode.  If this \N instance turns out to be
12893   * one such, the function generates the regnode, returns TRUE and sets *node_p
12894   * to point to the offset of that regnode into the regex engine program being
12895   * compiled.
12896   *
12897   * If this instance of \N isn't legal in any context, this function will
12898   * generate a fatal error and not return.
12899   *
12900   * On input, RExC_parse should point to the first char following the \N at the
12901   * time of the call.  On successful return, RExC_parse will have been updated
12902   * to point to just after the sequence identified by this routine.  Also
12903   * *flagp has been updated as needed.
12904   *
12905   * When there is some problem with the current context and this \N instance,
12906   * the function returns FALSE, without advancing RExC_parse, nor setting
12907   * *node_p, nor *code_point_p, nor *flagp.
12908   *
12909   * If <cp_count> is not NULL, the caller wants to know the length (in code
12910   * points) that this \N sequence matches.  This is set, and the input is
12911   * parsed for errors, even if the function returns FALSE, as detailed below.
12912   *
12913   * There are 6 possibilities here, as detailed in the next 6 paragraphs.
12914   *
12915   * Probably the most common case is for the \N to specify a single code point.
12916   * *cp_count will be set to 1, and *code_point_p will be set to that code
12917   * point.
12918   *
12919   * Another possibility is for the input to be an empty \N{}.  This is no
12920   * longer accepted, and will generate a fatal error.
12921   *
12922   * Another possibility is for a custom charnames handler to be in effect which
12923   * translates the input name to an empty string.  *cp_count will be set to 0.
12924   * *node_p will be set to a generated NOTHING node.
12925   *
12926   * Still another possibility is for the \N to mean [^\n]. *cp_count will be
12927   * set to 0. *node_p will be set to a generated REG_ANY node.
12928   *
12929   * The fifth possibility is that \N resolves to a sequence of more than one
12930   * code points.  *cp_count will be set to the number of code points in the
12931   * sequence. *node_p will be set to a generated node returned by this
12932   * function calling S_reg().
12933   *
12934   * The final possibility is that it is premature to be calling this function;
12935   * the parse needs to be restarted.  This can happen when this changes from
12936   * /d to /u rules, or when the pattern needs to be upgraded to UTF-8.  The
12937   * latter occurs only when the fifth possibility would otherwise be in
12938   * effect, and is because one of those code points requires the pattern to be
12939   * recompiled as UTF-8.  The function returns FALSE, and sets the
12940   * RESTART_PARSE and NEED_UTF8 flags in *flagp, as appropriate.  When this
12941   * happens, the caller needs to desist from continuing parsing, and return
12942   * this information to its caller.  This is not set for when there is only one
12943   * code point, as this can be called as part of an ANYOF node, and they can
12944   * store above-Latin1 code points without the pattern having to be in UTF-8.
12945   *
12946   * For non-single-quoted regexes, the tokenizer has resolved character and
12947   * sequence names inside \N{...} into their Unicode values, normalizing the
12948   * result into what we should see here: '\N{U+c1.c2...}', where c1... are the
12949   * hex-represented code points in the sequence.  This is done there because
12950   * the names can vary based on what charnames pragma is in scope at the time,
12951   * so we need a way to take a snapshot of what they resolve to at the time of
12952   * the original parse. [perl #56444].
12953   *
12954   * That parsing is skipped for single-quoted regexes, so here we may get
12955   * '\N{NAME}', which is parsed now.  If the single-quoted regex is something
12956   * like '\N{U+41}', that code point is Unicode, and has to be translated into
12957   * the native character set for non-ASCII platforms.  The other possibilities
12958   * are already native, so no translation is done. */
12959
12960     char * endbrace;    /* points to '}' following the name */
12961     char* p = RExC_parse; /* Temporary */
12962
12963     SV * substitute_parse = NULL;
12964     char *orig_end;
12965     char *save_start;
12966     I32 flags;
12967
12968     DECLARE_AND_GET_RE_DEBUG_FLAGS;
12969
12970     PERL_ARGS_ASSERT_GROK_BSLASH_N;
12971
12972     assert(cBOOL(node_p) ^ cBOOL(code_point_p));  /* Exactly one should be set */
12973     assert(! (node_p && cp_count));               /* At most 1 should be set */
12974
12975     if (cp_count) {     /* Initialize return for the most common case */
12976         *cp_count = 1;
12977     }
12978
12979     /* The [^\n] meaning of \N ignores spaces and comments under the /x
12980      * modifier.  The other meanings do not, so use a temporary until we find
12981      * out which we are being called with */
12982     skip_to_be_ignored_text(pRExC_state, &p,
12983                             FALSE /* Don't force to /x */ );
12984
12985     /* Disambiguate between \N meaning a named character versus \N meaning
12986      * [^\n].  The latter is assumed when the {...} following the \N is a legal
12987      * quantifier, or if there is no '{' at all */
12988     if (*p != '{' || regcurly(p)) {
12989         RExC_parse = p;
12990         if (cp_count) {
12991             *cp_count = -1;
12992         }
12993
12994         if (! node_p) {
12995             return FALSE;
12996         }
12997
12998         *node_p = reg_node(pRExC_state, REG_ANY);
12999         *flagp |= HASWIDTH|SIMPLE;
13000         MARK_NAUGHTY(1);
13001         Set_Node_Length(REGNODE_p(*(node_p)), 1); /* MJD */
13002         return TRUE;
13003     }
13004
13005     /* The test above made sure that the next real character is a '{', but
13006      * under the /x modifier, it could be separated by space (or a comment and
13007      * \n) and this is not allowed (for consistency with \x{...} and the
13008      * tokenizer handling of \N{NAME}). */
13009     if (*RExC_parse != '{') {
13010         vFAIL("Missing braces on \\N{}");
13011     }
13012
13013     RExC_parse++;       /* Skip past the '{' */
13014
13015     endbrace = (char *) memchr(RExC_parse, '}', RExC_end - RExC_parse);
13016     if (! endbrace) { /* no trailing brace */
13017         vFAIL2("Missing right brace on \\%c{}", 'N');
13018     }
13019
13020     /* Here, we have decided it should be a named character or sequence.  These
13021      * imply Unicode semantics */
13022     REQUIRE_UNI_RULES(flagp, FALSE);
13023
13024     /* \N{_} is what toke.c returns to us to indicate a name that evaluates to
13025      * nothing at all (not allowed under strict) */
13026     if (endbrace - RExC_parse == 1 && *RExC_parse == '_') {
13027         RExC_parse = endbrace;
13028         if (strict) {
13029             RExC_parse++;   /* Position after the "}" */
13030             vFAIL("Zero length \\N{}");
13031         }
13032
13033         if (cp_count) {
13034             *cp_count = 0;
13035         }
13036         nextchar(pRExC_state);
13037         if (! node_p) {
13038             return FALSE;
13039         }
13040
13041         *node_p = reg_node(pRExC_state, NOTHING);
13042         return TRUE;
13043     }
13044
13045     if (endbrace - RExC_parse < 2 || ! strBEGINs(RExC_parse, "U+")) {
13046
13047         /* Here, the name isn't of the form  U+....  This can happen if the
13048          * pattern is single-quoted, so didn't get evaluated in toke.c.  Now
13049          * is the time to find out what the name means */
13050
13051         const STRLEN name_len = endbrace - RExC_parse;
13052         SV *  value_sv;     /* What does this name evaluate to */
13053         SV ** value_svp;
13054         const U8 * value;   /* string of name's value */
13055         STRLEN value_len;   /* and its length */
13056
13057         /*  RExC_unlexed_names is a hash of names that weren't evaluated by
13058          *  toke.c, and their values. Make sure is initialized */
13059         if (! RExC_unlexed_names) {
13060             RExC_unlexed_names = newHV();
13061         }
13062
13063         /* If we have already seen this name in this pattern, use that.  This
13064          * allows us to only call the charnames handler once per name per
13065          * pattern.  A broken or malicious handler could return something
13066          * different each time, which could cause the results to vary depending
13067          * on if something gets added or subtracted from the pattern that
13068          * causes the number of passes to change, for example */
13069         if ((value_svp = hv_fetch(RExC_unlexed_names, RExC_parse,
13070                                                       name_len, 0)))
13071         {
13072             value_sv = *value_svp;
13073         }
13074         else { /* Otherwise we have to go out and get the name */
13075             const char * error_msg = NULL;
13076             value_sv = get_and_check_backslash_N_name(RExC_parse, endbrace,
13077                                                       UTF,
13078                                                       &error_msg);
13079             if (error_msg) {
13080                 RExC_parse = endbrace;
13081                 vFAIL(error_msg);
13082             }
13083
13084             /* If no error message, should have gotten a valid return */
13085             assert (value_sv);
13086
13087             /* Save the name's meaning for later use */
13088             if (! hv_store(RExC_unlexed_names, RExC_parse, name_len,
13089                            value_sv, 0))
13090             {
13091                 Perl_croak(aTHX_ "panic: hv_store() unexpectedly failed");
13092             }
13093         }
13094
13095         /* Here, we have the value the name evaluates to in 'value_sv' */
13096         value = (U8 *) SvPV(value_sv, value_len);
13097
13098         /* See if the result is one code point vs 0 or multiple */
13099         if (inRANGE(value_len, 1, ((UV) SvUTF8(value_sv)
13100                                   ? UTF8SKIP(value)
13101                                   : 1)))
13102         {
13103             /* Here, exactly one code point.  If that isn't what is wanted,
13104              * fail */
13105             if (! code_point_p) {
13106                 RExC_parse = p;
13107                 return FALSE;
13108             }
13109
13110             /* Convert from string to numeric code point */
13111             *code_point_p = (SvUTF8(value_sv))
13112                             ? valid_utf8_to_uvchr(value, NULL)
13113                             : *value;
13114
13115             /* Have parsed this entire single code point \N{...}.  *cp_count
13116              * has already been set to 1, so don't do it again. */
13117             RExC_parse = endbrace;
13118             nextchar(pRExC_state);
13119             return TRUE;
13120         } /* End of is a single code point */
13121
13122         /* Count the code points, if caller desires.  The API says to do this
13123          * even if we will later return FALSE */
13124         if (cp_count) {
13125             *cp_count = 0;
13126
13127             *cp_count = (SvUTF8(value_sv))
13128                         ? utf8_length(value, value + value_len)
13129                         : value_len;
13130         }
13131
13132         /* Fail if caller doesn't want to handle a multi-code-point sequence.
13133          * But don't back the pointer up if the caller wants to know how many
13134          * code points there are (they need to handle it themselves in this
13135          * case).  */
13136         if (! node_p) {
13137             if (! cp_count) {
13138                 RExC_parse = p;
13139             }
13140             return FALSE;
13141         }
13142
13143         /* Convert this to a sub-pattern of the form "(?: ... )", and then call
13144          * reg recursively to parse it.  That way, it retains its atomicness,
13145          * while not having to worry about any special handling that some code
13146          * points may have. */
13147
13148         substitute_parse = newSVpvs("?:");
13149         sv_catsv(substitute_parse, value_sv);
13150         sv_catpv(substitute_parse, ")");
13151
13152         /* The value should already be native, so no need to convert on EBCDIC
13153          * platforms.*/
13154         assert(! RExC_recode_x_to_native);
13155
13156     }
13157     else {   /* \N{U+...} */
13158         Size_t count = 0;   /* code point count kept internally */
13159
13160         /* We can get to here when the input is \N{U+...} or when toke.c has
13161          * converted a name to the \N{U+...} form.  This include changing a
13162          * name that evaluates to multiple code points to \N{U+c1.c2.c3 ...} */
13163
13164         RExC_parse += 2;    /* Skip past the 'U+' */
13165
13166         /* Code points are separated by dots.  The '}' terminates the whole
13167          * thing. */
13168
13169         do {    /* Loop until the ending brace */
13170             I32 flags = PERL_SCAN_SILENT_OVERFLOW
13171                       | PERL_SCAN_SILENT_ILLDIGIT
13172                       | PERL_SCAN_NOTIFY_ILLDIGIT
13173                       | PERL_SCAN_ALLOW_MEDIAL_UNDERSCORES
13174                       | PERL_SCAN_DISALLOW_PREFIX;
13175             STRLEN len = endbrace - RExC_parse;
13176             NV overflow_value;
13177             char * start_digit = RExC_parse;
13178             UV cp = grok_hex(RExC_parse, &len, &flags, &overflow_value);
13179
13180             if (len == 0) {
13181                 RExC_parse++;
13182               bad_NU:
13183                 vFAIL("Invalid hexadecimal number in \\N{U+...}");
13184             }
13185
13186             RExC_parse += len;
13187
13188             if (cp > MAX_LEGAL_CP) {
13189                 vFAIL(form_cp_too_large_msg(16, start_digit, len, 0));
13190             }
13191
13192             if (RExC_parse >= endbrace) { /* Got to the closing '}' */
13193                 if (count) {
13194                     goto do_concat;
13195                 }
13196
13197                 /* Here, is a single code point; fail if doesn't want that */
13198                 if (! code_point_p) {
13199                     RExC_parse = p;
13200                     return FALSE;
13201                 }
13202
13203                 /* A single code point is easy to handle; just return it */
13204                 *code_point_p = UNI_TO_NATIVE(cp);
13205                 RExC_parse = endbrace;
13206                 nextchar(pRExC_state);
13207                 return TRUE;
13208             }
13209
13210             /* Here, the parse stopped bfore the ending brace.  This is legal
13211              * only if that character is a dot separating code points, like a
13212              * multiple character sequence (of the form "\N{U+c1.c2. ... }".
13213              * So the next character must be a dot (and the one after that
13214              * can't be the endbrace, or we'd have something like \N{U+100.} )
13215              * */
13216             if (*RExC_parse != '.' || RExC_parse + 1 >= endbrace) {
13217                 RExC_parse += (RExC_orig_utf8)  /* point to after 1st invalid */
13218                               ? UTF8SKIP(RExC_parse)
13219                               : 1;
13220                 RExC_parse = MIN(endbrace, RExC_parse);/* Guard against
13221                                                           malformed utf8 */
13222                 goto bad_NU;
13223             }
13224
13225             /* Here, looks like its really a multiple character sequence.  Fail
13226              * if that's not what the caller wants.  But continue with counting
13227              * and error checking if they still want a count */
13228             if (! node_p && ! cp_count) {
13229                 return FALSE;
13230             }
13231
13232             /* What is done here is to convert this to a sub-pattern of the
13233              * form \x{char1}\x{char2}...  and then call reg recursively to
13234              * parse it (enclosing in "(?: ... )" ).  That way, it retains its
13235              * atomicness, while not having to worry about special handling
13236              * that some code points may have.  We don't create a subpattern,
13237              * but go through the motions of code point counting and error
13238              * checking, if the caller doesn't want a node returned. */
13239
13240             if (node_p && ! substitute_parse) {
13241                 substitute_parse = newSVpvs("?:");
13242             }
13243
13244           do_concat:
13245
13246             if (node_p) {
13247                 /* Convert to notation the rest of the code understands */
13248                 sv_catpvs(substitute_parse, "\\x{");
13249                 sv_catpvn(substitute_parse, start_digit,
13250                                             RExC_parse - start_digit);
13251                 sv_catpvs(substitute_parse, "}");
13252             }
13253
13254             /* Move to after the dot (or ending brace the final time through.)
13255              * */
13256             RExC_parse++;
13257             count++;
13258
13259         } while (RExC_parse < endbrace);
13260
13261         if (! node_p) { /* Doesn't want the node */
13262             assert (cp_count);
13263
13264             *cp_count = count;
13265             return FALSE;
13266         }
13267
13268         sv_catpvs(substitute_parse, ")");
13269
13270         /* The values are Unicode, and therefore have to be converted to native
13271          * on a non-Unicode (meaning non-ASCII) platform. */
13272         SET_recode_x_to_native(1);
13273     }
13274
13275     /* Here, we have the string the name evaluates to, ready to be parsed,
13276      * stored in 'substitute_parse' as a series of valid "\x{...}\x{...}"
13277      * constructs.  This can be called from within a substitute parse already.
13278      * The error reporting mechanism doesn't work for 2 levels of this, but the
13279      * code above has validated this new construct, so there should be no
13280      * errors generated by the below.  And this isn' an exact copy, so the
13281      * mechanism to seamlessly deal with this won't work, so turn off warnings
13282      * during it */
13283     save_start = RExC_start;
13284     orig_end = RExC_end;
13285
13286     RExC_parse = RExC_start = SvPVX(substitute_parse);
13287     RExC_end = RExC_parse + SvCUR(substitute_parse);
13288     TURN_OFF_WARNINGS_IN_SUBSTITUTE_PARSE;
13289
13290     *node_p = reg(pRExC_state, 1, &flags, depth+1);
13291
13292     /* Restore the saved values */
13293     RESTORE_WARNINGS;
13294     RExC_start = save_start;
13295     RExC_parse = endbrace;
13296     RExC_end = orig_end;
13297     SET_recode_x_to_native(0);
13298
13299     SvREFCNT_dec_NN(substitute_parse);
13300
13301     if (! *node_p) {
13302         RETURN_FAIL_ON_RESTART(flags, flagp);
13303         FAIL2("panic: reg returned failure to grok_bslash_N, flags=%#" UVxf,
13304             (UV) flags);
13305     }
13306     *flagp |= flags&(HASWIDTH|SIMPLE|POSTPONED);
13307
13308     nextchar(pRExC_state);
13309
13310     return TRUE;
13311 }
13312
13313
13314 STATIC U8
13315 S_compute_EXACTish(RExC_state_t *pRExC_state)
13316 {
13317     U8 op;
13318
13319     PERL_ARGS_ASSERT_COMPUTE_EXACTISH;
13320
13321     if (! FOLD) {
13322         return (LOC)
13323                 ? EXACTL
13324                 : EXACT;
13325     }
13326
13327     op = get_regex_charset(RExC_flags);
13328     if (op >= REGEX_ASCII_RESTRICTED_CHARSET) {
13329         op--; /* /a is same as /u, and map /aa's offset to what /a's would have
13330                  been, so there is no hole */
13331     }
13332
13333     return op + EXACTF;
13334 }
13335
13336 STATIC bool
13337 S_new_regcurly(const char *s, const char *e)
13338 {
13339     /* This is a temporary function designed to match the most lenient form of
13340      * a {m,n} quantifier we ever envision, with either number omitted, and
13341      * spaces anywhere between/before/after them.
13342      *
13343      * If this function fails, then the string it matches is very unlikely to
13344      * ever be considered a valid quantifier, so we can allow the '{' that
13345      * begins it to be considered as a literal */
13346
13347     bool has_min = FALSE;
13348     bool has_max = FALSE;
13349
13350     PERL_ARGS_ASSERT_NEW_REGCURLY;
13351
13352     if (s >= e || *s++ != '{')
13353         return FALSE;
13354
13355     while (s < e && isSPACE(*s)) {
13356         s++;
13357     }
13358     while (s < e && isDIGIT(*s)) {
13359         has_min = TRUE;
13360         s++;
13361     }
13362     while (s < e && isSPACE(*s)) {
13363         s++;
13364     }
13365
13366     if (*s == ',') {
13367         s++;
13368         while (s < e && isSPACE(*s)) {
13369             s++;
13370         }
13371         while (s < e && isDIGIT(*s)) {
13372             has_max = TRUE;
13373             s++;
13374         }
13375         while (s < e && isSPACE(*s)) {
13376             s++;
13377         }
13378     }
13379
13380     return s < e && *s == '}' && (has_min || has_max);
13381 }
13382
13383 /* Parse backref decimal value, unless it's too big to sensibly be a backref,
13384  * in which case return I32_MAX (rather than possibly 32-bit wrapping) */
13385
13386 static I32
13387 S_backref_value(char *p, char *e)
13388 {
13389     const char* endptr = e;
13390     UV val;
13391     if (grok_atoUV(p, &val, &endptr) && val <= I32_MAX)
13392         return (I32)val;
13393     return I32_MAX;
13394 }
13395
13396
13397 /*
13398  - regatom - the lowest level
13399
13400    Try to identify anything special at the start of the current parse position.
13401    If there is, then handle it as required. This may involve generating a
13402    single regop, such as for an assertion; or it may involve recursing, such as
13403    to handle a () structure.
13404
13405    If the string doesn't start with something special then we gobble up
13406    as much literal text as we can.  If we encounter a quantifier, we have to
13407    back off the final literal character, as that quantifier applies to just it
13408    and not to the whole string of literals.
13409
13410    Once we have been able to handle whatever type of thing started the
13411    sequence, we return the offset into the regex engine program being compiled
13412    at which any  next regnode should be placed.
13413
13414    Returns 0, setting *flagp to TRYAGAIN if reg() returns 0 with TRYAGAIN.
13415    Returns 0, setting *flagp to RESTART_PARSE if the parse needs to be
13416    restarted, or'd with NEED_UTF8 if the pattern needs to be upgraded to UTF-8
13417    Otherwise does not return 0.
13418
13419    Note: we have to be careful with escapes, as they can be both literal
13420    and special, and in the case of \10 and friends, context determines which.
13421
13422    A summary of the code structure is:
13423
13424    switch (first_byte) {
13425         cases for each special:
13426             handle this special;
13427             break;
13428         case '\\':
13429             switch (2nd byte) {
13430                 cases for each unambiguous special:
13431                     handle this special;
13432                     break;
13433                 cases for each ambigous special/literal:
13434                     disambiguate;
13435                     if (special)  handle here
13436                     else goto defchar;
13437                 default: // unambiguously literal:
13438                     goto defchar;
13439             }
13440         default:  // is a literal char
13441             // FALL THROUGH
13442         defchar:
13443             create EXACTish node for literal;
13444             while (more input and node isn't full) {
13445                 switch (input_byte) {
13446                    cases for each special;
13447                        make sure parse pointer is set so that the next call to
13448                            regatom will see this special first
13449                        goto loopdone; // EXACTish node terminated by prev. char
13450                    default:
13451                        append char to EXACTISH node;
13452                 }
13453                 get next input byte;
13454             }
13455         loopdone:
13456    }
13457    return the generated node;
13458
13459    Specifically there are two separate switches for handling
13460    escape sequences, with the one for handling literal escapes requiring
13461    a dummy entry for all of the special escapes that are actually handled
13462    by the other.
13463
13464 */
13465
13466 STATIC regnode_offset
13467 S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
13468 {
13469     regnode_offset ret = 0;
13470     I32 flags = 0;
13471     char *parse_start;
13472     U8 op;
13473     int invert = 0;
13474
13475     DECLARE_AND_GET_RE_DEBUG_FLAGS;
13476
13477     *flagp = 0;         /* Initialize. */
13478
13479     DEBUG_PARSE("atom");
13480
13481     PERL_ARGS_ASSERT_REGATOM;
13482
13483   tryagain:
13484     parse_start = RExC_parse;
13485     assert(RExC_parse < RExC_end);
13486     switch ((U8)*RExC_parse) {
13487     case '^':
13488         RExC_seen_zerolen++;
13489         nextchar(pRExC_state);
13490         if (RExC_flags & RXf_PMf_MULTILINE)
13491             ret = reg_node(pRExC_state, MBOL);
13492         else
13493             ret = reg_node(pRExC_state, SBOL);
13494         Set_Node_Length(REGNODE_p(ret), 1); /* MJD */
13495         break;
13496     case '$':
13497         nextchar(pRExC_state);
13498         if (*RExC_parse)
13499             RExC_seen_zerolen++;
13500         if (RExC_flags & RXf_PMf_MULTILINE)
13501             ret = reg_node(pRExC_state, MEOL);
13502         else
13503             ret = reg_node(pRExC_state, SEOL);
13504         Set_Node_Length(REGNODE_p(ret), 1); /* MJD */
13505         break;
13506     case '.':
13507         nextchar(pRExC_state);
13508         if (RExC_flags & RXf_PMf_SINGLELINE)
13509             ret = reg_node(pRExC_state, SANY);
13510         else
13511             ret = reg_node(pRExC_state, REG_ANY);
13512         *flagp |= HASWIDTH|SIMPLE;
13513         MARK_NAUGHTY(1);
13514         Set_Node_Length(REGNODE_p(ret), 1); /* MJD */
13515         break;
13516     case '[':
13517     {
13518         char * const oregcomp_parse = ++RExC_parse;
13519         ret = regclass(pRExC_state, flagp, depth+1,
13520                        FALSE, /* means parse the whole char class */
13521                        TRUE, /* allow multi-char folds */
13522                        FALSE, /* don't silence non-portable warnings. */
13523                        (bool) RExC_strict,
13524                        TRUE, /* Allow an optimized regnode result */
13525                        NULL);
13526         if (ret == 0) {
13527             RETURN_FAIL_ON_RESTART_FLAGP(flagp);
13528             FAIL2("panic: regclass returned failure to regatom, flags=%#" UVxf,
13529                   (UV) *flagp);
13530         }
13531         if (*RExC_parse != ']') {
13532             RExC_parse = oregcomp_parse;
13533             vFAIL("Unmatched [");
13534         }
13535         nextchar(pRExC_state);
13536         Set_Node_Length(REGNODE_p(ret), RExC_parse - oregcomp_parse + 1); /* MJD */
13537         break;
13538     }
13539     case '(':
13540         nextchar(pRExC_state);
13541         ret = reg(pRExC_state, 2, &flags, depth+1);
13542         if (ret == 0) {
13543                 if (flags & TRYAGAIN) {
13544                     if (RExC_parse >= RExC_end) {
13545                          /* Make parent create an empty node if needed. */
13546                         *flagp |= TRYAGAIN;
13547                         return(0);
13548                     }
13549                     goto tryagain;
13550                 }
13551                 RETURN_FAIL_ON_RESTART(flags, flagp);
13552                 FAIL2("panic: reg returned failure to regatom, flags=%#" UVxf,
13553                                                                  (UV) flags);
13554         }
13555         *flagp |= flags&(HASWIDTH|SIMPLE|POSTPONED);
13556         break;
13557     case '|':
13558     case ')':
13559         if (flags & TRYAGAIN) {
13560             *flagp |= TRYAGAIN;
13561             return 0;
13562         }
13563         vFAIL("Internal urp");
13564                                 /* Supposed to be caught earlier. */
13565         break;
13566     case '?':
13567     case '+':
13568     case '*':
13569         RExC_parse++;
13570         vFAIL("Quantifier follows nothing");
13571         break;
13572     case '\\':
13573         /* Special Escapes
13574
13575            This switch handles escape sequences that resolve to some kind
13576            of special regop and not to literal text. Escape sequences that
13577            resolve to literal text are handled below in the switch marked
13578            "Literal Escapes".
13579
13580            Every entry in this switch *must* have a corresponding entry
13581            in the literal escape switch. However, the opposite is not
13582            required, as the default for this switch is to jump to the
13583            literal text handling code.
13584         */
13585         RExC_parse++;
13586         switch ((U8)*RExC_parse) {
13587         /* Special Escapes */
13588         case 'A':
13589             RExC_seen_zerolen++;
13590             /* Under wildcards, this is changed to match \n; should be
13591              * invisible to the user, as they have to compile under /m */
13592             if (RExC_pm_flags & PMf_WILDCARD) {
13593                 ret = reg_node(pRExC_state, MBOL);
13594             }
13595             else {
13596                 ret = reg_node(pRExC_state, SBOL);
13597                 /* SBOL is shared with /^/ so we set the flags so we can tell
13598                  * /\A/ from /^/ in split. */
13599                 FLAGS(REGNODE_p(ret)) = 1;
13600             }
13601             goto finish_meta_pat;
13602         case 'G':
13603             if (RExC_pm_flags & PMf_WILDCARD) {
13604                 RExC_parse++;
13605                 /* diag_listed_as: Use of %s is not allowed in Unicode property
13606                    wildcard subpatterns in regex; marked by <-- HERE in m/%s/
13607                  */
13608                 vFAIL("Use of '\\G' is not allowed in Unicode property"
13609                       " wildcard subpatterns");
13610             }
13611             ret = reg_node(pRExC_state, GPOS);
13612             RExC_seen |= REG_GPOS_SEEN;
13613             goto finish_meta_pat;
13614         case 'K':
13615             if (!RExC_in_lookaround) {
13616                 RExC_seen_zerolen++;
13617                 ret = reg_node(pRExC_state, KEEPS);
13618                 /* XXX:dmq : disabling in-place substitution seems to
13619                  * be necessary here to avoid cases of memory corruption, as
13620                  * with: C<$_="x" x 80; s/x\K/y/> -- rgs
13621                  */
13622                 RExC_seen |= REG_LOOKBEHIND_SEEN;
13623                 goto finish_meta_pat;
13624             }
13625             else {
13626                 ++RExC_parse; /* advance past the 'K' */
13627                 vFAIL("\\K not permitted in lookahead/lookbehind");
13628             }
13629         case 'Z':
13630             if (RExC_pm_flags & PMf_WILDCARD) {
13631                 /* See comment under \A above */
13632                 ret = reg_node(pRExC_state, MEOL);
13633             }
13634             else {
13635                 ret = reg_node(pRExC_state, SEOL);
13636             }
13637             RExC_seen_zerolen++;                /* Do not optimize RE away */
13638             goto finish_meta_pat;
13639         case 'z':
13640             if (RExC_pm_flags & PMf_WILDCARD) {
13641                 /* See comment under \A above */
13642                 ret = reg_node(pRExC_state, MEOL);
13643             }
13644             else {
13645                 ret = reg_node(pRExC_state, EOS);
13646             }
13647             RExC_seen_zerolen++;                /* Do not optimize RE away */
13648             goto finish_meta_pat;
13649         case 'C':
13650             vFAIL("\\C no longer supported");
13651         case 'X':
13652             ret = reg_node(pRExC_state, CLUMP);
13653             *flagp |= HASWIDTH;
13654             goto finish_meta_pat;
13655
13656         case 'B':
13657             invert = 1;
13658             /* FALLTHROUGH */
13659         case 'b':
13660           {
13661             U8 flags = 0;
13662             regex_charset charset = get_regex_charset(RExC_flags);
13663
13664             RExC_seen_zerolen++;
13665             RExC_seen |= REG_LOOKBEHIND_SEEN;
13666             op = BOUND + charset;
13667
13668             if (RExC_parse >= RExC_end || *(RExC_parse + 1) != '{') {
13669                 flags = TRADITIONAL_BOUND;
13670                 if (op > BOUNDA) {  /* /aa is same as /a */
13671                     op = BOUNDA;
13672                 }
13673             }
13674             else {
13675                 STRLEN length;
13676                 char name = *RExC_parse;
13677                 char * endbrace = NULL;
13678                 RExC_parse += 2;
13679                 endbrace = (char *) memchr(RExC_parse, '}', RExC_end - RExC_parse);
13680
13681                 if (! endbrace) {
13682                     vFAIL2("Missing right brace on \\%c{}", name);
13683                 }
13684                 /* XXX Need to decide whether to take spaces or not.  Should be
13685                  * consistent with \p{}, but that currently is SPACE, which
13686                  * means vertical too, which seems wrong
13687                  * while (isBLANK(*RExC_parse)) {
13688                     RExC_parse++;
13689                 }*/
13690                 if (endbrace == RExC_parse) {
13691                     RExC_parse++;  /* After the '}' */
13692                     vFAIL2("Empty \\%c{}", name);
13693                 }
13694                 length = endbrace - RExC_parse;
13695                 /*while (isBLANK(*(RExC_parse + length - 1))) {
13696                     length--;
13697                 }*/
13698                 switch (*RExC_parse) {
13699                     case 'g':
13700                         if (    length != 1
13701                             && (memNEs(RExC_parse + 1, length - 1, "cb")))
13702                         {
13703                             goto bad_bound_type;
13704                         }
13705                         flags = GCB_BOUND;
13706                         break;
13707                     case 'l':
13708                         if (length != 2 || *(RExC_parse + 1) != 'b') {
13709                             goto bad_bound_type;
13710                         }
13711                         flags = LB_BOUND;
13712                         break;
13713                     case 's':
13714                         if (length != 2 || *(RExC_parse + 1) != 'b') {
13715                             goto bad_bound_type;
13716                         }
13717                         flags = SB_BOUND;
13718                         break;
13719                     case 'w':
13720                         if (length != 2 || *(RExC_parse + 1) != 'b') {
13721                             goto bad_bound_type;
13722                         }
13723                         flags = WB_BOUND;
13724                         break;
13725                     default:
13726                       bad_bound_type:
13727                         RExC_parse = endbrace;
13728                         vFAIL2utf8f(
13729                             "'%" UTF8f "' is an unknown bound type",
13730                             UTF8fARG(UTF, length, endbrace - length));
13731                         NOT_REACHED; /*NOTREACHED*/
13732                 }
13733                 RExC_parse = endbrace;
13734                 REQUIRE_UNI_RULES(flagp, 0);
13735
13736                 if (op == BOUND) {
13737                     op = BOUNDU;
13738                 }
13739                 else if (op >= BOUNDA) {  /* /aa is same as /a */
13740                     op = BOUNDU;
13741                     length += 4;
13742
13743                     /* Don't have to worry about UTF-8, in this message because
13744                      * to get here the contents of the \b must be ASCII */
13745                     ckWARN4reg(RExC_parse + 1,  /* Include the '}' in msg */
13746                               "Using /u for '%.*s' instead of /%s",
13747                               (unsigned) length,
13748                               endbrace - length + 1,
13749                               (charset == REGEX_ASCII_RESTRICTED_CHARSET)
13750                               ? ASCII_RESTRICT_PAT_MODS
13751                               : ASCII_MORE_RESTRICT_PAT_MODS);
13752                 }
13753             }
13754
13755             if (op == BOUND) {
13756                 RExC_seen_d_op = TRUE;
13757             }
13758             else if (op == BOUNDL) {
13759                 RExC_contains_locale = 1;
13760             }
13761
13762             if (invert) {
13763                 op += NBOUND - BOUND;
13764             }
13765
13766             ret = reg_node(pRExC_state, op);
13767             FLAGS(REGNODE_p(ret)) = flags;
13768
13769             goto finish_meta_pat;
13770           }
13771
13772         case 'R':
13773             ret = reg_node(pRExC_state, LNBREAK);
13774             *flagp |= HASWIDTH|SIMPLE;
13775             goto finish_meta_pat;
13776
13777         case 'd':
13778         case 'D':
13779         case 'h':
13780         case 'H':
13781         case 'p':
13782         case 'P':
13783         case 's':
13784         case 'S':
13785         case 'v':
13786         case 'V':
13787         case 'w':
13788         case 'W':
13789             /* These all have the same meaning inside [brackets], and it knows
13790              * how to do the best optimizations for them.  So, pretend we found
13791              * these within brackets, and let it do the work */
13792             RExC_parse--;
13793
13794             ret = regclass(pRExC_state, flagp, depth+1,
13795                            TRUE, /* means just parse this element */
13796                            FALSE, /* don't allow multi-char folds */
13797                            FALSE, /* don't silence non-portable warnings.  It
13798                                      would be a bug if these returned
13799                                      non-portables */
13800                            (bool) RExC_strict,
13801                            TRUE, /* Allow an optimized regnode result */
13802                            NULL);
13803             RETURN_FAIL_ON_RESTART_FLAGP(flagp);
13804             /* regclass() can only return RESTART_PARSE and NEED_UTF8 if
13805              * multi-char folds are allowed.  */
13806             if (!ret)
13807                 FAIL2("panic: regclass returned failure to regatom, flags=%#" UVxf,
13808                       (UV) *flagp);
13809
13810             RExC_parse--;   /* regclass() leaves this one too far ahead */
13811
13812           finish_meta_pat:
13813                    /* The escapes above that don't take a parameter can't be
13814                     * followed by a '{'.  But 'pX', 'p{foo}' and
13815                     * correspondingly 'P' can be */
13816             if (   RExC_parse - parse_start == 1
13817                 && UCHARAT(RExC_parse + 1) == '{'
13818                 && UNLIKELY(! new_regcurly(RExC_parse + 1, RExC_end)))
13819             {
13820                 RExC_parse += 2;
13821                 vFAIL("Unescaped left brace in regex is illegal here");
13822             }
13823             Set_Node_Offset(REGNODE_p(ret), parse_start);
13824             Set_Node_Length(REGNODE_p(ret), RExC_parse - parse_start + 1); /* MJD */
13825             nextchar(pRExC_state);
13826             break;
13827         case 'N':
13828             /* Handle \N, \N{} and \N{NAMED SEQUENCE} (the latter meaning the
13829              * \N{...} evaluates to a sequence of more than one code points).
13830              * The function call below returns a regnode, which is our result.
13831              * The parameters cause it to fail if the \N{} evaluates to a
13832              * single code point; we handle those like any other literal.  The
13833              * reason that the multicharacter case is handled here and not as
13834              * part of the EXACtish code is because of quantifiers.  In
13835              * /\N{BLAH}+/, the '+' applies to the whole thing, and doing it
13836              * this way makes that Just Happen. dmq.
13837              * join_exact() will join this up with adjacent EXACTish nodes
13838              * later on, if appropriate. */
13839             ++RExC_parse;
13840             if (grok_bslash_N(pRExC_state,
13841                               &ret,     /* Want a regnode returned */
13842                               NULL,     /* Fail if evaluates to a single code
13843                                            point */
13844                               NULL,     /* Don't need a count of how many code
13845                                            points */
13846                               flagp,
13847                               RExC_strict,
13848                               depth)
13849             ) {
13850                 break;
13851             }
13852
13853             RETURN_FAIL_ON_RESTART_FLAGP(flagp);
13854
13855             /* Here, evaluates to a single code point.  Go get that */
13856             RExC_parse = parse_start;
13857             goto defchar;
13858
13859         case 'k':    /* Handle \k<NAME> and \k'NAME' */
13860       parse_named_seq:
13861         {
13862             char ch;
13863             if (   RExC_parse >= RExC_end - 1
13864                 || ((   ch = RExC_parse[1]) != '<'
13865                                       && ch != '\''
13866                                       && ch != '{'))
13867             {
13868                 RExC_parse++;
13869                 /* diag_listed_as: Sequence \%s... not terminated in regex; marked by <-- HERE in m/%s/ */
13870                 vFAIL2("Sequence %.2s... not terminated", parse_start);
13871             } else {
13872                 RExC_parse += 2;
13873                 ret = handle_named_backref(pRExC_state,
13874                                            flagp,
13875                                            parse_start,
13876                                            (ch == '<')
13877                                            ? '>'
13878                                            : (ch == '{')
13879                                              ? '}'
13880                                              : '\'');
13881             }
13882             break;
13883         }
13884         case 'g':
13885         case '1': case '2': case '3': case '4':
13886         case '5': case '6': case '7': case '8': case '9':
13887             {
13888                 I32 num;
13889                 bool hasbrace = 0;
13890
13891                 if (*RExC_parse == 'g') {
13892                     bool isrel = 0;
13893
13894                     RExC_parse++;
13895                     if (*RExC_parse == '{') {
13896                         RExC_parse++;
13897                         hasbrace = 1;
13898                     }
13899                     if (*RExC_parse == '-') {
13900                         RExC_parse++;
13901                         isrel = 1;
13902                     }
13903                     if (hasbrace && !isDIGIT(*RExC_parse)) {
13904                         if (isrel) RExC_parse--;
13905                         RExC_parse -= 2;
13906                         goto parse_named_seq;
13907                     }
13908
13909                     if (RExC_parse >= RExC_end) {
13910                         goto unterminated_g;
13911                     }
13912                     num = S_backref_value(RExC_parse, RExC_end);
13913                     if (num == 0)
13914                         vFAIL("Reference to invalid group 0");
13915                     else if (num == I32_MAX) {
13916                          if (isDIGIT(*RExC_parse))
13917                             vFAIL("Reference to nonexistent group");
13918                         else
13919                           unterminated_g:
13920                             vFAIL("Unterminated \\g... pattern");
13921                     }
13922
13923                     if (isrel) {
13924                         num = RExC_npar - num;
13925                         if (num < 1)
13926                             vFAIL("Reference to nonexistent or unclosed group");
13927                     }
13928                 }
13929                 else {
13930                     num = S_backref_value(RExC_parse, RExC_end);
13931                     /* bare \NNN might be backref or octal - if it is larger
13932                      * than or equal RExC_npar then it is assumed to be an
13933                      * octal escape. Note RExC_npar is +1 from the actual
13934                      * number of parens. */
13935                     /* Note we do NOT check if num == I32_MAX here, as that is
13936                      * handled by the RExC_npar check */
13937
13938                     if (
13939                         /* any numeric escape < 10 is always a backref */
13940                         num > 9
13941                         /* any numeric escape < RExC_npar is a backref */
13942                         && num >= RExC_npar
13943                         /* cannot be an octal escape if it starts with [89] */
13944                         && ! inRANGE(*RExC_parse, '8', '9')
13945                     ) {
13946                         /* Probably not meant to be a backref, instead likely
13947                          * to be an octal character escape, e.g. \35 or \777.
13948                          * The above logic should make it obvious why using
13949                          * octal escapes in patterns is problematic. - Yves */
13950                         RExC_parse = parse_start;
13951                         goto defchar;
13952                     }
13953                 }
13954
13955                 /* At this point RExC_parse points at a numeric escape like
13956                  * \12 or \88 or something similar, which we should NOT treat
13957                  * as an octal escape. It may or may not be a valid backref
13958                  * escape. For instance \88888888 is unlikely to be a valid
13959                  * backref. */
13960                 while (isDIGIT(*RExC_parse))
13961                     RExC_parse++;
13962                 if (hasbrace) {
13963                     if (*RExC_parse != '}')
13964                         vFAIL("Unterminated \\g{...} pattern");
13965                     RExC_parse++;
13966                 }
13967                 if (num >= (I32)RExC_npar) {
13968
13969                     /* It might be a forward reference; we can't fail until we
13970                      * know, by completing the parse to get all the groups, and
13971                      * then reparsing */
13972                     if (ALL_PARENS_COUNTED)  {
13973                         if (num >= RExC_total_parens)  {
13974                             vFAIL("Reference to nonexistent group");
13975                         }
13976                     }
13977                     else {
13978                         REQUIRE_PARENS_PASS;
13979                     }
13980                 }
13981                 RExC_sawback = 1;
13982                 ret = reganode(pRExC_state,
13983                                ((! FOLD)
13984                                  ? REF
13985                                  : (ASCII_FOLD_RESTRICTED)
13986                                    ? REFFA
13987                                    : (AT_LEAST_UNI_SEMANTICS)
13988                                      ? REFFU
13989                                      : (LOC)
13990                                        ? REFFL
13991                                        : REFF),
13992                                 num);
13993                 if (OP(REGNODE_p(ret)) == REFF) {
13994                     RExC_seen_d_op = TRUE;
13995                 }
13996                 *flagp |= HASWIDTH;
13997
13998                 /* override incorrect value set in reganode MJD */
13999                 Set_Node_Offset(REGNODE_p(ret), parse_start);
14000                 Set_Node_Cur_Length(REGNODE_p(ret), parse_start-1);
14001                 skip_to_be_ignored_text(pRExC_state, &RExC_parse,
14002                                         FALSE /* Don't force to /x */ );
14003             }
14004             break;
14005         case '\0':
14006             if (RExC_parse >= RExC_end)
14007                 FAIL("Trailing \\");
14008             /* FALLTHROUGH */
14009         default:
14010             /* Do not generate "unrecognized" warnings here, we fall
14011                back into the quick-grab loop below */
14012             RExC_parse = parse_start;
14013             goto defchar;
14014         } /* end of switch on a \foo sequence */
14015         break;
14016
14017     case '#':
14018
14019         /* '#' comments should have been spaced over before this function was
14020          * called */
14021         assert((RExC_flags & RXf_PMf_EXTENDED) == 0);
14022         /*
14023         if (RExC_flags & RXf_PMf_EXTENDED) {
14024             RExC_parse = reg_skipcomment( pRExC_state, RExC_parse );
14025             if (RExC_parse < RExC_end)
14026                 goto tryagain;
14027         }
14028         */
14029
14030         /* FALLTHROUGH */
14031
14032     default:
14033           defchar: {
14034
14035             /* Here, we have determined that the next thing is probably a
14036              * literal character.  RExC_parse points to the first byte of its
14037              * definition.  (It still may be an escape sequence that evaluates
14038              * to a single character) */
14039
14040             STRLEN len = 0;
14041             UV ender = 0;
14042             char *p;
14043             char *s, *old_s = NULL, *old_old_s = NULL;
14044             char *s0;
14045             U32 max_string_len = 255;
14046
14047             /* We may have to reparse the node, artificially stopping filling
14048              * it early, based on info gleaned in the first parse.  This
14049              * variable gives where we stop.  Make it above the normal stopping
14050              * place first time through; otherwise it would stop too early */
14051             U32 upper_fill = max_string_len + 1;
14052
14053             /* We start out as an EXACT node, even if under /i, until we find a
14054              * character which is in a fold.  The algorithm now segregates into
14055              * separate nodes, characters that fold from those that don't under
14056              * /i.  (This hopefully will create nodes that are fixed strings
14057              * even under /i, giving the optimizer something to grab on to.)
14058              * So, if a node has something in it and the next character is in
14059              * the opposite category, that node is closed up, and the function
14060              * returns.  Then regatom is called again, and a new node is
14061              * created for the new category. */
14062             U8 node_type = EXACT;
14063
14064             /* Assume the node will be fully used; the excess is given back at
14065              * the end.  Under /i, we may need to temporarily add the fold of
14066              * an extra character or two at the end to check for splitting
14067              * multi-char folds, so allocate extra space for that.   We can't
14068              * make any other length assumptions, as a byte input sequence
14069              * could shrink down. */
14070             Ptrdiff_t current_string_nodes = STR_SZ(max_string_len
14071                                                  + ((! FOLD)
14072                                                     ? 0
14073                                                     : 2 * ((UTF)
14074                                                            ? UTF8_MAXBYTES_CASE
14075                         /* Max non-UTF-8 expansion is 2 */ : 2)));
14076
14077             bool next_is_quantifier;
14078             char * oldp = NULL;
14079
14080             /* We can convert EXACTF nodes to EXACTFU if they contain only
14081              * characters that match identically regardless of the target
14082              * string's UTF8ness.  The reason to do this is that EXACTF is not
14083              * trie-able, EXACTFU is, and EXACTFU requires fewer operations at
14084              * runtime.
14085              *
14086              * Similarly, we can convert EXACTFL nodes to EXACTFLU8 if they
14087              * contain only above-Latin1 characters (hence must be in UTF8),
14088              * which don't participate in folds with Latin1-range characters,
14089              * as the latter's folds aren't known until runtime. */
14090             bool maybe_exactfu = FOLD && (DEPENDS_SEMANTICS || LOC);
14091
14092             /* Single-character EXACTish nodes are almost always SIMPLE.  This
14093              * allows us to override this as encountered */
14094             U8 maybe_SIMPLE = SIMPLE;
14095
14096             /* Does this node contain something that can't match unless the
14097              * target string is (also) in UTF-8 */
14098             bool requires_utf8_target = FALSE;
14099
14100             /* The sequence 'ss' is problematic in non-UTF-8 patterns. */
14101             bool has_ss = FALSE;
14102
14103             /* So is the MICRO SIGN */
14104             bool has_micro_sign = FALSE;
14105
14106             /* Set when we fill up the current node and there is still more
14107              * text to process */
14108             bool overflowed;
14109
14110             /* Allocate an EXACT node.  The node_type may change below to
14111              * another EXACTish node, but since the size of the node doesn't
14112              * change, it works */
14113             ret = regnode_guts(pRExC_state, node_type, current_string_nodes,
14114                                                                     "exact");
14115             FILL_NODE(ret, node_type);
14116             RExC_emit++;
14117
14118             s = STRING(REGNODE_p(ret));
14119
14120             s0 = s;
14121
14122           reparse:
14123
14124             p = RExC_parse;
14125             len = 0;
14126             s = s0;
14127             node_type = EXACT;
14128             oldp = NULL;
14129             maybe_exactfu = FOLD && (DEPENDS_SEMANTICS || LOC);
14130             maybe_SIMPLE = SIMPLE;
14131             requires_utf8_target = FALSE;
14132             has_ss = FALSE;
14133             has_micro_sign = FALSE;
14134
14135           continue_parse:
14136
14137             /* This breaks under rare circumstances.  If folding, we do not
14138              * want to split a node at a character that is a non-final in a
14139              * multi-char fold, as an input string could just happen to want to
14140              * match across the node boundary.  The code at the end of the loop
14141              * looks for this, and backs off until it finds not such a
14142              * character, but it is possible (though extremely, extremely
14143              * unlikely) for all characters in the node to be non-final fold
14144              * ones, in which case we just leave the node fully filled, and
14145              * hope that it doesn't match the string in just the wrong place */
14146
14147             assert( ! UTF     /* Is at the beginning of a character */
14148                    || UTF8_IS_INVARIANT(UCHARAT(RExC_parse))
14149                    || UTF8_IS_START(UCHARAT(RExC_parse)));
14150
14151             overflowed = FALSE;
14152
14153             /* Here, we have a literal character.  Find the maximal string of
14154              * them in the input that we can fit into a single EXACTish node.
14155              * We quit at the first non-literal or when the node gets full, or
14156              * under /i the categorization of folding/non-folding character
14157              * changes */
14158             while (p < RExC_end && len < upper_fill) {
14159
14160                 /* In most cases each iteration adds one byte to the output.
14161                  * The exceptions override this */
14162                 Size_t added_len = 1;
14163
14164                 oldp = p;
14165                 old_old_s = old_s;
14166                 old_s = s;
14167
14168                 /* White space has already been ignored */
14169                 assert(   (RExC_flags & RXf_PMf_EXTENDED) == 0
14170                        || ! is_PATWS_safe((p), RExC_end, UTF));
14171
14172                 switch ((U8)*p) {
14173                   const char* message;
14174                   U32 packed_warn;
14175                   U8 grok_c_char;
14176
14177                 case '^':
14178                 case '$':
14179                 case '.':
14180                 case '[':
14181                 case '(':
14182                 case ')':
14183                 case '|':
14184                     goto loopdone;
14185                 case '\\':
14186                     /* Literal Escapes Switch
14187
14188                        This switch is meant to handle escape sequences that
14189                        resolve to a literal character.
14190
14191                        Every escape sequence that represents something
14192                        else, like an assertion or a char class, is handled
14193                        in the switch marked 'Special Escapes' above in this
14194                        routine, but also has an entry here as anything that
14195                        isn't explicitly mentioned here will be treated as
14196                        an unescaped equivalent literal.
14197                     */
14198
14199                     switch ((U8)*++p) {
14200
14201                     /* These are all the special escapes. */
14202                     case 'A':             /* Start assertion */
14203                     case 'b': case 'B':   /* Word-boundary assertion*/
14204                     case 'C':             /* Single char !DANGEROUS! */
14205                     case 'd': case 'D':   /* digit class */
14206                     case 'g': case 'G':   /* generic-backref, pos assertion */
14207                     case 'h': case 'H':   /* HORIZWS */
14208                     case 'k': case 'K':   /* named backref, keep marker */
14209                     case 'p': case 'P':   /* Unicode property */
14210                               case 'R':   /* LNBREAK */
14211                     case 's': case 'S':   /* space class */
14212                     case 'v': case 'V':   /* VERTWS */
14213                     case 'w': case 'W':   /* word class */
14214                     case 'X':             /* eXtended Unicode "combining
14215                                              character sequence" */
14216                     case 'z': case 'Z':   /* End of line/string assertion */
14217                         --p;
14218                         goto loopdone;
14219
14220                     /* Anything after here is an escape that resolves to a
14221                        literal. (Except digits, which may or may not)
14222                      */
14223                     case 'n':
14224                         ender = '\n';
14225                         p++;
14226                         break;
14227                     case 'N': /* Handle a single-code point named character. */
14228                         RExC_parse = p + 1;
14229                         if (! grok_bslash_N(pRExC_state,
14230                                             NULL,   /* Fail if evaluates to
14231                                                        anything other than a
14232                                                        single code point */
14233                                             &ender, /* The returned single code
14234                                                        point */
14235                                             NULL,   /* Don't need a count of
14236                                                        how many code points */
14237                                             flagp,
14238                                             RExC_strict,
14239                                             depth)
14240                         ) {
14241                             if (*flagp & NEED_UTF8)
14242                                 FAIL("panic: grok_bslash_N set NEED_UTF8");
14243                             RETURN_FAIL_ON_RESTART_FLAGP(flagp);
14244
14245                             /* Here, it wasn't a single code point.  Go close
14246                              * up this EXACTish node.  The switch() prior to
14247                              * this switch handles the other cases */
14248                             RExC_parse = p = oldp;
14249                             goto loopdone;
14250                         }
14251                         p = RExC_parse;
14252                         RExC_parse = parse_start;
14253
14254                         /* The \N{} means the pattern, if previously /d,
14255                          * becomes /u.  That means it can't be an EXACTF node,
14256                          * but an EXACTFU */
14257                         if (node_type == EXACTF) {
14258                             node_type = EXACTFU;
14259
14260                             /* If the node already contains something that
14261                              * differs between EXACTF and EXACTFU, reparse it
14262                              * as EXACTFU */
14263                             if (! maybe_exactfu) {
14264                                 len = 0;
14265                                 s = s0;
14266                                 goto reparse;
14267                             }
14268                         }
14269
14270                         break;
14271                     case 'r':
14272                         ender = '\r';
14273                         p++;
14274                         break;
14275                     case 't':
14276                         ender = '\t';
14277                         p++;
14278                         break;
14279                     case 'f':
14280                         ender = '\f';
14281                         p++;
14282                         break;
14283                     case 'e':
14284                         ender = ESC_NATIVE;
14285                         p++;
14286                         break;
14287                     case 'a':
14288                         ender = '\a';
14289                         p++;
14290                         break;
14291                     case 'o':
14292                         if (! grok_bslash_o(&p,
14293                                             RExC_end,
14294                                             &ender,
14295                                             &message,
14296                                             &packed_warn,
14297                                             (bool) RExC_strict,
14298                                             FALSE, /* No illegal cp's */
14299                                             UTF))
14300                         {
14301                             RExC_parse = p; /* going to die anyway; point to
14302                                                exact spot of failure */
14303                             vFAIL(message);
14304                         }
14305
14306                         if (message && TO_OUTPUT_WARNINGS(p)) {
14307                             warn_non_literal_string(p, packed_warn, message);
14308                         }
14309                         break;
14310                     case 'x':
14311                         if (! grok_bslash_x(&p,
14312                                             RExC_end,
14313                                             &ender,
14314                                             &message,
14315                                             &packed_warn,
14316                                             (bool) RExC_strict,
14317                                             FALSE, /* No illegal cp's */
14318                                             UTF))
14319                         {
14320                             RExC_parse = p;     /* going to die anyway; point
14321                                                    to exact spot of failure */
14322                             vFAIL(message);
14323                         }
14324
14325                         if (message && TO_OUTPUT_WARNINGS(p)) {
14326                             warn_non_literal_string(p, packed_warn, message);
14327                         }
14328
14329 #ifdef EBCDIC
14330                         if (ender < 0x100) {
14331                             if (RExC_recode_x_to_native) {
14332                                 ender = LATIN1_TO_NATIVE(ender);
14333                             }
14334                         }
14335 #endif
14336                         break;
14337                     case 'c':
14338                         p++;
14339                         if (! grok_bslash_c(*p, &grok_c_char,
14340                                             &message, &packed_warn))
14341                         {
14342                             /* going to die anyway; point to exact spot of
14343                              * failure */
14344                             RExC_parse = p + ((UTF)
14345                                               ? UTF8_SAFE_SKIP(p, RExC_end)
14346                                               : 1);
14347                             vFAIL(message);
14348                         }
14349
14350                         ender = grok_c_char;
14351                         p++;
14352                         if (message && TO_OUTPUT_WARNINGS(p)) {
14353                             warn_non_literal_string(p, packed_warn, message);
14354                         }
14355
14356                         break;
14357                     case '8': case '9': /* must be a backreference */
14358                         --p;
14359                         /* we have an escape like \8 which cannot be an octal escape
14360                          * so we exit the loop, and let the outer loop handle this
14361                          * escape which may or may not be a legitimate backref. */
14362                         goto loopdone;
14363                     case '1': case '2': case '3':case '4':
14364                     case '5': case '6': case '7':
14365                         /* When we parse backslash escapes there is ambiguity
14366                          * between backreferences and octal escapes. Any escape
14367                          * from \1 - \9 is a backreference, any multi-digit
14368                          * escape which does not start with 0 and which when
14369                          * evaluated as decimal could refer to an already
14370                          * parsed capture buffer is a back reference. Anything
14371                          * else is octal.
14372                          *
14373                          * Note this implies that \118 could be interpreted as
14374                          * 118 OR as "\11" . "8" depending on whether there
14375                          * were 118 capture buffers defined already in the
14376                          * pattern.  */
14377
14378                         /* NOTE, RExC_npar is 1 more than the actual number of
14379                          * parens we have seen so far, hence the "<" as opposed
14380                          * to "<=" */
14381                         if ( !isDIGIT(p[1]) || S_backref_value(p, RExC_end) < RExC_npar)
14382                         {  /* Not to be treated as an octal constant, go
14383                                    find backref */
14384                             --p;
14385                             goto loopdone;
14386                         }
14387                         /* FALLTHROUGH */
14388                     case '0':
14389                         {
14390                             I32 flags = PERL_SCAN_SILENT_ILLDIGIT
14391                                       | PERL_SCAN_NOTIFY_ILLDIGIT;
14392                             STRLEN numlen = 3;
14393                             ender = grok_oct(p, &numlen, &flags, NULL);
14394                             p += numlen;
14395                             if (  (flags & PERL_SCAN_NOTIFY_ILLDIGIT)
14396                                 && isDIGIT(*p)  /* like \08, \178 */
14397                                 && ckWARN(WARN_REGEXP))
14398                             {
14399                                 reg_warn_non_literal_string(
14400                                      p + 1,
14401                                      form_alien_digit_msg(8, numlen, p,
14402                                                         RExC_end, UTF, FALSE));
14403                             }
14404                         }
14405                         break;
14406                     case '\0':
14407                         if (p >= RExC_end)
14408                             FAIL("Trailing \\");
14409                         /* FALLTHROUGH */
14410                     default:
14411                         if (isALPHANUMERIC(*p)) {
14412                             /* An alpha followed by '{' is going to fail next
14413                              * iteration, so don't output this warning in that
14414                              * case */
14415                             if (! isALPHA(*p) || *(p + 1) != '{') {
14416                                 ckWARN2reg(p + 1, "Unrecognized escape \\%.1s"
14417                                                   " passed through", p);
14418                             }
14419                         }
14420                         goto normal_default;
14421                     } /* End of switch on '\' */
14422                     break;
14423                 case '{':
14424                     /* Trying to gain new uses for '{' without breaking too
14425                      * much existing code is hard.  The solution currently
14426                      * adopted is:
14427                      *  1)  If there is no ambiguity that a '{' should always
14428                      *      be taken literally, at the start of a construct, we
14429                      *      just do so.
14430                      *  2)  If the literal '{' conflicts with our desired use
14431                      *      of it as a metacharacter, we die.  The deprecation
14432                      *      cycles for this have come and gone.
14433                      *  3)  If there is ambiguity, we raise a simple warning.
14434                      *      This could happen, for example, if the user
14435                      *      intended it to introduce a quantifier, but slightly
14436                      *      misspelled the quantifier.  Without this warning,
14437                      *      the quantifier would silently be taken as a literal
14438                      *      string of characters instead of a meta construct */
14439                     if (len || (p > RExC_start && isALPHA_A(*(p - 1)))) {
14440                         if (      RExC_strict
14441                             || (  p > parse_start + 1
14442                                 && isALPHA_A(*(p - 1))
14443                                 && *(p - 2) == '\\')
14444                             || new_regcurly(p, RExC_end))
14445                         {
14446                             RExC_parse = p + 1;
14447                             vFAIL("Unescaped left brace in regex is "
14448                                   "illegal here");
14449                         }
14450                         ckWARNreg(p + 1, "Unescaped left brace in regex is"
14451                                          " passed through");
14452                     }
14453                     goto normal_default;
14454                 case '}':
14455                 case ']':
14456                     if (p > RExC_parse && RExC_strict) {
14457                         ckWARN2reg(p + 1, "Unescaped literal '%c'", *p);
14458                     }
14459                     /*FALLTHROUGH*/
14460                 default:    /* A literal character */
14461                   normal_default:
14462                     if (! UTF8_IS_INVARIANT(*p) && UTF) {
14463                         STRLEN numlen;
14464                         ender = utf8n_to_uvchr((U8*)p, RExC_end - p,
14465                                                &numlen, UTF8_ALLOW_DEFAULT);
14466                         p += numlen;
14467                     }
14468                     else
14469                         ender = (U8) *p++;
14470                     break;
14471                 } /* End of switch on the literal */
14472
14473                 /* Here, have looked at the literal character, and <ender>
14474                  * contains its ordinal; <p> points to the character after it.
14475                  * */
14476
14477                 if (ender > 255) {
14478                     REQUIRE_UTF8(flagp);
14479                     if (   UNICODE_IS_PERL_EXTENDED(ender)
14480                         && TO_OUTPUT_WARNINGS(p))
14481                     {
14482                         ckWARN2_non_literal_string(p,
14483                                                    packWARN(WARN_PORTABLE),
14484                                                    PL_extended_cp_format,
14485                                                    ender);
14486                     }
14487                 }
14488
14489                 /* We need to check if the next non-ignored thing is a
14490                  * quantifier.  Move <p> to after anything that should be
14491                  * ignored, which, as a side effect, positions <p> for the next
14492                  * loop iteration */
14493                 skip_to_be_ignored_text(pRExC_state, &p,
14494                                         FALSE /* Don't force to /x */ );
14495
14496                 /* If the next thing is a quantifier, it applies to this
14497                  * character only, which means that this character has to be in
14498                  * its own node and can't just be appended to the string in an
14499                  * existing node, so if there are already other characters in
14500                  * the node, close the node with just them, and set up to do
14501                  * this character again next time through, when it will be the
14502                  * only thing in its new node */
14503
14504                 next_is_quantifier =    LIKELY(p < RExC_end)
14505                                      && UNLIKELY(ISMULT2(p));
14506
14507                 if (next_is_quantifier && LIKELY(len)) {
14508                     p = oldp;
14509                     goto loopdone;
14510                 }
14511
14512                 /* Ready to add 'ender' to the node */
14513
14514                 if (! FOLD) {  /* The simple case, just append the literal */
14515                   not_fold_common:
14516
14517                     /* Don't output if it would overflow */
14518                     if (UNLIKELY(len > max_string_len - ((UTF)
14519                                                       ? UVCHR_SKIP(ender)
14520                                                       : 1)))
14521                     {
14522                         overflowed = TRUE;
14523                         break;
14524                     }
14525
14526                     if (UVCHR_IS_INVARIANT(ender) || ! UTF) {
14527                         *(s++) = (char) ender;
14528                     }
14529                     else {
14530                         U8 * new_s = uvchr_to_utf8((U8*)s, ender);
14531                         added_len = (char *) new_s - s;
14532                         s = (char *) new_s;
14533
14534                         if (ender > 255)  {
14535                             requires_utf8_target = TRUE;
14536                         }
14537                     }
14538                 }
14539                 else if (LOC && is_PROBLEMATIC_LOCALE_FOLD_cp(ender)) {
14540
14541                     /* Here are folding under /l, and the code point is
14542                      * problematic.  If this is the first character in the
14543                      * node, change the node type to folding.   Otherwise, if
14544                      * this is the first problematic character, close up the
14545                      * existing node, so can start a new node with this one */
14546                     if (! len) {
14547                         node_type = EXACTFL;
14548                         RExC_contains_locale = 1;
14549                     }
14550                     else if (node_type == EXACT) {
14551                         p = oldp;
14552                         goto loopdone;
14553                     }
14554
14555                     /* This problematic code point means we can't simplify
14556                      * things */
14557                     maybe_exactfu = FALSE;
14558
14559                     /* Although these two characters have folds that are
14560                      * locale-problematic, they also have folds to above Latin1
14561                      * that aren't a problem.  Doing these now helps at
14562                      * runtime. */
14563                     if (UNLIKELY(   ender == GREEK_CAPITAL_LETTER_MU
14564                                  || ender == LATIN_CAPITAL_LETTER_SHARP_S))
14565                     {
14566                         goto fold_anyway;
14567                     }
14568
14569                     /* Here, we are adding a problematic fold character.
14570                      * "Problematic" in this context means that its fold isn't
14571                      * known until runtime.  (The non-problematic code points
14572                      * are the above-Latin1 ones that fold to also all
14573                      * above-Latin1.  Their folds don't vary no matter what the
14574                      * locale is.) But here we have characters whose fold
14575                      * depends on the locale.  We just add in the unfolded
14576                      * character, and wait until runtime to fold it */
14577                     goto not_fold_common;
14578                 }
14579                 else /* regular fold; see if actually is in a fold */
14580                      if (   (ender < 256 && ! IS_IN_SOME_FOLD_L1(ender))
14581                          || (ender > 255
14582                             && ! _invlist_contains_cp(PL_in_some_fold, ender)))
14583                 {
14584                     /* Here, folding, but the character isn't in a fold.
14585                      *
14586                      * Start a new node if previous characters in the node were
14587                      * folded */
14588                     if (len && node_type != EXACT) {
14589                         p = oldp;
14590                         goto loopdone;
14591                     }
14592
14593                     /* Here, continuing a node with non-folded characters.  Add
14594                      * this one */
14595                     goto not_fold_common;
14596                 }
14597                 else {  /* Here, does participate in some fold */
14598
14599                     /* If this is the first character in the node, change its
14600                      * type to folding.  Otherwise, if this is the first
14601                      * folding character in the node, close up the existing
14602                      * node, so can start a new node with this one.  */
14603                     if (! len) {
14604                         node_type = compute_EXACTish(pRExC_state);
14605                     }
14606                     else if (node_type == EXACT) {
14607                         p = oldp;
14608                         goto loopdone;
14609                     }
14610
14611                     if (UTF) {  /* Alway use the folded value for UTF-8
14612                                    patterns */
14613                         if (UVCHR_IS_INVARIANT(ender)) {
14614                             if (UNLIKELY(len + 1 > max_string_len)) {
14615                                 overflowed = TRUE;
14616                                 break;
14617                             }
14618
14619                             *(s)++ = (U8) toFOLD(ender);
14620                         }
14621                         else {
14622                             UV folded;
14623
14624                           fold_anyway:
14625                             folded = _to_uni_fold_flags(
14626                                     ender,
14627                                     (U8 *) s,  /* We have allocated extra space
14628                                                   in 's' so can't run off the
14629                                                   end */
14630                                     &added_len,
14631                                     FOLD_FLAGS_FULL
14632                                   | ((   ASCII_FOLD_RESTRICTED
14633                                       || node_type == EXACTFL)
14634                                     ? FOLD_FLAGS_NOMIX_ASCII
14635                                     : 0));
14636                             if (UNLIKELY(len + added_len > max_string_len)) {
14637                                 overflowed = TRUE;
14638                                 break;
14639                             }
14640
14641                             s += added_len;
14642
14643                             if (   folded > 255
14644                                 && LIKELY(folded != GREEK_SMALL_LETTER_MU))
14645                             {
14646                                 /* U+B5 folds to the MU, so its possible for a
14647                                  * non-UTF-8 target to match it */
14648                                 requires_utf8_target = TRUE;
14649                             }
14650                         }
14651                     }
14652                     else { /* Here is non-UTF8. */
14653
14654                         /* The fold will be one or (rarely) two characters.
14655                          * Check that there's room for at least a single one
14656                          * before setting any flags, etc.  Because otherwise an
14657                          * overflowing character could cause a flag to be set
14658                          * even though it doesn't end up in this node.  (For
14659                          * the two character fold, we check again, before
14660                          * setting any flags) */
14661                         if (UNLIKELY(len + 1 > max_string_len)) {
14662                             overflowed = TRUE;
14663                             break;
14664                         }
14665
14666 #if    UNICODE_MAJOR_VERSION > 3 /* no multifolds in early Unicode */   \
14667    || (UNICODE_MAJOR_VERSION == 3 && (   UNICODE_DOT_VERSION > 0)       \
14668                                       || UNICODE_DOT_DOT_VERSION > 0)
14669
14670                         /* On non-ancient Unicodes, check for the only possible
14671                          * multi-char fold  */
14672                         if (UNLIKELY(ender == LATIN_SMALL_LETTER_SHARP_S)) {
14673
14674                             /* This potential multi-char fold means the node
14675                              * can't be simple (because it could match more
14676                              * than a single char).  And in some cases it will
14677                              * match 'ss', so set that flag */
14678                             maybe_SIMPLE = 0;
14679                             has_ss = TRUE;
14680
14681                             /* It can't change to be an EXACTFU (unless already
14682                              * is one).  We fold it iff under /u rules. */
14683                             if (node_type != EXACTFU) {
14684                                 maybe_exactfu = FALSE;
14685                             }
14686                             else {
14687                                 if (UNLIKELY(len + 2 > max_string_len)) {
14688                                     overflowed = TRUE;
14689                                     break;
14690                                 }
14691
14692                                 *(s++) = 's';
14693                                 *(s++) = 's';
14694                                 added_len = 2;
14695
14696                                 goto done_with_this_char;
14697                             }
14698                         }
14699                         else if (   UNLIKELY(isALPHA_FOLD_EQ(ender, 's'))
14700                                  && LIKELY(len > 0)
14701                                  && UNLIKELY(isALPHA_FOLD_EQ(*(s-1), 's')))
14702                         {
14703                             /* Also, the sequence 'ss' is special when not
14704                              * under /u.  If the target string is UTF-8, it
14705                              * should match SHARP S; otherwise it won't.  So,
14706                              * here we have to exclude the possibility of this
14707                              * node moving to /u.*/
14708                             has_ss = TRUE;
14709                             maybe_exactfu = FALSE;
14710                         }
14711 #endif
14712                         /* Here, the fold will be a single character */
14713
14714                         if (UNLIKELY(ender == MICRO_SIGN)) {
14715                             has_micro_sign = TRUE;
14716                         }
14717                         else if (PL_fold[ender] != PL_fold_latin1[ender]) {
14718
14719                             /* If the character's fold differs between /d and
14720                              * /u, this can't change to be an EXACTFU node */
14721                             maybe_exactfu = FALSE;
14722                         }
14723
14724                         *(s++) = (DEPENDS_SEMANTICS)
14725                                  ? (char) toFOLD(ender)
14726
14727                                    /* Under /u, the fold of any character in
14728                                     * the 0-255 range happens to be its
14729                                     * lowercase equivalent, except for LATIN
14730                                     * SMALL LETTER SHARP S, which was handled
14731                                     * above, and the MICRO SIGN, whose fold
14732                                     * requires UTF-8 to represent.  */
14733                                  : (char) toLOWER_L1(ender);
14734                     }
14735                 } /* End of adding current character to the node */
14736
14737               done_with_this_char:
14738
14739                 len += added_len;
14740
14741                 if (next_is_quantifier) {
14742
14743                     /* Here, the next input is a quantifier, and to get here,
14744                      * the current character is the only one in the node. */
14745                     goto loopdone;
14746                 }
14747
14748             } /* End of loop through literal characters */
14749
14750             /* Here we have either exhausted the input or run out of room in
14751              * the node.  If the former, we are done.  (If we encountered a
14752              * character that can't be in the node, transfer is made directly
14753              * to <loopdone>, and so we wouldn't have fallen off the end of the
14754              * loop.)  */
14755             if (LIKELY(! overflowed)) {
14756                 goto loopdone;
14757             }
14758
14759             /* Here we have run out of room.  We can grow plain EXACT and
14760              * LEXACT nodes.  If the pattern is gigantic enough, though,
14761              * eventually we'll have to artificially chunk the pattern into
14762              * multiple nodes. */
14763             if (! LOC && (node_type == EXACT || node_type == LEXACT)) {
14764                 Size_t overhead = 1 + regarglen[OP(REGNODE_p(ret))];
14765                 Size_t overhead_expansion = 0;
14766                 char temp[256];
14767                 Size_t max_nodes_for_string;
14768                 Size_t achievable;
14769                 SSize_t delta;
14770
14771                 /* Here we couldn't fit the final character in the current
14772                  * node, so it will have to be reparsed, no matter what else we
14773                  * do */
14774                 p = oldp;
14775
14776                 /* If would have overflowed a regular EXACT node, switch
14777                  * instead to an LEXACT.  The code below is structured so that
14778                  * the actual growing code is common to changing from an EXACT
14779                  * or just increasing the LEXACT size.  This means that we have
14780                  * to save the string in the EXACT case before growing, and
14781                  * then copy it afterwards to its new location */
14782                 if (node_type == EXACT) {
14783                     overhead_expansion = regarglen[LEXACT] - regarglen[EXACT];
14784                     RExC_emit += overhead_expansion;
14785                     Copy(s0, temp, len, char);
14786                 }
14787
14788                 /* Ready to grow.  If it was a plain EXACT, the string was
14789                  * saved, and the first few bytes of it overwritten by adding
14790                  * an argument field.  We assume, as we do elsewhere in this
14791                  * file, that one byte of remaining input will translate into
14792                  * one byte of output, and if that's too small, we grow again,
14793                  * if too large the excess memory is freed at the end */
14794
14795                 max_nodes_for_string = U16_MAX - overhead - overhead_expansion;
14796                 achievable = MIN(max_nodes_for_string,
14797                                  current_string_nodes + STR_SZ(RExC_end - p));
14798                 delta = achievable - current_string_nodes;
14799
14800                 /* If there is just no more room, go finish up this chunk of
14801                  * the pattern. */
14802                 if (delta <= 0) {
14803                     goto loopdone;
14804                 }
14805
14806                 change_engine_size(pRExC_state, delta + overhead_expansion);
14807                 current_string_nodes += delta;
14808                 max_string_len
14809                            = sizeof(struct regnode) * current_string_nodes;
14810                 upper_fill = max_string_len + 1;
14811
14812                 /* If the length was small, we know this was originally an
14813                  * EXACT node now converted to LEXACT, and the string has to be
14814                  * restored.  Otherwise the string was untouched.  260 is just
14815                  * a number safely above 255 so don't have to worry about
14816                  * getting it precise */
14817                 if (len < 260) {
14818                     node_type = LEXACT;
14819                     FILL_NODE(ret, node_type);
14820                     s0 = STRING(REGNODE_p(ret));
14821                     Copy(temp, s0, len, char);
14822                     s = s0 + len;
14823                 }
14824
14825                 goto continue_parse;
14826             }
14827             else if (FOLD) {
14828                 bool splittable = FALSE;
14829                 bool backed_up = FALSE;
14830                 char * e;       /* should this be U8? */
14831                 char * s_start; /* should this be U8? */
14832
14833                 /* Here is /i.  Running out of room creates a problem if we are
14834                  * folding, and the split happens in the middle of a
14835                  * multi-character fold, as a match that should have occurred,
14836                  * won't, due to the way nodes are matched, and our artificial
14837                  * boundary.  So back off until we aren't splitting such a
14838                  * fold.  If there is no such place to back off to, we end up
14839                  * taking the entire node as-is.  This can happen if the node
14840                  * consists entirely of 'f' or entirely of 's' characters (or
14841                  * things that fold to them) as 'ff' and 'ss' are
14842                  * multi-character folds.
14843                  *
14844                  * The Unicode standard says that multi character folds consist
14845                  * of either two or three characters.  That means we would be
14846                  * splitting one if the final character in the node is at the
14847                  * beginning of either type, or is the second of a three
14848                  * character fold.
14849                  *
14850                  * At this point:
14851                  *  ender     is the code point of the character that won't fit
14852                  *            in the node
14853                  *  s         points to just beyond the final byte in the node.
14854                  *            It's where we would place ender if there were
14855                  *            room, and where in fact we do place ender's fold
14856                  *            in the code below, as we've over-allocated space
14857                  *            for s0 (hence s) to allow for this
14858                  *  e         starts at 's' and advances as we append things.
14859                  *  old_s     is the same as 's'.  (If ender had fit, 's' would
14860                  *            have been advanced to beyond it).
14861                  *  old_old_s points to the beginning byte of the final
14862                  *            character in the node
14863                  *  p         points to the beginning byte in the input of the
14864                  *            character beyond 'ender'.
14865                  *  oldp      points to the beginning byte in the input of
14866                  *            'ender'.
14867                  *
14868                  * In the case of /il, we haven't folded anything that could be
14869                  * affected by the locale.  That means only above-Latin1
14870                  * characters that fold to other above-latin1 characters get
14871                  * folded at compile time.  To check where a good place to
14872                  * split nodes is, everything in it will have to be folded.
14873                  * The boolean 'maybe_exactfu' keeps track in /il if there are
14874                  * any unfolded characters in the node. */
14875                 bool need_to_fold_loc = LOC && ! maybe_exactfu;
14876
14877                 /* If we do need to fold the node, we need a place to store the
14878                  * folded copy, and a way to map back to the unfolded original
14879                  * */
14880                 char * locfold_buf = NULL;
14881                 Size_t * loc_correspondence = NULL;
14882
14883                 if (! need_to_fold_loc) {   /* The normal case.  Just
14884                                                initialize to the actual node */
14885                     e = s;
14886                     s_start = s0;
14887                     s = old_old_s;  /* Point to the beginning of the final char
14888                                        that fits in the node */
14889                 }
14890                 else {
14891
14892                     /* Here, we have filled a /il node, and there are unfolded
14893                      * characters in it.  If the runtime locale turns out to be
14894                      * UTF-8, there are possible multi-character folds, just
14895                      * like when not under /l.  The node hence can't terminate
14896                      * in the middle of such a fold.  To determine this, we
14897                      * have to create a folded copy of this node.  That means
14898                      * reparsing the node, folding everything assuming a UTF-8
14899                      * locale.  (If at runtime it isn't such a locale, the
14900                      * actions here wouldn't have been necessary, but we have
14901                      * to assume the worst case.)  If we find we need to back
14902                      * off the folded string, we do so, and then map that
14903                      * position back to the original unfolded node, which then
14904                      * gets output, truncated at that spot */
14905
14906                     char * redo_p = RExC_parse;
14907                     char * redo_e;
14908                     char * old_redo_e;
14909
14910                     /* Allow enough space assuming a single byte input folds to
14911                      * a single byte output, plus assume that the two unparsed
14912                      * characters (that we may need) fold to the largest number
14913                      * of bytes possible, plus extra for one more worst case
14914                      * scenario.  In the loop below, if we start eating into
14915                      * that final spare space, we enlarge this initial space */
14916                     Size_t size = max_string_len + (3 * UTF8_MAXBYTES_CASE) + 1;
14917
14918                     Newxz(locfold_buf, size, char);
14919                     Newxz(loc_correspondence, size, Size_t);
14920
14921                     /* Redo this node's parse, folding into 'locfold_buf' */
14922                     redo_p = RExC_parse;
14923                     old_redo_e = redo_e = locfold_buf;
14924                     while (redo_p <= oldp) {
14925
14926                         old_redo_e = redo_e;
14927                         loc_correspondence[redo_e - locfold_buf]
14928                                                         = redo_p - RExC_parse;
14929
14930                         if (UTF) {
14931                             Size_t added_len;
14932
14933                             (void) _to_utf8_fold_flags((U8 *) redo_p,
14934                                                        (U8 *) RExC_end,
14935                                                        (U8 *) redo_e,
14936                                                        &added_len,
14937                                                        FOLD_FLAGS_FULL);
14938                             redo_e += added_len;
14939                             redo_p += UTF8SKIP(redo_p);
14940                         }
14941                         else {
14942
14943                             /* Note that if this code is run on some ancient
14944                              * Unicode versions, SHARP S doesn't fold to 'ss',
14945                              * but rather than clutter the code with #ifdef's,
14946                              * as is done above, we ignore that possibility.
14947                              * This is ok because this code doesn't affect what
14948                              * gets matched, but merely where the node gets
14949                              * split */
14950                             if (UCHARAT(redo_p) != LATIN_SMALL_LETTER_SHARP_S) {
14951                                 *redo_e++ = toLOWER_L1(UCHARAT(redo_p));
14952                             }
14953                             else {
14954                                 *redo_e++ = 's';
14955                                 *redo_e++ = 's';
14956                             }
14957                             redo_p++;
14958                         }
14959
14960
14961                         /* If we're getting so close to the end that a
14962                          * worst-case fold in the next character would cause us
14963                          * to overflow, increase, assuming one byte output byte
14964                          * per one byte input one, plus room for another worst
14965                          * case fold */
14966                         if (   redo_p <= oldp
14967                             && redo_e > locfold_buf + size
14968                                                     - (UTF8_MAXBYTES_CASE + 1))
14969                         {
14970                             Size_t new_size = size
14971                                             + (oldp - redo_p)
14972                                             + UTF8_MAXBYTES_CASE + 1;
14973                             Ptrdiff_t e_offset = redo_e - locfold_buf;
14974
14975                             Renew(locfold_buf, new_size, char);
14976                             Renew(loc_correspondence, new_size, Size_t);
14977                             size = new_size;
14978
14979                             redo_e = locfold_buf + e_offset;
14980                         }
14981                     }
14982
14983                     /* Set so that things are in terms of the folded, temporary
14984                      * string */
14985                     s = old_redo_e;
14986                     s_start = locfold_buf;
14987                     e = redo_e;
14988
14989                 }
14990
14991                 /* Here, we have 's', 's_start' and 'e' set up to point to the
14992                  * input that goes into the node, folded.
14993                  *
14994                  * If the final character of the node and the fold of ender
14995                  * form the first two characters of a three character fold, we
14996                  * need to peek ahead at the next (unparsed) character in the
14997                  * input to determine if the three actually do form such a
14998                  * fold.  Just looking at that character is not generally
14999                  * sufficient, as it could be, for example, an escape sequence
15000                  * that evaluates to something else, and it needs to be folded.
15001                  *
15002                  * khw originally thought to just go through the parse loop one
15003                  * extra time, but that doesn't work easily as that iteration
15004                  * could cause things to think that the parse is over and to
15005                  * goto loopdone.  The character could be a '$' for example, or
15006                  * the character beyond could be a quantifier, and other
15007                  * glitches as well.
15008                  *
15009                  * The solution used here for peeking ahead is to look at that
15010                  * next character.  If it isn't ASCII punctuation, then it will
15011                  * be something that would continue on in an EXACTish node if
15012                  * there were space.  We append the fold of it to s, having
15013                  * reserved enough room in s0 for the purpose.  If we can't
15014                  * reasonably peek ahead, we instead assume the worst case:
15015                  * that it is something that would form the completion of a
15016                  * multi-char fold.
15017                  *
15018                  * If we can't split between s and ender, we work backwards
15019                  * character-by-character down to s0.  At each current point
15020                  * see if we are at the beginning of a multi-char fold.  If so,
15021                  * that means we would be splitting the fold across nodes, and
15022                  * so we back up one and try again.
15023                  *
15024                  * If we're not at the beginning, we still could be at the
15025                  * final two characters of a (rare) three character fold.  We
15026                  * check if the sequence starting at the character before the
15027                  * current position (and including the current and next
15028                  * characters) is a three character fold.  If not, the node can
15029                  * be split here.  If it is, we have to backup two characters
15030                  * and try again.
15031                  *
15032                  * Otherwise, the node can be split at the current position.
15033                  *
15034                  * The same logic is used for UTF-8 patterns and not */
15035                 if (UTF) {
15036                     Size_t added_len;
15037
15038                     /* Append the fold of ender */
15039                     (void) _to_uni_fold_flags(
15040                         ender,
15041                         (U8 *) e,
15042                         &added_len,
15043                         FOLD_FLAGS_FULL | ((ASCII_FOLD_RESTRICTED)
15044                                         ? FOLD_FLAGS_NOMIX_ASCII
15045                                         : 0));
15046                     e += added_len;
15047
15048                     /* 's' and the character folded to by ender may be the
15049                      * first two of a three-character fold, in which case the
15050                      * node should not be split here.  That may mean examining
15051                      * the so-far unparsed character starting at 'p'.  But if
15052                      * ender folded to more than one character, we already have
15053                      * three characters to look at.  Also, we first check if
15054                      * the sequence consisting of s and the next character form
15055                      * the first two of some three character fold.  If not,
15056                      * there's no need to peek ahead. */
15057                     if (   added_len <= UTF8SKIP(e - added_len)
15058                         && UNLIKELY(is_THREE_CHAR_FOLD_HEAD_utf8_safe(s, e)))
15059                     {
15060                         /* Here, the two do form the beginning of a potential
15061                          * three character fold.  The unexamined character may
15062                          * or may not complete it.  Peek at it.  It might be
15063                          * something that ends the node or an escape sequence,
15064                          * in which case we don't know without a lot of work
15065                          * what it evaluates to, so we have to assume the worst
15066                          * case: that it does complete the fold, and so we
15067                          * can't split here.  All such instances  will have
15068                          * that character be an ASCII punctuation character,
15069                          * like a backslash.  So, for that case, backup one and
15070                          * drop down to try at that position */
15071                         if (isPUNCT(*p)) {
15072                             s = (char *) utf8_hop_back((U8 *) s, -1,
15073                                        (U8 *) s_start);
15074                             backed_up = TRUE;
15075                         }
15076                         else {
15077                             /* Here, since it's not punctuation, it must be a
15078                              * real character, and we can append its fold to
15079                              * 'e' (having deliberately reserved enough space
15080                              * for this eventuality) and drop down to check if
15081                              * the three actually do form a folded sequence */
15082                             (void) _to_utf8_fold_flags(
15083                                 (U8 *) p, (U8 *) RExC_end,
15084                                 (U8 *) e,
15085                                 &added_len,
15086                                 FOLD_FLAGS_FULL | ((ASCII_FOLD_RESTRICTED)
15087                                                 ? FOLD_FLAGS_NOMIX_ASCII
15088                                                 : 0));
15089                             e += added_len;
15090                         }
15091                     }
15092
15093                     /* Here, we either have three characters available in
15094                      * sequence starting at 's', or we have two characters and
15095                      * know that the following one can't possibly be part of a
15096                      * three character fold.  We go through the node backwards
15097                      * until we find a place where we can split it without
15098                      * breaking apart a multi-character fold.  At any given
15099                      * point we have to worry about if such a fold begins at
15100                      * the current 's', and also if a three-character fold
15101                      * begins at s-1, (containing s and s+1).  Splitting in
15102                      * either case would break apart a fold */
15103                     do {
15104                         char *prev_s = (char *) utf8_hop_back((U8 *) s, -1,
15105                                                             (U8 *) s_start);
15106
15107                         /* If is a multi-char fold, can't split here.  Backup
15108                          * one char and try again */
15109                         if (UNLIKELY(is_MULTI_CHAR_FOLD_utf8_safe(s, e))) {
15110                             s = prev_s;
15111                             backed_up = TRUE;
15112                             continue;
15113                         }
15114
15115                         /* If the two characters beginning at 's' are part of a
15116                          * three character fold starting at the character
15117                          * before s, we can't split either before or after s.
15118                          * Backup two chars and try again */
15119                         if (   LIKELY(s > s_start)
15120                             && UNLIKELY(is_THREE_CHAR_FOLD_utf8_safe(prev_s, e)))
15121                         {
15122                             s = prev_s;
15123                             s = (char *) utf8_hop_back((U8 *) s, -1, (U8 *) s_start);
15124                             backed_up = TRUE;
15125                             continue;
15126                         }
15127
15128                         /* Here there's no multi-char fold between s and the
15129                          * next character following it.  We can split */
15130                         splittable = TRUE;
15131                         break;
15132
15133                     } while (s > s_start); /* End of loops backing up through the node */
15134
15135                     /* Here we either couldn't find a place to split the node,
15136                      * or else we broke out of the loop setting 'splittable' to
15137                      * true.  In the latter case, the place to split is between
15138                      * the first and second characters in the sequence starting
15139                      * at 's' */
15140                     if (splittable) {
15141                         s += UTF8SKIP(s);
15142                     }
15143                 }
15144                 else {  /* Pattern not UTF-8 */
15145                     if (   ender != LATIN_SMALL_LETTER_SHARP_S
15146                         || ASCII_FOLD_RESTRICTED)
15147                     {
15148                         assert( toLOWER_L1(ender) < 256 );
15149                         *e++ = (char)(toLOWER_L1(ender)); /* should e and the cast be U8? */
15150                     }
15151                     else {
15152                         *e++ = 's';
15153                         *e++ = 's';
15154                     }
15155
15156                     if (   e - s  <= 1
15157                         && UNLIKELY(is_THREE_CHAR_FOLD_HEAD_latin1_safe(s, e)))
15158                     {
15159                         if (isPUNCT(*p)) {
15160                             s--;
15161                             backed_up = TRUE;
15162                         }
15163                         else {
15164                             if (   UCHARAT(p) != LATIN_SMALL_LETTER_SHARP_S
15165                                 || ASCII_FOLD_RESTRICTED)
15166                             {
15167                                 assert( toLOWER_L1(ender) < 256 );
15168                                 *e++ = (char)(toLOWER_L1(ender)); /* should e and the cast be U8? */
15169                             }
15170                             else {
15171                                 *e++ = 's';
15172                                 *e++ = 's';
15173                             }
15174                         }
15175                     }
15176
15177                     do {
15178                         if (UNLIKELY(is_MULTI_CHAR_FOLD_latin1_safe(s, e))) {
15179                             s--;
15180                             backed_up = TRUE;
15181                             continue;
15182                         }
15183
15184                         if (   LIKELY(s > s_start)
15185                             && UNLIKELY(is_THREE_CHAR_FOLD_latin1_safe(s - 1, e)))
15186                         {
15187                             s -= 2;
15188                             backed_up = TRUE;
15189                             continue;
15190                         }
15191
15192                         splittable = TRUE;
15193                         break;
15194
15195                     } while (s > s_start);
15196
15197                     if (splittable) {
15198                         s++;
15199                     }
15200                 }
15201
15202                 /* Here, we are done backing up.  If we didn't backup at all
15203                  * (the likely case), just proceed */
15204                 if (backed_up) {
15205
15206                    /* If we did find a place to split, reparse the entire node
15207                     * stopping where we have calculated. */
15208                     if (splittable) {
15209
15210                        /* If we created a temporary folded string under /l, we
15211                         * have to map that back to the original */
15212                         if (need_to_fold_loc) {
15213                             upper_fill = loc_correspondence[s - s_start];
15214                             if (upper_fill == 0) {
15215                                 FAIL2("panic: loc_correspondence[%d] is 0",
15216                                       (int) (s - s_start));
15217                             }
15218                             Safefree(locfold_buf);
15219                             Safefree(loc_correspondence);
15220                         }
15221                         else {
15222                             upper_fill = s - s0;
15223                         }
15224                         goto reparse;
15225                     }
15226
15227                     /* Here the node consists entirely of non-final multi-char
15228                      * folds.  (Likely it is all 'f's or all 's's.)  There's no
15229                      * decent place to split it, so give up and just take the
15230                      * whole thing */
15231                     len = old_s - s0;
15232                 }
15233
15234                 if (need_to_fold_loc) {
15235                     Safefree(locfold_buf);
15236                     Safefree(loc_correspondence);
15237                 }
15238             }   /* End of verifying node ends with an appropriate char */
15239
15240             /* We need to start the next node at the character that didn't fit
15241              * in this one */
15242             p = oldp;
15243
15244           loopdone:   /* Jumped to when encounters something that shouldn't be
15245                          in the node */
15246
15247             /* Free up any over-allocated space; cast is to silence bogus
15248              * warning in MS VC */
15249             change_engine_size(pRExC_state,
15250                         - (Ptrdiff_t) (current_string_nodes - STR_SZ(len)));
15251
15252             /* I (khw) don't know if you can get here with zero length, but the
15253              * old code handled this situation by creating a zero-length EXACT
15254              * node.  Might as well be NOTHING instead */
15255             if (len == 0) {
15256                 OP(REGNODE_p(ret)) = NOTHING;
15257             }
15258             else {
15259
15260                 /* If the node type is EXACT here, check to see if it
15261                  * should be EXACTL, or EXACT_REQ8. */
15262                 if (node_type == EXACT) {
15263                     if (LOC) {
15264                         node_type = EXACTL;
15265                     }
15266                     else if (requires_utf8_target) {
15267                         node_type = EXACT_REQ8;
15268                     }
15269                 }
15270                 else if (node_type == LEXACT) {
15271                     if (requires_utf8_target) {
15272                         node_type = LEXACT_REQ8;
15273                     }
15274                 }
15275                 else if (FOLD) {
15276                     if (    UNLIKELY(has_micro_sign || has_ss)
15277                         && (node_type == EXACTFU || (   node_type == EXACTF
15278                                                      && maybe_exactfu)))
15279                     {   /* These two conditions are problematic in non-UTF-8
15280                            EXACTFU nodes. */
15281                         assert(! UTF);
15282                         node_type = EXACTFUP;
15283                     }
15284                     else if (node_type == EXACTFL) {
15285
15286                         /* 'maybe_exactfu' is deliberately set above to
15287                          * indicate this node type, where all code points in it
15288                          * are above 255 */
15289                         if (maybe_exactfu) {
15290                             node_type = EXACTFLU8;
15291                         }
15292                         else if (UNLIKELY(
15293                              _invlist_contains_cp(PL_HasMultiCharFold, ender)))
15294                         {
15295                             /* A character that folds to more than one will
15296                              * match multiple characters, so can't be SIMPLE.
15297                              * We don't have to worry about this with EXACTFLU8
15298                              * nodes just above, as they have already been
15299                              * folded (since the fold doesn't vary at run
15300                              * time).  Here, if the final character in the node
15301                              * folds to multiple, it can't be simple.  (This
15302                              * only has an effect if the node has only a single
15303                              * character, hence the final one, as elsewhere we
15304                              * turn off simple for nodes whose length > 1 */
15305                             maybe_SIMPLE = 0;
15306                         }
15307                     }
15308                     else if (node_type == EXACTF) {  /* Means is /di */
15309
15310                         /* This intermediate variable is needed solely because
15311                          * the asserts in the macro where used exceed Win32's
15312                          * literal string capacity */
15313                         char first_char = * STRING(REGNODE_p(ret));
15314
15315                         /* If 'maybe_exactfu' is clear, then we need to stay
15316                          * /di.  If it is set, it means there are no code
15317                          * points that match differently depending on UTF8ness
15318                          * of the target string, so it can become an EXACTFU
15319                          * node */
15320                         if (! maybe_exactfu) {
15321                             RExC_seen_d_op = TRUE;
15322                         }
15323                         else if (   isALPHA_FOLD_EQ(first_char, 's')
15324                                  || isALPHA_FOLD_EQ(ender, 's'))
15325                         {
15326                             /* But, if the node begins or ends in an 's' we
15327                              * have to defer changing it into an EXACTFU, as
15328                              * the node could later get joined with another one
15329                              * that ends or begins with 's' creating an 'ss'
15330                              * sequence which would then wrongly match the
15331                              * sharp s without the target being UTF-8.  We
15332                              * create a special node that we resolve later when
15333                              * we join nodes together */
15334
15335                             node_type = EXACTFU_S_EDGE;
15336                         }
15337                         else {
15338                             node_type = EXACTFU;
15339                         }
15340                     }
15341
15342                     if (requires_utf8_target && node_type == EXACTFU) {
15343                         node_type = EXACTFU_REQ8;
15344                     }
15345                 }
15346
15347                 OP(REGNODE_p(ret)) = node_type;
15348                 setSTR_LEN(REGNODE_p(ret), len);
15349                 RExC_emit += STR_SZ(len);
15350
15351                 /* If the node isn't a single character, it can't be SIMPLE */
15352                 if (len > (Size_t) ((UTF) ? UTF8SKIP(STRING(REGNODE_p(ret))) : 1)) {
15353                     maybe_SIMPLE = 0;
15354                 }
15355
15356                 *flagp |= HASWIDTH | maybe_SIMPLE;
15357             }
15358
15359             Set_Node_Length(REGNODE_p(ret), p - parse_start - 1);
15360             RExC_parse = p;
15361
15362             {
15363                 /* len is STRLEN which is unsigned, need to copy to signed */
15364                 IV iv = len;
15365                 if (iv < 0)
15366                     vFAIL("Internal disaster");
15367             }
15368
15369         } /* End of label 'defchar:' */
15370         break;
15371     } /* End of giant switch on input character */
15372
15373     /* Position parse to next real character */
15374     skip_to_be_ignored_text(pRExC_state, &RExC_parse,
15375                                             FALSE /* Don't force to /x */ );
15376     if (   *RExC_parse == '{'
15377         && OP(REGNODE_p(ret)) != SBOL && ! regcurly(RExC_parse))
15378     {
15379         if (RExC_strict || new_regcurly(RExC_parse, RExC_end)) {
15380             RExC_parse++;
15381             vFAIL("Unescaped left brace in regex is illegal here");
15382         }
15383         ckWARNreg(RExC_parse + 1, "Unescaped left brace in regex is"
15384                                   " passed through");
15385     }
15386
15387     return(ret);
15388 }
15389
15390
15391 STATIC void
15392 S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr)
15393 {
15394     /* Uses the inversion list '*invlist_ptr' to populate the ANYOF 'node'.  It
15395      * sets up the bitmap and any flags, removing those code points from the
15396      * inversion list, setting it to NULL should it become completely empty */
15397
15398
15399     PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST;
15400     assert(PL_regkind[OP(node)] == ANYOF);
15401
15402     /* There is no bitmap for this node type */
15403     if (inRANGE(OP(node), ANYOFH, ANYOFRb)) {
15404         return;
15405     }
15406
15407     ANYOF_BITMAP_ZERO(node);
15408     if (*invlist_ptr) {
15409
15410         /* This gets set if we actually need to modify things */
15411         bool change_invlist = FALSE;
15412
15413         UV start, end;
15414
15415         /* Start looking through *invlist_ptr */
15416         invlist_iterinit(*invlist_ptr);
15417         while (invlist_iternext(*invlist_ptr, &start, &end)) {
15418             UV high;
15419             int i;
15420
15421             if (end == UV_MAX && start <= NUM_ANYOF_CODE_POINTS) {
15422                 ANYOF_FLAGS(node) |= ANYOF_MATCHES_ALL_ABOVE_BITMAP;
15423             }
15424
15425             /* Quit if are above what we should change */
15426             if (start >= NUM_ANYOF_CODE_POINTS) {
15427                 break;
15428             }
15429
15430             change_invlist = TRUE;
15431
15432             /* Set all the bits in the range, up to the max that we are doing */
15433             high = (end < NUM_ANYOF_CODE_POINTS - 1)
15434                    ? end
15435                    : NUM_ANYOF_CODE_POINTS - 1;
15436             for (i = start; i <= (int) high; i++) {
15437                 ANYOF_BITMAP_SET(node, i);
15438             }
15439         }
15440         invlist_iterfinish(*invlist_ptr);
15441
15442         /* Done with loop; remove any code points that are in the bitmap from
15443          * *invlist_ptr; similarly for code points above the bitmap if we have
15444          * a flag to match all of them anyways */
15445         if (change_invlist) {
15446             _invlist_subtract(*invlist_ptr, PL_InBitmap, invlist_ptr);
15447         }
15448         if (ANYOF_FLAGS(node) & ANYOF_MATCHES_ALL_ABOVE_BITMAP) {
15449             _invlist_intersection(*invlist_ptr, PL_InBitmap, invlist_ptr);
15450         }
15451
15452         /* If have completely emptied it, remove it completely */
15453         if (_invlist_len(*invlist_ptr) == 0) {
15454             SvREFCNT_dec_NN(*invlist_ptr);
15455             *invlist_ptr = NULL;
15456         }
15457     }
15458 }
15459
15460 /* Parse POSIX character classes: [[:foo:]], [[=foo=]], [[.foo.]].
15461    Character classes ([:foo:]) can also be negated ([:^foo:]).
15462    Returns a named class id (ANYOF_XXX) if successful, -1 otherwise.
15463    Equivalence classes ([=foo=]) and composites ([.foo.]) are parsed,
15464    but trigger failures because they are currently unimplemented. */
15465
15466 #define POSIXCC_DONE(c)   ((c) == ':')
15467 #define POSIXCC_NOTYET(c) ((c) == '=' || (c) == '.')
15468 #define POSIXCC(c) (POSIXCC_DONE(c) || POSIXCC_NOTYET(c))
15469 #define MAYBE_POSIXCC(c) (POSIXCC(c) || (c) == '^' || (c) == ';')
15470
15471 #define WARNING_PREFIX              "Assuming NOT a POSIX class since "
15472 #define NO_BLANKS_POSIX_WARNING     "no blanks are allowed in one"
15473 #define SEMI_COLON_POSIX_WARNING    "a semi-colon was found instead of a colon"
15474
15475 #define NOT_MEANT_TO_BE_A_POSIX_CLASS (OOB_NAMEDCLASS - 1)
15476
15477 /* 'posix_warnings' and 'warn_text' are names of variables in the following
15478  * routine. q.v. */
15479 #define ADD_POSIX_WARNING(p, text)  STMT_START {                            \
15480         if (posix_warnings) {                                               \
15481             if (! RExC_warn_text ) RExC_warn_text =                         \
15482                                          (AV *) sv_2mortal((SV *) newAV()); \
15483             av_push(RExC_warn_text, Perl_newSVpvf(aTHX_                     \
15484                                              WARNING_PREFIX                 \
15485                                              text                           \
15486                                              REPORT_LOCATION,               \
15487                                              REPORT_LOCATION_ARGS(p)));     \
15488         }                                                                   \
15489     } STMT_END
15490 #define CLEAR_POSIX_WARNINGS()                                              \
15491     STMT_START {                                                            \
15492         if (posix_warnings && RExC_warn_text)                               \
15493             av_clear(RExC_warn_text);                                       \
15494     } STMT_END
15495
15496 #define CLEAR_POSIX_WARNINGS_AND_RETURN(ret)                                \
15497     STMT_START {                                                            \
15498         CLEAR_POSIX_WARNINGS();                                             \
15499         return ret;                                                         \
15500     } STMT_END
15501
15502 STATIC int
15503 S_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state,
15504
15505     const char * const s,      /* Where the putative posix class begins.
15506                                   Normally, this is one past the '['.  This
15507                                   parameter exists so it can be somewhere
15508                                   besides RExC_parse. */
15509     char ** updated_parse_ptr, /* Where to set the updated parse pointer, or
15510                                   NULL */
15511     AV ** posix_warnings,      /* Where to place any generated warnings, or
15512                                   NULL */
15513     const bool check_only      /* Don't die if error */
15514 )
15515 {
15516     /* This parses what the caller thinks may be one of the three POSIX
15517      * constructs:
15518      *  1) a character class, like [:blank:]
15519      *  2) a collating symbol, like [. .]
15520      *  3) an equivalence class, like [= =]
15521      * In the latter two cases, it croaks if it finds a syntactically legal
15522      * one, as these are not handled by Perl.
15523      *
15524      * The main purpose is to look for a POSIX character class.  It returns:
15525      *  a) the class number
15526      *      if it is a completely syntactically and semantically legal class.
15527      *      'updated_parse_ptr', if not NULL, is set to point to just after the
15528      *      closing ']' of the class
15529      *  b) OOB_NAMEDCLASS
15530      *      if it appears that one of the three POSIX constructs was meant, but
15531      *      its specification was somehow defective.  'updated_parse_ptr', if
15532      *      not NULL, is set to point to the character just after the end
15533      *      character of the class.  See below for handling of warnings.
15534      *  c) NOT_MEANT_TO_BE_A_POSIX_CLASS
15535      *      if it  doesn't appear that a POSIX construct was intended.
15536      *      'updated_parse_ptr' is not changed.  No warnings nor errors are
15537      *      raised.
15538      *
15539      * In b) there may be errors or warnings generated.  If 'check_only' is
15540      * TRUE, then any errors are discarded.  Warnings are returned to the
15541      * caller via an AV* created into '*posix_warnings' if it is not NULL.  If
15542      * instead it is NULL, warnings are suppressed.
15543      *
15544      * The reason for this function, and its complexity is that a bracketed
15545      * character class can contain just about anything.  But it's easy to
15546      * mistype the very specific posix class syntax but yielding a valid
15547      * regular bracketed class, so it silently gets compiled into something
15548      * quite unintended.
15549      *
15550      * The solution adopted here maintains backward compatibility except that
15551      * it adds a warning if it looks like a posix class was intended but
15552      * improperly specified.  The warning is not raised unless what is input
15553      * very closely resembles one of the 14 legal posix classes.  To do this,
15554      * it uses fuzzy parsing.  It calculates how many single-character edits it
15555      * would take to transform what was input into a legal posix class.  Only
15556      * if that number is quite small does it think that the intention was a
15557      * posix class.  Obviously these are heuristics, and there will be cases
15558      * where it errs on one side or another, and they can be tweaked as
15559      * experience informs.
15560      *
15561      * The syntax for a legal posix class is:
15562      *
15563      * qr/(?xa: \[ : \^? [[:lower:]]{4,6} : \] )/
15564      *
15565      * What this routine considers syntactically to be an intended posix class
15566      * is this (the comments indicate some restrictions that the pattern
15567      * doesn't show):
15568      *
15569      *  qr/(?x: \[?                         # The left bracket, possibly
15570      *                                      # omitted
15571      *          \h*                         # possibly followed by blanks
15572      *          (?: \^ \h* )?               # possibly a misplaced caret
15573      *          [:;]?                       # The opening class character,
15574      *                                      # possibly omitted.  A typo
15575      *                                      # semi-colon can also be used.
15576      *          \h*
15577      *          \^?                         # possibly a correctly placed
15578      *                                      # caret, but not if there was also
15579      *                                      # a misplaced one
15580      *          \h*
15581      *          .{3,15}                     # The class name.  If there are
15582      *                                      # deviations from the legal syntax,
15583      *                                      # its edit distance must be close
15584      *                                      # to a real class name in order
15585      *                                      # for it to be considered to be
15586      *                                      # an intended posix class.
15587      *          \h*
15588      *          [[:punct:]]?                # The closing class character,
15589      *                                      # possibly omitted.  If not a colon
15590      *                                      # nor semi colon, the class name
15591      *                                      # must be even closer to a valid
15592      *                                      # one
15593      *          \h*
15594      *          \]?                         # The right bracket, possibly
15595      *                                      # omitted.
15596      *     )/
15597      *
15598      * In the above, \h must be ASCII-only.
15599      *
15600      * These are heuristics, and can be tweaked as field experience dictates.
15601      * There will be cases when someone didn't intend to specify a posix class
15602      * that this warns as being so.  The goal is to minimize these, while
15603      * maximizing the catching of things intended to be a posix class that
15604      * aren't parsed as such.
15605      */
15606
15607     const char* p             = s;
15608     const char * const e      = RExC_end;
15609     unsigned complement       = 0;      /* If to complement the class */
15610     bool found_problem        = FALSE;  /* Assume OK until proven otherwise */
15611     bool has_opening_bracket  = FALSE;
15612     bool has_opening_colon    = FALSE;
15613     int class_number          = OOB_NAMEDCLASS; /* Out-of-bounds until find
15614                                                    valid class */
15615     const char * possible_end = NULL;   /* used for a 2nd parse pass */
15616     const char* name_start;             /* ptr to class name first char */
15617
15618     /* If the number of single-character typos the input name is away from a
15619      * legal name is no more than this number, it is considered to have meant
15620      * the legal name */
15621     int max_distance          = 2;
15622
15623     /* to store the name.  The size determines the maximum length before we
15624      * decide that no posix class was intended.  Should be at least
15625      * sizeof("alphanumeric") */
15626     UV input_text[15];
15627     STATIC_ASSERT_DECL(C_ARRAY_LENGTH(input_text) >= sizeof "alphanumeric");
15628
15629     PERL_ARGS_ASSERT_HANDLE_POSSIBLE_POSIX;
15630
15631     CLEAR_POSIX_WARNINGS();
15632
15633     if (p >= e) {
15634         return NOT_MEANT_TO_BE_A_POSIX_CLASS;
15635     }
15636
15637     if (*(p - 1) != '[') {
15638         ADD_POSIX_WARNING(p, "it doesn't start with a '['");
15639         found_problem = TRUE;
15640     }
15641     else {
15642         has_opening_bracket = TRUE;
15643     }
15644
15645     /* They could be confused and think you can put spaces between the
15646      * components */
15647     if (isBLANK(*p)) {
15648         found_problem = TRUE;
15649
15650         do {
15651             p++;
15652         } while (p < e && isBLANK(*p));
15653
15654         ADD_POSIX_WARNING(p, NO_BLANKS_POSIX_WARNING);
15655     }
15656
15657     /* For [. .] and [= =].  These are quite different internally from [: :],
15658      * so they are handled separately.  */
15659     if (POSIXCC_NOTYET(*p) && p < e - 3) /* 1 for the close, and 1 for the ']'
15660                                             and 1 for at least one char in it
15661                                           */
15662     {
15663         const char open_char  = *p;
15664         const char * temp_ptr = p + 1;
15665
15666         /* These two constructs are not handled by perl, and if we find a
15667          * syntactically valid one, we croak.  khw, who wrote this code, finds
15668          * this explanation of them very unclear:
15669          * http://pubs.opengroup.org/onlinepubs/009696899/basedefs/xbd_chap09.html
15670          * And searching the rest of the internet wasn't very helpful either.
15671          * It looks like just about any byte can be in these constructs,
15672          * depending on the locale.  But unless the pattern is being compiled
15673          * under /l, which is very rare, Perl runs under the C or POSIX locale.
15674          * In that case, it looks like [= =] isn't allowed at all, and that
15675          * [. .] could be any single code point, but for longer strings the
15676          * constituent characters would have to be the ASCII alphabetics plus
15677          * the minus-hyphen.  Any sensible locale definition would limit itself
15678          * to these.  And any portable one definitely should.  Trying to parse
15679          * the general case is a nightmare (see [perl #127604]).  So, this code
15680          * looks only for interiors of these constructs that match:
15681          *      qr/.|[-\w]{2,}/
15682          * Using \w relaxes the apparent rules a little, without adding much
15683          * danger of mistaking something else for one of these constructs.
15684          *
15685          * [. .] in some implementations described on the internet is usable to
15686          * escape a character that otherwise is special in bracketed character
15687          * classes.  For example [.].] means a literal right bracket instead of
15688          * the ending of the class
15689          *
15690          * [= =] can legitimately contain a [. .] construct, but we don't
15691          * handle this case, as that [. .] construct will later get parsed
15692          * itself and croak then.  And [= =] is checked for even when not under
15693          * /l, as Perl has long done so.
15694          *
15695          * The code below relies on there being a trailing NUL, so it doesn't
15696          * have to keep checking if the parse ptr < e.
15697          */
15698         if (temp_ptr[1] == open_char) {
15699             temp_ptr++;
15700         }
15701         else while (    temp_ptr < e
15702                     && (isWORDCHAR(*temp_ptr) || *temp_ptr == '-'))
15703         {
15704             temp_ptr++;
15705         }
15706
15707         if (*temp_ptr == open_char) {
15708             temp_ptr++;
15709             if (*temp_ptr == ']') {
15710                 temp_ptr++;
15711                 if (! found_problem && ! check_only) {
15712                     RExC_parse = (char *) temp_ptr;
15713                     vFAIL3("POSIX syntax [%c %c] is reserved for future "
15714                             "extensions", open_char, open_char);
15715                 }
15716
15717                 /* Here, the syntax wasn't completely valid, or else the call
15718                  * is to check-only */
15719                 if (updated_parse_ptr) {
15720                     *updated_parse_ptr = (char *) temp_ptr;
15721                 }
15722
15723                 CLEAR_POSIX_WARNINGS_AND_RETURN(OOB_NAMEDCLASS);
15724             }
15725         }
15726
15727         /* If we find something that started out to look like one of these
15728          * constructs, but isn't, we continue below so that it can be checked
15729          * for being a class name with a typo of '.' or '=' instead of a colon.
15730          * */
15731     }
15732
15733     /* Here, we think there is a possibility that a [: :] class was meant, and
15734      * we have the first real character.  It could be they think the '^' comes
15735      * first */
15736     if (*p == '^') {
15737         found_problem = TRUE;
15738         ADD_POSIX_WARNING(p + 1, "the '^' must come after the colon");
15739         complement = 1;
15740         p++;
15741
15742         if (isBLANK(*p)) {
15743             found_problem = TRUE;
15744
15745             do {
15746                 p++;
15747             } while (p < e && isBLANK(*p));
15748
15749             ADD_POSIX_WARNING(p, NO_BLANKS_POSIX_WARNING);
15750         }
15751     }
15752
15753     /* But the first character should be a colon, which they could have easily
15754      * mistyped on a qwerty keyboard as a semi-colon (and which may be hard to
15755      * distinguish from a colon, so treat that as a colon).  */
15756     if (*p == ':') {
15757         p++;
15758         has_opening_colon = TRUE;
15759     }
15760     else if (*p == ';') {
15761         found_problem = TRUE;
15762         p++;
15763         ADD_POSIX_WARNING(p, SEMI_COLON_POSIX_WARNING);
15764         has_opening_colon = TRUE;
15765     }
15766     else {
15767         found_problem = TRUE;
15768         ADD_POSIX_WARNING(p, "there must be a starting ':'");
15769
15770         /* Consider an initial punctuation (not one of the recognized ones) to
15771          * be a left terminator */
15772         if (*p != '^' && *p != ']' && isPUNCT(*p)) {
15773             p++;
15774         }
15775     }
15776
15777     /* They may think that you can put spaces between the components */
15778     if (isBLANK(*p)) {
15779         found_problem = TRUE;
15780
15781         do {
15782             p++;
15783         } while (p < e && isBLANK(*p));
15784
15785         ADD_POSIX_WARNING(p, NO_BLANKS_POSIX_WARNING);
15786     }
15787
15788     if (*p == '^') {
15789
15790         /* We consider something like [^:^alnum:]] to not have been intended to
15791          * be a posix class, but XXX maybe we should */
15792         if (complement) {
15793             CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);
15794         }
15795
15796         complement = 1;
15797         p++;
15798     }
15799
15800     /* Again, they may think that you can put spaces between the components */
15801     if (isBLANK(*p)) {
15802         found_problem = TRUE;
15803
15804         do {
15805             p++;
15806         } while (p < e && isBLANK(*p));
15807
15808         ADD_POSIX_WARNING(p, NO_BLANKS_POSIX_WARNING);
15809     }
15810
15811     if (*p == ']') {
15812
15813         /* XXX This ']' may be a typo, and something else was meant.  But
15814          * treating it as such creates enough complications, that that
15815          * possibility isn't currently considered here.  So we assume that the
15816          * ']' is what is intended, and if we've already found an initial '[',
15817          * this leaves this construct looking like [:] or [:^], which almost
15818          * certainly weren't intended to be posix classes */
15819         if (has_opening_bracket) {
15820             CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);
15821         }
15822
15823         /* But this function can be called when we parse the colon for
15824          * something like qr/[alpha:]]/, so we back up to look for the
15825          * beginning */
15826         p--;
15827
15828         if (*p == ';') {
15829             found_problem = TRUE;
15830             ADD_POSIX_WARNING(p, SEMI_COLON_POSIX_WARNING);
15831         }
15832         else if (*p != ':') {
15833
15834             /* XXX We are currently very restrictive here, so this code doesn't
15835              * consider the possibility that, say, /[alpha.]]/ was intended to
15836              * be a posix class. */
15837             CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);
15838         }
15839
15840         /* Here we have something like 'foo:]'.  There was no initial colon,
15841          * and we back up over 'foo.  XXX Unlike the going forward case, we
15842          * don't handle typos of non-word chars in the middle */
15843         has_opening_colon = FALSE;
15844         p--;
15845
15846         while (p > RExC_start && isWORDCHAR(*p)) {
15847             p--;
15848         }
15849         p++;
15850
15851         /* Here, we have positioned ourselves to where we think the first
15852          * character in the potential class is */
15853     }
15854
15855     /* Now the interior really starts.  There are certain key characters that
15856      * can end the interior, or these could just be typos.  To catch both
15857      * cases, we may have to do two passes.  In the first pass, we keep on
15858      * going unless we come to a sequence that matches
15859      *      qr/ [[:punct:]] [[:blank:]]* \] /xa
15860      * This means it takes a sequence to end the pass, so two typos in a row if
15861      * that wasn't what was intended.  If the class is perfectly formed, just
15862      * this one pass is needed.  We also stop if there are too many characters
15863      * being accumulated, but this number is deliberately set higher than any
15864      * real class.  It is set high enough so that someone who thinks that
15865      * 'alphanumeric' is a correct name would get warned that it wasn't.
15866      * While doing the pass, we keep track of where the key characters were in
15867      * it.  If we don't find an end to the class, and one of the key characters
15868      * was found, we redo the pass, but stop when we get to that character.
15869      * Thus the key character was considered a typo in the first pass, but a
15870      * terminator in the second.  If two key characters are found, we stop at
15871      * the second one in the first pass.  Again this can miss two typos, but
15872      * catches a single one
15873      *
15874      * In the first pass, 'possible_end' starts as NULL, and then gets set to
15875      * point to the first key character.  For the second pass, it starts as -1.
15876      * */
15877
15878     name_start = p;
15879   parse_name:
15880     {
15881         bool has_blank               = FALSE;
15882         bool has_upper               = FALSE;
15883         bool has_terminating_colon   = FALSE;
15884         bool has_terminating_bracket = FALSE;
15885         bool has_semi_colon          = FALSE;
15886         unsigned int name_len        = 0;
15887         int punct_count              = 0;
15888
15889         while (p < e) {
15890
15891             /* Squeeze out blanks when looking up the class name below */
15892             if (isBLANK(*p) ) {
15893                 has_blank = TRUE;
15894                 found_problem = TRUE;
15895                 p++;
15896                 continue;
15897             }
15898
15899             /* The name will end with a punctuation */
15900             if (isPUNCT(*p)) {
15901                 const char * peek = p + 1;
15902
15903                 /* Treat any non-']' punctuation followed by a ']' (possibly
15904                  * with intervening blanks) as trying to terminate the class.
15905                  * ']]' is very likely to mean a class was intended (but
15906                  * missing the colon), but the warning message that gets
15907                  * generated shows the error position better if we exit the
15908                  * loop at the bottom (eventually), so skip it here. */
15909                 if (*p != ']') {
15910                     if (peek < e && isBLANK(*peek)) {
15911                         has_blank = TRUE;
15912                         found_problem = TRUE;
15913                         do {
15914                             peek++;
15915                         } while (peek < e && isBLANK(*peek));
15916                     }
15917
15918                     if (peek < e && *peek == ']') {
15919                         has_terminating_bracket = TRUE;
15920                         if (*p == ':') {
15921                             has_terminating_colon = TRUE;
15922                         }
15923                         else if (*p == ';') {
15924                             has_semi_colon = TRUE;
15925                             has_terminating_colon = TRUE;
15926                         }
15927                         else {
15928                             found_problem = TRUE;
15929                         }
15930                         p = peek + 1;
15931                         goto try_posix;
15932                     }
15933                 }
15934
15935                 /* Here we have punctuation we thought didn't end the class.
15936                  * Keep track of the position of the key characters that are
15937                  * more likely to have been class-enders */
15938                 if (*p == ']' || *p == '[' || *p == ':' || *p == ';') {
15939
15940                     /* Allow just one such possible class-ender not actually
15941                      * ending the class. */
15942                     if (possible_end) {
15943                         break;
15944                     }
15945                     possible_end = p;
15946                 }
15947
15948                 /* If we have too many punctuation characters, no use in
15949                  * keeping going */
15950                 if (++punct_count > max_distance) {
15951                     break;
15952                 }
15953
15954                 /* Treat the punctuation as a typo. */
15955                 input_text[name_len++] = *p;
15956                 p++;
15957             }
15958             else if (isUPPER(*p)) { /* Use lowercase for lookup */
15959                 input_text[name_len++] = toLOWER(*p);
15960                 has_upper = TRUE;
15961                 found_problem = TRUE;
15962                 p++;
15963             } else if (! UTF || UTF8_IS_INVARIANT(*p)) {
15964                 input_text[name_len++] = *p;
15965                 p++;
15966             }
15967             else {
15968                 input_text[name_len++] = utf8_to_uvchr_buf((U8 *) p, e, NULL);
15969                 p+= UTF8SKIP(p);
15970             }
15971
15972             /* The declaration of 'input_text' is how long we allow a potential
15973              * class name to be, before saying they didn't mean a class name at
15974              * all */
15975             if (name_len >= C_ARRAY_LENGTH(input_text)) {
15976                 break;
15977             }
15978         }
15979
15980         /* We get to here when the possible class name hasn't been properly
15981          * terminated before:
15982          *   1) we ran off the end of the pattern; or
15983          *   2) found two characters, each of which might have been intended to
15984          *      be the name's terminator
15985          *   3) found so many punctuation characters in the purported name,
15986          *      that the edit distance to a valid one is exceeded
15987          *   4) we decided it was more characters than anyone could have
15988          *      intended to be one. */
15989
15990         found_problem = TRUE;
15991
15992         /* In the final two cases, we know that looking up what we've
15993          * accumulated won't lead to a match, even a fuzzy one. */
15994         if (   name_len >= C_ARRAY_LENGTH(input_text)
15995             || punct_count > max_distance)
15996         {
15997             /* If there was an intermediate key character that could have been
15998              * an intended end, redo the parse, but stop there */
15999             if (possible_end && possible_end != (char *) -1) {
16000                 possible_end = (char *) -1; /* Special signal value to say
16001                                                we've done a first pass */
16002                 p = name_start;
16003                 goto parse_name;
16004             }
16005
16006             /* Otherwise, it can't have meant to have been a class */
16007             CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);
16008         }
16009
16010         /* If we ran off the end, and the final character was a punctuation
16011          * one, back up one, to look at that final one just below.  Later, we
16012          * will restore the parse pointer if appropriate */
16013         if (name_len && p == e && isPUNCT(*(p-1))) {
16014             p--;
16015             name_len--;
16016         }
16017
16018         if (p < e && isPUNCT(*p)) {
16019             if (*p == ']') {
16020                 has_terminating_bracket = TRUE;
16021
16022                 /* If this is a 2nd ']', and the first one is just below this
16023                  * one, consider that to be the real terminator.  This gives a
16024                  * uniform and better positioning for the warning message  */
16025                 if (   possible_end
16026                     && possible_end != (char *) -1
16027                     && *possible_end == ']'
16028                     && name_len && input_text[name_len - 1] == ']')
16029                 {
16030                     name_len--;
16031                     p = possible_end;
16032
16033                     /* And this is actually equivalent to having done the 2nd
16034                      * pass now, so set it to not try again */
16035                     possible_end = (char *) -1;
16036                 }
16037             }
16038             else {
16039                 if (*p == ':') {
16040                     has_terminating_colon = TRUE;
16041                 }
16042                 else if (*p == ';') {
16043                     has_semi_colon = TRUE;
16044                     has_terminating_colon = TRUE;
16045                 }
16046                 p++;
16047             }
16048         }
16049
16050     try_posix:
16051
16052         /* Here, we have a class name to look up.  We can short circuit the
16053          * stuff below for short names that can't possibly be meant to be a
16054          * class name.  (We can do this on the first pass, as any second pass
16055          * will yield an even shorter name) */
16056         if (name_len < 3) {
16057             CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);
16058         }
16059
16060         /* Find which class it is.  Initially switch on the length of the name.
16061          * */
16062         switch (name_len) {
16063             case 4:
16064                 if (memEQs(name_start, 4, "word")) {
16065                     /* this is not POSIX, this is the Perl \w */
16066                     class_number = ANYOF_WORDCHAR;
16067                 }
16068                 break;
16069             case 5:
16070                 /* Names all of length 5: alnum alpha ascii blank cntrl digit
16071                  *                        graph lower print punct space upper
16072                  * Offset 4 gives the best switch position.  */
16073                 switch (name_start[4]) {
16074                     case 'a':
16075                         if (memBEGINs(name_start, 5, "alph")) /* alpha */
16076                             class_number = ANYOF_ALPHA;
16077                         break;
16078                     case 'e':
16079                         if (memBEGINs(name_start, 5, "spac")) /* space */
16080                             class_number = ANYOF_SPACE;
16081                         break;
16082                     case 'h':
16083                         if (memBEGINs(name_start, 5, "grap")) /* graph */
16084                             class_number = ANYOF_GRAPH;
16085                         break;
16086                     case 'i':
16087                         if (memBEGINs(name_start, 5, "asci")) /* ascii */
16088                             class_number = ANYOF_ASCII;
16089                         break;
16090                     case 'k':
16091                         if (memBEGINs(name_start, 5, "blan")) /* blank */
16092                             class_number = ANYOF_BLANK;
16093                         break;
16094                     case 'l':
16095                         if (memBEGINs(name_start, 5, "cntr")) /* cntrl */
16096                             class_number = ANYOF_CNTRL;
16097                         break;
16098                     case 'm':
16099                         if (memBEGINs(name_start, 5, "alnu")) /* alnum */
16100                             class_number = ANYOF_ALPHANUMERIC;
16101                         break;
16102                     case 'r':
16103                         if (memBEGINs(name_start, 5, "lowe")) /* lower */
16104                             class_number = (FOLD) ? ANYOF_CASED : ANYOF_LOWER;
16105                         else if (memBEGINs(name_start, 5, "uppe")) /* upper */
16106                             class_number = (FOLD) ? ANYOF_CASED : ANYOF_UPPER;
16107                         break;
16108                     case 't':
16109                         if (memBEGINs(name_start, 5, "digi")) /* digit */
16110                             class_number = ANYOF_DIGIT;
16111                         else if (memBEGINs(name_start, 5, "prin")) /* print */
16112                             class_number = ANYOF_PRINT;
16113                         else if (memBEGINs(name_start, 5, "punc")) /* punct */
16114                             class_number = ANYOF_PUNCT;
16115                         break;
16116                 }
16117                 break;
16118             case 6:
16119                 if (memEQs(name_start, 6, "xdigit"))
16120                     class_number = ANYOF_XDIGIT;
16121                 break;
16122         }
16123
16124         /* If the name exactly matches a posix class name the class number will
16125          * here be set to it, and the input almost certainly was meant to be a
16126          * posix class, so we can skip further checking.  If instead the syntax
16127          * is exactly correct, but the name isn't one of the legal ones, we
16128          * will return that as an error below.  But if neither of these apply,
16129          * it could be that no posix class was intended at all, or that one
16130          * was, but there was a typo.  We tease these apart by doing fuzzy
16131          * matching on the name */
16132         if (class_number == OOB_NAMEDCLASS && found_problem) {
16133             const UV posix_names[][6] = {
16134                                                 { 'a', 'l', 'n', 'u', 'm' },
16135                                                 { 'a', 'l', 'p', 'h', 'a' },
16136                                                 { 'a', 's', 'c', 'i', 'i' },
16137                                                 { 'b', 'l', 'a', 'n', 'k' },
16138                                                 { 'c', 'n', 't', 'r', 'l' },
16139                                                 { 'd', 'i', 'g', 'i', 't' },
16140                                                 { 'g', 'r', 'a', 'p', 'h' },
16141                                                 { 'l', 'o', 'w', 'e', 'r' },
16142                                                 { 'p', 'r', 'i', 'n', 't' },
16143                                                 { 'p', 'u', 'n', 'c', 't' },
16144                                                 { 's', 'p', 'a', 'c', 'e' },
16145                                                 { 'u', 'p', 'p', 'e', 'r' },
16146                                                 { 'w', 'o', 'r', 'd' },
16147                                                 { 'x', 'd', 'i', 'g', 'i', 't' }
16148                                             };
16149             /* The names of the above all have added NULs to make them the same
16150              * size, so we need to also have the real lengths */
16151             const UV posix_name_lengths[] = {
16152                                                 sizeof("alnum") - 1,
16153                                                 sizeof("alpha") - 1,
16154                                                 sizeof("ascii") - 1,
16155                                                 sizeof("blank") - 1,
16156                                                 sizeof("cntrl") - 1,
16157                                                 sizeof("digit") - 1,
16158                                                 sizeof("graph") - 1,
16159                                                 sizeof("lower") - 1,
16160                                                 sizeof("print") - 1,
16161                                                 sizeof("punct") - 1,
16162                                                 sizeof("space") - 1,
16163                                                 sizeof("upper") - 1,
16164                                                 sizeof("word")  - 1,
16165                                                 sizeof("xdigit")- 1
16166                                             };
16167             unsigned int i;
16168             int temp_max = max_distance;    /* Use a temporary, so if we
16169                                                reparse, we haven't changed the
16170                                                outer one */
16171
16172             /* Use a smaller max edit distance if we are missing one of the
16173              * delimiters */
16174             if (   has_opening_bracket + has_opening_colon < 2
16175                 || has_terminating_bracket + has_terminating_colon < 2)
16176             {
16177                 temp_max--;
16178             }
16179
16180             /* See if the input name is close to a legal one */
16181             for (i = 0; i < C_ARRAY_LENGTH(posix_names); i++) {
16182
16183                 /* Short circuit call if the lengths are too far apart to be
16184                  * able to match */
16185                 if (abs( (int) (name_len - posix_name_lengths[i]))
16186                     > temp_max)
16187                 {
16188                     continue;
16189                 }
16190
16191                 if (edit_distance(input_text,
16192                                   posix_names[i],
16193                                   name_len,
16194                                   posix_name_lengths[i],
16195                                   temp_max
16196                                  )
16197                     > -1)
16198                 { /* If it is close, it probably was intended to be a class */
16199                     goto probably_meant_to_be;
16200                 }
16201             }
16202
16203             /* Here the input name is not close enough to a valid class name
16204              * for us to consider it to be intended to be a posix class.  If
16205              * we haven't already done so, and the parse found a character that
16206              * could have been terminators for the name, but which we absorbed
16207              * as typos during the first pass, repeat the parse, signalling it
16208              * to stop at that character */
16209             if (possible_end && possible_end != (char *) -1) {
16210                 possible_end = (char *) -1;
16211                 p = name_start;
16212                 goto parse_name;
16213             }
16214
16215             /* Here neither pass found a close-enough class name */
16216             CLEAR_POSIX_WARNINGS_AND_RETURN(NOT_MEANT_TO_BE_A_POSIX_CLASS);
16217         }
16218
16219     probably_meant_to_be:
16220
16221         /* Here we think that a posix specification was intended.  Update any
16222          * parse pointer */
16223         if (updated_parse_ptr) {
16224             *updated_parse_ptr = (char *) p;
16225         }
16226
16227         /* If a posix class name was intended but incorrectly specified, we
16228          * output or return the warnings */
16229         if (found_problem) {
16230
16231             /* We set flags for these issues in the parse loop above instead of
16232              * adding them to the list of warnings, because we can parse it
16233              * twice, and we only want one warning instance */
16234             if (has_upper) {
16235                 ADD_POSIX_WARNING(p, "the name must be all lowercase letters");
16236             }
16237             if (has_blank) {
16238                 ADD_POSIX_WARNING(p, NO_BLANKS_POSIX_WARNING);
16239             }
16240             if (has_semi_colon) {
16241                 ADD_POSIX_WARNING(p, SEMI_COLON_POSIX_WARNING);
16242             }
16243             else if (! has_terminating_colon) {
16244                 ADD_POSIX_WARNING(p, "there is no terminating ':'");
16245             }
16246             if (! has_terminating_bracket) {
16247                 ADD_POSIX_WARNING(p, "there is no terminating ']'");
16248             }
16249
16250             if (   posix_warnings
16251                 && RExC_warn_text
16252                 && av_count(RExC_warn_text) > 0)
16253             {
16254                 *posix_warnings = RExC_warn_text;
16255             }
16256         }
16257         else if (class_number != OOB_NAMEDCLASS) {
16258             /* If it is a known class, return the class.  The class number
16259              * #defines are structured so each complement is +1 to the normal
16260              * one */
16261             CLEAR_POSIX_WARNINGS_AND_RETURN(class_number + complement);
16262         }
16263         else if (! check_only) {
16264
16265             /* Here, it is an unrecognized class.  This is an error (unless the
16266             * call is to check only, which we've already handled above) */
16267             const char * const complement_string = (complement)
16268                                                    ? "^"
16269                                                    : "";
16270             RExC_parse = (char *) p;
16271             vFAIL3utf8f("POSIX class [:%s%" UTF8f ":] unknown",
16272                         complement_string,
16273                         UTF8fARG(UTF, RExC_parse - name_start - 2, name_start));
16274         }
16275     }
16276
16277     return OOB_NAMEDCLASS;
16278 }
16279 #undef ADD_POSIX_WARNING
16280
16281 STATIC unsigned  int
16282 S_regex_set_precedence(const U8 my_operator) {
16283
16284     /* Returns the precedence in the (?[...]) construct of the input operator,
16285      * specified by its character representation.  The precedence follows
16286      * general Perl rules, but it extends this so that ')' and ']' have (low)
16287      * precedence even though they aren't really operators */
16288
16289     switch (my_operator) {
16290         case '!':
16291             return 5;
16292         case '&':
16293             return 4;
16294         case '^':
16295         case '|':
16296         case '+':
16297         case '-':
16298             return 3;
16299         case ')':
16300             return 2;
16301         case ']':
16302             return 1;
16303     }
16304
16305     NOT_REACHED; /* NOTREACHED */
16306     return 0;   /* Silence compiler warning */
16307 }
16308
16309 STATIC regnode_offset
16310 S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV** return_invlist,
16311                     I32 *flagp, U32 depth,
16312                     char * const oregcomp_parse)
16313 {
16314     /* Handle the (?[...]) construct to do set operations */
16315
16316     U8 curchar;                     /* Current character being parsed */
16317     UV start, end;                  /* End points of code point ranges */
16318     SV* final = NULL;               /* The end result inversion list */
16319     SV* result_string;              /* 'final' stringified */
16320     AV* stack;                      /* stack of operators and operands not yet
16321                                        resolved */
16322     AV* fence_stack = NULL;         /* A stack containing the positions in
16323                                        'stack' of where the undealt-with left
16324                                        parens would be if they were actually
16325                                        put there */
16326     /* The 'volatile' is a workaround for an optimiser bug
16327      * in Solaris Studio 12.3. See RT #127455 */
16328     volatile IV fence = 0;          /* Position of where most recent undealt-
16329                                        with left paren in stack is; -1 if none.
16330                                      */
16331     STRLEN len;                     /* Temporary */
16332     regnode_offset node;            /* Temporary, and final regnode returned by
16333                                        this function */
16334     const bool save_fold = FOLD;    /* Temporary */
16335     char *save_end, *save_parse;    /* Temporaries */
16336     const bool in_locale = LOC;     /* we turn off /l during processing */
16337
16338     DECLARE_AND_GET_RE_DEBUG_FLAGS;
16339
16340     PERL_ARGS_ASSERT_HANDLE_REGEX_SETS;
16341     PERL_UNUSED_ARG(oregcomp_parse); /* Only for Set_Node_Length */
16342
16343     DEBUG_PARSE("xcls");
16344
16345     if (in_locale) {
16346         set_regex_charset(&RExC_flags, REGEX_UNICODE_CHARSET);
16347     }
16348
16349     /* The use of this operator implies /u.  This is required so that the
16350      * compile time values are valid in all runtime cases */
16351     REQUIRE_UNI_RULES(flagp, 0);
16352
16353     ckWARNexperimental(RExC_parse,
16354                        WARN_EXPERIMENTAL__REGEX_SETS,
16355                        "The regex_sets feature is experimental");
16356
16357     /* Everything in this construct is a metacharacter.  Operands begin with
16358      * either a '\' (for an escape sequence), or a '[' for a bracketed
16359      * character class.  Any other character should be an operator, or
16360      * parenthesis for grouping.  Both types of operands are handled by calling
16361      * regclass() to parse them.  It is called with a parameter to indicate to
16362      * return the computed inversion list.  The parsing here is implemented via
16363      * a stack.  Each entry on the stack is a single character representing one
16364      * of the operators; or else a pointer to an operand inversion list. */
16365
16366 #define IS_OPERATOR(a) SvIOK(a)
16367 #define IS_OPERAND(a)  (! IS_OPERATOR(a))
16368
16369     /* The stack is kept in Łukasiewicz order.  (That's pronounced similar
16370      * to luke-a-shave-itch (or -itz), but people who didn't want to bother
16371      * with pronouncing it called it Reverse Polish instead, but now that YOU
16372      * know how to pronounce it you can use the correct term, thus giving due
16373      * credit to the person who invented it, and impressing your geek friends.
16374      * Wikipedia says that the pronounciation of "Ł" has been changing so that
16375      * it is now more like an English initial W (as in wonk) than an L.)
16376      *
16377      * This means that, for example, 'a | b & c' is stored on the stack as
16378      *
16379      * c  [4]
16380      * b  [3]
16381      * &  [2]
16382      * a  [1]
16383      * |  [0]
16384      *
16385      * where the numbers in brackets give the stack [array] element number.
16386      * In this implementation, parentheses are not stored on the stack.
16387      * Instead a '(' creates a "fence" so that the part of the stack below the
16388      * fence is invisible except to the corresponding ')' (this allows us to
16389      * replace testing for parens, by using instead subtraction of the fence
16390      * position).  As new operands are processed they are pushed onto the stack
16391      * (except as noted in the next paragraph).  New operators of higher
16392      * precedence than the current final one are inserted on the stack before
16393      * the lhs operand (so that when the rhs is pushed next, everything will be
16394      * in the correct positions shown above.  When an operator of equal or
16395      * lower precedence is encountered in parsing, all the stacked operations
16396      * of equal or higher precedence are evaluated, leaving the result as the
16397      * top entry on the stack.  This makes higher precedence operations
16398      * evaluate before lower precedence ones, and causes operations of equal
16399      * precedence to left associate.
16400      *
16401      * The only unary operator '!' is immediately pushed onto the stack when
16402      * encountered.  When an operand is encountered, if the top of the stack is
16403      * a '!", the complement is immediately performed, and the '!' popped.  The
16404      * resulting value is treated as a new operand, and the logic in the
16405      * previous paragraph is executed.  Thus in the expression
16406      *      [a] + ! [b]
16407      * the stack looks like
16408      *
16409      * !
16410      * a
16411      * +
16412      *
16413      * as 'b' gets parsed, the latter gets evaluated to '!b', and the stack
16414      * becomes
16415      *
16416      * !b
16417      * a
16418      * +
16419      *
16420      * A ')' is treated as an operator with lower precedence than all the
16421      * aforementioned ones, which causes all operations on the stack above the
16422      * corresponding '(' to be evaluated down to a single resultant operand.
16423      * Then the fence for the '(' is removed, and the operand goes through the
16424      * algorithm above, without the fence.
16425      *
16426      * A separate stack is kept of the fence positions, so that the position of
16427      * the latest so-far unbalanced '(' is at the top of it.
16428      *
16429      * The ']' ending the construct is treated as the lowest operator of all,
16430      * so that everything gets evaluated down to a single operand, which is the
16431      * result */
16432
16433     sv_2mortal((SV *)(stack = newAV()));
16434     sv_2mortal((SV *)(fence_stack = newAV()));
16435
16436     while (RExC_parse < RExC_end) {
16437         I32 top_index;              /* Index of top-most element in 'stack' */
16438         SV** top_ptr;               /* Pointer to top 'stack' element */
16439         SV* current = NULL;         /* To contain the current inversion list
16440                                        operand */
16441         SV* only_to_avoid_leaks;
16442
16443         skip_to_be_ignored_text(pRExC_state, &RExC_parse,
16444                                 TRUE /* Force /x */ );
16445         if (RExC_parse >= RExC_end) {   /* Fail */
16446             break;
16447         }
16448
16449         curchar = UCHARAT(RExC_parse);
16450
16451 redo_curchar:
16452
16453 #ifdef ENABLE_REGEX_SETS_DEBUGGING
16454                     /* Enable with -Accflags=-DENABLE_REGEX_SETS_DEBUGGING */
16455         DEBUG_U(dump_regex_sets_structures(pRExC_state,
16456                                            stack, fence, fence_stack));
16457 #endif
16458
16459         top_index = av_tindex_skip_len_mg(stack);
16460
16461         switch (curchar) {
16462             SV** stacked_ptr;       /* Ptr to something already on 'stack' */
16463             char stacked_operator;  /* The topmost operator on the 'stack'. */
16464             SV* lhs;                /* Operand to the left of the operator */
16465             SV* rhs;                /* Operand to the right of the operator */
16466             SV* fence_ptr;          /* Pointer to top element of the fence
16467                                        stack */
16468             case '(':
16469
16470                 if (   RExC_parse < RExC_end - 2
16471                     && UCHARAT(RExC_parse + 1) == '?'
16472                     && UCHARAT(RExC_parse + 2) == '^')
16473                 {
16474                     const regnode_offset orig_emit = RExC_emit;
16475                     SV * resultant_invlist;
16476
16477                     /* If is a '(?^', could be an embedded '(?^flags:(?[...])'.
16478                      * This happens when we have some thing like
16479                      *
16480                      *   my $thai_or_lao = qr/(?[ \p{Thai} + \p{Lao} ])/;
16481                      *   ...
16482                      *   qr/(?[ \p{Digit} & $thai_or_lao ])/;
16483                      *
16484                      * Here we would be handling the interpolated
16485                      * '$thai_or_lao'.  We handle this by a recursive call to
16486                      * reg which returns the inversion list the
16487                      * interpolated expression evaluates to.  Actually, the
16488                      * return is a special regnode containing a pointer to that
16489                      * inversion list.  If the return isn't that regnode alone,
16490                      * we know that this wasn't such an interpolation, which is
16491                      * an error: we need to get a single inversion list back
16492                      * from the recursion */
16493
16494                     RExC_parse++;
16495                     RExC_sets_depth++;
16496
16497                     node = reg(pRExC_state, 2, flagp, depth+1);
16498                     RETURN_FAIL_ON_RESTART(*flagp, flagp);
16499
16500                     if (   OP(REGNODE_p(node)) != REGEX_SET
16501                            /* If more than a single node returned, the nested
16502                             * parens evaluated to more than just a (?[...]),
16503                             * which isn't legal */
16504                         || RExC_emit != orig_emit
16505                                       + NODE_STEP_REGNODE
16506                                       + regarglen[REGEX_SET])
16507                     {
16508                         vFAIL("Expecting interpolated extended charclass");
16509                     }
16510                     resultant_invlist = (SV *) ARGp(REGNODE_p(node));
16511                     current = invlist_clone(resultant_invlist, NULL);
16512                     SvREFCNT_dec(resultant_invlist);
16513
16514                     RExC_sets_depth--;
16515                     RExC_emit = orig_emit;
16516                     goto handle_operand;
16517                 }
16518
16519                 /* A regular '('.  Look behind for illegal syntax */
16520                 if (top_index - fence >= 0) {
16521                     /* If the top entry on the stack is an operator, it had
16522                      * better be a '!', otherwise the entry below the top
16523                      * operand should be an operator */
16524                     if (   ! (top_ptr = av_fetch(stack, top_index, FALSE))
16525                         || (IS_OPERATOR(*top_ptr) && SvUV(*top_ptr) != '!')
16526                         || (   IS_OPERAND(*top_ptr)
16527                             && (   top_index - fence < 1
16528                                 || ! (stacked_ptr = av_fetch(stack,
16529                                                              top_index - 1,
16530                                                              FALSE))
16531                                 || ! IS_OPERATOR(*stacked_ptr))))
16532                     {
16533                         RExC_parse++;
16534                         vFAIL("Unexpected '(' with no preceding operator");
16535                     }
16536                 }
16537
16538                 /* Stack the position of this undealt-with left paren */
16539                 av_push(fence_stack, newSViv(fence));
16540                 fence = top_index + 1;
16541                 break;
16542
16543             case '\\':
16544                 /* regclass() can only return RESTART_PARSE and NEED_UTF8 if
16545                  * multi-char folds are allowed.  */
16546                 if (!regclass(pRExC_state, flagp, depth+1,
16547                               TRUE, /* means parse just the next thing */
16548                               FALSE, /* don't allow multi-char folds */
16549                               FALSE, /* don't silence non-portable warnings.  */
16550                               TRUE,  /* strict */
16551                               FALSE, /* Require return to be an ANYOF */
16552                               &current))
16553                 {
16554                     RETURN_FAIL_ON_RESTART(*flagp, flagp);
16555                     goto regclass_failed;
16556                 }
16557
16558                 assert(current);
16559
16560                 /* regclass() will return with parsing just the \ sequence,
16561                  * leaving the parse pointer at the next thing to parse */
16562                 RExC_parse--;
16563                 goto handle_operand;
16564
16565             case '[':   /* Is a bracketed character class */
16566             {
16567                 /* See if this is a [:posix:] class. */
16568                 bool is_posix_class = (OOB_NAMEDCLASS
16569                             < handle_possible_posix(pRExC_state,
16570                                                 RExC_parse + 1,
16571                                                 NULL,
16572                                                 NULL,
16573                                                 TRUE /* checking only */));
16574                 /* If it is a posix class, leave the parse pointer at the '['
16575                  * to fool regclass() into thinking it is part of a
16576                  * '[[:posix:]]'. */
16577                 if (! is_posix_class) {
16578                     RExC_parse++;
16579                 }
16580
16581                 /* regclass() can only return RESTART_PARSE and NEED_UTF8 if
16582                  * multi-char folds are allowed.  */
16583                 if (!regclass(pRExC_state, flagp, depth+1,
16584                                 is_posix_class, /* parse the whole char
16585                                                     class only if not a
16586                                                     posix class */
16587                                 FALSE, /* don't allow multi-char folds */
16588                                 TRUE, /* silence non-portable warnings. */
16589                                 TRUE, /* strict */
16590                                 FALSE, /* Require return to be an ANYOF */
16591                                 &current))
16592                 {
16593                     RETURN_FAIL_ON_RESTART(*flagp, flagp);
16594                     goto regclass_failed;
16595                 }
16596
16597                 assert(current);
16598
16599                 /* function call leaves parse pointing to the ']', except if we
16600                  * faked it */
16601                 if (is_posix_class) {
16602                     RExC_parse--;
16603                 }
16604
16605                 goto handle_operand;
16606             }
16607
16608             case ']':
16609                 if (top_index >= 1) {
16610                     goto join_operators;
16611                 }
16612
16613                 /* Only a single operand on the stack: are done */
16614                 goto done;
16615
16616             case ')':
16617                 if (av_tindex_skip_len_mg(fence_stack) < 0) {
16618                     if (UCHARAT(RExC_parse - 1) == ']')  {
16619                         break;
16620                     }
16621                     RExC_parse++;
16622                     vFAIL("Unexpected ')'");
16623                 }
16624
16625                 /* If nothing after the fence, is missing an operand */
16626                 if (top_index - fence < 0) {
16627                     RExC_parse++;
16628                     goto bad_syntax;
16629                 }
16630                 /* If at least two things on the stack, treat this as an
16631                   * operator */
16632                 if (top_index - fence >= 1) {
16633                     goto join_operators;
16634                 }
16635
16636                 /* Here only a single thing on the fenced stack, and there is a
16637                  * fence.  Get rid of it */
16638                 fence_ptr = av_pop(fence_stack);
16639                 assert(fence_ptr);
16640                 fence = SvIV(fence_ptr);
16641                 SvREFCNT_dec_NN(fence_ptr);
16642                 fence_ptr = NULL;
16643
16644                 if (fence < 0) {
16645                     fence = 0;
16646                 }
16647
16648                 /* Having gotten rid of the fence, we pop the operand at the
16649                  * stack top and process it as a newly encountered operand */
16650                 current = av_pop(stack);
16651                 if (IS_OPERAND(current)) {
16652                     goto handle_operand;
16653                 }
16654
16655                 RExC_parse++;
16656                 goto bad_syntax;
16657
16658             case '&':
16659             case '|':
16660             case '+':
16661             case '-':
16662             case '^':
16663
16664                 /* These binary operators should have a left operand already
16665                  * parsed */
16666                 if (   top_index - fence < 0
16667                     || top_index - fence == 1
16668                     || ( ! (top_ptr = av_fetch(stack, top_index, FALSE)))
16669                     || ! IS_OPERAND(*top_ptr))
16670                 {
16671                     goto unexpected_binary;
16672                 }
16673
16674                 /* If only the one operand is on the part of the stack visible
16675                  * to us, we just place this operator in the proper position */
16676                 if (top_index - fence < 2) {
16677
16678                     /* Place the operator before the operand */
16679
16680                     SV* lhs = av_pop(stack);
16681                     av_push(stack, newSVuv(curchar));
16682                     av_push(stack, lhs);
16683                     break;
16684                 }
16685
16686                 /* But if there is something else on the stack, we need to
16687                  * process it before this new operator if and only if the
16688                  * stacked operation has equal or higher precedence than the
16689                  * new one */
16690
16691              join_operators:
16692
16693                 /* The operator on the stack is supposed to be below both its
16694                  * operands */
16695                 if (   ! (stacked_ptr = av_fetch(stack, top_index - 2, FALSE))
16696                     || IS_OPERAND(*stacked_ptr))
16697                 {
16698                     /* But if not, it's legal and indicates we are completely
16699                      * done if and only if we're currently processing a ']',
16700                      * which should be the final thing in the expression */
16701                     if (curchar == ']') {
16702                         goto done;
16703                     }
16704
16705                   unexpected_binary:
16706                     RExC_parse++;
16707                     vFAIL2("Unexpected binary operator '%c' with no "
16708                            "preceding operand", curchar);
16709                 }
16710                 stacked_operator = (char) SvUV(*stacked_ptr);
16711
16712                 if (regex_set_precedence(curchar)
16713                     > regex_set_precedence(stacked_operator))
16714                 {
16715                     /* Here, the new operator has higher precedence than the
16716                      * stacked one.  This means we need to add the new one to
16717                      * the stack to await its rhs operand (and maybe more
16718                      * stuff).  We put it before the lhs operand, leaving
16719                      * untouched the stacked operator and everything below it
16720                      * */
16721                     lhs = av_pop(stack);
16722                     assert(IS_OPERAND(lhs));
16723
16724                     av_push(stack, newSVuv(curchar));
16725                     av_push(stack, lhs);
16726                     break;
16727                 }
16728
16729                 /* Here, the new operator has equal or lower precedence than
16730                  * what's already there.  This means the operation already
16731                  * there should be performed now, before the new one. */
16732
16733                 rhs = av_pop(stack);
16734                 if (! IS_OPERAND(rhs)) {
16735
16736                     /* This can happen when a ! is not followed by an operand,
16737                      * like in /(?[\t &!])/ */
16738                     goto bad_syntax;
16739                 }
16740
16741                 lhs = av_pop(stack);
16742
16743                 if (! IS_OPERAND(lhs)) {
16744
16745                     /* This can happen when there is an empty (), like in
16746                      * /(?[[0]+()+])/ */
16747                     goto bad_syntax;
16748                 }
16749
16750                 switch (stacked_operator) {
16751                     case '&':
16752                         _invlist_intersection(lhs, rhs, &rhs);
16753                         break;
16754
16755                     case '|':
16756                     case '+':
16757                         _invlist_union(lhs, rhs, &rhs);
16758                         break;
16759
16760                     case '-':
16761                         _invlist_subtract(lhs, rhs, &rhs);
16762                         break;
16763
16764                     case '^':   /* The union minus the intersection */
16765                     {
16766                         SV* i = NULL;
16767                         SV* u = NULL;
16768
16769                         _invlist_union(lhs, rhs, &u);
16770                         _invlist_intersection(lhs, rhs, &i);
16771                         _invlist_subtract(u, i, &rhs);
16772                         SvREFCNT_dec_NN(i);
16773                         SvREFCNT_dec_NN(u);
16774                         break;
16775                     }
16776                 }
16777                 SvREFCNT_dec(lhs);
16778
16779                 /* Here, the higher precedence operation has been done, and the
16780                  * result is in 'rhs'.  We overwrite the stacked operator with
16781                  * the result.  Then we redo this code to either push the new
16782                  * operator onto the stack or perform any higher precedence
16783                  * stacked operation */
16784                 only_to_avoid_leaks = av_pop(stack);
16785                 SvREFCNT_dec(only_to_avoid_leaks);
16786                 av_push(stack, rhs);
16787                 goto redo_curchar;
16788
16789             case '!':   /* Highest priority, right associative */
16790
16791                 /* If what's already at the top of the stack is another '!",
16792                  * they just cancel each other out */
16793                 if (   (top_ptr = av_fetch(stack, top_index, FALSE))
16794                     && (IS_OPERATOR(*top_ptr) && SvUV(*top_ptr) == '!'))
16795                 {
16796                     only_to_avoid_leaks = av_pop(stack);
16797                     SvREFCNT_dec(only_to_avoid_leaks);
16798                 }
16799                 else { /* Otherwise, since it's right associative, just push
16800                           onto the stack */
16801                     av_push(stack, newSVuv(curchar));
16802                 }
16803                 break;
16804
16805             default:
16806                 RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;
16807                 if (RExC_parse >= RExC_end) {
16808                     break;
16809                 }
16810                 vFAIL("Unexpected character");
16811
16812           handle_operand:
16813
16814             /* Here 'current' is the operand.  If something is already on the
16815              * stack, we have to check if it is a !.  But first, the code above
16816              * may have altered the stack in the time since we earlier set
16817              * 'top_index'.  */
16818
16819             top_index = av_tindex_skip_len_mg(stack);
16820             if (top_index - fence >= 0) {
16821                 /* If the top entry on the stack is an operator, it had better
16822                  * be a '!', otherwise the entry below the top operand should
16823                  * be an operator */
16824                 top_ptr = av_fetch(stack, top_index, FALSE);
16825                 assert(top_ptr);
16826                 if (IS_OPERATOR(*top_ptr)) {
16827
16828                     /* The only permissible operator at the top of the stack is
16829                      * '!', which is applied immediately to this operand. */
16830                     curchar = (char) SvUV(*top_ptr);
16831                     if (curchar != '!') {
16832                         SvREFCNT_dec(current);
16833                         vFAIL2("Unexpected binary operator '%c' with no "
16834                                 "preceding operand", curchar);
16835                     }
16836
16837                     _invlist_invert(current);
16838
16839                     only_to_avoid_leaks = av_pop(stack);
16840                     SvREFCNT_dec(only_to_avoid_leaks);
16841
16842                     /* And we redo with the inverted operand.  This allows
16843                      * handling multiple ! in a row */
16844                     goto handle_operand;
16845                 }
16846                           /* Single operand is ok only for the non-binary ')'
16847                            * operator */
16848                 else if ((top_index - fence == 0 && curchar != ')')
16849                          || (top_index - fence > 0
16850                              && (! (stacked_ptr = av_fetch(stack,
16851                                                            top_index - 1,
16852                                                            FALSE))
16853                                  || IS_OPERAND(*stacked_ptr))))
16854                 {
16855                     SvREFCNT_dec(current);
16856                     vFAIL("Operand with no preceding operator");
16857                 }
16858             }
16859
16860             /* Here there was nothing on the stack or the top element was
16861              * another operand.  Just add this new one */
16862             av_push(stack, current);
16863
16864         } /* End of switch on next parse token */
16865
16866         RExC_parse += (UTF) ? UTF8SKIP(RExC_parse) : 1;
16867     } /* End of loop parsing through the construct */
16868
16869     vFAIL("Syntax error in (?[...])");
16870
16871   done:
16872
16873     if (RExC_parse >= RExC_end || RExC_parse[1] != ')') {
16874         if (RExC_parse < RExC_end) {
16875             RExC_parse++;
16876         }
16877
16878         vFAIL("Unexpected ']' with no following ')' in (?[...");
16879     }
16880
16881     if (av_tindex_skip_len_mg(fence_stack) >= 0) {
16882         vFAIL("Unmatched (");
16883     }
16884
16885     if (av_tindex_skip_len_mg(stack) < 0   /* Was empty */
16886         || ((final = av_pop(stack)) == NULL)
16887         || ! IS_OPERAND(final)
16888         || ! is_invlist(final)
16889         || av_tindex_skip_len_mg(stack) >= 0)  /* More left on stack */
16890     {
16891       bad_syntax:
16892         SvREFCNT_dec(final);
16893         vFAIL("Incomplete expression within '(?[ ])'");
16894     }
16895
16896     /* Here, 'final' is the resultant inversion list from evaluating the
16897      * expression.  Return it if so requested */
16898     if (return_invlist) {
16899         *return_invlist = final;
16900         return END;
16901     }
16902
16903     if (RExC_sets_depth) {  /* If within a recursive call, return in a special
16904                                regnode */
16905         RExC_parse++;
16906         node = regpnode(pRExC_state, REGEX_SET, final);
16907     }
16908     else {
16909
16910         /* Otherwise generate a resultant node, based on 'final'.  regclass()
16911          * is expecting a string of ranges and individual code points */
16912         invlist_iterinit(final);
16913         result_string = newSVpvs("");
16914         while (invlist_iternext(final, &start, &end)) {
16915             if (start == end) {
16916                 Perl_sv_catpvf(aTHX_ result_string, "\\x{%" UVXf "}", start);
16917             }
16918             else {
16919                 Perl_sv_catpvf(aTHX_ result_string, "\\x{%" UVXf "}-\\x{%"
16920                                                         UVXf "}", start, end);
16921             }
16922         }
16923
16924         /* About to generate an ANYOF (or similar) node from the inversion list
16925          * we have calculated */
16926         save_parse = RExC_parse;
16927         RExC_parse = SvPV(result_string, len);
16928         save_end = RExC_end;
16929         RExC_end = RExC_parse + len;
16930         TURN_OFF_WARNINGS_IN_SUBSTITUTE_PARSE;
16931
16932         /* We turn off folding around the call, as the class we have
16933          * constructed already has all folding taken into consideration, and we
16934          * don't want regclass() to add to that */
16935         RExC_flags &= ~RXf_PMf_FOLD;
16936         /* regclass() can only return RESTART_PARSE and NEED_UTF8 if multi-char
16937          * folds are allowed.  */
16938         node = regclass(pRExC_state, flagp, depth+1,
16939                         FALSE, /* means parse the whole char class */
16940                         FALSE, /* don't allow multi-char folds */
16941                         TRUE, /* silence non-portable warnings.  The above may
16942                                  very well have generated non-portable code
16943                                  points, but they're valid on this machine */
16944                         FALSE, /* similarly, no need for strict */
16945
16946                         /* We can optimize into something besides an ANYOF,
16947                          * except under /l, which needs to be ANYOF because of
16948                          * runtime checks for locale sanity, etc */
16949                     ! in_locale,
16950                         NULL
16951                     );
16952
16953         RESTORE_WARNINGS;
16954         RExC_parse = save_parse + 1;
16955         RExC_end = save_end;
16956         SvREFCNT_dec_NN(final);
16957         SvREFCNT_dec_NN(result_string);
16958
16959         if (save_fold) {
16960             RExC_flags |= RXf_PMf_FOLD;
16961         }
16962
16963         if (!node) {
16964             RETURN_FAIL_ON_RESTART(*flagp, flagp);
16965             goto regclass_failed;
16966         }
16967
16968         /* Fix up the node type if we are in locale.  (We have pretended we are
16969          * under /u for the purposes of regclass(), as this construct will only
16970          * work under UTF-8 locales.  But now we change the opcode to be ANYOFL
16971          * (so as to cause any warnings about bad locales to be output in
16972          * regexec.c), and add the flag that indicates to check if not in a
16973          * UTF-8 locale.  The reason we above forbid optimization into
16974          * something other than an ANYOF node is simply to minimize the number
16975          * of code changes in regexec.c.  Otherwise we would have to create new
16976          * EXACTish node types and deal with them.  This decision could be
16977          * revisited should this construct become popular.
16978          *
16979          * (One might think we could look at the resulting ANYOF node and
16980          * suppress the flag if everything is above 255, as those would be
16981          * UTF-8 only, but this isn't true, as the components that led to that
16982          * result could have been locale-affected, and just happen to cancel
16983          * each other out under UTF-8 locales.) */
16984         if (in_locale) {
16985             set_regex_charset(&RExC_flags, REGEX_LOCALE_CHARSET);
16986
16987             assert(OP(REGNODE_p(node)) == ANYOF);
16988
16989             OP(REGNODE_p(node)) = ANYOFL;
16990             ANYOF_FLAGS(REGNODE_p(node))
16991                     |= ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD;
16992         }
16993     }
16994
16995     nextchar(pRExC_state);
16996     Set_Node_Length(REGNODE_p(node), RExC_parse - oregcomp_parse + 1); /* MJD */
16997     return node;
16998
16999   regclass_failed:
17000     FAIL2("panic: regclass returned failure to handle_sets, " "flags=%#" UVxf,
17001                                                                 (UV) *flagp);
17002 }
17003
17004 #ifdef ENABLE_REGEX_SETS_DEBUGGING
17005
17006 STATIC void
17007 S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state,
17008                              AV * stack, const IV fence, AV * fence_stack)
17009 {   /* Dumps the stacks in handle_regex_sets() */
17010
17011     const SSize_t stack_top = av_tindex_skip_len_mg(stack);
17012     const SSize_t fence_stack_top = av_tindex_skip_len_mg(fence_stack);
17013     SSize_t i;
17014
17015     PERL_ARGS_ASSERT_DUMP_REGEX_SETS_STRUCTURES;
17016
17017     PerlIO_printf(Perl_debug_log, "\nParse position is:%s\n", RExC_parse);
17018
17019     if (stack_top < 0) {
17020         PerlIO_printf(Perl_debug_log, "Nothing on stack\n");
17021     }
17022     else {
17023         PerlIO_printf(Perl_debug_log, "Stack: (fence=%d)\n", (int) fence);
17024         for (i = stack_top; i >= 0; i--) {
17025             SV ** element_ptr = av_fetch(stack, i, FALSE);
17026             if (! element_ptr) {
17027             }
17028
17029             if (IS_OPERATOR(*element_ptr)) {
17030                 PerlIO_printf(Perl_debug_log, "[%d]: %c\n",
17031                                             (int) i, (int) SvIV(*element_ptr));
17032             }
17033             else {
17034                 PerlIO_printf(Perl_debug_log, "[%d] ", (int) i);
17035                 sv_dump(*element_ptr);
17036             }
17037         }
17038     }
17039
17040     if (fence_stack_top < 0) {
17041         PerlIO_printf(Perl_debug_log, "Nothing on fence_stack\n");
17042     }
17043     else {
17044         PerlIO_printf(Perl_debug_log, "Fence_stack: \n");
17045         for (i = fence_stack_top; i >= 0; i--) {
17046             SV ** element_ptr = av_fetch(fence_stack, i, FALSE);
17047             if (! element_ptr) {
17048             }
17049
17050             PerlIO_printf(Perl_debug_log, "[%d]: %d\n",
17051                                             (int) i, (int) SvIV(*element_ptr));
17052         }
17053     }
17054 }
17055
17056 #endif
17057
17058 #undef IS_OPERATOR
17059 #undef IS_OPERAND
17060
17061 STATIC void
17062 S_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** invlist)
17063 {
17064     /* This adds the Latin1/above-Latin1 folding rules.
17065      *
17066      * This should be called only for a Latin1-range code points, cp, which is
17067      * known to be involved in a simple fold with other code points above
17068      * Latin1.  It would give false results if /aa has been specified.
17069      * Multi-char folds are outside the scope of this, and must be handled
17070      * specially. */
17071
17072     PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS;
17073
17074     assert(HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(cp));
17075
17076     /* The rules that are valid for all Unicode versions are hard-coded in */
17077     switch (cp) {
17078         case 'k':
17079         case 'K':
17080           *invlist =
17081              add_cp_to_invlist(*invlist, KELVIN_SIGN);
17082             break;
17083         case 's':
17084         case 'S':
17085           *invlist = add_cp_to_invlist(*invlist, LATIN_SMALL_LETTER_LONG_S);
17086             break;
17087         case MICRO_SIGN:
17088           *invlist = add_cp_to_invlist(*invlist, GREEK_CAPITAL_LETTER_MU);
17089           *invlist = add_cp_to_invlist(*invlist, GREEK_SMALL_LETTER_MU);
17090             break;
17091         case LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE:
17092         case LATIN_SMALL_LETTER_A_WITH_RING_ABOVE:
17093           *invlist = add_cp_to_invlist(*invlist, ANGSTROM_SIGN);
17094             break;
17095         case LATIN_SMALL_LETTER_Y_WITH_DIAERESIS:
17096           *invlist = add_cp_to_invlist(*invlist,
17097                                         LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS);
17098             break;
17099
17100         default:    /* Other code points are checked against the data for the
17101                        current Unicode version */
17102           {
17103             Size_t folds_count;
17104             U32 first_fold;
17105             const U32 * remaining_folds;
17106             UV folded_cp;
17107
17108             if (isASCII(cp)) {
17109                 folded_cp = toFOLD(cp);
17110             }
17111             else {
17112                 U8 dummy_fold[UTF8_MAXBYTES_CASE+1];
17113                 Size_t dummy_len;
17114                 folded_cp = _to_fold_latin1(cp, dummy_fold, &dummy_len, 0);
17115             }
17116
17117             if (folded_cp > 255) {
17118                 *invlist = add_cp_to_invlist(*invlist, folded_cp);
17119             }
17120
17121             folds_count = _inverse_folds(folded_cp, &first_fold,
17122                                                     &remaining_folds);
17123             if (folds_count == 0) {
17124
17125                 /* Use deprecated warning to increase the chances of this being
17126                  * output */
17127                 ckWARN2reg_d(RExC_parse,
17128                         "Perl folding rules are not up-to-date for 0x%02X;"
17129                         " please use the perlbug utility to report;", cp);
17130             }
17131             else {
17132                 unsigned int i;
17133
17134                 if (first_fold > 255) {
17135                     *invlist = add_cp_to_invlist(*invlist, first_fold);
17136                 }
17137                 for (i = 0; i < folds_count - 1; i++) {
17138                     if (remaining_folds[i] > 255) {
17139                         *invlist = add_cp_to_invlist(*invlist,
17140                                                     remaining_folds[i]);
17141                     }
17142                 }
17143             }
17144             break;
17145          }
17146     }
17147 }
17148
17149 STATIC void
17150 S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV* posix_warnings)
17151 {
17152     /* Output the elements of the array given by '*posix_warnings' as REGEXP
17153      * warnings. */
17154
17155     SV * msg;
17156     const bool first_is_fatal = ckDEAD(packWARN(WARN_REGEXP));
17157
17158     PERL_ARGS_ASSERT_OUTPUT_POSIX_WARNINGS;
17159
17160     if (! TO_OUTPUT_WARNINGS(RExC_parse)) {
17161         CLEAR_POSIX_WARNINGS();
17162         return;
17163     }
17164
17165     while ((msg = av_shift(posix_warnings)) != &PL_sv_undef) {
17166         if (first_is_fatal) {           /* Avoid leaking this */
17167             av_undef(posix_warnings);   /* This isn't necessary if the
17168                                             array is mortal, but is a
17169                                             fail-safe */
17170             (void) sv_2mortal(msg);
17171             PREPARE_TO_DIE;
17172         }
17173         Perl_warner(aTHX_ packWARN(WARN_REGEXP), "%s", SvPVX(msg));
17174         SvREFCNT_dec_NN(msg);
17175     }
17176
17177     UPDATE_WARNINGS_LOC(RExC_parse);
17178 }
17179
17180 PERL_STATIC_INLINE Size_t
17181 S_find_first_differing_byte_pos(const U8 * s1, const U8 * s2, const Size_t max)
17182 {
17183     const U8 * const start = s1;
17184     const U8 * const send = start + max;
17185
17186     PERL_ARGS_ASSERT_FIND_FIRST_DIFFERING_BYTE_POS;
17187
17188     while (s1 < send && *s1  == *s2) {
17189         s1++; s2++;
17190     }
17191
17192     return s1 - start;
17193 }
17194
17195
17196 STATIC AV *
17197 S_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, const STRLEN cp_count)
17198 {
17199     /* This adds the string scalar <multi_string> to the array
17200      * <multi_char_matches>.  <multi_string> is known to have exactly
17201      * <cp_count> code points in it.  This is used when constructing a
17202      * bracketed character class and we find something that needs to match more
17203      * than a single character.
17204      *
17205      * <multi_char_matches> is actually an array of arrays.  Each top-level
17206      * element is an array that contains all the strings known so far that are
17207      * the same length.  And that length (in number of code points) is the same
17208      * as the index of the top-level array.  Hence, the [2] element is an
17209      * array, each element thereof is a string containing TWO code points;
17210      * while element [3] is for strings of THREE characters, and so on.  Since
17211      * this is for multi-char strings there can never be a [0] nor [1] element.
17212      *
17213      * When we rewrite the character class below, we will do so such that the
17214      * longest strings are written first, so that it prefers the longest
17215      * matching strings first.  This is done even if it turns out that any
17216      * quantifier is non-greedy, out of this programmer's (khw) laziness.  Tom
17217      * Christiansen has agreed that this is ok.  This makes the test for the
17218      * ligature 'ffi' come before the test for 'ff', for example */
17219
17220     AV* this_array;
17221     AV** this_array_ptr;
17222
17223     PERL_ARGS_ASSERT_ADD_MULTI_MATCH;
17224
17225     if (! multi_char_matches) {
17226         multi_char_matches = newAV();
17227     }
17228
17229     if (av_exists(multi_char_matches, cp_count)) {
17230         this_array_ptr = (AV**) av_fetch(multi_char_matches, cp_count, FALSE);
17231         this_array = *this_array_ptr;
17232     }
17233     else {
17234         this_array = newAV();
17235         av_store(multi_char_matches, cp_count,
17236                  (SV*) this_array);
17237     }
17238     av_push(this_array, multi_string);
17239
17240     return multi_char_matches;
17241 }
17242
17243 /* The names of properties whose definitions are not known at compile time are
17244  * stored in this SV, after a constant heading.  So if the length has been
17245  * changed since initialization, then there is a run-time definition. */
17246 #define HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION                            \
17247                                         (SvCUR(listsv) != initial_listsv_len)
17248
17249 /* There is a restricted set of white space characters that are legal when
17250  * ignoring white space in a bracketed character class.  This generates the
17251  * code to skip them.
17252  *
17253  * There is a line below that uses the same white space criteria but is outside
17254  * this macro.  Both here and there must use the same definition */
17255 #define SKIP_BRACKETED_WHITE_SPACE(do_skip, p, stop_p)                  \
17256     STMT_START {                                                        \
17257         if (do_skip) {                                                  \
17258             while (p < stop_p && isBLANK_A(UCHARAT(p)))                 \
17259             {                                                           \
17260                 p++;                                                    \
17261             }                                                           \
17262         }                                                               \
17263     } STMT_END
17264
17265 STATIC regnode_offset
17266 S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth,
17267                  const bool stop_at_1,  /* Just parse the next thing, don't
17268                                            look for a full character class */
17269                  bool allow_mutiple_chars,
17270                  const bool silence_non_portable,   /* Don't output warnings
17271                                                        about too large
17272                                                        characters */
17273                  const bool strict,
17274                  bool optimizable,                  /* ? Allow a non-ANYOF return
17275                                                        node */
17276                  SV** ret_invlist  /* Return an inversion list, not a node */
17277           )
17278 {
17279     /* parse a bracketed class specification.  Most of these will produce an
17280      * ANYOF node; but something like [a] will produce an EXACT node; [aA], an
17281      * EXACTFish node; [[:ascii:]], a POSIXA node; etc.  It is more complex
17282      * under /i with multi-character folds: it will be rewritten following the
17283      * paradigm of this example, where the <multi-fold>s are characters which
17284      * fold to multiple character sequences:
17285      *      /[abc\x{multi-fold1}def\x{multi-fold2}ghi]/i
17286      * gets effectively rewritten as:
17287      *      /(?:\x{multi-fold1}|\x{multi-fold2}|[abcdefghi]/i
17288      * reg() gets called (recursively) on the rewritten version, and this
17289      * function will return what it constructs.  (Actually the <multi-fold>s
17290      * aren't physically removed from the [abcdefghi], it's just that they are
17291      * ignored in the recursion by means of a flag:
17292      * <RExC_in_multi_char_class>.)
17293      *
17294      * ANYOF nodes contain a bit map for the first NUM_ANYOF_CODE_POINTS
17295      * characters, with the corresponding bit set if that character is in the
17296      * list.  For characters above this, an inversion list is used.  There
17297      * are extra bits for \w, etc. in locale ANYOFs, as what these match is not
17298      * determinable at compile time
17299      *
17300      * On success, returns the offset at which any next node should be placed
17301      * into the regex engine program being compiled.
17302      *
17303      * Returns 0 otherwise, setting flagp to RESTART_PARSE if the parse needs
17304      * to be restarted, or'd with NEED_UTF8 if the pattern needs to be upgraded to
17305      * UTF-8
17306      */
17307
17308     UV prevvalue = OOB_UNICODE, save_prevvalue = OOB_UNICODE;
17309     IV range = 0;
17310     UV value = OOB_UNICODE, save_value = OOB_UNICODE;
17311     regnode_offset ret = -1;    /* Initialized to an illegal value */
17312     STRLEN numlen;
17313     int namedclass = OOB_NAMEDCLASS;
17314     char *rangebegin = NULL;
17315     SV *listsv = NULL;      /* List of \p{user-defined} whose definitions
17316                                aren't available at the time this was called */
17317     STRLEN initial_listsv_len = 0; /* Kind of a kludge to see if it is more
17318                                       than just initialized.  */
17319     SV* properties = NULL;    /* Code points that match \p{} \P{} */
17320     SV* posixes = NULL;     /* Code points that match classes like [:word:],
17321                                extended beyond the Latin1 range.  These have to
17322                                be kept separate from other code points for much
17323                                of this function because their handling  is
17324                                different under /i, and for most classes under
17325                                /d as well */
17326     SV* nposixes = NULL;    /* Similarly for [:^word:].  These are kept
17327                                separate for a while from the non-complemented
17328                                versions because of complications with /d
17329                                matching */
17330     SV* simple_posixes = NULL; /* But under some conditions, the classes can be
17331                                   treated more simply than the general case,
17332                                   leading to less compilation and execution
17333                                   work */
17334     UV element_count = 0;   /* Number of distinct elements in the class.
17335                                Optimizations may be possible if this is tiny */
17336     AV * multi_char_matches = NULL; /* Code points that fold to more than one
17337                                        character; used under /i */
17338     UV n;
17339     char * stop_ptr = RExC_end;    /* where to stop parsing */
17340
17341     /* ignore unescaped whitespace? */
17342     const bool skip_white = cBOOL(   ret_invlist
17343                                   || (RExC_flags & RXf_PMf_EXTENDED_MORE));
17344
17345     /* inversion list of code points this node matches only when the target
17346      * string is in UTF-8.  These are all non-ASCII, < 256.  (Because is under
17347      * /d) */
17348     SV* upper_latin1_only_utf8_matches = NULL;
17349
17350     /* Inversion list of code points this node matches regardless of things
17351      * like locale, folding, utf8ness of the target string */
17352     SV* cp_list = NULL;
17353
17354     /* Like cp_list, but code points on this list need to be checked for things
17355      * that fold to/from them under /i */
17356     SV* cp_foldable_list = NULL;
17357
17358     /* Like cp_list, but code points on this list are valid only when the
17359      * runtime locale is UTF-8 */
17360     SV* only_utf8_locale_list = NULL;
17361
17362     /* In a range, if one of the endpoints is non-character-set portable,
17363      * meaning that it hard-codes a code point that may mean a different
17364      * charactger in ASCII vs. EBCDIC, as opposed to, say, a literal 'A' or a
17365      * mnemonic '\t' which each mean the same character no matter which
17366      * character set the platform is on. */
17367     unsigned int non_portable_endpoint = 0;
17368
17369     /* Is the range unicode? which means on a platform that isn't 1-1 native
17370      * to Unicode (i.e. non-ASCII), each code point in it should be considered
17371      * to be a Unicode value.  */
17372     bool unicode_range = FALSE;
17373     bool invert = FALSE;    /* Is this class to be complemented */
17374
17375     bool warn_super = ALWAYS_WARN_SUPER;
17376
17377     const char * orig_parse = RExC_parse;
17378
17379     /* This variable is used to mark where the end in the input is of something
17380      * that looks like a POSIX construct but isn't.  During the parse, when
17381      * something looks like it could be such a construct is encountered, it is
17382      * checked for being one, but not if we've already checked this area of the
17383      * input.  Only after this position is reached do we check again */
17384     char *not_posix_region_end = RExC_parse - 1;
17385
17386     AV* posix_warnings = NULL;
17387     const bool do_posix_warnings = ckWARN(WARN_REGEXP);
17388     U8 op = END;    /* The returned node-type, initialized to an impossible
17389                        one.  */
17390     U8 anyof_flags = 0;   /* flag bits if the node is an ANYOF-type */
17391     U32 posixl = 0;       /* bit field of posix classes matched under /l */
17392
17393
17394 /* Flags as to what things aren't knowable until runtime.  (Note that these are
17395  * mutually exclusive.) */
17396 #define HAS_USER_DEFINED_PROPERTY 0x01   /* /u any user-defined properties that
17397                                             haven't been defined as of yet */
17398 #define HAS_D_RUNTIME_DEPENDENCY  0x02   /* /d if the target being matched is
17399                                             UTF-8 or not */
17400 #define HAS_L_RUNTIME_DEPENDENCY   0x04 /* /l what the posix classes match and
17401                                             what gets folded */
17402     U32 has_runtime_dependency = 0;     /* OR of the above flags */
17403
17404     DECLARE_AND_GET_RE_DEBUG_FLAGS;
17405
17406     PERL_ARGS_ASSERT_REGCLASS;
17407 #ifndef DEBUGGING
17408     PERL_UNUSED_ARG(depth);
17409 #endif
17410
17411     assert(! (ret_invlist && allow_mutiple_chars));
17412
17413     /* If wants an inversion list returned, we can't optimize to something
17414      * else. */
17415     if (ret_invlist) {
17416         optimizable = FALSE;
17417     }
17418
17419     DEBUG_PARSE("clas");
17420
17421 #if UNICODE_MAJOR_VERSION < 3 /* no multifolds in early Unicode */      \
17422     || (UNICODE_MAJOR_VERSION == 3 && UNICODE_DOT_VERSION == 0          \
17423                                    && UNICODE_DOT_DOT_VERSION == 0)
17424     allow_mutiple_chars = FALSE;
17425 #endif
17426
17427     /* We include the /i status at the beginning of this so that we can
17428      * know it at runtime */
17429     listsv = sv_2mortal(Perl_newSVpvf(aTHX_ "#%d\n", cBOOL(FOLD)));
17430     initial_listsv_len = SvCUR(listsv);
17431     SvTEMP_off(listsv); /* Grr, TEMPs and mortals are conflated.  */
17432
17433     SKIP_BRACKETED_WHITE_SPACE(skip_white, RExC_parse, RExC_end);
17434
17435     assert(RExC_parse <= RExC_end);
17436
17437     if (UCHARAT(RExC_parse) == '^') {   /* Complement the class */
17438         RExC_parse++;
17439         invert = TRUE;
17440         allow_mutiple_chars = FALSE;
17441         MARK_NAUGHTY(1);
17442         SKIP_BRACKETED_WHITE_SPACE(skip_white, RExC_parse, RExC_end);
17443     }
17444
17445     /* Check that they didn't say [:posix:] instead of [[:posix:]] */
17446     if (! ret_invlist && MAYBE_POSIXCC(UCHARAT(RExC_parse))) {
17447         int maybe_class = handle_possible_posix(pRExC_state,
17448                                                 RExC_parse,
17449                                                 &not_posix_region_end,
17450                                                 NULL,
17451                                                 TRUE /* checking only */);
17452         if (maybe_class >= OOB_NAMEDCLASS && do_posix_warnings) {
17453             ckWARN4reg(not_posix_region_end,
17454                     "POSIX syntax [%c %c] belongs inside character classes%s",
17455                     *RExC_parse, *RExC_parse,
17456                     (maybe_class == OOB_NAMEDCLASS)
17457                     ? ((POSIXCC_NOTYET(*RExC_parse))
17458                         ? " (but this one isn't implemented)"
17459                         : " (but this one isn't fully valid)")
17460                     : ""
17461                     );
17462         }
17463     }
17464
17465     /* If the caller wants us to just parse a single element, accomplish this
17466      * by faking the loop ending condition */
17467     if (stop_at_1 && RExC_end > RExC_parse) {
17468         stop_ptr = RExC_parse + 1;
17469     }
17470
17471     /* allow 1st char to be ']' (allowing it to be '-' is dealt with later) */
17472     if (UCHARAT(RExC_parse) == ']')
17473         goto charclassloop;
17474
17475     while (1) {
17476
17477         if (   posix_warnings
17478             && av_tindex_skip_len_mg(posix_warnings) >= 0
17479             && RExC_parse > not_posix_region_end)
17480         {
17481             /* Warnings about posix class issues are considered tentative until
17482              * we are far enough along in the parse that we can no longer
17483              * change our mind, at which point we output them.  This is done
17484              * each time through the loop so that a later class won't zap them
17485              * before they have been dealt with. */
17486             output_posix_warnings(pRExC_state, posix_warnings);
17487         }
17488
17489         SKIP_BRACKETED_WHITE_SPACE(skip_white, RExC_parse, RExC_end);
17490
17491         if  (RExC_parse >= stop_ptr) {
17492             break;
17493         }
17494
17495         if  (UCHARAT(RExC_parse) == ']') {
17496             break;
17497         }
17498
17499       charclassloop:
17500
17501         namedclass = OOB_NAMEDCLASS; /* initialize as illegal */
17502         save_value = value;
17503         save_prevvalue = prevvalue;
17504
17505         if (!range) {
17506             rangebegin = RExC_parse;
17507             element_count++;
17508             non_portable_endpoint = 0;
17509         }
17510         if (UTF && ! UTF8_IS_INVARIANT(* RExC_parse)) {
17511             value = utf8n_to_uvchr((U8*)RExC_parse,
17512                                    RExC_end - RExC_parse,
17513                                    &numlen, UTF8_ALLOW_DEFAULT);
17514             RExC_parse += numlen;
17515         }
17516         else
17517             value = UCHARAT(RExC_parse++);
17518
17519         if (value == '[') {
17520             char * posix_class_end;
17521             namedclass = handle_possible_posix(pRExC_state,
17522                                                RExC_parse,
17523                                                &posix_class_end,
17524                                                do_posix_warnings ? &posix_warnings : NULL,
17525                                                FALSE    /* die if error */);
17526             if (namedclass > OOB_NAMEDCLASS) {
17527
17528                 /* If there was an earlier attempt to parse this particular
17529                  * posix class, and it failed, it was a false alarm, as this
17530                  * successful one proves */
17531                 if (   posix_warnings
17532                     && av_tindex_skip_len_mg(posix_warnings) >= 0
17533                     && not_posix_region_end >= RExC_parse
17534                     && not_posix_region_end <= posix_class_end)
17535                 {
17536                     av_undef(posix_warnings);
17537                 }
17538
17539                 RExC_parse = posix_class_end;
17540             }
17541             else if (namedclass == OOB_NAMEDCLASS) {
17542                 not_posix_region_end = posix_class_end;
17543             }
17544             else {
17545                 namedclass = OOB_NAMEDCLASS;
17546             }
17547         }
17548         else if (   RExC_parse - 1 > not_posix_region_end
17549                  && MAYBE_POSIXCC(value))
17550         {
17551             (void) handle_possible_posix(
17552                         pRExC_state,
17553                         RExC_parse - 1,  /* -1 because parse has already been
17554                                             advanced */
17555                         &not_posix_region_end,
17556                         do_posix_warnings ? &posix_warnings : NULL,
17557                         TRUE /* checking only */);
17558         }
17559         else if (  strict && ! skip_white
17560                  && (   _generic_isCC(value, _CC_VERTSPACE)
17561                      || is_VERTWS_cp_high(value)))
17562         {
17563             vFAIL("Literal vertical space in [] is illegal except under /x");
17564         }
17565         else if (value == '\\') {
17566             /* Is a backslash; get the code point of the char after it */
17567
17568             if (RExC_parse >= RExC_end) {
17569                 vFAIL("Unmatched [");
17570             }
17571
17572             if (UTF && ! UTF8_IS_INVARIANT(UCHARAT(RExC_parse))) {
17573                 value = utf8n_to_uvchr((U8*)RExC_parse,
17574                                    RExC_end - RExC_parse,
17575                                    &numlen, UTF8_ALLOW_DEFAULT);
17576                 RExC_parse += numlen;
17577             }
17578             else
17579                 value = UCHARAT(RExC_parse++);
17580
17581             /* Some compilers cannot handle switching on 64-bit integer
17582              * values, therefore value cannot be an UV.  Yes, this will
17583              * be a problem later if we want switch on Unicode.
17584              * A similar issue a little bit later when switching on
17585              * namedclass. --jhi */
17586
17587             /* If the \ is escaping white space when white space is being
17588              * skipped, it means that that white space is wanted literally, and
17589              * is already in 'value'.  Otherwise, need to translate the escape
17590              * into what it signifies. */
17591             if (! skip_white || ! isBLANK_A(value)) switch ((I32)value) {
17592                 const char * message;
17593                 U32 packed_warn;
17594                 U8 grok_c_char;
17595
17596             case 'w':   namedclass = ANYOF_WORDCHAR;    break;
17597             case 'W':   namedclass = ANYOF_NWORDCHAR;   break;
17598             case 's':   namedclass = ANYOF_SPACE;       break;
17599             case 'S':   namedclass = ANYOF_NSPACE;      break;
17600             case 'd':   namedclass = ANYOF_DIGIT;       break;
17601             case 'D':   namedclass = ANYOF_NDIGIT;      break;
17602             case 'v':   namedclass = ANYOF_VERTWS;      break;
17603             case 'V':   namedclass = ANYOF_NVERTWS;     break;
17604             case 'h':   namedclass = ANYOF_HORIZWS;     break;
17605             case 'H':   namedclass = ANYOF_NHORIZWS;    break;
17606             case 'N':  /* Handle \N{NAME} in class */
17607                 {
17608                     const char * const backslash_N_beg = RExC_parse - 2;
17609                     int cp_count;
17610
17611                     if (! grok_bslash_N(pRExC_state,
17612                                         NULL,      /* No regnode */
17613                                         &value,    /* Yes single value */
17614                                         &cp_count, /* Multiple code pt count */
17615                                         flagp,
17616                                         strict,
17617                                         depth)
17618                     ) {
17619
17620                         if (*flagp & NEED_UTF8)
17621                             FAIL("panic: grok_bslash_N set NEED_UTF8");
17622
17623                         RETURN_FAIL_ON_RESTART_FLAGP(flagp);
17624
17625                         if (cp_count < 0) {
17626                             vFAIL("\\N in a character class must be a named character: \\N{...}");
17627                         }
17628                         else if (cp_count == 0) {
17629                             ckWARNreg(RExC_parse,
17630                               "Ignoring zero length \\N{} in character class");
17631                         }
17632                         else { /* cp_count > 1 */
17633                             assert(cp_count > 1);
17634                             if (! RExC_in_multi_char_class) {
17635                                 if ( ! allow_mutiple_chars
17636                                     || invert
17637                                     || range
17638                                     || *RExC_parse == '-')
17639                                 {
17640                                     if (strict) {
17641                                         RExC_parse--;
17642                                         vFAIL("\\N{} here is restricted to one character");
17643                                     }
17644                                     ckWARNreg(RExC_parse, "Using just the first character returned by \\N{} in character class");
17645                                     break; /* <value> contains the first code
17646                                               point. Drop out of the switch to
17647                                               process it */
17648                                 }
17649                                 else {
17650                                     SV * multi_char_N = newSVpvn(backslash_N_beg,
17651                                                  RExC_parse - backslash_N_beg);
17652                                     multi_char_matches
17653                                         = add_multi_match(multi_char_matches,
17654                                                           multi_char_N,
17655                                                           cp_count);
17656                                 }
17657                             }
17658                         } /* End of cp_count != 1 */
17659
17660                         /* This element should not be processed further in this
17661                          * class */
17662                         element_count--;
17663                         value = save_value;
17664                         prevvalue = save_prevvalue;
17665                         continue;   /* Back to top of loop to get next char */
17666                     }
17667
17668                     /* Here, is a single code point, and <value> contains it */
17669                     unicode_range = TRUE;   /* \N{} are Unicode */
17670                 }
17671                 break;
17672             case 'p':
17673             case 'P':
17674                 {
17675                 char *e;
17676
17677                 if (RExC_pm_flags & PMf_WILDCARD) {
17678                     RExC_parse++;
17679                     /* diag_listed_as: Use of %s is not allowed in Unicode
17680                        property wildcard subpatterns in regex; marked by <--
17681                        HERE in m/%s/ */
17682                     vFAIL3("Use of '\\%c%c' is not allowed in Unicode property"
17683                            " wildcard subpatterns", (char) value, *(RExC_parse - 1));
17684                 }
17685
17686                 /* \p means they want Unicode semantics */
17687                 REQUIRE_UNI_RULES(flagp, 0);
17688
17689                 if (RExC_parse >= RExC_end)
17690                     vFAIL2("Empty \\%c", (U8)value);
17691                 if (*RExC_parse == '{') {
17692                     const U8 c = (U8)value;
17693                     e = (char *) memchr(RExC_parse, '}', RExC_end - RExC_parse);
17694                     if (!e) {
17695                         RExC_parse++;
17696                         vFAIL2("Missing right brace on \\%c{}", c);
17697                     }
17698
17699                     RExC_parse++;
17700
17701                     /* White space is allowed adjacent to the braces and after
17702                      * any '^', even when not under /x */
17703                     while (isSPACE(*RExC_parse)) {
17704                          RExC_parse++;
17705                     }
17706
17707                     if (UCHARAT(RExC_parse) == '^') {
17708
17709                         /* toggle.  (The rhs xor gets the single bit that
17710                          * differs between P and p; the other xor inverts just
17711                          * that bit) */
17712                         value ^= 'P' ^ 'p';
17713
17714                         RExC_parse++;
17715                         while (isSPACE(*RExC_parse)) {
17716                             RExC_parse++;
17717                         }
17718                     }
17719
17720                     if (e == RExC_parse)
17721                         vFAIL2("Empty \\%c{}", c);
17722
17723                     n = e - RExC_parse;
17724                     while (isSPACE(*(RExC_parse + n - 1)))
17725                         n--;
17726
17727                 }   /* The \p isn't immediately followed by a '{' */
17728                 else if (! isALPHA(*RExC_parse)) {
17729                     RExC_parse += (UTF)
17730                                   ? UTF8_SAFE_SKIP(RExC_parse, RExC_end)
17731                                   : 1;
17732                     vFAIL2("Character following \\%c must be '{' or a "
17733                            "single-character Unicode property name",
17734                            (U8) value);
17735                 }
17736                 else {
17737                     e = RExC_parse;
17738                     n = 1;
17739                 }
17740                 {
17741                     char* name = RExC_parse;
17742
17743                     /* Any message returned about expanding the definition */
17744                     SV* msg = newSVpvs_flags("", SVs_TEMP);
17745
17746                     /* If set TRUE, the property is user-defined as opposed to
17747                      * official Unicode */
17748                     bool user_defined = FALSE;
17749                     AV * strings = NULL;
17750
17751                     SV * prop_definition = parse_uniprop_string(
17752                                             name, n, UTF, FOLD,
17753                                             FALSE, /* This is compile-time */
17754
17755                                             /* We can't defer this defn when
17756                                              * the full result is required in
17757                                              * this call */
17758                                             ! cBOOL(ret_invlist),
17759
17760                                             &strings,
17761                                             &user_defined,
17762                                             msg,
17763                                             0 /* Base level */
17764                                            );
17765                     if (SvCUR(msg)) {   /* Assumes any error causes a msg */
17766                         assert(prop_definition == NULL);
17767                         RExC_parse = e + 1;
17768                         if (SvUTF8(msg)) {  /* msg being UTF-8 makes the whole
17769                                                thing so, or else the display is
17770                                                mojibake */
17771                             RExC_utf8 = TRUE;
17772                         }
17773                         /* diag_listed_as: Can't find Unicode property definition "%s" in regex; marked by <-- HERE in m/%s/ */
17774                         vFAIL2utf8f("%" UTF8f, UTF8fARG(SvUTF8(msg),
17775                                     SvCUR(msg), SvPVX(msg)));
17776                     }
17777
17778                     assert(prop_definition || strings);
17779
17780                     if (strings) {
17781                         if (ret_invlist) {
17782                             if (! prop_definition) {
17783                                 RExC_parse = e + 1;
17784                                 vFAIL("Unicode string properties are not implemented in (?[...])");
17785                             }
17786                             else {
17787                                 ckWARNreg(e + 1,
17788                                     "Using just the single character results"
17789                                     " returned by \\p{} in (?[...])");
17790                             }
17791                         }
17792                         else if (! RExC_in_multi_char_class) {
17793                             if (invert ^ (value == 'P')) {
17794                                 RExC_parse = e + 1;
17795                                 vFAIL("Inverting a character class which contains"
17796                                     " a multi-character sequence is illegal");
17797                             }
17798
17799                             /* For each multi-character string ... */
17800                             while (av_count(strings) > 0) {
17801                                 /* ... Each entry is itself an array of code
17802                                 * points. */
17803                                 AV * this_string = (AV *) av_shift( strings);
17804                                 STRLEN cp_count = av_count(this_string);
17805                                 SV * final = newSV(cp_count * 4);
17806                                 SvPVCLEAR(final);
17807
17808                                 /* Create another string of sequences of \x{...} */
17809                                 while (av_count(this_string) > 0) {
17810                                     SV * character = av_shift(this_string);
17811                                     UV cp = SvUV(character);
17812
17813                                     if (cp > 255) {
17814                                         REQUIRE_UTF8(flagp);
17815                                     }
17816                                     Perl_sv_catpvf(aTHX_ final, "\\x{%" UVXf "}",
17817                                                                         cp);
17818                                     SvREFCNT_dec_NN(character);
17819                                 }
17820                                 SvREFCNT_dec_NN(this_string);
17821
17822                                 /* And add that to the list of such things */
17823                                 multi_char_matches
17824                                             = add_multi_match(multi_char_matches,
17825                                                             final,
17826                                                             cp_count);
17827                             }
17828                         }
17829                         SvREFCNT_dec_NN(strings);
17830                     }
17831
17832                     if (! prop_definition) {    /* If we got only a string,
17833                                                    this iteration didn't really
17834                                                    find a character */
17835                         element_count--;
17836                     }
17837                     else if (! is_invlist(prop_definition)) {
17838
17839                         /* Here, the definition isn't known, so we have gotten
17840                          * returned a string that will be evaluated if and when
17841                          * encountered at runtime.  We add it to the list of
17842                          * such properties, along with whether it should be
17843                          * complemented or not */
17844                         if (value == 'P') {
17845                             sv_catpvs(listsv, "!");
17846                         }
17847                         else {
17848                             sv_catpvs(listsv, "+");
17849                         }
17850                         sv_catsv(listsv, prop_definition);
17851
17852                         has_runtime_dependency |= HAS_USER_DEFINED_PROPERTY;
17853
17854                         /* We don't know yet what this matches, so have to flag
17855                          * it */
17856                         anyof_flags |= ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP;
17857                     }
17858                     else {
17859                         assert (prop_definition && is_invlist(prop_definition));
17860
17861                         /* Here we do have the complete property definition
17862                          *
17863                          * Temporary workaround for [perl #133136].  For this
17864                          * precise input that is in the .t that is failing,
17865                          * load utf8.pm, which is what the test wants, so that
17866                          * that .t passes */
17867                         if (     memEQs(RExC_start, e + 1 - RExC_start,
17868                                         "foo\\p{Alnum}")
17869                             && ! hv_common(GvHVn(PL_incgv),
17870                                            NULL,
17871                                            "utf8.pm", sizeof("utf8.pm") - 1,
17872                                            0, HV_FETCH_ISEXISTS, NULL, 0))
17873                         {
17874                             require_pv("utf8.pm");
17875                         }
17876
17877                         if (! user_defined &&
17878                             /* We warn on matching an above-Unicode code point
17879                              * if the match would return true, except don't
17880                              * warn for \p{All}, which has exactly one element
17881                              * = 0 */
17882                             (_invlist_contains_cp(prop_definition, 0x110000)
17883                                 && (! (_invlist_len(prop_definition) == 1
17884                                        && *invlist_array(prop_definition) == 0))))
17885                         {
17886                             warn_super = TRUE;
17887                         }
17888
17889                         /* Invert if asking for the complement */
17890                         if (value == 'P') {
17891                             _invlist_union_complement_2nd(properties,
17892                                                           prop_definition,
17893                                                           &properties);
17894                         }
17895                         else {
17896                             _invlist_union(properties, prop_definition, &properties);
17897                         }
17898                     }
17899                 }
17900
17901                 RExC_parse = e + 1;
17902                 namedclass = ANYOF_UNIPROP;  /* no official name, but it's
17903                                                 named */
17904                 }
17905                 break;
17906             case 'n':   value = '\n';                   break;
17907             case 'r':   value = '\r';                   break;
17908             case 't':   value = '\t';                   break;
17909             case 'f':   value = '\f';                   break;
17910             case 'b':   value = '\b';                   break;
17911             case 'e':   value = ESC_NATIVE;             break;
17912             case 'a':   value = '\a';                   break;
17913             case 'o':
17914                 RExC_parse--;   /* function expects to be pointed at the 'o' */
17915                 if (! grok_bslash_o(&RExC_parse,
17916                                             RExC_end,
17917                                             &value,
17918                                             &message,
17919                                             &packed_warn,
17920                                             strict,
17921                                             cBOOL(range), /* MAX_UV allowed for range
17922                                                       upper limit */
17923                                             UTF))
17924                 {
17925                     vFAIL(message);
17926                 }
17927                 else if (message && TO_OUTPUT_WARNINGS(RExC_parse)) {
17928                     warn_non_literal_string(RExC_parse, packed_warn, message);
17929                 }
17930
17931                 if (value < 256) {
17932                     non_portable_endpoint++;
17933                 }
17934                 break;
17935             case 'x':
17936                 RExC_parse--;   /* function expects to be pointed at the 'x' */
17937                 if (!  grok_bslash_x(&RExC_parse,
17938                                             RExC_end,
17939                                             &value,
17940                                             &message,
17941                                             &packed_warn,
17942                                             strict,
17943                                             cBOOL(range), /* MAX_UV allowed for range
17944                                                       upper limit */
17945                                             UTF))
17946                 {
17947                     vFAIL(message);
17948                 }
17949                 else if (message && TO_OUTPUT_WARNINGS(RExC_parse)) {
17950                     warn_non_literal_string(RExC_parse, packed_warn, message);
17951                 }
17952
17953                 if (value < 256) {
17954                     non_portable_endpoint++;
17955                 }
17956                 break;
17957             case 'c':
17958                 if (! grok_bslash_c(*RExC_parse, &grok_c_char, &message,
17959                                                                 &packed_warn))
17960                 {
17961                     /* going to die anyway; point to exact spot of
17962                         * failure */
17963                     RExC_parse += (UTF)
17964                                   ? UTF8_SAFE_SKIP(RExC_parse, RExC_end)
17965                                   : 1;
17966                     vFAIL(message);
17967                 }
17968
17969                 value = grok_c_char;
17970                 RExC_parse++;
17971                 if (message && TO_OUTPUT_WARNINGS(RExC_parse)) {
17972                     warn_non_literal_string(RExC_parse, packed_warn, message);
17973                 }
17974
17975                 non_portable_endpoint++;
17976                 break;
17977             case '0': case '1': case '2': case '3': case '4':
17978             case '5': case '6': case '7':
17979                 {
17980                     /* Take 1-3 octal digits */
17981                     I32 flags = PERL_SCAN_SILENT_ILLDIGIT
17982                               | PERL_SCAN_NOTIFY_ILLDIGIT;
17983                     numlen = (strict) ? 4 : 3;
17984                     value = grok_oct(--RExC_parse, &numlen, &flags, NULL);
17985                     RExC_parse += numlen;
17986                     if (numlen != 3) {
17987                         if (strict) {
17988                             RExC_parse += (UTF)
17989                                           ? UTF8_SAFE_SKIP(RExC_parse, RExC_end)
17990                                           : 1;
17991                             vFAIL("Need exactly 3 octal digits");
17992                         }
17993                         else if (  (flags & PERL_SCAN_NOTIFY_ILLDIGIT)
17994                                  && RExC_parse < RExC_end
17995                                  && isDIGIT(*RExC_parse)
17996                                  && ckWARN(WARN_REGEXP))
17997                         {
17998                             reg_warn_non_literal_string(
17999                                  RExC_parse + 1,
18000                                  form_alien_digit_msg(8, numlen, RExC_parse,
18001                                                         RExC_end, UTF, FALSE));
18002                         }
18003                     }
18004                     if (value < 256) {
18005                         non_portable_endpoint++;
18006                     }
18007                     break;
18008                 }
18009             default:
18010                 /* Allow \_ to not give an error */
18011                 if (isWORDCHAR(value) && value != '_') {
18012                     if (strict) {
18013                         vFAIL2("Unrecognized escape \\%c in character class",
18014                                (int)value);
18015                     }
18016                     else {
18017                         ckWARN2reg(RExC_parse,
18018                             "Unrecognized escape \\%c in character class passed through",
18019                             (int)value);
18020                     }
18021                 }
18022                 break;
18023             }   /* End of switch on char following backslash */
18024         } /* end of handling backslash escape sequences */
18025
18026         /* Here, we have the current token in 'value' */
18027
18028         if (namedclass > OOB_NAMEDCLASS) { /* this is a named class \blah */
18029             U8 classnum;
18030
18031             /* a bad range like a-\d, a-[:digit:].  The '-' is taken as a
18032              * literal, as is the character that began the false range, i.e.
18033              * the 'a' in the examples */
18034             if (range) {
18035                 const int w = (RExC_parse >= rangebegin)
18036                                 ? RExC_parse - rangebegin
18037                                 : 0;
18038                 if (strict) {
18039                     vFAIL2utf8f(
18040                         "False [] range \"%" UTF8f "\"",
18041                         UTF8fARG(UTF, w, rangebegin));
18042                 }
18043                 else {
18044                     ckWARN2reg(RExC_parse,
18045                         "False [] range \"%" UTF8f "\"",
18046                         UTF8fARG(UTF, w, rangebegin));
18047                     cp_list = add_cp_to_invlist(cp_list, '-');
18048                     cp_foldable_list = add_cp_to_invlist(cp_foldable_list,
18049                                                             prevvalue);
18050                 }
18051
18052                 range = 0; /* this was not a true range */
18053                 element_count += 2; /* So counts for three values */
18054             }
18055
18056             classnum = namedclass_to_classnum(namedclass);
18057
18058             if (LOC && namedclass < ANYOF_POSIXL_MAX
18059 #ifndef HAS_ISASCII
18060                 && classnum != _CC_ASCII
18061 #endif
18062             ) {
18063                 SV* scratch_list = NULL;
18064
18065                 /* What the Posix classes (like \w, [:space:]) match isn't
18066                  * generally knowable under locale until actual match time.  A
18067                  * special node is used for these which has extra space for a
18068                  * bitmap, with a bit reserved for each named class that is to
18069                  * be matched against.  (This isn't needed for \p{} and
18070                  * pseudo-classes, as they are not affected by locale, and
18071                  * hence are dealt with separately.)  However, if a named class
18072                  * and its complement are both present, then it matches
18073                  * everything, and there is no runtime dependency.  Odd numbers
18074                  * are the complements of the next lower number, so xor works.
18075                  * (Note that something like [\w\D] should match everything,
18076                  * because \d should be a proper subset of \w.  But rather than
18077                  * trust that the locale is well behaved, we leave this to
18078                  * runtime to sort out) */
18079                 if (POSIXL_TEST(posixl, namedclass ^ 1)) {
18080                     cp_list = _add_range_to_invlist(cp_list, 0, UV_MAX);
18081                     POSIXL_ZERO(posixl);
18082                     has_runtime_dependency &= ~HAS_L_RUNTIME_DEPENDENCY;
18083                     anyof_flags &= ~ANYOF_MATCHES_POSIXL;
18084                     continue;   /* We could ignore the rest of the class, but
18085                                    best to parse it for any errors */
18086                 }
18087                 else { /* Here, isn't the complement of any already parsed
18088                           class */
18089                     POSIXL_SET(posixl, namedclass);
18090                     has_runtime_dependency |= HAS_L_RUNTIME_DEPENDENCY;
18091                     anyof_flags |= ANYOF_MATCHES_POSIXL;
18092
18093                     /* The above-Latin1 characters are not subject to locale
18094                      * rules.  Just add them to the unconditionally-matched
18095                      * list */
18096
18097                     /* Get the list of the above-Latin1 code points this
18098                      * matches */
18099                     _invlist_intersection_maybe_complement_2nd(PL_AboveLatin1,
18100                                             PL_XPosix_ptrs[classnum],
18101
18102                                             /* Odd numbers are complements,
18103                                              * like NDIGIT, NASCII, ... */
18104                                             namedclass % 2 != 0,
18105                                             &scratch_list);
18106                     /* Checking if 'cp_list' is NULL first saves an extra
18107                      * clone.  Its reference count will be decremented at the
18108                      * next union, etc, or if this is the only instance, at the
18109                      * end of the routine */
18110                     if (! cp_list) {
18111                         cp_list = scratch_list;
18112                     }
18113                     else {
18114                         _invlist_union(cp_list, scratch_list, &cp_list);
18115                         SvREFCNT_dec_NN(scratch_list);
18116                     }
18117                     continue;   /* Go get next character */
18118                 }
18119             }
18120             else {
18121
18122                 /* Here, is not /l, or is a POSIX class for which /l doesn't
18123                  * matter (or is a Unicode property, which is skipped here). */
18124                 if (namedclass >= ANYOF_POSIXL_MAX) {  /* If a special class */
18125                     if (namedclass != ANYOF_UNIPROP) { /* UNIPROP = \p and \P */
18126
18127                         /* Here, should be \h, \H, \v, or \V.  None of /d, /i
18128                          * nor /l make a difference in what these match,
18129                          * therefore we just add what they match to cp_list. */
18130                         if (classnum != _CC_VERTSPACE) {
18131                             assert(   namedclass == ANYOF_HORIZWS
18132                                    || namedclass == ANYOF_NHORIZWS);
18133
18134                             /* It turns out that \h is just a synonym for
18135                              * XPosixBlank */
18136                             classnum = _CC_BLANK;
18137                         }
18138
18139                         _invlist_union_maybe_complement_2nd(
18140                                 cp_list,
18141                                 PL_XPosix_ptrs[classnum],
18142                                 namedclass % 2 != 0,    /* Complement if odd
18143                                                           (NHORIZWS, NVERTWS)
18144                                                         */
18145                                 &cp_list);
18146                     }
18147                 }
18148                 else if (   AT_LEAST_UNI_SEMANTICS
18149                          || classnum == _CC_ASCII
18150                          || (DEPENDS_SEMANTICS && (   classnum == _CC_DIGIT
18151                                                    || classnum == _CC_XDIGIT)))
18152                 {
18153                     /* We usually have to worry about /d affecting what POSIX
18154                      * classes match, with special code needed because we won't
18155                      * know until runtime what all matches.  But there is no
18156                      * extra work needed under /u and /a; and [:ascii:] is
18157                      * unaffected by /d; and :digit: and :xdigit: don't have
18158                      * runtime differences under /d.  So we can special case
18159                      * these, and avoid some extra work below, and at runtime.
18160                      * */
18161                     _invlist_union_maybe_complement_2nd(
18162                                                      simple_posixes,
18163                                                       ((AT_LEAST_ASCII_RESTRICTED)
18164                                                        ? PL_Posix_ptrs[classnum]
18165                                                        : PL_XPosix_ptrs[classnum]),
18166                                                      namedclass % 2 != 0,
18167                                                      &simple_posixes);
18168                 }
18169                 else {  /* Garden variety class.  If is NUPPER, NALPHA, ...
18170                            complement and use nposixes */
18171                     SV** posixes_ptr = namedclass % 2 == 0
18172                                        ? &posixes
18173                                        : &nposixes;
18174                     _invlist_union_maybe_complement_2nd(
18175                                                      *posixes_ptr,
18176                                                      PL_XPosix_ptrs[classnum],
18177                                                      namedclass % 2 != 0,
18178                                                      posixes_ptr);
18179                 }
18180             }
18181         } /* end of namedclass \blah */
18182
18183         SKIP_BRACKETED_WHITE_SPACE(skip_white, RExC_parse, RExC_end);
18184
18185         /* If 'range' is set, 'value' is the ending of a range--check its
18186          * validity.  (If value isn't a single code point in the case of a
18187          * range, we should have figured that out above in the code that
18188          * catches false ranges).  Later, we will handle each individual code
18189          * point in the range.  If 'range' isn't set, this could be the
18190          * beginning of a range, so check for that by looking ahead to see if
18191          * the next real character to be processed is the range indicator--the
18192          * minus sign */
18193
18194         if (range) {
18195 #ifdef EBCDIC
18196             /* For unicode ranges, we have to test that the Unicode as opposed
18197              * to the native values are not decreasing.  (Above 255, there is
18198              * no difference between native and Unicode) */
18199             if (unicode_range && prevvalue < 255 && value < 255) {
18200                 if (NATIVE_TO_LATIN1(prevvalue) > NATIVE_TO_LATIN1(value)) {
18201                     goto backwards_range;
18202                 }
18203             }
18204             else
18205 #endif
18206             if (prevvalue > value) /* b-a */ {
18207                 int w;
18208 #ifdef EBCDIC
18209               backwards_range:
18210 #endif
18211                 w = RExC_parse - rangebegin;
18212                 vFAIL2utf8f(
18213                     "Invalid [] range \"%" UTF8f "\"",
18214                     UTF8fARG(UTF, w, rangebegin));
18215                 NOT_REACHED; /* NOTREACHED */
18216             }
18217         }
18218         else {
18219             prevvalue = value; /* save the beginning of the potential range */
18220             if (! stop_at_1     /* Can't be a range if parsing just one thing */
18221                 && *RExC_parse == '-')
18222             {
18223                 char* next_char_ptr = RExC_parse + 1;
18224
18225                 /* Get the next real char after the '-' */
18226                 SKIP_BRACKETED_WHITE_SPACE(skip_white, next_char_ptr, RExC_end);
18227
18228                 /* If the '-' is at the end of the class (just before the ']',
18229                  * it is a literal minus; otherwise it is a range */
18230                 if (next_char_ptr < RExC_end && *next_char_ptr != ']') {
18231                     RExC_parse = next_char_ptr;
18232
18233                     /* a bad range like \w-, [:word:]- ? */
18234                     if (namedclass > OOB_NAMEDCLASS) {
18235                         if (strict || ckWARN(WARN_REGEXP)) {
18236                             const int w = RExC_parse >= rangebegin
18237                                           ?  RExC_parse - rangebegin
18238                                           : 0;
18239                             if (strict) {
18240                                 vFAIL4("False [] range \"%*.*s\"",
18241                                     w, w, rangebegin);
18242                             }
18243                             else {
18244                                 vWARN4(RExC_parse,
18245                                     "False [] range \"%*.*s\"",
18246                                     w, w, rangebegin);
18247                             }
18248                         }
18249                         cp_list = add_cp_to_invlist(cp_list, '-');
18250                         element_count++;
18251                     } else
18252                         range = 1;      /* yeah, it's a range! */
18253                     continue;   /* but do it the next time */
18254                 }
18255             }
18256         }
18257
18258         if (namedclass > OOB_NAMEDCLASS) {
18259             continue;
18260         }
18261
18262         /* Here, we have a single value this time through the loop, and
18263          * <prevvalue> is the beginning of the range, if any; or <value> if
18264          * not. */
18265
18266         /* non-Latin1 code point implies unicode semantics. */
18267         if (value > 255) {
18268             if (value > MAX_LEGAL_CP && (   value != UV_MAX
18269                                          || prevvalue > MAX_LEGAL_CP))
18270             {
18271                 vFAIL(form_cp_too_large_msg(16, NULL, 0, value));
18272             }
18273             REQUIRE_UNI_RULES(flagp, 0);
18274             if (  ! silence_non_portable
18275                 &&  UNICODE_IS_PERL_EXTENDED(value)
18276                 &&  TO_OUTPUT_WARNINGS(RExC_parse))
18277             {
18278                 ckWARN2_non_literal_string(RExC_parse,
18279                                            packWARN(WARN_PORTABLE),
18280                                            PL_extended_cp_format,
18281                                            value);
18282             }
18283         }
18284
18285         /* Ready to process either the single value, or the completed range.
18286          * For single-valued non-inverted ranges, we consider the possibility
18287          * of multi-char folds.  (We made a conscious decision to not do this
18288          * for the other cases because it can often lead to non-intuitive
18289          * results.  For example, you have the peculiar case that:
18290          *  "s s" =~ /^[^\xDF]+$/i => Y
18291          *  "ss"  =~ /^[^\xDF]+$/i => N
18292          *
18293          * See [perl #89750] */
18294         if (FOLD && allow_mutiple_chars && value == prevvalue) {
18295             if (    value == LATIN_SMALL_LETTER_SHARP_S
18296                 || (value > 255 && _invlist_contains_cp(PL_HasMultiCharFold,
18297                                                         value)))
18298             {
18299                 /* Here <value> is indeed a multi-char fold.  Get what it is */
18300
18301                 U8 foldbuf[UTF8_MAXBYTES_CASE+1];
18302                 STRLEN foldlen;
18303
18304                 UV folded = _to_uni_fold_flags(
18305                                 value,
18306                                 foldbuf,
18307                                 &foldlen,
18308                                 FOLD_FLAGS_FULL | (ASCII_FOLD_RESTRICTED
18309                                                    ? FOLD_FLAGS_NOMIX_ASCII
18310                                                    : 0)
18311                                 );
18312
18313                 /* Here, <folded> should be the first character of the
18314                  * multi-char fold of <value>, with <foldbuf> containing the
18315                  * whole thing.  But, if this fold is not allowed (because of
18316                  * the flags), <fold> will be the same as <value>, and should
18317                  * be processed like any other character, so skip the special
18318                  * handling */
18319                 if (folded != value) {
18320
18321                     /* Skip if we are recursed, currently parsing the class
18322                      * again.  Otherwise add this character to the list of
18323                      * multi-char folds. */
18324                     if (! RExC_in_multi_char_class) {
18325                         STRLEN cp_count = utf8_length(foldbuf,
18326                                                       foldbuf + foldlen);
18327                         SV* multi_fold = sv_2mortal(newSVpvs(""));
18328
18329                         Perl_sv_catpvf(aTHX_ multi_fold, "\\x{%" UVXf "}", value);
18330
18331                         multi_char_matches
18332                                         = add_multi_match(multi_char_matches,
18333                                                           multi_fold,
18334                                                           cp_count);
18335
18336                     }
18337
18338                     /* This element should not be processed further in this
18339                      * class */
18340                     element_count--;
18341                     value = save_value;
18342                     prevvalue = save_prevvalue;
18343                     continue;
18344                 }
18345             }
18346         }
18347
18348         if (strict && ckWARN(WARN_REGEXP)) {
18349             if (range) {
18350
18351                 /* If the range starts above 255, everything is portable and
18352                  * likely to be so for any forseeable character set, so don't
18353                  * warn. */
18354                 if (unicode_range && non_portable_endpoint && prevvalue < 256) {
18355                     vWARN(RExC_parse, "Both or neither range ends should be Unicode");
18356                 }
18357                 else if (prevvalue != value) {
18358
18359                     /* Under strict, ranges that stop and/or end in an ASCII
18360                      * printable should have each end point be a portable value
18361                      * for it (preferably like 'A', but we don't warn if it is
18362                      * a (portable) Unicode name or code point), and the range
18363                      * must be all digits or all letters of the same case.
18364                      * Otherwise, the range is non-portable and unclear as to
18365                      * what it contains */
18366                     if (             (isPRINT_A(prevvalue) || isPRINT_A(value))
18367                         && (          non_portable_endpoint
18368                             || ! (   (isDIGIT_A(prevvalue) && isDIGIT_A(value))
18369                                   || (isLOWER_A(prevvalue) && isLOWER_A(value))
18370                                   || (isUPPER_A(prevvalue) && isUPPER_A(value))
18371                     ))) {
18372                         vWARN(RExC_parse, "Ranges of ASCII printables should"
18373                                           " be some subset of \"0-9\","
18374                                           " \"A-Z\", or \"a-z\"");
18375                     }
18376                     else if (prevvalue >= FIRST_NON_ASCII_DECIMAL_DIGIT) {
18377                         SSize_t index_start;
18378                         SSize_t index_final;
18379
18380                         /* But the nature of Unicode and languages mean we
18381                          * can't do the same checks for above-ASCII ranges,
18382                          * except in the case of digit ones.  These should
18383                          * contain only digits from the same group of 10.  The
18384                          * ASCII case is handled just above.  Hence here, the
18385                          * range could be a range of digits.  First some
18386                          * unlikely special cases.  Grandfather in that a range
18387                          * ending in 19DA (NEW TAI LUE THAM DIGIT ONE) is bad
18388                          * if its starting value is one of the 10 digits prior
18389                          * to it.  This is because it is an alternate way of
18390                          * writing 19D1, and some people may expect it to be in
18391                          * that group.  But it is bad, because it won't give
18392                          * the expected results.  In Unicode 5.2 it was
18393                          * considered to be in that group (of 11, hence), but
18394                          * this was fixed in the next version */
18395
18396                         if (UNLIKELY(value == 0x19DA && prevvalue >= 0x19D0)) {
18397                             goto warn_bad_digit_range;
18398                         }
18399                         else if (UNLIKELY(   prevvalue >= 0x1D7CE
18400                                           &&     value <= 0x1D7FF))
18401                         {
18402                             /* This is the only other case currently in Unicode
18403                              * where the algorithm below fails.  The code
18404                              * points just above are the end points of a single
18405                              * range containing only decimal digits.  It is 5
18406                              * different series of 0-9.  All other ranges of
18407                              * digits currently in Unicode are just a single
18408                              * series.  (And mktables will notify us if a later
18409                              * Unicode version breaks this.)
18410                              *
18411                              * If the range being checked is at most 9 long,
18412                              * and the digit values represented are in
18413                              * numerical order, they are from the same series.
18414                              * */
18415                             if (         value - prevvalue > 9
18416                                 ||    (((    value - 0x1D7CE) % 10)
18417                                      <= (prevvalue - 0x1D7CE) % 10))
18418                             {
18419                                 goto warn_bad_digit_range;
18420                             }
18421                         }
18422                         else {
18423
18424                             /* For all other ranges of digits in Unicode, the
18425                              * algorithm is just to check if both end points
18426                              * are in the same series, which is the same range.
18427                              * */
18428                             index_start = _invlist_search(
18429                                                     PL_XPosix_ptrs[_CC_DIGIT],
18430                                                     prevvalue);
18431
18432                             /* Warn if the range starts and ends with a digit,
18433                              * and they are not in the same group of 10. */
18434                             if (   index_start >= 0
18435                                 && ELEMENT_RANGE_MATCHES_INVLIST(index_start)
18436                                 && (index_final =
18437                                     _invlist_search(PL_XPosix_ptrs[_CC_DIGIT],
18438                                                     value)) != index_start
18439                                 && index_final >= 0
18440                                 && ELEMENT_RANGE_MATCHES_INVLIST(index_final))
18441                             {
18442                               warn_bad_digit_range:
18443                                 vWARN(RExC_parse, "Ranges of digits should be"
18444                                                   " from the same group of"
18445                                                   " 10");
18446                             }
18447                         }
18448                     }
18449                 }
18450             }
18451             if ((! range || prevvalue == value) && non_portable_endpoint) {
18452                 if (isPRINT_A(value)) {
18453                     char literal[3];
18454                     unsigned d = 0;
18455                     if (isBACKSLASHED_PUNCT(value)) {
18456                         literal[d++] = '\\';
18457                     }
18458                     literal[d++] = (char) value;
18459                     literal[d++] = '\0';
18460
18461                     vWARN4(RExC_parse,
18462                            "\"%.*s\" is more clearly written simply as \"%s\"",
18463                            (int) (RExC_parse - rangebegin),
18464                            rangebegin,
18465                            literal
18466                         );
18467                 }
18468                 else if (isMNEMONIC_CNTRL(value)) {
18469                     vWARN4(RExC_parse,
18470                            "\"%.*s\" is more clearly written simply as \"%s\"",
18471                            (int) (RExC_parse - rangebegin),
18472                            rangebegin,
18473                            cntrl_to_mnemonic((U8) value)
18474                         );
18475                 }
18476             }
18477         }
18478
18479         /* Deal with this element of the class */
18480
18481 #ifndef EBCDIC
18482         cp_foldable_list = _add_range_to_invlist(cp_foldable_list,
18483                                                     prevvalue, value);
18484 #else
18485         /* On non-ASCII platforms, for ranges that span all of 0..255, and ones
18486          * that don't require special handling, we can just add the range like
18487          * we do for ASCII platforms */
18488         if ((UNLIKELY(prevvalue == 0) && value >= 255)
18489             || ! (prevvalue < 256
18490                     && (unicode_range
18491                         || (! non_portable_endpoint
18492                             && ((isLOWER_A(prevvalue) && isLOWER_A(value))
18493                                 || (isUPPER_A(prevvalue)
18494                                     && isUPPER_A(value)))))))
18495         {
18496             cp_foldable_list = _add_range_to_invlist(cp_foldable_list,
18497                                                         prevvalue, value);
18498         }
18499         else {
18500             /* Here, requires special handling.  This can be because it is a
18501              * range whose code points are considered to be Unicode, and so
18502              * must be individually translated into native, or because its a
18503              * subrange of 'A-Z' or 'a-z' which each aren't contiguous in
18504              * EBCDIC, but we have defined them to include only the "expected"
18505              * upper or lower case ASCII alphabetics.  Subranges above 255 are
18506              * the same in native and Unicode, so can be added as a range */
18507             U8 start = NATIVE_TO_LATIN1(prevvalue);
18508             unsigned j;
18509             U8 end = (value < 256) ? NATIVE_TO_LATIN1(value) : 255;
18510             for (j = start; j <= end; j++) {
18511                 cp_foldable_list = add_cp_to_invlist(cp_foldable_list, LATIN1_TO_NATIVE(j));
18512             }
18513             if (value > 255) {
18514                 cp_foldable_list = _add_range_to_invlist(cp_foldable_list,
18515                                                             256, value);
18516             }
18517         }
18518 #endif
18519
18520         range = 0; /* this range (if it was one) is done now */
18521     } /* End of loop through all the text within the brackets */
18522
18523     if (   posix_warnings && av_tindex_skip_len_mg(posix_warnings) >= 0) {
18524         output_posix_warnings(pRExC_state, posix_warnings);
18525     }
18526
18527     /* If anything in the class expands to more than one character, we have to
18528      * deal with them by building up a substitute parse string, and recursively
18529      * calling reg() on it, instead of proceeding */
18530     if (multi_char_matches) {
18531         SV * substitute_parse = newSVpvn_flags("?:", 2, SVs_TEMP);
18532         I32 cp_count;
18533         STRLEN len;
18534         char *save_end = RExC_end;
18535         char *save_parse = RExC_parse;
18536         char *save_start = RExC_start;
18537         Size_t constructed_prefix_len = 0; /* This gives the length of the
18538                                               constructed portion of the
18539                                               substitute parse. */
18540         bool first_time = TRUE;     /* First multi-char occurrence doesn't get
18541                                        a "|" */
18542         I32 reg_flags;
18543
18544         assert(! invert);
18545         /* Only one level of recursion allowed */
18546         assert(RExC_copy_start_in_constructed == RExC_precomp);
18547
18548 #if 0   /* Have decided not to deal with multi-char folds in inverted classes,
18549            because too confusing */
18550         if (invert) {
18551             sv_catpvs(substitute_parse, "(?:");
18552         }
18553 #endif
18554
18555         /* Look at the longest strings first */
18556         for (cp_count = av_tindex_skip_len_mg(multi_char_matches);
18557                         cp_count > 0;
18558                         cp_count--)
18559         {
18560
18561             if (av_exists(multi_char_matches, cp_count)) {
18562                 AV** this_array_ptr;
18563                 SV* this_sequence;
18564
18565                 this_array_ptr = (AV**) av_fetch(multi_char_matches,
18566                                                  cp_count, FALSE);
18567                 while ((this_sequence = av_pop(*this_array_ptr)) !=
18568                                                                 &PL_sv_undef)
18569                 {
18570                     if (! first_time) {
18571                         sv_catpvs(substitute_parse, "|");
18572                     }
18573                     first_time = FALSE;
18574
18575                     sv_catpv(substitute_parse, SvPVX(this_sequence));
18576                 }
18577             }
18578         }
18579
18580         /* If the character class contains anything else besides these
18581          * multi-character strings, have to include it in recursive parsing */
18582         if (element_count) {
18583             bool has_l_bracket = orig_parse > RExC_start && *(orig_parse - 1) == '[';
18584
18585             sv_catpvs(substitute_parse, "|");
18586             if (has_l_bracket) {    /* Add an [ if the original had one */
18587                 sv_catpvs(substitute_parse, "[");
18588             }
18589             constructed_prefix_len = SvCUR(substitute_parse);
18590             sv_catpvn(substitute_parse, orig_parse, RExC_parse - orig_parse);
18591
18592             /* Put in a closing ']' to match any opening one, but not if going
18593              * off the end, as otherwise we are adding something that really
18594              * isn't there */
18595             if (has_l_bracket && RExC_parse < RExC_end) {
18596                 sv_catpvs(substitute_parse, "]");
18597             }
18598         }
18599
18600         sv_catpvs(substitute_parse, ")");
18601 #if 0
18602         if (invert) {
18603             /* This is a way to get the parse to skip forward a whole named
18604              * sequence instead of matching the 2nd character when it fails the
18605              * first */
18606             sv_catpvs(substitute_parse, "(*THEN)(*SKIP)(*FAIL)|.)");
18607         }
18608 #endif
18609
18610         /* Set up the data structure so that any errors will be properly
18611          * reported.  See the comments at the definition of
18612          * REPORT_LOCATION_ARGS for details */
18613         RExC_copy_start_in_input = (char *) orig_parse;
18614         RExC_start = RExC_parse = SvPV(substitute_parse, len);
18615         RExC_copy_start_in_constructed = RExC_start + constructed_prefix_len;
18616         RExC_end = RExC_parse + len;
18617         RExC_in_multi_char_class = 1;
18618
18619         ret = reg(pRExC_state, 1, &reg_flags, depth+1);
18620
18621         *flagp |= reg_flags & (HASWIDTH|SIMPLE|POSTPONED|RESTART_PARSE|NEED_UTF8);
18622
18623         /* And restore so can parse the rest of the pattern */
18624         RExC_parse = save_parse;
18625         RExC_start = RExC_copy_start_in_constructed = RExC_copy_start_in_input = save_start;
18626         RExC_end = save_end;
18627         RExC_in_multi_char_class = 0;
18628         SvREFCNT_dec_NN(multi_char_matches);
18629         return ret;
18630     }
18631
18632     /* If folding, we calculate all characters that could fold to or from the
18633      * ones already on the list */
18634     if (cp_foldable_list) {
18635         if (FOLD) {
18636             UV start, end;      /* End points of code point ranges */
18637
18638             SV* fold_intersection = NULL;
18639             SV** use_list;
18640
18641             /* Our calculated list will be for Unicode rules.  For locale
18642              * matching, we have to keep a separate list that is consulted at
18643              * runtime only when the locale indicates Unicode rules (and we
18644              * don't include potential matches in the ASCII/Latin1 range, as
18645              * any code point could fold to any other, based on the run-time
18646              * locale).   For non-locale, we just use the general list */
18647             if (LOC) {
18648                 use_list = &only_utf8_locale_list;
18649             }
18650             else {
18651                 use_list = &cp_list;
18652             }
18653
18654             /* Only the characters in this class that participate in folds need
18655              * be checked.  Get the intersection of this class and all the
18656              * possible characters that are foldable.  This can quickly narrow
18657              * down a large class */
18658             _invlist_intersection(PL_in_some_fold, cp_foldable_list,
18659                                   &fold_intersection);
18660
18661             /* Now look at the foldable characters in this class individually */
18662             invlist_iterinit(fold_intersection);
18663             while (invlist_iternext(fold_intersection, &start, &end)) {
18664                 UV j;
18665                 UV folded;
18666
18667                 /* Look at every character in the range */
18668                 for (j = start; j <= end; j++) {
18669                     U8 foldbuf[UTF8_MAXBYTES_CASE+1];
18670                     STRLEN foldlen;
18671                     unsigned int k;
18672                     Size_t folds_count;
18673                     U32 first_fold;
18674                     const U32 * remaining_folds;
18675
18676                     if (j < 256) {
18677
18678                         /* Under /l, we don't know what code points below 256
18679                          * fold to, except we do know the MICRO SIGN folds to
18680                          * an above-255 character if the locale is UTF-8, so we
18681                          * add it to the special list (in *use_list)  Otherwise
18682                          * we know now what things can match, though some folds
18683                          * are valid under /d only if the target is UTF-8.
18684                          * Those go in a separate list */
18685                         if (      IS_IN_SOME_FOLD_L1(j)
18686                             && ! (LOC && j != MICRO_SIGN))
18687                         {
18688
18689                             /* ASCII is always matched; non-ASCII is matched
18690                              * only under Unicode rules (which could happen
18691                              * under /l if the locale is a UTF-8 one */
18692                             if (isASCII(j) || ! DEPENDS_SEMANTICS) {
18693                                 *use_list = add_cp_to_invlist(*use_list,
18694                                                             PL_fold_latin1[j]);
18695                             }
18696                             else if (j != PL_fold_latin1[j]) {
18697                                 upper_latin1_only_utf8_matches
18698                                         = add_cp_to_invlist(
18699                                                 upper_latin1_only_utf8_matches,
18700                                                 PL_fold_latin1[j]);
18701                             }
18702                         }
18703
18704                         if (HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(j)
18705                             && (! isASCII(j) || ! ASCII_FOLD_RESTRICTED))
18706                         {
18707                             add_above_Latin1_folds(pRExC_state,
18708                                                    (U8) j,
18709                                                    use_list);
18710                         }
18711                         continue;
18712                     }
18713
18714                     /* Here is an above Latin1 character.  We don't have the
18715                      * rules hard-coded for it.  First, get its fold.  This is
18716                      * the simple fold, as the multi-character folds have been
18717                      * handled earlier and separated out */
18718                     folded = _to_uni_fold_flags(j, foldbuf, &foldlen,
18719                                                         (ASCII_FOLD_RESTRICTED)
18720                                                         ? FOLD_FLAGS_NOMIX_ASCII
18721                                                         : 0);
18722
18723                     /* Single character fold of above Latin1.  Add everything
18724                      * in its fold closure to the list that this node should
18725                      * match. */
18726                     folds_count = _inverse_folds(folded, &first_fold,
18727                                                     &remaining_folds);
18728                     for (k = 0; k <= folds_count; k++) {
18729                         UV c = (k == 0)     /* First time through use itself */
18730                                 ? folded
18731                                 : (k == 1)  /* 2nd time use, the first fold */
18732                                    ? first_fold
18733
18734                                      /* Then the remaining ones */
18735                                    : remaining_folds[k-2];
18736
18737                         /* /aa doesn't allow folds between ASCII and non- */
18738                         if ((   ASCII_FOLD_RESTRICTED
18739                             && (isASCII(c) != isASCII(j))))
18740                         {
18741                             continue;
18742                         }
18743
18744                         /* Folds under /l which cross the 255/256 boundary are
18745                          * added to a separate list.  (These are valid only
18746                          * when the locale is UTF-8.) */
18747                         if (c < 256 && LOC) {
18748                             *use_list = add_cp_to_invlist(*use_list, c);
18749                             continue;
18750                         }
18751
18752                         if (isASCII(c) || c > 255 || AT_LEAST_UNI_SEMANTICS)
18753                         {
18754                             cp_list = add_cp_to_invlist(cp_list, c);
18755                         }
18756                         else {
18757                             /* Similarly folds involving non-ascii Latin1
18758                              * characters under /d are added to their list */
18759                             upper_latin1_only_utf8_matches
18760                                     = add_cp_to_invlist(
18761                                                 upper_latin1_only_utf8_matches,
18762                                                 c);
18763                         }
18764                     }
18765                 }
18766             }
18767             SvREFCNT_dec_NN(fold_intersection);
18768         }
18769
18770         /* Now that we have finished adding all the folds, there is no reason
18771          * to keep the foldable list separate */
18772         _invlist_union(cp_list, cp_foldable_list, &cp_list);
18773         SvREFCNT_dec_NN(cp_foldable_list);
18774     }
18775
18776     /* And combine the result (if any) with any inversion lists from posix
18777      * classes.  The lists are kept separate up to now because we don't want to
18778      * fold the classes */
18779     if (simple_posixes) {   /* These are the classes known to be unaffected by
18780                                /a, /aa, and /d */
18781         if (cp_list) {
18782             _invlist_union(cp_list, simple_posixes, &cp_list);
18783             SvREFCNT_dec_NN(simple_posixes);
18784         }
18785         else {
18786             cp_list = simple_posixes;
18787         }
18788     }
18789     if (posixes || nposixes) {
18790         if (! DEPENDS_SEMANTICS) {
18791
18792             /* For everything but /d, we can just add the current 'posixes' and
18793              * 'nposixes' to the main list */
18794             if (posixes) {
18795                 if (cp_list) {
18796                     _invlist_union(cp_list, posixes, &cp_list);
18797                     SvREFCNT_dec_NN(posixes);
18798                 }
18799                 else {
18800                     cp_list = posixes;
18801                 }
18802             }
18803             if (nposixes) {
18804                 if (cp_list) {
18805                     _invlist_union(cp_list, nposixes, &cp_list);
18806                     SvREFCNT_dec_NN(nposixes);
18807                 }
18808                 else {
18809                     cp_list = nposixes;
18810                 }
18811             }
18812         }
18813         else {
18814             /* Under /d, things like \w match upper Latin1 characters only if
18815              * the target string is in UTF-8.  But things like \W match all the
18816              * upper Latin1 characters if the target string is not in UTF-8.
18817              *
18818              * Handle the case with something like \W separately */
18819             if (nposixes) {
18820                 SV* only_non_utf8_list = invlist_clone(PL_UpperLatin1, NULL);
18821
18822                 /* A complemented posix class matches all upper Latin1
18823                  * characters if not in UTF-8.  And it matches just certain
18824                  * ones when in UTF-8.  That means those certain ones are
18825                  * matched regardless, so can just be added to the
18826                  * unconditional list */
18827                 if (cp_list) {
18828                     _invlist_union(cp_list, nposixes, &cp_list);
18829                     SvREFCNT_dec_NN(nposixes);
18830                     nposixes = NULL;
18831                 }
18832                 else {
18833                     cp_list = nposixes;
18834                 }
18835
18836                 /* Likewise for 'posixes' */
18837                 _invlist_union(posixes, cp_list, &cp_list);
18838                 SvREFCNT_dec(posixes);
18839
18840                 /* Likewise for anything else in the range that matched only
18841                  * under UTF-8 */
18842                 if (upper_latin1_only_utf8_matches) {
18843                     _invlist_union(cp_list,
18844                                    upper_latin1_only_utf8_matches,
18845                                    &cp_list);
18846                     SvREFCNT_dec_NN(upper_latin1_only_utf8_matches);
18847                     upper_latin1_only_utf8_matches = NULL;
18848                 }
18849
18850                 /* If we don't match all the upper Latin1 characters regardless
18851                  * of UTF-8ness, we have to set a flag to match the rest when
18852                  * not in UTF-8 */
18853                 _invlist_subtract(only_non_utf8_list, cp_list,
18854                                   &only_non_utf8_list);
18855                 if (_invlist_len(only_non_utf8_list) != 0) {
18856                     anyof_flags |= ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER;
18857                 }
18858                 SvREFCNT_dec_NN(only_non_utf8_list);
18859             }
18860             else {
18861                 /* Here there were no complemented posix classes.  That means
18862                  * the upper Latin1 characters in 'posixes' match only when the
18863                  * target string is in UTF-8.  So we have to add them to the
18864                  * list of those types of code points, while adding the
18865                  * remainder to the unconditional list.
18866                  *
18867                  * First calculate what they are */
18868                 SV* nonascii_but_latin1_properties = NULL;
18869                 _invlist_intersection(posixes, PL_UpperLatin1,
18870                                       &nonascii_but_latin1_properties);
18871
18872                 /* And add them to the final list of such characters. */
18873                 _invlist_union(upper_latin1_only_utf8_matches,
18874                                nonascii_but_latin1_properties,
18875                                &upper_latin1_only_utf8_matches);
18876
18877                 /* Remove them from what now becomes the unconditional list */
18878                 _invlist_subtract(posixes, nonascii_but_latin1_properties,
18879                                   &posixes);
18880
18881                 /* And add those unconditional ones to the final list */
18882                 if (cp_list) {
18883                     _invlist_union(cp_list, posixes, &cp_list);
18884                     SvREFCNT_dec_NN(posixes);
18885                     posixes = NULL;
18886                 }
18887                 else {
18888                     cp_list = posixes;
18889                 }
18890
18891                 SvREFCNT_dec(nonascii_but_latin1_properties);
18892
18893                 /* Get rid of any characters from the conditional list that we
18894                  * now know are matched unconditionally, which may make that
18895                  * list empty */
18896                 _invlist_subtract(upper_latin1_only_utf8_matches,
18897                                   cp_list,
18898                                   &upper_latin1_only_utf8_matches);
18899                 if (_invlist_len(upper_latin1_only_utf8_matches) == 0) {
18900                     SvREFCNT_dec_NN(upper_latin1_only_utf8_matches);
18901                     upper_latin1_only_utf8_matches = NULL;
18902                 }
18903             }
18904         }
18905     }
18906
18907     /* And combine the result (if any) with any inversion list from properties.
18908      * The lists are kept separate up to now so that we can distinguish the two
18909      * in regards to matching above-Unicode.  A run-time warning is generated
18910      * if a Unicode property is matched against a non-Unicode code point. But,
18911      * we allow user-defined properties to match anything, without any warning,
18912      * and we also suppress the warning if there is a portion of the character
18913      * class that isn't a Unicode property, and which matches above Unicode, \W
18914      * or [\x{110000}] for example.
18915      * (Note that in this case, unlike the Posix one above, there is no
18916      * <upper_latin1_only_utf8_matches>, because having a Unicode property
18917      * forces Unicode semantics */
18918     if (properties) {
18919         if (cp_list) {
18920
18921             /* If it matters to the final outcome, see if a non-property
18922              * component of the class matches above Unicode.  If so, the
18923              * warning gets suppressed.  This is true even if just a single
18924              * such code point is specified, as, though not strictly correct if
18925              * another such code point is matched against, the fact that they
18926              * are using above-Unicode code points indicates they should know
18927              * the issues involved */
18928             if (warn_super) {
18929                 warn_super = ! (invert
18930                                ^ (invlist_highest(cp_list) > PERL_UNICODE_MAX));
18931             }
18932
18933             _invlist_union(properties, cp_list, &cp_list);
18934             SvREFCNT_dec_NN(properties);
18935         }
18936         else {
18937             cp_list = properties;
18938         }
18939
18940         if (warn_super) {
18941             anyof_flags
18942              |= ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER;
18943
18944             /* Because an ANYOF node is the only one that warns, this node
18945              * can't be optimized into something else */
18946             optimizable = FALSE;
18947         }
18948     }
18949
18950     /* Here, we have calculated what code points should be in the character
18951      * class.
18952      *
18953      * Now we can see about various optimizations.  Fold calculation (which we
18954      * did above) needs to take place before inversion.  Otherwise /[^k]/i
18955      * would invert to include K, which under /i would match k, which it
18956      * shouldn't.  Therefore we can't invert folded locale now, as it won't be
18957      * folded until runtime */
18958
18959     /* If we didn't do folding, it's because some information isn't available
18960      * until runtime; set the run-time fold flag for these  We know to set the
18961      * flag if we have a non-NULL list for UTF-8 locales, or the class matches
18962      * at least one 0-255 range code point */
18963     if (LOC && FOLD) {
18964
18965         /* Some things on the list might be unconditionally included because of
18966          * other components.  Remove them, and clean up the list if it goes to
18967          * 0 elements */
18968         if (only_utf8_locale_list && cp_list) {
18969             _invlist_subtract(only_utf8_locale_list, cp_list,
18970                               &only_utf8_locale_list);
18971
18972             if (_invlist_len(only_utf8_locale_list) == 0) {
18973                 SvREFCNT_dec_NN(only_utf8_locale_list);
18974                 only_utf8_locale_list = NULL;
18975             }
18976         }
18977         if (    only_utf8_locale_list
18978             || (cp_list && (   _invlist_contains_cp(cp_list, LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE)
18979                             || _invlist_contains_cp(cp_list, LATIN_SMALL_LETTER_DOTLESS_I))))
18980         {
18981             has_runtime_dependency |= HAS_L_RUNTIME_DEPENDENCY;
18982             anyof_flags
18983                  |= ANYOFL_FOLD
18984                  |  ANYOFL_SHARED_UTF8_LOCALE_fold_HAS_MATCHES_nonfold_REQD;
18985         }
18986         else if (cp_list && invlist_lowest(cp_list) < 256) {
18987             /* If nothing is below 256, has no locale dependency; otherwise it
18988              * does */
18989             anyof_flags |= ANYOFL_FOLD;
18990             has_runtime_dependency |= HAS_L_RUNTIME_DEPENDENCY;
18991         }
18992     }
18993     else if (   DEPENDS_SEMANTICS
18994              && (    upper_latin1_only_utf8_matches
18995                  || (anyof_flags & ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER)))
18996     {
18997         RExC_seen_d_op = TRUE;
18998         has_runtime_dependency |= HAS_D_RUNTIME_DEPENDENCY;
18999     }
19000
19001     /* Optimize inverted patterns (e.g. [^a-z]) when everything is known at
19002      * compile time. */
19003     if (     cp_list
19004         &&   invert
19005         && ! has_runtime_dependency)
19006     {
19007         _invlist_invert(cp_list);
19008
19009         /* Clear the invert flag since have just done it here */
19010         invert = FALSE;
19011     }
19012
19013     /* All possible optimizations below still have these characteristics.
19014      * (Multi-char folds aren't SIMPLE, but they don't get this far in this
19015      * routine) */
19016     *flagp |= HASWIDTH|SIMPLE;
19017
19018     if (ret_invlist) {
19019         *ret_invlist = cp_list;
19020
19021         return (cp_list) ? RExC_emit : 0;
19022     }
19023
19024     if (anyof_flags & ANYOF_LOCALE_FLAGS) {
19025         RExC_contains_locale = 1;
19026     }
19027
19028     /* Some character classes are equivalent to other nodes.  Such nodes take
19029      * up less room, and some nodes require fewer operations to execute, than
19030      * ANYOF nodes.  EXACTish nodes may be joinable with adjacent nodes to
19031      * improve efficiency. */
19032
19033     if (optimizable) {
19034         PERL_UINT_FAST8_T i;
19035         UV partial_cp_count = 0;
19036         UV start[MAX_FOLD_FROMS+1] = { 0 }; /* +1 for the folded-to char */
19037         UV   end[MAX_FOLD_FROMS+1] = { 0 };
19038         bool single_range = FALSE;
19039
19040         if (cp_list) { /* Count the code points in enough ranges that we would
19041                           see all the ones possible in any fold in this version
19042                           of Unicode */
19043
19044             invlist_iterinit(cp_list);
19045             for (i = 0; i <= MAX_FOLD_FROMS; i++) {
19046                 if (! invlist_iternext(cp_list, &start[i], &end[i])) {
19047                     break;
19048                 }
19049                 partial_cp_count += end[i] - start[i] + 1;
19050             }
19051
19052             if (i == 1) {
19053                 single_range = TRUE;
19054             }
19055             invlist_iterfinish(cp_list);
19056         }
19057
19058         /* If we know at compile time that this matches every possible code
19059          * point, any run-time dependencies don't matter */
19060         if (start[0] == 0 && end[0] == UV_MAX) {
19061             if (invert) {
19062                 ret = reganode(pRExC_state, OPFAIL, 0);
19063             }
19064             else {
19065                 ret = reg_node(pRExC_state, SANY);
19066                 MARK_NAUGHTY(1);
19067             }
19068             goto not_anyof;
19069         }
19070
19071         /* Similarly, for /l posix classes, if both a class and its
19072          * complement match, any run-time dependencies don't matter */
19073         if (posixl) {
19074             for (namedclass = 0; namedclass < ANYOF_POSIXL_MAX;
19075                                                         namedclass += 2)
19076             {
19077                 if (   POSIXL_TEST(posixl, namedclass)      /* class */
19078                     && POSIXL_TEST(posixl, namedclass + 1)) /* its complement */
19079                 {
19080                     if (invert) {
19081                         ret = reganode(pRExC_state, OPFAIL, 0);
19082                     }
19083                     else {
19084                         ret = reg_node(pRExC_state, SANY);
19085                         MARK_NAUGHTY(1);
19086                     }
19087                     goto not_anyof;
19088                 }
19089             }
19090
19091             /* For well-behaved locales, some classes are subsets of others,
19092              * so complementing the subset and including the non-complemented
19093              * superset should match everything, like [\D[:alnum:]], and
19094              * [[:^alpha:][:alnum:]], but some implementations of locales are
19095              * buggy, and khw thinks its a bad idea to have optimization change
19096              * behavior, even if it avoids an OS bug in a given case */
19097
19098 #define isSINGLE_BIT_SET(n) isPOWER_OF_2(n)
19099
19100             /* If is a single posix /l class, can optimize to just that op.
19101              * Such a node will not match anything in the Latin1 range, as that
19102              * is not determinable until runtime, but will match whatever the
19103              * class does outside that range.  (Note that some classes won't
19104              * match anything outside the range, like [:ascii:]) */
19105             if (    isSINGLE_BIT_SET(posixl)
19106                 && (partial_cp_count == 0 || start[0] > 255))
19107             {
19108                 U8 classnum;
19109                 SV * class_above_latin1 = NULL;
19110                 bool already_inverted;
19111                 bool are_equivalent;
19112
19113                 /* Compute which bit is set, which is the same thing as, e.g.,
19114                  * ANYOF_CNTRL.  From
19115                  * https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn
19116                  * */
19117                 static const int MultiplyDeBruijnBitPosition2[32] =
19118                     {
19119                     0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
19120                     31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
19121                     };
19122
19123                 namedclass = MultiplyDeBruijnBitPosition2[(posixl
19124                                                           * 0x077CB531U) >> 27];
19125                 classnum = namedclass_to_classnum(namedclass);
19126
19127                 /* The named classes are such that the inverted number is one
19128                  * larger than the non-inverted one */
19129                 already_inverted = namedclass
19130                                  - classnum_to_namedclass(classnum);
19131
19132                 /* Create an inversion list of the official property, inverted
19133                  * if the constructed node list is inverted, and restricted to
19134                  * only the above latin1 code points, which are the only ones
19135                  * known at compile time */
19136                 _invlist_intersection_maybe_complement_2nd(
19137                                                     PL_AboveLatin1,
19138                                                     PL_XPosix_ptrs[classnum],
19139                                                     already_inverted,
19140                                                     &class_above_latin1);
19141                 are_equivalent = _invlistEQ(class_above_latin1, cp_list,
19142                                                                         FALSE);
19143                 SvREFCNT_dec_NN(class_above_latin1);
19144
19145                 if (are_equivalent) {
19146
19147                     /* Resolve the run-time inversion flag with this possibly
19148                      * inverted class */
19149                     invert = invert ^ already_inverted;
19150
19151                     ret = reg_node(pRExC_state,
19152                                    POSIXL + invert * (NPOSIXL - POSIXL));
19153                     FLAGS(REGNODE_p(ret)) = classnum;
19154                     goto not_anyof;
19155                 }
19156             }
19157         }
19158
19159         /* khw can't think of any other possible transformation involving
19160          * these. */
19161         if (has_runtime_dependency & HAS_USER_DEFINED_PROPERTY) {
19162             goto is_anyof;
19163         }
19164
19165         if (! has_runtime_dependency) {
19166
19167             /* If the list is empty, nothing matches.  This happens, for
19168              * example, when a Unicode property that doesn't match anything is
19169              * the only element in the character class (perluniprops.pod notes
19170              * such properties). */
19171             if (partial_cp_count == 0) {
19172                 if (invert) {
19173                     ret = reg_node(pRExC_state, SANY);
19174                 }
19175                 else {
19176                     ret = reganode(pRExC_state, OPFAIL, 0);
19177                 }
19178
19179                 goto not_anyof;
19180             }
19181
19182             /* If matches everything but \n */
19183             if (   start[0] == 0 && end[0] == '\n' - 1
19184                 && start[1] == '\n' + 1 && end[1] == UV_MAX)
19185             {
19186                 assert (! invert);
19187                 ret = reg_node(pRExC_state, REG_ANY);
19188                 MARK_NAUGHTY(1);
19189                 goto not_anyof;
19190             }
19191         }
19192
19193         /* Next see if can optimize classes that contain just a few code points
19194          * into an EXACTish node.  The reason to do this is to let the
19195          * optimizer join this node with adjacent EXACTish ones, and ANYOF
19196          * nodes require conversion to code point from UTF-8.
19197          *
19198          * An EXACTFish node can be generated even if not under /i, and vice
19199          * versa.  But care must be taken.  An EXACTFish node has to be such
19200          * that it only matches precisely the code points in the class, but we
19201          * want to generate the least restrictive one that does that, to
19202          * increase the odds of being able to join with an adjacent node.  For
19203          * example, if the class contains [kK], we have to make it an EXACTFAA
19204          * node to prevent the KELVIN SIGN from matching.  Whether we are under
19205          * /i or not is irrelevant in this case.  Less obvious is the pattern
19206          * qr/[\x{02BC}]n/i.  U+02BC is MODIFIER LETTER APOSTROPHE. That is
19207          * supposed to match the single character U+0149 LATIN SMALL LETTER N
19208          * PRECEDED BY APOSTROPHE.  And so even though there is no simple fold
19209          * that includes \X{02BC}, there is a multi-char fold that does, and so
19210          * the node generated for it must be an EXACTFish one.  On the other
19211          * hand qr/:/i should generate a plain EXACT node since the colon
19212          * participates in no fold whatsoever, and having it EXACT tells the
19213          * optimizer the target string cannot match unless it has a colon in
19214          * it.
19215          */
19216         if (   ! posixl
19217             && ! invert
19218
19219                 /* Only try if there are no more code points in the class than
19220                  * in the max possible fold */
19221             &&   inRANGE(partial_cp_count, 1, MAX_FOLD_FROMS + 1))
19222         {
19223             if (partial_cp_count == 1 && ! upper_latin1_only_utf8_matches)
19224             {
19225                 /* We can always make a single code point class into an
19226                  * EXACTish node. */
19227
19228                 if (LOC) {
19229
19230                     /* Here is /l:  Use EXACTL, except if there is a fold not
19231                      * known until runtime so shows as only a single code point
19232                      * here.  For code points above 255, we know which can
19233                      * cause problems by having a potential fold to the Latin1
19234                      * range. */
19235                     if (  ! FOLD
19236                         || (     start[0] > 255
19237                             && ! is_PROBLEMATIC_LOCALE_FOLD_cp(start[0])))
19238                     {
19239                         op = EXACTL;
19240                     }
19241                     else {
19242                         op = EXACTFL;
19243                     }
19244                 }
19245                 else if (! FOLD) { /* Not /l and not /i */
19246                     op = (start[0] < 256) ? EXACT : EXACT_REQ8;
19247                 }
19248                 else if (start[0] < 256) { /* /i, not /l, and the code point is
19249                                               small */
19250
19251                     /* Under /i, it gets a little tricky.  A code point that
19252                      * doesn't participate in a fold should be an EXACT node.
19253                      * We know this one isn't the result of a simple fold, or
19254                      * there'd be more than one code point in the list, but it
19255                      * could be part of a multi- character fold.  In that case
19256                      * we better not create an EXACT node, as we would wrongly
19257                      * be telling the optimizer that this code point must be in
19258                      * the target string, and that is wrong.  This is because
19259                      * if the sequence around this code point forms a
19260                      * multi-char fold, what needs to be in the string could be
19261                      * the code point that folds to the sequence.
19262                      *
19263                      * This handles the case of below-255 code points, as we
19264                      * have an easy look up for those.  The next clause handles
19265                      * the above-256 one */
19266                     op = IS_IN_SOME_FOLD_L1(start[0])
19267                          ? EXACTFU
19268                          : EXACT;
19269                 }
19270                 else {  /* /i, larger code point.  Since we are under /i, and
19271                            have just this code point, we know that it can't
19272                            fold to something else, so PL_InMultiCharFold
19273                            applies to it */
19274                     op = _invlist_contains_cp(PL_InMultiCharFold,
19275                                               start[0])
19276                          ? EXACTFU_REQ8
19277                          : EXACT_REQ8;
19278                 }
19279
19280                 value = start[0];
19281             }
19282             else if (  ! (has_runtime_dependency & ~HAS_D_RUNTIME_DEPENDENCY)
19283                      && _invlist_contains_cp(PL_in_some_fold, start[0]))
19284             {
19285                 /* Here, the only runtime dependency, if any, is from /d, and
19286                  * the class matches more than one code point, and the lowest
19287                  * code point participates in some fold.  It might be that the
19288                  * other code points are /i equivalent to this one, and hence
19289                  * they would representable by an EXACTFish node.  Above, we
19290                  * eliminated classes that contain too many code points to be
19291                  * EXACTFish, with the test for MAX_FOLD_FROMS
19292                  *
19293                  * First, special case the ASCII fold pairs, like 'B' and 'b'.
19294                  * We do this because we have EXACTFAA at our disposal for the
19295                  * ASCII range */
19296                 if (partial_cp_count == 2 && isASCII(start[0])) {
19297
19298                     /* The only ASCII characters that participate in folds are
19299                      * alphabetics */
19300                     assert(isALPHA(start[0]));
19301                     if (   end[0] == start[0]   /* First range is a single
19302                                                    character, so 2nd exists */
19303                         && isALPHA_FOLD_EQ(start[0], start[1]))
19304                     {
19305
19306                         /* Here, is part of an ASCII fold pair */
19307
19308                         if (   ASCII_FOLD_RESTRICTED
19309                             || HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(start[0]))
19310                         {
19311                             /* If the second clause just above was true, it
19312                              * means we can't be under /i, or else the list
19313                              * would have included more than this fold pair.
19314                              * Therefore we have to exclude the possibility of
19315                              * whatever else it is that folds to these, by
19316                              * using EXACTFAA */
19317                             op = EXACTFAA;
19318                         }
19319                         else if (HAS_NONLATIN1_FOLD_CLOSURE(start[0])) {
19320
19321                             /* Here, there's no simple fold that start[0] is part
19322                              * of, but there is a multi-character one.  If we
19323                              * are not under /i, we want to exclude that
19324                              * possibility; if under /i, we want to include it
19325                              * */
19326                             op = (FOLD) ? EXACTFU : EXACTFAA;
19327                         }
19328                         else {
19329
19330                             /* Here, the only possible fold start[0] particpates in
19331                              * is with start[1].  /i or not isn't relevant */
19332                             op = EXACTFU;
19333                         }
19334
19335                         value = toFOLD(start[0]);
19336                     }
19337                 }
19338                 else if (  ! upper_latin1_only_utf8_matches
19339                          || (   _invlist_len(upper_latin1_only_utf8_matches)
19340                                                                           == 2
19341                              && PL_fold_latin1[
19342                                invlist_highest(upper_latin1_only_utf8_matches)]
19343                              == start[0]))
19344                 {
19345                     /* Here, the smallest character is non-ascii or there are
19346                      * more than 2 code points matched by this node.  Also, we
19347                      * either don't have /d UTF-8 dependent matches, or if we
19348                      * do, they look like they could be a single character that
19349                      * is the fold of the lowest one in the always-match list.
19350                      * This test quickly excludes most of the false positives
19351                      * when there are /d UTF-8 depdendent matches.  These are
19352                      * like LATIN CAPITAL LETTER A WITH GRAVE matching LATIN
19353                      * SMALL LETTER A WITH GRAVE iff the target string is
19354                      * UTF-8.  (We don't have to worry above about exceeding
19355                      * the array bounds of PL_fold_latin1[] because any code
19356                      * point in 'upper_latin1_only_utf8_matches' is below 256.)
19357                      *
19358                      * EXACTFAA would apply only to pairs (hence exactly 2 code
19359                      * points) in the ASCII range, so we can't use it here to
19360                      * artificially restrict the fold domain, so we check if
19361                      * the class does or does not match some EXACTFish node.
19362                      * Further, if we aren't under /i, and the folded-to
19363                      * character is part of a multi-character fold, we can't do
19364                      * this optimization, as the sequence around it could be
19365                      * that multi-character fold, and we don't here know the
19366                      * context, so we have to assume it is that multi-char
19367                      * fold, to prevent potential bugs.
19368                      *
19369                      * To do the general case, we first find the fold of the
19370                      * lowest code point (which may be higher than the lowest
19371                      * one), then find everything that folds to it.  (The data
19372                      * structure we have only maps from the folded code points,
19373                      * so we have to do the earlier step.) */
19374
19375                     Size_t foldlen;
19376                     U8 foldbuf[UTF8_MAXBYTES_CASE];
19377                     UV folded = _to_uni_fold_flags(start[0],
19378                                                         foldbuf, &foldlen, 0);
19379                     U32 first_fold;
19380                     const U32 * remaining_folds;
19381                     Size_t folds_to_this_cp_count = _inverse_folds(
19382                                                             folded,
19383                                                             &first_fold,
19384                                                             &remaining_folds);
19385                     Size_t folds_count = folds_to_this_cp_count + 1;
19386                     SV * fold_list = _new_invlist(folds_count);
19387                     unsigned int i;
19388
19389                     /* If there are UTF-8 dependent matches, create a temporary
19390                      * list of what this node matches, including them. */
19391                     SV * all_cp_list = NULL;
19392                     SV ** use_this_list = &cp_list;
19393
19394                     if (upper_latin1_only_utf8_matches) {
19395                         all_cp_list = _new_invlist(0);
19396                         use_this_list = &all_cp_list;
19397                         _invlist_union(cp_list,
19398                                        upper_latin1_only_utf8_matches,
19399                                        use_this_list);
19400                     }
19401
19402                     /* Having gotten everything that participates in the fold
19403                      * containing the lowest code point, we turn that into an
19404                      * inversion list, making sure everything is included. */
19405                     fold_list = add_cp_to_invlist(fold_list, start[0]);
19406                     fold_list = add_cp_to_invlist(fold_list, folded);
19407                     if (folds_to_this_cp_count > 0) {
19408                         fold_list = add_cp_to_invlist(fold_list, first_fold);
19409                         for (i = 0; i + 1 < folds_to_this_cp_count; i++) {
19410                             fold_list = add_cp_to_invlist(fold_list,
19411                                                         remaining_folds[i]);
19412                         }
19413                     }
19414
19415                     /* If the fold list is identical to what's in this ANYOF
19416                      * node, the node can be represented by an EXACTFish one
19417                      * instead */
19418                     if (_invlistEQ(*use_this_list, fold_list,
19419                                    0 /* Don't complement */ )
19420                     ) {
19421
19422                         /* But, we have to be careful, as mentioned above.
19423                          * Just the right sequence of characters could match
19424                          * this if it is part of a multi-character fold.  That
19425                          * IS what we want if we are under /i.  But it ISN'T
19426                          * what we want if not under /i, as it could match when
19427                          * it shouldn't.  So, when we aren't under /i and this
19428                          * character participates in a multi-char fold, we
19429                          * don't optimize into an EXACTFish node.  So, for each
19430                          * case below we have to check if we are folding
19431                          * and if not, if it is not part of a multi-char fold.
19432                          * */
19433                         if (start[0] > 255) {    /* Highish code point */
19434                             if (FOLD || ! _invlist_contains_cp(
19435                                             PL_InMultiCharFold, folded))
19436                             {
19437                                 op = (LOC)
19438                                      ? EXACTFLU8
19439                                      : (ASCII_FOLD_RESTRICTED)
19440                                        ? EXACTFAA
19441                                        : EXACTFU_REQ8;
19442                                 value = folded;
19443                             }
19444                         }   /* Below, the lowest code point < 256 */
19445                         else if (    FOLD
19446                                  &&  folded == 's'
19447                                  &&  DEPENDS_SEMANTICS)
19448                         {   /* An EXACTF node containing a single character
19449                                 's', can be an EXACTFU if it doesn't get
19450                                 joined with an adjacent 's' */
19451                             op = EXACTFU_S_EDGE;
19452                             value = folded;
19453                         }
19454                         else if (    FOLD
19455                                 || ! HAS_NONLATIN1_FOLD_CLOSURE(start[0]))
19456                         {
19457                             if (upper_latin1_only_utf8_matches) {
19458                                 op = EXACTF;
19459
19460                                 /* We can't use the fold, as that only matches
19461                                  * under UTF-8 */
19462                                 value = start[0];
19463                             }
19464                             else if (     UNLIKELY(start[0] == MICRO_SIGN)
19465                                      && ! UTF)
19466                             {   /* EXACTFUP is a special node for this
19467                                    character */
19468                                 op = (ASCII_FOLD_RESTRICTED)
19469                                      ? EXACTFAA
19470                                      : EXACTFUP;
19471                                 value = MICRO_SIGN;
19472                             }
19473                             else if (     ASCII_FOLD_RESTRICTED
19474                                      && ! isASCII(start[0]))
19475                             {   /* For ASCII under /iaa, we can use EXACTFU
19476                                    below */
19477                                 op = EXACTFAA;
19478                                 value = folded;
19479                             }
19480                             else {
19481                                 op = EXACTFU;
19482                                 value = folded;
19483                             }
19484                         }
19485                     }
19486
19487                     SvREFCNT_dec_NN(fold_list);
19488                     SvREFCNT_dec(all_cp_list);
19489                 }
19490             }
19491
19492             if (op != END) {
19493                 U8 len;
19494
19495                 /* Here, we have calculated what EXACTish node to use.  Have to
19496                  * convert to UTF-8 if not already there */
19497                 if (value > 255) {
19498                     if (! UTF) {
19499                         SvREFCNT_dec(cp_list);;
19500                         REQUIRE_UTF8(flagp);
19501                     }
19502
19503                     /* This is a kludge to the special casing issues with this
19504                      * ligature under /aa.  FB05 should fold to FB06, but the
19505                      * call above to _to_uni_fold_flags() didn't find this, as
19506                      * it didn't use the /aa restriction in order to not miss
19507                      * other folds that would be affected.  This is the only
19508                      * instance likely to ever be a problem in all of Unicode.
19509                      * So special case it. */
19510                     if (   value == LATIN_SMALL_LIGATURE_LONG_S_T
19511                         && ASCII_FOLD_RESTRICTED)
19512                     {
19513                         value = LATIN_SMALL_LIGATURE_ST;
19514                     }
19515                 }
19516
19517                 len = (UTF) ? UVCHR_SKIP(value) : 1;
19518
19519                 ret = regnode_guts(pRExC_state, op, len, "exact");
19520                 FILL_NODE(ret, op);
19521                 RExC_emit += 1 + STR_SZ(len);
19522                 setSTR_LEN(REGNODE_p(ret), len);
19523                 if (len == 1) {
19524                     *STRINGs(REGNODE_p(ret)) = (U8) value;
19525                 }
19526                 else {
19527                     uvchr_to_utf8((U8 *) STRINGs(REGNODE_p(ret)), value);
19528                 }
19529                 goto not_anyof;
19530             }
19531         }
19532
19533         if (! has_runtime_dependency) {
19534
19535             /* See if this can be turned into an ANYOFM node.  Think about the
19536              * bit patterns in two different bytes.  In some positions, the
19537              * bits in each will be 1; and in other positions both will be 0;
19538              * and in some positions the bit will be 1 in one byte, and 0 in
19539              * the other.  Let 'n' be the number of positions where the bits
19540              * differ.  We create a mask which has exactly 'n' 0 bits, each in
19541              * a position where the two bytes differ.  Now take the set of all
19542              * bytes that when ANDed with the mask yield the same result.  That
19543              * set has 2**n elements, and is representable by just two 8 bit
19544              * numbers: the result and the mask.  Importantly, matching the set
19545              * can be vectorized by creating a word full of the result bytes,
19546              * and a word full of the mask bytes, yielding a significant speed
19547              * up.  Here, see if this node matches such a set.  As a concrete
19548              * example consider [01], and the byte representing '0' which is
19549              * 0x30 on ASCII machines.  It has the bits 0011 0000.  Take the
19550              * mask 1111 1110.  If we AND 0x31 and 0x30 with that mask we get
19551              * 0x30.  Any other bytes ANDed yield something else.  So [01],
19552              * which is a common usage, is optimizable into ANYOFM, and can
19553              * benefit from the speed up.  We can only do this on UTF-8
19554              * invariant bytes, because they have the same bit patterns under
19555              * UTF-8 as not. */
19556             PERL_UINT_FAST8_T inverted = 0;
19557 #ifdef EBCDIC
19558             const PERL_UINT_FAST8_T max_permissible = 0xFF;
19559 #else
19560             const PERL_UINT_FAST8_T max_permissible = 0x7F;
19561 #endif
19562             /* If doesn't fit the criteria for ANYOFM, invert and try again.
19563              * If that works we will instead later generate an NANYOFM, and
19564              * invert back when through */
19565             if (invlist_highest(cp_list) > max_permissible) {
19566                 _invlist_invert(cp_list);
19567                 inverted = 1;
19568             }
19569
19570             if (invlist_highest(cp_list) <= max_permissible) {
19571                 UV this_start, this_end;
19572                 UV lowest_cp = UV_MAX;  /* init'ed to suppress compiler warn */
19573                 U8 bits_differing = 0;
19574                 Size_t full_cp_count = 0;
19575                 bool first_time = TRUE;
19576
19577                 /* Go through the bytes and find the bit positions that differ
19578                  * */
19579                 invlist_iterinit(cp_list);
19580                 while (invlist_iternext(cp_list, &this_start, &this_end)) {
19581                     unsigned int i = this_start;
19582
19583                     if (first_time) {
19584                         if (! UVCHR_IS_INVARIANT(i)) {
19585                             goto done_anyofm;
19586                         }
19587
19588                         first_time = FALSE;
19589                         lowest_cp = this_start;
19590
19591                         /* We have set up the code point to compare with.
19592                          * Don't compare it with itself */
19593                         i++;
19594                     }
19595
19596                     /* Find the bit positions that differ from the lowest code
19597                      * point in the node.  Keep track of all such positions by
19598                      * OR'ing */
19599                     for (; i <= this_end; i++) {
19600                         if (! UVCHR_IS_INVARIANT(i)) {
19601                             goto done_anyofm;
19602                         }
19603
19604                         bits_differing  |= i ^ lowest_cp;
19605                     }
19606
19607                     full_cp_count += this_end - this_start + 1;
19608                 }
19609
19610                 /* At the end of the loop, we count how many bits differ from
19611                  * the bits in lowest code point, call the count 'd'.  If the
19612                  * set we found contains 2**d elements, it is the closure of
19613                  * all code points that differ only in those bit positions.  To
19614                  * convince yourself of that, first note that the number in the
19615                  * closure must be a power of 2, which we test for.  The only
19616                  * way we could have that count and it be some differing set,
19617                  * is if we got some code points that don't differ from the
19618                  * lowest code point in any position, but do differ from each
19619                  * other in some other position.  That means one code point has
19620                  * a 1 in that position, and another has a 0.  But that would
19621                  * mean that one of them differs from the lowest code point in
19622                  * that position, which possibility we've already excluded.  */
19623                 if (  (inverted || full_cp_count > 1)
19624                     && full_cp_count == 1U << PL_bitcount[bits_differing])
19625                 {
19626                     U8 ANYOFM_mask;
19627
19628                     op = ANYOFM + inverted;;
19629
19630                     /* We need to make the bits that differ be 0's */
19631                     ANYOFM_mask = ~ bits_differing; /* This goes into FLAGS */
19632
19633                     /* The argument is the lowest code point */
19634                     ret = reganode(pRExC_state, op, lowest_cp);
19635                     FLAGS(REGNODE_p(ret)) = ANYOFM_mask;
19636                 }
19637
19638               done_anyofm:
19639                 invlist_iterfinish(cp_list);
19640             }
19641
19642             if (inverted) {
19643                 _invlist_invert(cp_list);
19644             }
19645
19646             if (op != END) {
19647                 goto not_anyof;
19648             }
19649
19650             /* XXX We could create an ANYOFR_LOW node here if we saved above if
19651              * all were invariants, it wasn't inverted, and there is a single
19652              * range.  This would be faster than some of the posix nodes we
19653              * create below like /\d/a, but would be twice the size.  Without
19654              * having actually measured the gain, khw doesn't think the
19655              * tradeoff is really worth it */
19656         }
19657
19658         if (! (anyof_flags & ANYOF_LOCALE_FLAGS)) {
19659             PERL_UINT_FAST8_T type;
19660             SV * intersection = NULL;
19661             SV* d_invlist = NULL;
19662
19663             /* See if this matches any of the POSIX classes.  The POSIXA and
19664              * POSIXD ones are about the same speed as ANYOF ops, but take less
19665              * room; the ones that have above-Latin1 code point matches are
19666              * somewhat faster than ANYOF.  */
19667
19668             for (type = POSIXA; type >= POSIXD; type--) {
19669                 int posix_class;
19670
19671                 if (type == POSIXL) {   /* But not /l posix classes */
19672                     continue;
19673                 }
19674
19675                 for (posix_class = 0;
19676                      posix_class <= _HIGHEST_REGCOMP_DOT_H_SYNC;
19677                      posix_class++)
19678                 {
19679                     SV** our_code_points = &cp_list;
19680                     SV** official_code_points;
19681                     int try_inverted;
19682
19683                     if (type == POSIXA) {
19684                         official_code_points = &PL_Posix_ptrs[posix_class];
19685                     }
19686                     else {
19687                         official_code_points = &PL_XPosix_ptrs[posix_class];
19688                     }
19689
19690                     /* Skip non-existent classes of this type.  e.g. \v only
19691                      * has an entry in PL_XPosix_ptrs */
19692                     if (! *official_code_points) {
19693                         continue;
19694                     }
19695
19696                     /* Try both the regular class, and its inversion */
19697                     for (try_inverted = 0; try_inverted < 2; try_inverted++) {
19698                         bool this_inverted = invert ^ try_inverted;
19699
19700                         if (type != POSIXD) {
19701
19702                             /* This class that isn't /d can't match if we have
19703                              * /d dependencies */
19704                             if (has_runtime_dependency
19705                                                     & HAS_D_RUNTIME_DEPENDENCY)
19706                             {
19707                                 continue;
19708                             }
19709                         }
19710                         else /* is /d */ if (! this_inverted) {
19711
19712                             /* /d classes don't match anything non-ASCII below
19713                              * 256 unconditionally (which cp_list contains) */
19714                             _invlist_intersection(cp_list, PL_UpperLatin1,
19715                                                            &intersection);
19716                             if (_invlist_len(intersection) != 0) {
19717                                 continue;
19718                             }
19719
19720                             SvREFCNT_dec(d_invlist);
19721                             d_invlist = invlist_clone(cp_list, NULL);
19722
19723                             /* But under UTF-8 it turns into using /u rules.
19724                              * Add the things it matches under these conditions
19725                              * so that we check below that these are identical
19726                              * to what the tested class should match */
19727                             if (upper_latin1_only_utf8_matches) {
19728                                 _invlist_union(
19729                                             d_invlist,
19730                                             upper_latin1_only_utf8_matches,
19731                                             &d_invlist);
19732                             }
19733                             our_code_points = &d_invlist;
19734                         }
19735                         else {  /* POSIXD, inverted.  If this doesn't have this
19736                                    flag set, it isn't /d. */
19737                             if (! (anyof_flags & ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER))
19738                             {
19739                                 continue;
19740                             }
19741                             our_code_points = &cp_list;
19742                         }
19743
19744                         /* Here, have weeded out some things.  We want to see
19745                          * if the list of characters this node contains
19746                          * ('*our_code_points') precisely matches those of the
19747                          * class we are currently checking against
19748                          * ('*official_code_points'). */
19749                         if (_invlistEQ(*our_code_points,
19750                                        *official_code_points,
19751                                        try_inverted))
19752                         {
19753                             /* Here, they precisely match.  Optimize this ANYOF
19754                              * node into its equivalent POSIX one of the
19755                              * correct type, possibly inverted */
19756                             ret = reg_node(pRExC_state, (try_inverted)
19757                                                         ? type + NPOSIXA
19758                                                                 - POSIXA
19759                                                         : type);
19760                             FLAGS(REGNODE_p(ret)) = posix_class;
19761                             SvREFCNT_dec(d_invlist);
19762                             SvREFCNT_dec(intersection);
19763                             goto not_anyof;
19764                         }
19765                     }
19766                 }
19767             }
19768             SvREFCNT_dec(d_invlist);
19769             SvREFCNT_dec(intersection);
19770         }
19771
19772         /* If it is a single contiguous range, ANYOFR is an efficient regnode,
19773          * both in size and speed.  Currently, a 20 bit range base (smallest
19774          * code point in the range), and a 12 bit maximum delta are packed into
19775          * a 32 bit word.  This allows for using it on all of the Unicode code
19776          * points except for the highest plane, which is only for private use
19777          * code points.  khw doubts that a bigger delta is likely in real world
19778          * applications */
19779         if (     single_range
19780             && ! has_runtime_dependency
19781             &&   anyof_flags == 0
19782             &&   start[0] < (1 << ANYOFR_BASE_BITS)
19783             &&   end[0] - start[0]
19784                     < ((1U << (sizeof(((struct regnode_1 *)NULL)->arg1)
19785                                    * CHARBITS - ANYOFR_BASE_BITS))))
19786
19787         {
19788             U8 low_utf8[UTF8_MAXBYTES+1];
19789             U8 high_utf8[UTF8_MAXBYTES+1];
19790
19791             ret = reganode(pRExC_state, ANYOFR,
19792                         (start[0] | (end[0] - start[0]) << ANYOFR_BASE_BITS));
19793
19794             /* Place the lowest UTF-8 start byte in the flags field, so as to
19795              * allow efficient ruling out at run time of many possible inputs.
19796              * */
19797             (void) uvchr_to_utf8(low_utf8, start[0]);
19798             (void) uvchr_to_utf8(high_utf8, end[0]);
19799
19800             /* If all code points share the same first byte, this can be an
19801              * ANYOFRb.  Otherwise store the lowest UTF-8 start byte which can
19802              * quickly rule out many inputs at run-time without having to
19803              * compute the code point from UTF-8.  For EBCDIC, we use I8, as
19804              * not doing that transformation would not rule out nearly so many
19805              * things */
19806             if (low_utf8[0] == high_utf8[0]) {
19807                 OP(REGNODE_p(ret)) = ANYOFRb;
19808                 ANYOF_FLAGS(REGNODE_p(ret)) = low_utf8[0];
19809             }
19810             else {
19811                 ANYOF_FLAGS(REGNODE_p(ret))
19812                                     = NATIVE_UTF8_TO_I8(low_utf8[0]);
19813             }
19814
19815             goto not_anyof;
19816         }
19817
19818         /* If didn't find an optimization and there is no need for a bitmap,
19819          * optimize to indicate that */
19820         if (     start[0] >= NUM_ANYOF_CODE_POINTS
19821             && ! LOC
19822             && ! upper_latin1_only_utf8_matches
19823             &&   anyof_flags == 0)
19824         {
19825             U8 low_utf8[UTF8_MAXBYTES+1];
19826             UV highest_cp = invlist_highest(cp_list);
19827
19828             /* Currently the maximum allowed code point by the system is
19829              * IV_MAX.  Higher ones are reserved for future internal use.  This
19830              * particular regnode can be used for higher ones, but we can't
19831              * calculate the code point of those.  IV_MAX suffices though, as
19832              * it will be a large first byte */
19833             Size_t low_len = uvchr_to_utf8(low_utf8, MIN(start[0], IV_MAX))
19834                            - low_utf8;
19835
19836             /* We store the lowest possible first byte of the UTF-8
19837              * representation, using the flags field.  This allows for quick
19838              * ruling out of some inputs without having to convert from UTF-8
19839              * to code point.  For EBCDIC, we use I8, as not doing that
19840              * transformation would not rule out nearly so many things */
19841             anyof_flags = NATIVE_UTF8_TO_I8(low_utf8[0]);
19842
19843             op = ANYOFH;
19844
19845             /* If the first UTF-8 start byte for the highest code point in the
19846              * range is suitably small, we may be able to get an upper bound as
19847              * well */
19848             if (highest_cp <= IV_MAX) {
19849                 U8 high_utf8[UTF8_MAXBYTES+1];
19850                 Size_t high_len = uvchr_to_utf8(high_utf8, highest_cp)
19851                                 - high_utf8;
19852
19853                 /* If the lowest and highest are the same, we can get an exact
19854                  * first byte instead of a just minimum or even a sequence of
19855                  * exact leading bytes.  We signal these with different
19856                  * regnodes */
19857                 if (low_utf8[0] == high_utf8[0]) {
19858                     Size_t len = find_first_differing_byte_pos(low_utf8,
19859                                                                high_utf8,
19860                                                        MIN(low_len, high_len));
19861
19862                     if (len == 1) {
19863
19864                         /* No need to convert to I8 for EBCDIC as this is an
19865                          * exact match */
19866                         anyof_flags = low_utf8[0];
19867                         op = ANYOFHb;
19868                     }
19869                     else {
19870                         op = ANYOFHs;
19871                         ret = regnode_guts(pRExC_state, op,
19872                                            regarglen[op] + STR_SZ(len),
19873                                            "anyofhs");
19874                         FILL_NODE(ret, op);
19875                         ((struct regnode_anyofhs *) REGNODE_p(ret))->str_len
19876                                                                         = len;
19877                         Copy(low_utf8,  /* Add the common bytes */
19878                            ((struct regnode_anyofhs *) REGNODE_p(ret))->string,
19879                            len, U8);
19880                         RExC_emit += NODE_SZ_STR(REGNODE_p(ret));
19881                         set_ANYOF_arg(pRExC_state, REGNODE_p(ret), cp_list,
19882                                                   NULL, only_utf8_locale_list);
19883                         goto not_anyof;
19884                     }
19885                 }
19886                 else if (NATIVE_UTF8_TO_I8(high_utf8[0]) <= MAX_ANYOF_HRx_BYTE)
19887                 {
19888
19889                     /* Here, the high byte is not the same as the low, but is
19890                      * small enough that its reasonable to have a loose upper
19891                      * bound, which is packed in with the strict lower bound.
19892                      * See comments at the definition of MAX_ANYOF_HRx_BYTE.
19893                      * On EBCDIC platforms, I8 is used.  On ASCII platforms I8
19894                      * is the same thing as UTF-8 */
19895
19896                     U8 bits = 0;
19897                     U8 max_range_diff = MAX_ANYOF_HRx_BYTE - anyof_flags;
19898                     U8 range_diff = NATIVE_UTF8_TO_I8(high_utf8[0])
19899                                   - anyof_flags;
19900
19901                     if (range_diff <= max_range_diff / 8) {
19902                         bits = 3;
19903                     }
19904                     else if (range_diff <= max_range_diff / 4) {
19905                         bits = 2;
19906                     }
19907                     else if (range_diff <= max_range_diff / 2) {
19908                         bits = 1;
19909                     }
19910                     anyof_flags = (anyof_flags - 0xC0) << 2 | bits;
19911                     op = ANYOFHr;
19912                 }
19913             }
19914
19915             goto done_finding_op;
19916         }
19917     }   /* End of seeing if can optimize it into a different node */
19918
19919   is_anyof: /* It's going to be an ANYOF node. */
19920     op = (has_runtime_dependency & HAS_D_RUNTIME_DEPENDENCY)
19921          ? ANYOFD
19922          : ((posixl)
19923             ? ANYOFPOSIXL
19924             : ((LOC)
19925                ? ANYOFL
19926                : ANYOF));
19927
19928   done_finding_op:
19929
19930     ret = regnode_guts(pRExC_state, op, regarglen[op], "anyof");
19931     FILL_NODE(ret, op);        /* We set the argument later */
19932     RExC_emit += 1 + regarglen[op];
19933     ANYOF_FLAGS(REGNODE_p(ret)) = anyof_flags;
19934
19935     /* Here, <cp_list> contains all the code points we can determine at
19936      * compile time that match under all conditions.  Go through it, and
19937      * for things that belong in the bitmap, put them there, and delete from
19938      * <cp_list>.  While we are at it, see if everything above 255 is in the
19939      * list, and if so, set a flag to speed up execution */
19940
19941     populate_ANYOF_from_invlist(REGNODE_p(ret), &cp_list);
19942
19943     if (posixl) {
19944         ANYOF_POSIXL_SET_TO_BITMAP(REGNODE_p(ret), posixl);
19945     }
19946
19947     if (invert) {
19948         ANYOF_FLAGS(REGNODE_p(ret)) |= ANYOF_INVERT;
19949     }
19950
19951     /* Here, the bitmap has been populated with all the Latin1 code points that
19952      * always match.  Can now add to the overall list those that match only
19953      * when the target string is UTF-8 (<upper_latin1_only_utf8_matches>).
19954      * */
19955     if (upper_latin1_only_utf8_matches) {
19956         if (cp_list) {
19957             _invlist_union(cp_list,
19958                            upper_latin1_only_utf8_matches,
19959                            &cp_list);
19960             SvREFCNT_dec_NN(upper_latin1_only_utf8_matches);
19961         }
19962         else {
19963             cp_list = upper_latin1_only_utf8_matches;
19964         }
19965         ANYOF_FLAGS(REGNODE_p(ret)) |= ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP;
19966     }
19967
19968     set_ANYOF_arg(pRExC_state, REGNODE_p(ret), cp_list,
19969                   (HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION)
19970                    ? listsv
19971                    : NULL,
19972                   only_utf8_locale_list);
19973     SvREFCNT_dec(cp_list);;
19974     SvREFCNT_dec(only_utf8_locale_list);
19975     return ret;
19976
19977   not_anyof:
19978
19979     /* Here, the node is getting optimized into something that's not an ANYOF
19980      * one.  Finish up. */
19981
19982     Set_Node_Offset_Length(REGNODE_p(ret), orig_parse - RExC_start,
19983                                            RExC_parse - orig_parse);;
19984     SvREFCNT_dec(cp_list);;
19985     SvREFCNT_dec(only_utf8_locale_list);
19986     return ret;
19987 }
19988
19989 #undef HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION
19990
19991 STATIC void
19992 S_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state,
19993                 regnode* const node,
19994                 SV* const cp_list,
19995                 SV* const runtime_defns,
19996                 SV* const only_utf8_locale_list)
19997 {
19998     /* Sets the arg field of an ANYOF-type node 'node', using information about
19999      * the node passed-in.  If there is nothing outside the node's bitmap, the
20000      * arg is set to ANYOF_ONLY_HAS_BITMAP.  Otherwise, it sets the argument to
20001      * the count returned by add_data(), having allocated and stored an array,
20002      * av, as follows:
20003      *
20004      *  av[0] stores the inversion list defining this class as far as known at
20005      *        this time, or PL_sv_undef if nothing definite is now known.
20006      *  av[1] stores the inversion list of code points that match only if the
20007      *        current locale is UTF-8, or if none, PL_sv_undef if there is an
20008      *        av[2], or no entry otherwise.
20009      *  av[2] stores the list of user-defined properties whose subroutine
20010      *        definitions aren't known at this time, or no entry if none. */
20011
20012     UV n;
20013
20014     PERL_ARGS_ASSERT_SET_ANYOF_ARG;
20015
20016     if (! cp_list && ! runtime_defns && ! only_utf8_locale_list) {
20017         assert(! (ANYOF_FLAGS(node)
20018                 & ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP));
20019         ARG_SET(node, ANYOF_ONLY_HAS_BITMAP);
20020     }
20021     else {
20022         AV * const av = newAV();
20023         SV *rv;
20024
20025         if (cp_list) {
20026             av_store(av, INVLIST_INDEX, SvREFCNT_inc_NN(cp_list));
20027         }
20028
20029         /* (Note that if any of this changes, the size calculations in
20030          * S_optimize_regclass() might need to be updated.) */
20031
20032         if (only_utf8_locale_list) {
20033             av_store(av, ONLY_LOCALE_MATCHES_INDEX,
20034                                      SvREFCNT_inc_NN(only_utf8_locale_list));
20035         }
20036
20037         if (runtime_defns) {
20038             av_store(av, DEFERRED_USER_DEFINED_INDEX,
20039                          SvREFCNT_inc_NN(runtime_defns));
20040         }
20041
20042         rv = newRV_noinc(MUTABLE_SV(av));
20043         n = add_data(pRExC_state, STR_WITH_LEN("s"));
20044         RExC_rxi->data->data[n] = (void*)rv;
20045         ARG_SET(node, n);
20046     }
20047 }
20048
20049 SV *
20050
20051 #if !defined(PERL_IN_XSUB_RE) || defined(PLUGGABLE_RE_EXTENSION)
20052 Perl_get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const regnode* node, bool doinit, SV** listsvp, SV** only_utf8_locale_ptr, SV** output_invlist)
20053 #else
20054 Perl_get_re_gclass_nonbitmap_data(pTHX_ const regexp *prog, const regnode* node, bool doinit, SV** listsvp, SV** only_utf8_locale_ptr, SV** output_invlist)
20055 #endif
20056
20057 {
20058     /* For internal core use only.
20059      * Returns the inversion list for the input 'node' in the regex 'prog'.
20060      * If <doinit> is 'true', will attempt to create the inversion list if not
20061      *    already done.
20062      * If <listsvp> is non-null, will return the printable contents of the
20063      *    property definition.  This can be used to get debugging information
20064      *    even before the inversion list exists, by calling this function with
20065      *    'doinit' set to false, in which case the components that will be used
20066      *    to eventually create the inversion list are returned  (in a printable
20067      *    form).
20068      * If <only_utf8_locale_ptr> is not NULL, it is where this routine is to
20069      *    store an inversion list of code points that should match only if the
20070      *    execution-time locale is a UTF-8 one.
20071      * If <output_invlist> is not NULL, it is where this routine is to store an
20072      *    inversion list of the code points that would be instead returned in
20073      *    <listsvp> if this were NULL.  Thus, what gets output in <listsvp>
20074      *    when this parameter is used, is just the non-code point data that
20075      *    will go into creating the inversion list.  This currently should be just
20076      *    user-defined properties whose definitions were not known at compile
20077      *    time.  Using this parameter allows for easier manipulation of the
20078      *    inversion list's data by the caller.  It is illegal to call this
20079      *    function with this parameter set, but not <listsvp>
20080      *
20081      * Tied intimately to how S_set_ANYOF_arg sets up the data structure.  Note
20082      * that, in spite of this function's name, the inversion list it returns
20083      * may include the bitmap data as well */
20084
20085     SV *si  = NULL;         /* Input initialization string */
20086     SV* invlist = NULL;
20087
20088     RXi_GET_DECL(prog, progi);
20089     const struct reg_data * const data = prog ? progi->data : NULL;
20090
20091 #if !defined(PERL_IN_XSUB_RE) || defined(PLUGGABLE_RE_EXTENSION)
20092     PERL_ARGS_ASSERT_GET_REGCLASS_NONBITMAP_DATA;
20093 #else
20094     PERL_ARGS_ASSERT_GET_RE_GCLASS_NONBITMAP_DATA;
20095 #endif
20096     assert(! output_invlist || listsvp);
20097
20098     if (data && data->count) {
20099         const U32 n = ARG(node);
20100
20101         if (data->what[n] == 's') {
20102             SV * const rv = MUTABLE_SV(data->data[n]);
20103             AV * const av = MUTABLE_AV(SvRV(rv));
20104             SV **const ary = AvARRAY(av);
20105
20106             invlist = ary[INVLIST_INDEX];
20107
20108             if (av_tindex_skip_len_mg(av) >= ONLY_LOCALE_MATCHES_INDEX) {
20109                 *only_utf8_locale_ptr = ary[ONLY_LOCALE_MATCHES_INDEX];
20110             }
20111
20112             if (av_tindex_skip_len_mg(av) >= DEFERRED_USER_DEFINED_INDEX) {
20113                 si = ary[DEFERRED_USER_DEFINED_INDEX];
20114             }
20115
20116             if (doinit && (si || invlist)) {
20117                 if (si) {
20118                     bool user_defined;
20119                     SV * msg = newSVpvs_flags("", SVs_TEMP);
20120
20121                     SV * prop_definition = handle_user_defined_property(
20122                             "", 0, FALSE,   /* There is no \p{}, \P{} */
20123                             SvPVX_const(si)[1] - '0',   /* /i or not has been
20124                                                            stored here for just
20125                                                            this occasion */
20126                             TRUE,           /* run time */
20127                             FALSE,          /* This call must find the defn */
20128                             si,             /* The property definition  */
20129                             &user_defined,
20130                             msg,
20131                             0               /* base level call */
20132                            );
20133
20134                     if (SvCUR(msg)) {
20135                         assert(prop_definition == NULL);
20136
20137                         Perl_croak(aTHX_ "%" UTF8f,
20138                                 UTF8fARG(SvUTF8(msg), SvCUR(msg), SvPVX(msg)));
20139                     }
20140
20141                     if (invlist) {
20142                         _invlist_union(invlist, prop_definition, &invlist);
20143                         SvREFCNT_dec_NN(prop_definition);
20144                     }
20145                     else {
20146                         invlist = prop_definition;
20147                     }
20148
20149                     STATIC_ASSERT_STMT(ONLY_LOCALE_MATCHES_INDEX == 1 + INVLIST_INDEX);
20150                     STATIC_ASSERT_STMT(DEFERRED_USER_DEFINED_INDEX == 1 + ONLY_LOCALE_MATCHES_INDEX);
20151
20152                     ary[INVLIST_INDEX] = invlist;
20153                     av_fill(av, (ary[ONLY_LOCALE_MATCHES_INDEX])
20154                                  ? ONLY_LOCALE_MATCHES_INDEX
20155                                  : INVLIST_INDEX);
20156                     si = NULL;
20157                 }
20158             }
20159         }
20160     }
20161
20162     /* If requested, return a printable version of what this ANYOF node matches
20163      * */
20164     if (listsvp) {
20165         SV* matches_string = NULL;
20166
20167         /* This function can be called at compile-time, before everything gets
20168          * resolved, in which case we return the currently best available
20169          * information, which is the string that will eventually be used to do
20170          * that resolving, 'si' */
20171         if (si) {
20172             /* Here, we only have 'si' (and possibly some passed-in data in
20173              * 'invlist', which is handled below)  If the caller only wants
20174              * 'si', use that.  */
20175             if (! output_invlist) {
20176                 matches_string = newSVsv(si);
20177             }
20178             else {
20179                 /* But if the caller wants an inversion list of the node, we
20180                  * need to parse 'si' and place as much as possible in the
20181                  * desired output inversion list, making 'matches_string' only
20182                  * contain the currently unresolvable things */
20183                 const char *si_string = SvPVX(si);
20184                 STRLEN remaining = SvCUR(si);
20185                 UV prev_cp = 0;
20186                 U8 count = 0;
20187
20188                 /* Ignore everything before and including the first new-line */
20189                 si_string = (const char *) memchr(si_string, '\n', SvCUR(si));
20190                 assert (si_string != NULL);
20191                 si_string++;
20192                 remaining = SvPVX(si) + SvCUR(si) - si_string;
20193
20194                 while (remaining > 0) {
20195
20196                     /* The data consists of just strings defining user-defined
20197                      * property names, but in prior incarnations, and perhaps
20198                      * somehow from pluggable regex engines, it could still
20199                      * hold hex code point definitions, all of which should be
20200                      * legal (or it wouldn't have gotten this far).  Each
20201                      * component of a range would be separated by a tab, and
20202                      * each range by a new-line.  If these are found, instead
20203                      * add them to the inversion list */
20204                     I32 grok_flags =  PERL_SCAN_SILENT_ILLDIGIT
20205                                      |PERL_SCAN_SILENT_NON_PORTABLE;
20206                     STRLEN len = remaining;
20207                     UV cp = grok_hex(si_string, &len, &grok_flags, NULL);
20208
20209                     /* If the hex decode routine found something, it should go
20210                      * up to the next \n */
20211                     if (   *(si_string + len) == '\n') {
20212                         if (count) {    /* 2nd code point on line */
20213                             *output_invlist = _add_range_to_invlist(*output_invlist, prev_cp, cp);
20214                         }
20215                         else {
20216                             *output_invlist = add_cp_to_invlist(*output_invlist, cp);
20217                         }
20218                         count = 0;
20219                         goto prepare_for_next_iteration;
20220                     }
20221
20222                     /* If the hex decode was instead for the lower range limit,
20223                      * save it, and go parse the upper range limit */
20224                     if (*(si_string + len) == '\t') {
20225                         assert(count == 0);
20226
20227                         prev_cp = cp;
20228                         count = 1;
20229                       prepare_for_next_iteration:
20230                         si_string += len + 1;
20231                         remaining -= len + 1;
20232                         continue;
20233                     }
20234
20235                     /* Here, didn't find a legal hex number.  Just add the text
20236                      * from here up to the next \n, omitting any trailing
20237                      * markers. */
20238
20239                     remaining -= len;
20240                     len = strcspn(si_string,
20241                                         DEFERRED_COULD_BE_OFFICIAL_MARKERs "\n");
20242                     remaining -= len;
20243                     if (matches_string) {
20244                         sv_catpvn(matches_string, si_string, len);
20245                     }
20246                     else {
20247                         matches_string = newSVpvn(si_string, len);
20248                     }
20249                     sv_catpvs(matches_string, " ");
20250
20251                     si_string += len;
20252                     if (   remaining
20253                         && UCHARAT(si_string)
20254                                             == DEFERRED_COULD_BE_OFFICIAL_MARKERc)
20255                     {
20256                         si_string++;
20257                         remaining--;
20258                     }
20259                     if (remaining && UCHARAT(si_string) == '\n') {
20260                         si_string++;
20261                         remaining--;
20262                     }
20263                 } /* end of loop through the text */
20264
20265                 assert(matches_string);
20266                 if (SvCUR(matches_string)) {  /* Get rid of trailing blank */
20267                     SvCUR_set(matches_string, SvCUR(matches_string) - 1);
20268                 }
20269             } /* end of has an 'si' */
20270         }
20271
20272         /* Add the stuff that's already known */
20273         if (invlist) {
20274
20275             /* Again, if the caller doesn't want the output inversion list, put
20276              * everything in 'matches-string' */
20277             if (! output_invlist) {
20278                 if ( ! matches_string) {
20279                     matches_string = newSVpvs("\n");
20280                 }
20281                 sv_catsv(matches_string, invlist_contents(invlist,
20282                                                   TRUE /* traditional style */
20283                                                   ));
20284             }
20285             else if (! *output_invlist) {
20286                 *output_invlist = invlist_clone(invlist, NULL);
20287             }
20288             else {
20289                 _invlist_union(*output_invlist, invlist, output_invlist);
20290             }
20291         }
20292
20293         *listsvp = matches_string;
20294     }
20295
20296     return invlist;
20297 }
20298
20299 /* reg_skipcomment()
20300
20301    Absorbs an /x style # comment from the input stream,
20302    returning a pointer to the first character beyond the comment, or if the
20303    comment terminates the pattern without anything following it, this returns
20304    one past the final character of the pattern (in other words, RExC_end) and
20305    sets the REG_RUN_ON_COMMENT_SEEN flag.
20306
20307    Note it's the callers responsibility to ensure that we are
20308    actually in /x mode
20309
20310 */
20311
20312 PERL_STATIC_INLINE char*
20313 S_reg_skipcomment(RExC_state_t *pRExC_state, char* p)
20314 {
20315     PERL_ARGS_ASSERT_REG_SKIPCOMMENT;
20316
20317     assert(*p == '#');
20318
20319     while (p < RExC_end) {
20320         if (*(++p) == '\n') {
20321             return p+1;
20322         }
20323     }
20324
20325     /* we ran off the end of the pattern without ending the comment, so we have
20326      * to add an \n when wrapping */
20327     RExC_seen |= REG_RUN_ON_COMMENT_SEEN;
20328     return p;
20329 }
20330
20331 STATIC void
20332 S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state,
20333                                 char ** p,
20334                                 const bool force_to_xmod
20335                          )
20336 {
20337     /* If the text at the current parse position '*p' is a '(?#...)' comment,
20338      * or if we are under /x or 'force_to_xmod' is TRUE, and the text at '*p'
20339      * is /x whitespace, advance '*p' so that on exit it points to the first
20340      * byte past all such white space and comments */
20341
20342     const bool use_xmod = force_to_xmod || (RExC_flags & RXf_PMf_EXTENDED);
20343
20344     PERL_ARGS_ASSERT_SKIP_TO_BE_IGNORED_TEXT;
20345
20346     assert( ! UTF || UTF8_IS_INVARIANT(**p) || UTF8_IS_START(**p));
20347
20348     for (;;) {
20349         if (RExC_end - (*p) >= 3
20350             && *(*p)     == '('
20351             && *(*p + 1) == '?'
20352             && *(*p + 2) == '#')
20353         {
20354             while (*(*p) != ')') {
20355                 if ((*p) == RExC_end)
20356                     FAIL("Sequence (?#... not terminated");
20357                 (*p)++;
20358             }
20359             (*p)++;
20360             continue;
20361         }
20362
20363         if (use_xmod) {
20364             const char * save_p = *p;
20365             while ((*p) < RExC_end) {
20366                 STRLEN len;
20367                 if ((len = is_PATWS_safe((*p), RExC_end, UTF))) {
20368                     (*p) += len;
20369                 }
20370                 else if (*(*p) == '#') {
20371                     (*p) = reg_skipcomment(pRExC_state, (*p));
20372                 }
20373                 else {
20374                     break;
20375                 }
20376             }
20377             if (*p != save_p) {
20378                 continue;
20379             }
20380         }
20381
20382         break;
20383     }
20384
20385     return;
20386 }
20387
20388 /* nextchar()
20389
20390    Advances the parse position by one byte, unless that byte is the beginning
20391    of a '(?#...)' style comment, or is /x whitespace and /x is in effect.  In
20392    those two cases, the parse position is advanced beyond all such comments and
20393    white space.
20394
20395    This is the UTF, (?#...), and /x friendly way of saying RExC_parse++.
20396 */
20397
20398 STATIC void
20399 S_nextchar(pTHX_ RExC_state_t *pRExC_state)
20400 {
20401     PERL_ARGS_ASSERT_NEXTCHAR;
20402
20403     if (RExC_parse < RExC_end) {
20404         assert(   ! UTF
20405                || UTF8_IS_INVARIANT(*RExC_parse)
20406                || UTF8_IS_START(*RExC_parse));
20407
20408         RExC_parse += (UTF)
20409                       ? UTF8_SAFE_SKIP(RExC_parse, RExC_end)
20410                       : 1;
20411
20412         skip_to_be_ignored_text(pRExC_state, &RExC_parse,
20413                                 FALSE /* Don't force /x */ );
20414     }
20415 }
20416
20417 STATIC void
20418 S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const Ptrdiff_t size)
20419 {
20420     /* 'size' is the delta number of smallest regnode equivalents to add or
20421      * subtract from the current memory allocated to the regex engine being
20422      * constructed. */
20423
20424     PERL_ARGS_ASSERT_CHANGE_ENGINE_SIZE;
20425
20426     RExC_size += size;
20427
20428     Renewc(RExC_rxi,
20429            sizeof(regexp_internal) + (RExC_size + 1) * sizeof(regnode),
20430                                                 /* +1 for REG_MAGIC */
20431            char,
20432            regexp_internal);
20433     if ( RExC_rxi == NULL )
20434         FAIL("Regexp out of space");
20435     RXi_SET(RExC_rx, RExC_rxi);
20436
20437     RExC_emit_start = RExC_rxi->program;
20438     if (size > 0) {
20439         Zero(REGNODE_p(RExC_emit), size, regnode);
20440     }
20441
20442 #ifdef RE_TRACK_PATTERN_OFFSETS
20443     Renew(RExC_offsets, 2*RExC_size+1, U32);
20444     if (size > 0) {
20445         Zero(RExC_offsets + 2*(RExC_size - size) + 1, 2 * size, U32);
20446     }
20447     RExC_offsets[0] = RExC_size;
20448 #endif
20449 }
20450
20451 STATIC regnode_offset
20452 S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_size, const char* const name)
20453 {
20454     /* Allocate a regnode for 'op', with 'extra_size' extra (smallest) regnode
20455      * equivalents space.  It aligns and increments RExC_size
20456      *
20457      * It returns the regnode's offset into the regex engine program */
20458
20459     const regnode_offset ret = RExC_emit;
20460
20461     DECLARE_AND_GET_RE_DEBUG_FLAGS;
20462
20463     PERL_ARGS_ASSERT_REGNODE_GUTS;
20464
20465     SIZE_ALIGN(RExC_size);
20466     change_engine_size(pRExC_state, (Ptrdiff_t) 1 + extra_size);
20467     NODE_ALIGN_FILL(REGNODE_p(ret));
20468 #ifndef RE_TRACK_PATTERN_OFFSETS
20469     PERL_UNUSED_ARG(name);
20470     PERL_UNUSED_ARG(op);
20471 #else
20472     assert(extra_size >= regarglen[op] || PL_regkind[op] == ANYOF);
20473
20474     if (RExC_offsets) {         /* MJD */
20475         MJD_OFFSET_DEBUG(
20476               ("%s:%d: (op %s) %s %" UVuf " (len %" UVuf ") (max %" UVuf ").\n",
20477               name, __LINE__,
20478               PL_reg_name[op],
20479               (UV)(RExC_emit) > RExC_offsets[0]
20480                 ? "Overwriting end of array!\n" : "OK",
20481               (UV)(RExC_emit),
20482               (UV)(RExC_parse - RExC_start),
20483               (UV)RExC_offsets[0]));
20484         Set_Node_Offset(REGNODE_p(RExC_emit), RExC_parse + (op == END));
20485     }
20486 #endif
20487     return(ret);
20488 }
20489
20490 /*
20491 - reg_node - emit a node
20492 */
20493 STATIC regnode_offset /* Location. */
20494 S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op)
20495 {
20496     const regnode_offset ret = regnode_guts(pRExC_state, op, regarglen[op], "reg_node");
20497     regnode_offset ptr = ret;
20498
20499     PERL_ARGS_ASSERT_REG_NODE;
20500
20501     assert(regarglen[op] == 0);
20502
20503     FILL_ADVANCE_NODE(ptr, op);
20504     RExC_emit = ptr;
20505     return(ret);
20506 }
20507
20508 /*
20509 - reganode - emit a node with an argument
20510 */
20511 STATIC regnode_offset /* Location. */
20512 S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)
20513 {
20514     const regnode_offset ret = regnode_guts(pRExC_state, op, regarglen[op], "reganode");
20515     regnode_offset ptr = ret;
20516
20517     PERL_ARGS_ASSERT_REGANODE;
20518
20519     /* ANYOF are special cased to allow non-length 1 args */
20520     assert(regarglen[op] == 1);
20521
20522     FILL_ADVANCE_NODE_ARG(ptr, op, arg);
20523     RExC_emit = ptr;
20524     return(ret);
20525 }
20526
20527 /*
20528 - regpnode - emit a temporary node with a SV* argument
20529 */
20530 STATIC regnode_offset /* Location. */
20531 S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, SV * arg)
20532 {
20533     const regnode_offset ret = regnode_guts(pRExC_state, op, regarglen[op], "regpnode");
20534     regnode_offset ptr = ret;
20535
20536     PERL_ARGS_ASSERT_REGPNODE;
20537
20538     FILL_ADVANCE_NODE_ARGp(ptr, op, arg);
20539     RExC_emit = ptr;
20540     return(ret);
20541 }
20542
20543 STATIC regnode_offset
20544 S_reg2Lanode(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2)
20545 {
20546     /* emit a node with U32 and I32 arguments */
20547
20548     const regnode_offset ret = regnode_guts(pRExC_state, op, regarglen[op], "reg2Lanode");
20549     regnode_offset ptr = ret;
20550
20551     PERL_ARGS_ASSERT_REG2LANODE;
20552
20553     assert(regarglen[op] == 2);
20554
20555     FILL_ADVANCE_NODE_2L_ARG(ptr, op, arg1, arg2);
20556     RExC_emit = ptr;
20557     return(ret);
20558 }
20559
20560 /*
20561 - reginsert - insert an operator in front of already-emitted operand
20562 *
20563 * That means that on exit 'operand' is the offset of the newly inserted
20564 * operator, and the original operand has been relocated.
20565 *
20566 * IMPORTANT NOTE - it is the *callers* responsibility to correctly
20567 * set up NEXT_OFF() of the inserted node if needed. Something like this:
20568 *
20569 *   reginsert(pRExC, OPFAIL, orig_emit, depth+1);
20570 *   NEXT_OFF(orig_emit) = regarglen[OPFAIL] + NODE_STEP_REGNODE;
20571 *
20572 * ALSO NOTE - FLAGS(newly-inserted-operator) will be set to 0 as well.
20573 */
20574 STATIC void
20575 S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op,
20576                   const regnode_offset operand, const U32 depth)
20577 {
20578     regnode *src;
20579     regnode *dst;
20580     regnode *place;
20581     const int offset = regarglen[(U8)op];
20582     const int size = NODE_STEP_REGNODE + offset;
20583     DECLARE_AND_GET_RE_DEBUG_FLAGS;
20584
20585     PERL_ARGS_ASSERT_REGINSERT;
20586     PERL_UNUSED_CONTEXT;
20587     PERL_UNUSED_ARG(depth);
20588 /* (PL_regkind[(U8)op] == CURLY ? EXTRA_STEP_2ARGS : 0); */
20589     DEBUG_PARSE_FMT("inst"," - %s", PL_reg_name[op]);
20590     assert(!RExC_study_started); /* I believe we should never use reginsert once we have started
20591                                     studying. If this is wrong then we need to adjust RExC_recurse
20592                                     below like we do with RExC_open_parens/RExC_close_parens. */
20593     change_engine_size(pRExC_state, (Ptrdiff_t) size);
20594     src = REGNODE_p(RExC_emit);
20595     RExC_emit += size;
20596     dst = REGNODE_p(RExC_emit);
20597
20598     /* If we are in a "count the parentheses" pass, the numbers are unreliable,
20599      * and [perl #133871] shows this can lead to problems, so skip this
20600      * realignment of parens until a later pass when they are reliable */
20601     if (! IN_PARENS_PASS && RExC_open_parens) {
20602         int paren;
20603         /*DEBUG_PARSE_FMT("inst"," - %" IVdf, (IV)RExC_npar);*/
20604         /* remember that RExC_npar is rex->nparens + 1,
20605          * iow it is 1 more than the number of parens seen in
20606          * the pattern so far. */
20607         for ( paren=0 ; paren < RExC_npar ; paren++ ) {
20608             /* note, RExC_open_parens[0] is the start of the
20609              * regex, it can't move. RExC_close_parens[0] is the end
20610              * of the regex, it *can* move. */
20611             if ( paren && RExC_open_parens[paren] >= operand ) {
20612                 /*DEBUG_PARSE_FMT("open"," - %d", size);*/
20613                 RExC_open_parens[paren] += size;
20614             } else {
20615                 /*DEBUG_PARSE_FMT("open"," - %s","ok");*/
20616             }
20617             if ( RExC_close_parens[paren] >= operand ) {
20618                 /*DEBUG_PARSE_FMT("close"," - %d", size);*/
20619                 RExC_close_parens[paren] += size;
20620             } else {
20621                 /*DEBUG_PARSE_FMT("close"," - %s","ok");*/
20622             }
20623         }
20624     }
20625     if (RExC_end_op)
20626         RExC_end_op += size;
20627
20628     while (src > REGNODE_p(operand)) {
20629         StructCopy(--src, --dst, regnode);
20630 #ifdef RE_TRACK_PATTERN_OFFSETS
20631         if (RExC_offsets) {     /* MJD 20010112 */
20632             MJD_OFFSET_DEBUG(
20633                  ("%s(%d): (op %s) %s copy %" UVuf " -> %" UVuf " (max %" UVuf ").\n",
20634                   "reginsert",
20635                   __LINE__,
20636                   PL_reg_name[op],
20637                   (UV)(REGNODE_OFFSET(dst)) > RExC_offsets[0]
20638                     ? "Overwriting end of array!\n" : "OK",
20639                   (UV)REGNODE_OFFSET(src),
20640                   (UV)REGNODE_OFFSET(dst),
20641                   (UV)RExC_offsets[0]));
20642             Set_Node_Offset_To_R(REGNODE_OFFSET(dst), Node_Offset(src));
20643             Set_Node_Length_To_R(REGNODE_OFFSET(dst), Node_Length(src));
20644         }
20645 #endif
20646     }
20647
20648     place = REGNODE_p(operand); /* Op node, where operand used to be. */
20649 #ifdef RE_TRACK_PATTERN_OFFSETS
20650     if (RExC_offsets) {         /* MJD */
20651         MJD_OFFSET_DEBUG(
20652               ("%s(%d): (op %s) %s %" UVuf " <- %" UVuf " (max %" UVuf ").\n",
20653               "reginsert",
20654               __LINE__,
20655               PL_reg_name[op],
20656               (UV)REGNODE_OFFSET(place) > RExC_offsets[0]
20657               ? "Overwriting end of array!\n" : "OK",
20658               (UV)REGNODE_OFFSET(place),
20659               (UV)(RExC_parse - RExC_start),
20660               (UV)RExC_offsets[0]));
20661         Set_Node_Offset(place, RExC_parse);
20662         Set_Node_Length(place, 1);
20663     }
20664 #endif
20665     src = NEXTOPER(place);
20666     FLAGS(place) = 0;
20667     FILL_NODE(operand, op);
20668
20669     /* Zero out any arguments in the new node */
20670     Zero(src, offset, regnode);
20671 }
20672
20673 /*
20674 - regtail - set the next-pointer at the end of a node chain of p to val.  If
20675             that value won't fit in the space available, instead returns FALSE.
20676             (Except asserts if we can't fit in the largest space the regex
20677             engine is designed for.)
20678 - SEE ALSO: regtail_study
20679 */
20680 STATIC bool
20681 S_regtail(pTHX_ RExC_state_t * pRExC_state,
20682                 const regnode_offset p,
20683                 const regnode_offset val,
20684                 const U32 depth)
20685 {
20686     regnode_offset scan;
20687     DECLARE_AND_GET_RE_DEBUG_FLAGS;
20688
20689     PERL_ARGS_ASSERT_REGTAIL;
20690 #ifndef DEBUGGING
20691     PERL_UNUSED_ARG(depth);
20692 #endif
20693
20694     /* The final node in the chain is the first one with a nonzero next pointer
20695      * */
20696     scan = (regnode_offset) p;
20697     for (;;) {
20698         regnode * const temp = regnext(REGNODE_p(scan));
20699         DEBUG_PARSE_r({
20700             DEBUG_PARSE_MSG((scan==p ? "tail" : ""));
20701             regprop(RExC_rx, RExC_mysv, REGNODE_p(scan), NULL, pRExC_state);
20702             Perl_re_printf( aTHX_  "~ %s (%zu) %s %s\n",
20703                 SvPV_nolen_const(RExC_mysv), scan,
20704                     (temp == NULL ? "->" : ""),
20705                     (temp == NULL ? PL_reg_name[OP(REGNODE_p(val))] : "")
20706             );
20707         });
20708         if (temp == NULL)
20709             break;
20710         scan = REGNODE_OFFSET(temp);
20711     }
20712
20713     /* Populate this node's next pointer */
20714     assert(val >= scan);
20715     if (reg_off_by_arg[OP(REGNODE_p(scan))]) {
20716         assert((UV) (val - scan) <= U32_MAX);
20717         ARG_SET(REGNODE_p(scan), val - scan);
20718     }
20719     else {
20720         if (val - scan > U16_MAX) {
20721             /* Populate this with something that won't loop and will likely
20722              * lead to a crash if the caller ignores the failure return, and
20723              * execution continues */
20724             NEXT_OFF(REGNODE_p(scan)) = U16_MAX;
20725             return FALSE;
20726         }
20727         NEXT_OFF(REGNODE_p(scan)) = val - scan;
20728     }
20729
20730     return TRUE;
20731 }
20732
20733 #ifdef DEBUGGING
20734 /*
20735 - regtail_study - set the next-pointer at the end of a node chain of p to val.
20736 - Look for optimizable sequences at the same time.
20737 - currently only looks for EXACT chains.
20738
20739 This is experimental code. The idea is to use this routine to perform
20740 in place optimizations on branches and groups as they are constructed,
20741 with the long term intention of removing optimization from study_chunk so
20742 that it is purely analytical.
20743
20744 Currently only used when in DEBUG mode. The macro REGTAIL_STUDY() is used
20745 to control which is which.
20746
20747 This used to return a value that was ignored.  It was a problem that it is
20748 #ifdef'd to be another function that didn't return a value.  khw has changed it
20749 so both currently return a pass/fail return.
20750
20751 */
20752 /* TODO: All four parms should be const */
20753
20754 STATIC bool
20755 S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p,
20756                       const regnode_offset val, U32 depth)
20757 {
20758     regnode_offset scan;
20759     U8 exact = PSEUDO;
20760 #ifdef EXPERIMENTAL_INPLACESCAN
20761     I32 min = 0;
20762 #endif
20763     DECLARE_AND_GET_RE_DEBUG_FLAGS;
20764
20765     PERL_ARGS_ASSERT_REGTAIL_STUDY;
20766
20767
20768     /* Find last node. */
20769
20770     scan = p;
20771     for (;;) {
20772         regnode * const temp = regnext(REGNODE_p(scan));
20773 #ifdef EXPERIMENTAL_INPLACESCAN
20774         if (PL_regkind[OP(REGNODE_p(scan))] == EXACT) {
20775             bool unfolded_multi_char;   /* Unexamined in this routine */
20776             if (join_exact(pRExC_state, scan, &min,
20777                            &unfolded_multi_char, 1, REGNODE_p(val), depth+1))
20778                 return TRUE; /* Was return EXACT */
20779         }
20780 #endif
20781         if ( exact ) {
20782             if (PL_regkind[OP(REGNODE_p(scan))] == EXACT) {
20783                 if (exact == PSEUDO )
20784                     exact= OP(REGNODE_p(scan));
20785                 else if (exact != OP(REGNODE_p(scan)) )
20786                     exact= 0;
20787             }
20788             else if (OP(REGNODE_p(scan)) != NOTHING) {
20789                 exact= 0;
20790             }
20791         }
20792         DEBUG_PARSE_r({
20793             DEBUG_PARSE_MSG((scan==p ? "tsdy" : ""));
20794             regprop(RExC_rx, RExC_mysv, REGNODE_p(scan), NULL, pRExC_state);
20795             Perl_re_printf( aTHX_  "~ %s (%zu) -> %s\n",
20796                 SvPV_nolen_const(RExC_mysv),
20797                 scan,
20798                 PL_reg_name[exact]);
20799         });
20800         if (temp == NULL)
20801             break;
20802         scan = REGNODE_OFFSET(temp);
20803     }
20804     DEBUG_PARSE_r({
20805         DEBUG_PARSE_MSG("");
20806         regprop(RExC_rx, RExC_mysv, REGNODE_p(val), NULL, pRExC_state);
20807         Perl_re_printf( aTHX_
20808                       "~ attach to %s (%" IVdf ") offset to %" IVdf "\n",
20809                       SvPV_nolen_const(RExC_mysv),
20810                       (IV)val,
20811                       (IV)(val - scan)
20812         );
20813     });
20814     if (reg_off_by_arg[OP(REGNODE_p(scan))]) {
20815         assert((UV) (val - scan) <= U32_MAX);
20816         ARG_SET(REGNODE_p(scan), val - scan);
20817     }
20818     else {
20819         if (val - scan > U16_MAX) {
20820             /* Populate this with something that won't loop and will likely
20821              * lead to a crash if the caller ignores the failure return, and
20822              * execution continues */
20823             NEXT_OFF(REGNODE_p(scan)) = U16_MAX;
20824             return FALSE;
20825         }
20826         NEXT_OFF(REGNODE_p(scan)) = val - scan;
20827     }
20828
20829     return TRUE; /* Was 'return exact' */
20830 }
20831 #endif
20832
20833 STATIC SV*
20834 S_get_ANYOFM_contents(pTHX_ const regnode * n) {
20835
20836     /* Returns an inversion list of all the code points matched by the
20837      * ANYOFM/NANYOFM node 'n' */
20838
20839     SV * cp_list = _new_invlist(-1);
20840     const U8 lowest = (U8) ARG(n);
20841     unsigned int i;
20842     U8 count = 0;
20843     U8 needed = 1U << PL_bitcount[ (U8) ~ FLAGS(n)];
20844
20845     PERL_ARGS_ASSERT_GET_ANYOFM_CONTENTS;
20846
20847     /* Starting with the lowest code point, any code point that ANDed with the
20848      * mask yields the lowest code point is in the set */
20849     for (i = lowest; i <= 0xFF; i++) {
20850         if ((i & FLAGS(n)) == ARG(n)) {
20851             cp_list = add_cp_to_invlist(cp_list, i);
20852             count++;
20853
20854             /* We know how many code points (a power of two) that are in the
20855              * set.  No use looking once we've got that number */
20856             if (count >= needed) break;
20857         }
20858     }
20859
20860     if (OP(n) == NANYOFM) {
20861         _invlist_invert(cp_list);
20862     }
20863     return cp_list;
20864 }
20865
20866 /*
20867  - regdump - dump a regexp onto Perl_debug_log in vaguely comprehensible form
20868  */
20869 #ifdef DEBUGGING
20870
20871 static void
20872 S_regdump_intflags(pTHX_ const char *lead, const U32 flags)
20873 {
20874     int bit;
20875     int set=0;
20876
20877     ASSUME(REG_INTFLAGS_NAME_SIZE <= sizeof(flags)*8);
20878
20879     for (bit=0; bit<REG_INTFLAGS_NAME_SIZE; bit++) {
20880         if (flags & (1<<bit)) {
20881             if (!set++ && lead)
20882                 Perl_re_printf( aTHX_  "%s", lead);
20883             Perl_re_printf( aTHX_  "%s ", PL_reg_intflags_name[bit]);
20884         }
20885     }
20886     if (lead)  {
20887         if (set)
20888             Perl_re_printf( aTHX_  "\n");
20889         else
20890             Perl_re_printf( aTHX_  "%s[none-set]\n", lead);
20891     }
20892 }
20893
20894 static void
20895 S_regdump_extflags(pTHX_ const char *lead, const U32 flags)
20896 {
20897     int bit;
20898     int set=0;
20899     regex_charset cs;
20900
20901     ASSUME(REG_EXTFLAGS_NAME_SIZE <= sizeof(flags)*8);
20902
20903     for (bit=0; bit<REG_EXTFLAGS_NAME_SIZE; bit++) {
20904         if (flags & (1<<bit)) {
20905             if ((1<<bit) & RXf_PMf_CHARSET) {   /* Output separately, below */
20906                 continue;
20907             }
20908             if (!set++ && lead)
20909                 Perl_re_printf( aTHX_  "%s", lead);
20910             Perl_re_printf( aTHX_  "%s ", PL_reg_extflags_name[bit]);
20911         }
20912     }
20913     if ((cs = get_regex_charset(flags)) != REGEX_DEPENDS_CHARSET) {
20914             if (!set++ && lead) {
20915                 Perl_re_printf( aTHX_  "%s", lead);
20916             }
20917             switch (cs) {
20918                 case REGEX_UNICODE_CHARSET:
20919                     Perl_re_printf( aTHX_  "UNICODE");
20920                     break;
20921                 case REGEX_LOCALE_CHARSET:
20922                     Perl_re_printf( aTHX_  "LOCALE");
20923                     break;
20924                 case REGEX_ASCII_RESTRICTED_CHARSET:
20925                     Perl_re_printf( aTHX_  "ASCII-RESTRICTED");
20926                     break;
20927                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
20928                     Perl_re_printf( aTHX_  "ASCII-MORE_RESTRICTED");
20929                     break;
20930                 default:
20931                     Perl_re_printf( aTHX_  "UNKNOWN CHARACTER SET");
20932                     break;
20933             }
20934     }
20935     if (lead)  {
20936         if (set)
20937             Perl_re_printf( aTHX_  "\n");
20938         else
20939             Perl_re_printf( aTHX_  "%s[none-set]\n", lead);
20940     }
20941 }
20942 #endif
20943
20944 void
20945 Perl_regdump(pTHX_ const regexp *r)
20946 {
20947 #ifdef DEBUGGING
20948     int i;
20949     SV * const sv = sv_newmortal();
20950     SV *dsv= sv_newmortal();
20951     RXi_GET_DECL(r, ri);
20952     DECLARE_AND_GET_RE_DEBUG_FLAGS;
20953
20954     PERL_ARGS_ASSERT_REGDUMP;
20955
20956     (void)dumpuntil(r, ri->program, ri->program + 1, NULL, NULL, sv, 0, 0);
20957
20958     /* Header fields of interest. */
20959     for (i = 0; i < 2; i++) {
20960         if (r->substrs->data[i].substr) {
20961             RE_PV_QUOTED_DECL(s, 0, dsv,
20962                             SvPVX_const(r->substrs->data[i].substr),
20963                             RE_SV_DUMPLEN(r->substrs->data[i].substr),
20964                             PL_dump_re_max_len);
20965             Perl_re_printf( aTHX_
20966                           "%s %s%s at %" IVdf "..%" UVuf " ",
20967                           i ? "floating" : "anchored",
20968                           s,
20969                           RE_SV_TAIL(r->substrs->data[i].substr),
20970                           (IV)r->substrs->data[i].min_offset,
20971                           (UV)r->substrs->data[i].max_offset);
20972         }
20973         else if (r->substrs->data[i].utf8_substr) {
20974             RE_PV_QUOTED_DECL(s, 1, dsv,
20975                             SvPVX_const(r->substrs->data[i].utf8_substr),
20976                             RE_SV_DUMPLEN(r->substrs->data[i].utf8_substr),
20977                             30);
20978             Perl_re_printf( aTHX_
20979                           "%s utf8 %s%s at %" IVdf "..%" UVuf " ",
20980                           i ? "floating" : "anchored",
20981                           s,
20982                           RE_SV_TAIL(r->substrs->data[i].utf8_substr),
20983                           (IV)r->substrs->data[i].min_offset,
20984                           (UV)r->substrs->data[i].max_offset);
20985         }
20986     }
20987
20988     if (r->check_substr || r->check_utf8)
20989         Perl_re_printf( aTHX_
20990                       (const char *)
20991                       (   r->check_substr == r->substrs->data[1].substr
20992                        && r->check_utf8   == r->substrs->data[1].utf8_substr
20993                        ? "(checking floating" : "(checking anchored"));
20994     if (r->intflags & PREGf_NOSCAN)
20995         Perl_re_printf( aTHX_  " noscan");
20996     if (r->extflags & RXf_CHECK_ALL)
20997         Perl_re_printf( aTHX_  " isall");
20998     if (r->check_substr || r->check_utf8)
20999         Perl_re_printf( aTHX_  ") ");
21000
21001     if (ri->regstclass) {
21002         regprop(r, sv, ri->regstclass, NULL, NULL);
21003         Perl_re_printf( aTHX_  "stclass %s ", SvPVX_const(sv));
21004     }
21005     if (r->intflags & PREGf_ANCH) {
21006         Perl_re_printf( aTHX_  "anchored");
21007         if (r->intflags & PREGf_ANCH_MBOL)
21008             Perl_re_printf( aTHX_  "(MBOL)");
21009         if (r->intflags & PREGf_ANCH_SBOL)
21010             Perl_re_printf( aTHX_  "(SBOL)");
21011         if (r->intflags & PREGf_ANCH_GPOS)
21012             Perl_re_printf( aTHX_  "(GPOS)");
21013         Perl_re_printf( aTHX_ " ");
21014     }
21015     if (r->intflags & PREGf_GPOS_SEEN)
21016         Perl_re_printf( aTHX_  "GPOS:%" UVuf " ", (UV)r->gofs);
21017     if (r->intflags & PREGf_SKIP)
21018         Perl_re_printf( aTHX_  "plus ");
21019     if (r->intflags & PREGf_IMPLICIT)
21020         Perl_re_printf( aTHX_  "implicit ");
21021     Perl_re_printf( aTHX_  "minlen %" IVdf " ", (IV)r->minlen);
21022     if (r->extflags & RXf_EVAL_SEEN)
21023         Perl_re_printf( aTHX_  "with eval ");
21024     Perl_re_printf( aTHX_  "\n");
21025     DEBUG_FLAGS_r({
21026         regdump_extflags("r->extflags: ", r->extflags);
21027         regdump_intflags("r->intflags: ", r->intflags);
21028     });
21029 #else
21030     PERL_ARGS_ASSERT_REGDUMP;
21031     PERL_UNUSED_CONTEXT;
21032     PERL_UNUSED_ARG(r);
21033 #endif  /* DEBUGGING */
21034 }
21035
21036 /* Should be synchronized with ANYOF_ #defines in regcomp.h */
21037 #ifdef DEBUGGING
21038
21039 #  if   _CC_WORDCHAR != 0 || _CC_DIGIT != 1        || _CC_ALPHA != 2    \
21040      || _CC_LOWER != 3    || _CC_UPPER != 4        || _CC_PUNCT != 5    \
21041      || _CC_PRINT != 6    || _CC_ALPHANUMERIC != 7 || _CC_GRAPH != 8    \
21042      || _CC_CASED != 9    || _CC_SPACE != 10       || _CC_BLANK != 11   \
21043      || _CC_XDIGIT != 12  || _CC_CNTRL != 13       || _CC_ASCII != 14   \
21044      || _CC_VERTSPACE != 15
21045 #   error Need to adjust order of anyofs[]
21046 #  endif
21047 static const char * const anyofs[] = {
21048     "\\w",
21049     "\\W",
21050     "\\d",
21051     "\\D",
21052     "[:alpha:]",
21053     "[:^alpha:]",
21054     "[:lower:]",
21055     "[:^lower:]",
21056     "[:upper:]",
21057     "[:^upper:]",
21058     "[:punct:]",
21059     "[:^punct:]",
21060     "[:print:]",
21061     "[:^print:]",
21062     "[:alnum:]",
21063     "[:^alnum:]",
21064     "[:graph:]",
21065     "[:^graph:]",
21066     "[:cased:]",
21067     "[:^cased:]",
21068     "\\s",
21069     "\\S",
21070     "[:blank:]",
21071     "[:^blank:]",
21072     "[:xdigit:]",
21073     "[:^xdigit:]",
21074     "[:cntrl:]",
21075     "[:^cntrl:]",
21076     "[:ascii:]",
21077     "[:^ascii:]",
21078     "\\v",
21079     "\\V"
21080 };
21081 #endif
21082
21083 /*
21084 - regprop - printable representation of opcode, with run time support
21085 */
21086
21087 void
21088 Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state)
21089 {
21090 #ifdef DEBUGGING
21091     int k;
21092     RXi_GET_DECL(prog, progi);
21093     DECLARE_AND_GET_RE_DEBUG_FLAGS;
21094
21095     PERL_ARGS_ASSERT_REGPROP;
21096
21097     SvPVCLEAR(sv);
21098
21099     if (OP(o) > REGNODE_MAX) {          /* regnode.type is unsigned */
21100         if (pRExC_state) {  /* This gives more info, if we have it */
21101             FAIL3("panic: corrupted regexp opcode %d > %d",
21102                   (int)OP(o), (int)REGNODE_MAX);
21103         }
21104         else {
21105             Perl_croak(aTHX_ "panic: corrupted regexp opcode %d > %d",
21106                              (int)OP(o), (int)REGNODE_MAX);
21107         }
21108     }
21109     sv_catpv(sv, PL_reg_name[OP(o)]); /* Take off const! */
21110
21111     k = PL_regkind[OP(o)];
21112
21113     if (k == EXACT) {
21114         sv_catpvs(sv, " ");
21115         /* Using is_utf8_string() (via PERL_PV_UNI_DETECT)
21116          * is a crude hack but it may be the best for now since
21117          * we have no flag "this EXACTish node was UTF-8"
21118          * --jhi */
21119         pv_pretty(sv, STRING(o), STR_LEN(o), PL_dump_re_max_len,
21120                   PL_colors[0], PL_colors[1],
21121                   PERL_PV_ESCAPE_UNI_DETECT |
21122                   PERL_PV_ESCAPE_NONASCII   |
21123                   PERL_PV_PRETTY_ELLIPSES   |
21124                   PERL_PV_PRETTY_LTGT       |
21125                   PERL_PV_PRETTY_NOCLEAR
21126                   );
21127     } else if (k == TRIE) {
21128         /* print the details of the trie in dumpuntil instead, as
21129          * progi->data isn't available here */
21130         const char op = OP(o);
21131         const U32 n = ARG(o);
21132         const reg_ac_data * const ac = IS_TRIE_AC(op) ?
21133                (reg_ac_data *)progi->data->data[n] :
21134                NULL;
21135         const reg_trie_data * const trie
21136             = (reg_trie_data*)progi->data->data[!IS_TRIE_AC(op) ? n : ac->trie];
21137
21138         Perl_sv_catpvf(aTHX_ sv, "-%s", PL_reg_name[o->flags]);
21139         DEBUG_TRIE_COMPILE_r({
21140           if (trie->jump)
21141             sv_catpvs(sv, "(JUMP)");
21142           Perl_sv_catpvf(aTHX_ sv,
21143             "<S:%" UVuf "/%" IVdf " W:%" UVuf " L:%" UVuf "/%" UVuf " C:%" UVuf "/%" UVuf ">",
21144             (UV)trie->startstate,
21145             (IV)trie->statecount-1, /* -1 because of the unused 0 element */
21146             (UV)trie->wordcount,
21147             (UV)trie->minlen,
21148             (UV)trie->maxlen,
21149             (UV)TRIE_CHARCOUNT(trie),
21150             (UV)trie->uniquecharcount
21151           );
21152         });
21153         if ( IS_ANYOF_TRIE(op) || trie->bitmap ) {
21154             sv_catpvs(sv, "[");
21155             (void) put_charclass_bitmap_innards(sv,
21156                                                 ((IS_ANYOF_TRIE(op))
21157                                                  ? ANYOF_BITMAP(o)
21158                                                  : TRIE_BITMAP(trie)),
21159                                                 NULL,
21160                                                 NULL,
21161                                                 NULL,
21162                                                 0,
21163                                                 FALSE
21164                                                );
21165             sv_catpvs(sv, "]");
21166         }
21167     } else if (k == CURLY) {
21168         U32 lo = ARG1(o), hi = ARG2(o);
21169         if (OP(o) == CURLYM || OP(o) == CURLYN || OP(o) == CURLYX)
21170             Perl_sv_catpvf(aTHX_ sv, "[%d]", o->flags); /* Parenth number */
21171         Perl_sv_catpvf(aTHX_ sv, "{%u,", (unsigned) lo);
21172         if (hi == REG_INFTY)
21173             sv_catpvs(sv, "INFTY");
21174         else
21175             Perl_sv_catpvf(aTHX_ sv, "%u", (unsigned) hi);
21176         sv_catpvs(sv, "}");
21177     }
21178     else if (k == WHILEM && o->flags)                   /* Ordinal/of */
21179         Perl_sv_catpvf(aTHX_ sv, "[%d/%d]", o->flags & 0xf, o->flags>>4);
21180     else if (k == REF || k == OPEN || k == CLOSE
21181              || k == GROUPP || OP(o)==ACCEPT)
21182     {
21183         AV *name_list= NULL;
21184         U32 parno= OP(o) == ACCEPT ? (U32)ARG2L(o) : ARG(o);
21185         Perl_sv_catpvf(aTHX_ sv, "%" UVuf, (UV)parno);        /* Parenth number */
21186         if ( RXp_PAREN_NAMES(prog) ) {
21187             name_list= MUTABLE_AV(progi->data->data[progi->name_list_idx]);
21188         } else if ( pRExC_state ) {
21189             name_list= RExC_paren_name_list;
21190         }
21191         if (name_list) {
21192             if ( k != REF || (OP(o) < REFN)) {
21193                 SV **name= av_fetch(name_list, parno, 0 );
21194                 if (name)
21195                     Perl_sv_catpvf(aTHX_ sv, " '%" SVf "'", SVfARG(*name));
21196             }
21197             else {
21198                 SV *sv_dat= MUTABLE_SV(progi->data->data[ parno ]);
21199                 I32 *nums=(I32*)SvPVX(sv_dat);
21200                 SV **name= av_fetch(name_list, nums[0], 0 );
21201                 I32 n;
21202                 if (name) {
21203                     for ( n=0; n<SvIVX(sv_dat); n++ ) {
21204                         Perl_sv_catpvf(aTHX_ sv, "%s%" IVdf,
21205                                     (n ? "," : ""), (IV)nums[n]);
21206                     }
21207                     Perl_sv_catpvf(aTHX_ sv, " '%" SVf "'", SVfARG(*name));
21208                 }
21209             }
21210         }
21211         if ( k == REF && reginfo) {
21212             U32 n = ARG(o);  /* which paren pair */
21213             I32 ln = prog->offs[n].start;
21214             if (prog->lastparen < n || ln == -1 || prog->offs[n].end == -1)
21215                 Perl_sv_catpvf(aTHX_ sv, ": FAIL");
21216             else if (ln == prog->offs[n].end)
21217                 Perl_sv_catpvf(aTHX_ sv, ": ACCEPT - EMPTY STRING");
21218             else {
21219                 const char *s = reginfo->strbeg + ln;
21220                 Perl_sv_catpvf(aTHX_ sv, ": ");
21221                 Perl_pv_pretty( aTHX_ sv, s, prog->offs[n].end - prog->offs[n].start, 32, 0, 0,
21222                     PERL_PV_ESCAPE_UNI_DETECT|PERL_PV_PRETTY_NOCLEAR|PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE );
21223             }
21224         }
21225     } else if (k == GOSUB) {
21226         AV *name_list= NULL;
21227         if ( RXp_PAREN_NAMES(prog) ) {
21228             name_list= MUTABLE_AV(progi->data->data[progi->name_list_idx]);
21229         } else if ( pRExC_state ) {
21230             name_list= RExC_paren_name_list;
21231         }
21232
21233         /* Paren and offset */
21234         Perl_sv_catpvf(aTHX_ sv, "%d[%+d:%d]", (int)ARG(o),(int)ARG2L(o),
21235                 (int)((o + (int)ARG2L(o)) - progi->program) );
21236         if (name_list) {
21237             SV **name= av_fetch(name_list, ARG(o), 0 );
21238             if (name)
21239                 Perl_sv_catpvf(aTHX_ sv, " '%" SVf "'", SVfARG(*name));
21240         }
21241     }
21242     else if (k == LOGICAL)
21243         /* 2: embedded, otherwise 1 */
21244         Perl_sv_catpvf(aTHX_ sv, "[%d]", o->flags);
21245     else if (k == ANYOF || k == ANYOFR) {
21246         U8 flags;
21247         char * bitmap;
21248         U32 arg;
21249         bool do_sep = FALSE;    /* Do we need to separate various components of
21250                                    the output? */
21251         /* Set if there is still an unresolved user-defined property */
21252         SV *unresolved                = NULL;
21253
21254         /* Things that are ignored except when the runtime locale is UTF-8 */
21255         SV *only_utf8_locale_invlist = NULL;
21256
21257         /* Code points that don't fit in the bitmap */
21258         SV *nonbitmap_invlist = NULL;
21259
21260         /* And things that aren't in the bitmap, but are small enough to be */
21261         SV* bitmap_range_not_in_bitmap = NULL;
21262
21263         bool inverted;
21264
21265         if (inRANGE(OP(o), ANYOFH, ANYOFRb)) {
21266             flags = 0;
21267             bitmap = NULL;
21268             arg = 0;
21269         }
21270         else {
21271             flags = ANYOF_FLAGS(o);
21272             bitmap = ANYOF_BITMAP(o);
21273             arg = ARG(o);
21274         }
21275
21276         if (OP(o) == ANYOFL || OP(o) == ANYOFPOSIXL) {
21277             if (ANYOFL_UTF8_LOCALE_REQD(flags)) {
21278                 sv_catpvs(sv, "{utf8-locale-reqd}");
21279             }
21280             if (flags & ANYOFL_FOLD) {
21281                 sv_catpvs(sv, "{i}");
21282             }
21283         }
21284
21285         inverted = flags & ANYOF_INVERT;
21286
21287         /* If there is stuff outside the bitmap, get it */
21288         if (arg != ANYOF_ONLY_HAS_BITMAP) {
21289             if (inRANGE(OP(o), ANYOFR, ANYOFRb)) {
21290                 nonbitmap_invlist = _add_range_to_invlist(nonbitmap_invlist,
21291                                             ANYOFRbase(o),
21292                                             ANYOFRbase(o) + ANYOFRdelta(o));
21293             }
21294             else {
21295 #if !defined(PERL_IN_XSUB_RE) || defined(PLUGGABLE_RE_EXTENSION)
21296                 (void) get_regclass_nonbitmap_data(prog, o, FALSE,
21297                                                 &unresolved,
21298                                                 &only_utf8_locale_invlist,
21299                                                 &nonbitmap_invlist);
21300 #else
21301                 (void) get_re_gclass_nonbitmap_data(prog, o, FALSE,
21302                                                 &unresolved,
21303                                                 &only_utf8_locale_invlist,
21304                                                 &nonbitmap_invlist);
21305 #endif
21306             }
21307
21308             /* The non-bitmap data may contain stuff that could fit in the
21309              * bitmap.  This could come from a user-defined property being
21310              * finally resolved when this call was done; or much more likely
21311              * because there are matches that require UTF-8 to be valid, and so
21312              * aren't in the bitmap (or ANYOFR).  This is teased apart later */
21313             _invlist_intersection(nonbitmap_invlist,
21314                                   PL_InBitmap,
21315                                   &bitmap_range_not_in_bitmap);
21316             /* Leave just the things that don't fit into the bitmap */
21317             _invlist_subtract(nonbitmap_invlist,
21318                               PL_InBitmap,
21319                               &nonbitmap_invlist);
21320         }
21321
21322         /* Obey this flag to add all above-the-bitmap code points */
21323         if (flags & ANYOF_MATCHES_ALL_ABOVE_BITMAP) {
21324             nonbitmap_invlist = _add_range_to_invlist(nonbitmap_invlist,
21325                                                       NUM_ANYOF_CODE_POINTS,
21326                                                       UV_MAX);
21327         }
21328
21329         /* Ready to start outputting.  First, the initial left bracket */
21330         Perl_sv_catpvf(aTHX_ sv, "[%s", PL_colors[0]);
21331
21332         /* ANYOFH by definition doesn't have anything that will fit inside the
21333          * bitmap;  ANYOFR may or may not. */
21334         if (  ! inRANGE(OP(o), ANYOFH, ANYOFHr)
21335             && (   ! inRANGE(OP(o), ANYOFR, ANYOFRb)
21336                 ||   ANYOFRbase(o) < NUM_ANYOF_CODE_POINTS))
21337         {
21338             /* Then all the things that could fit in the bitmap */
21339             do_sep = put_charclass_bitmap_innards(sv,
21340                                                   bitmap,
21341                                                   bitmap_range_not_in_bitmap,
21342                                                   only_utf8_locale_invlist,
21343                                                   o,
21344                                                   flags,
21345
21346                                                   /* Can't try inverting for a
21347                                                    * better display if there
21348                                                    * are things that haven't
21349                                                    * been resolved */
21350                                                   unresolved != NULL
21351                                             || inRANGE(OP(o), ANYOFR, ANYOFRb));
21352             SvREFCNT_dec(bitmap_range_not_in_bitmap);
21353
21354             /* If there are user-defined properties which haven't been defined
21355              * yet, output them.  If the result is not to be inverted, it is
21356              * clearest to output them in a separate [] from the bitmap range
21357              * stuff.  If the result is to be complemented, we have to show
21358              * everything in one [], as the inversion applies to the whole
21359              * thing.  Use {braces} to separate them from anything in the
21360              * bitmap and anything above the bitmap. */
21361             if (unresolved) {
21362                 if (inverted) {
21363                     if (! do_sep) { /* If didn't output anything in the bitmap
21364                                      */
21365                         sv_catpvs(sv, "^");
21366                     }
21367                     sv_catpvs(sv, "{");
21368                 }
21369                 else if (do_sep) {
21370                     Perl_sv_catpvf(aTHX_ sv,"%s][%s", PL_colors[1],
21371                                                       PL_colors[0]);
21372                 }
21373                 sv_catsv(sv, unresolved);
21374                 if (inverted) {
21375                     sv_catpvs(sv, "}");
21376                 }
21377                 do_sep = ! inverted;
21378             }
21379         }
21380
21381         /* And, finally, add the above-the-bitmap stuff */
21382         if (nonbitmap_invlist && _invlist_len(nonbitmap_invlist)) {
21383             SV* contents;
21384
21385             /* See if truncation size is overridden */
21386             const STRLEN dump_len = (PL_dump_re_max_len > 256)
21387                                     ? PL_dump_re_max_len
21388                                     : 256;
21389
21390             /* This is output in a separate [] */
21391             if (do_sep) {
21392                 Perl_sv_catpvf(aTHX_ sv,"%s][%s", PL_colors[1], PL_colors[0]);
21393             }
21394
21395             /* And, for easy of understanding, it is shown in the
21396              * uncomplemented form if possible.  The one exception being if
21397              * there are unresolved items, where the inversion has to be
21398              * delayed until runtime */
21399             if (inverted && ! unresolved) {
21400                 _invlist_invert(nonbitmap_invlist);
21401                 _invlist_subtract(nonbitmap_invlist, PL_InBitmap, &nonbitmap_invlist);
21402             }
21403
21404             contents = invlist_contents(nonbitmap_invlist,
21405                                         FALSE /* output suitable for catsv */
21406                                        );
21407
21408             /* If the output is shorter than the permissible maximum, just do it. */
21409             if (SvCUR(contents) <= dump_len) {
21410                 sv_catsv(sv, contents);
21411             }
21412             else {
21413                 const char * contents_string = SvPVX(contents);
21414                 STRLEN i = dump_len;
21415
21416                 /* Otherwise, start at the permissible max and work back to the
21417                  * first break possibility */
21418                 while (i > 0 && contents_string[i] != ' ') {
21419                     i--;
21420                 }
21421                 if (i == 0) {       /* Fail-safe.  Use the max if we couldn't
21422                                        find a legal break */
21423                     i = dump_len;
21424                 }
21425
21426                 sv_catpvn(sv, contents_string, i);
21427                 sv_catpvs(sv, "...");
21428             }
21429
21430             SvREFCNT_dec_NN(contents);
21431             SvREFCNT_dec_NN(nonbitmap_invlist);
21432         }
21433
21434         /* And finally the matching, closing ']' */
21435         Perl_sv_catpvf(aTHX_ sv, "%s]", PL_colors[1]);
21436
21437         if (OP(o) == ANYOFHs) {
21438             Perl_sv_catpvf(aTHX_ sv, " (Leading UTF-8 bytes=%s", _byte_dump_string((U8 *) ((struct regnode_anyofhs *) o)->string, FLAGS(o), 1));
21439         }
21440         else if (inRANGE(OP(o), ANYOFH, ANYOFRb)) {
21441             U8 lowest = (OP(o) != ANYOFHr)
21442                          ? FLAGS(o)
21443                          : LOWEST_ANYOF_HRx_BYTE(FLAGS(o));
21444             U8 highest = (OP(o) == ANYOFHr)
21445                          ? HIGHEST_ANYOF_HRx_BYTE(FLAGS(o))
21446                          : (OP(o) == ANYOFH || OP(o) == ANYOFR)
21447                            ? 0xFF
21448                            : lowest;
21449 #ifndef EBCDIC
21450             if (OP(o) != ANYOFR || ! isASCII(ANYOFRbase(o) + ANYOFRdelta(o)))
21451 #endif
21452             {
21453                 Perl_sv_catpvf(aTHX_ sv, " (First UTF-8 byte=%02X", lowest);
21454                 if (lowest != highest) {
21455                     Perl_sv_catpvf(aTHX_ sv, "-%02X", highest);
21456                 }
21457                 Perl_sv_catpvf(aTHX_ sv, ")");
21458             }
21459         }
21460
21461         SvREFCNT_dec(unresolved);
21462     }
21463     else if (k == ANYOFM) {
21464         SV * cp_list = get_ANYOFM_contents(o);
21465
21466         Perl_sv_catpvf(aTHX_ sv, "[%s", PL_colors[0]);
21467         if (OP(o) == NANYOFM) {
21468             _invlist_invert(cp_list);
21469         }
21470
21471         put_charclass_bitmap_innards(sv, NULL, cp_list, NULL, NULL, 0, TRUE);
21472         Perl_sv_catpvf(aTHX_ sv, "%s]", PL_colors[1]);
21473
21474         SvREFCNT_dec(cp_list);
21475     }
21476     else if (k == POSIXD || k == NPOSIXD) {
21477         U8 index = FLAGS(o) * 2;
21478         if (index < C_ARRAY_LENGTH(anyofs)) {
21479             if (*anyofs[index] != '[')  {
21480                 sv_catpvs(sv, "[");
21481             }
21482             sv_catpv(sv, anyofs[index]);
21483             if (*anyofs[index] != '[')  {
21484                 sv_catpvs(sv, "]");
21485             }
21486         }
21487         else {
21488             Perl_sv_catpvf(aTHX_ sv, "[illegal type=%d])", index);
21489         }
21490     }
21491     else if (k == BOUND || k == NBOUND) {
21492         /* Must be synced with order of 'bound_type' in regcomp.h */
21493         const char * const bounds[] = {
21494             "",      /* Traditional */
21495             "{gcb}",
21496             "{lb}",
21497             "{sb}",
21498             "{wb}"
21499         };
21500         assert(FLAGS(o) < C_ARRAY_LENGTH(bounds));
21501         sv_catpv(sv, bounds[FLAGS(o)]);
21502     }
21503     else if (k == BRANCHJ && (OP(o) == UNLESSM || OP(o) == IFMATCH)) {
21504         Perl_sv_catpvf(aTHX_ sv, "[%d", -(o->flags));
21505         if (o->next_off) {
21506             Perl_sv_catpvf(aTHX_ sv, "..-%d", o->flags - o->next_off);
21507         }
21508         Perl_sv_catpvf(aTHX_ sv, "]");
21509     }
21510     else if (OP(o) == SBOL)
21511         Perl_sv_catpvf(aTHX_ sv, " /%s/", o->flags ? "\\A" : "^");
21512
21513     /* add on the verb argument if there is one */
21514     if ( ( k == VERB || OP(o) == ACCEPT || OP(o) == OPFAIL ) && o->flags) {
21515         if ( ARG(o) )
21516             Perl_sv_catpvf(aTHX_ sv, ":%" SVf,
21517                        SVfARG((MUTABLE_SV(progi->data->data[ ARG( o ) ]))));
21518         else
21519             sv_catpvs(sv, ":NULL");
21520     }
21521 #else
21522     PERL_UNUSED_CONTEXT;
21523     PERL_UNUSED_ARG(sv);
21524     PERL_UNUSED_ARG(o);
21525     PERL_UNUSED_ARG(prog);
21526     PERL_UNUSED_ARG(reginfo);
21527     PERL_UNUSED_ARG(pRExC_state);
21528 #endif  /* DEBUGGING */
21529 }
21530
21531
21532
21533 SV *
21534 Perl_re_intuit_string(pTHX_ REGEXP * const r)
21535 {                               /* Assume that RE_INTUIT is set */
21536     /* Returns an SV containing a string that must appear in the target for it
21537      * to match, or NULL if nothing is known that must match.
21538      *
21539      * CAUTION: the SV can be freed during execution of the regex engine */
21540
21541     struct regexp *const prog = ReANY(r);
21542     DECLARE_AND_GET_RE_DEBUG_FLAGS;
21543
21544     PERL_ARGS_ASSERT_RE_INTUIT_STRING;
21545     PERL_UNUSED_CONTEXT;
21546
21547     DEBUG_COMPILE_r(
21548         {
21549             if (prog->maxlen > 0) {
21550                 const char * const s = SvPV_nolen_const(RX_UTF8(r)
21551                       ? prog->check_utf8 : prog->check_substr);
21552
21553                 if (!PL_colorset) reginitcolors();
21554                 Perl_re_printf( aTHX_
21555                       "%sUsing REx %ssubstr:%s \"%s%.60s%s%s\"\n",
21556                       PL_colors[4],
21557                       RX_UTF8(r) ? "utf8 " : "",
21558                       PL_colors[5], PL_colors[0],
21559                       s,
21560                       PL_colors[1],
21561                       (strlen(s) > PL_dump_re_max_len ? "..." : ""));
21562             }
21563         } );
21564
21565     /* use UTF8 check substring if regexp pattern itself is in UTF8 */
21566     return RX_UTF8(r) ? prog->check_utf8 : prog->check_substr;
21567 }
21568
21569 /*
21570    pregfree()
21571
21572    handles refcounting and freeing the perl core regexp structure. When
21573    it is necessary to actually free the structure the first thing it
21574    does is call the 'free' method of the regexp_engine associated to
21575    the regexp, allowing the handling of the void *pprivate; member
21576    first. (This routine is not overridable by extensions, which is why
21577    the extensions free is called first.)
21578
21579    See regdupe and regdupe_internal if you change anything here.
21580 */
21581 #ifndef PERL_IN_XSUB_RE
21582 void
21583 Perl_pregfree(pTHX_ REGEXP *r)
21584 {
21585     SvREFCNT_dec(r);
21586 }
21587
21588 void
21589 Perl_pregfree2(pTHX_ REGEXP *rx)
21590 {
21591     struct regexp *const r = ReANY(rx);
21592     DECLARE_AND_GET_RE_DEBUG_FLAGS;
21593
21594     PERL_ARGS_ASSERT_PREGFREE2;
21595
21596     if (! r)
21597         return;
21598
21599     if (r->mother_re) {
21600         ReREFCNT_dec(r->mother_re);
21601     } else {
21602         CALLREGFREE_PVT(rx); /* free the private data */
21603         SvREFCNT_dec(RXp_PAREN_NAMES(r));
21604     }
21605     if (r->substrs) {
21606         int i;
21607         for (i = 0; i < 2; i++) {
21608             SvREFCNT_dec(r->substrs->data[i].substr);
21609             SvREFCNT_dec(r->substrs->data[i].utf8_substr);
21610         }
21611         Safefree(r->substrs);
21612     }
21613     RX_MATCH_COPY_FREE(rx);
21614 #ifdef PERL_ANY_COW
21615     SvREFCNT_dec(r->saved_copy);
21616 #endif
21617     Safefree(r->offs);
21618     SvREFCNT_dec(r->qr_anoncv);
21619     if (r->recurse_locinput)
21620         Safefree(r->recurse_locinput);
21621 }
21622
21623
21624 /*  reg_temp_copy()
21625
21626     Copy ssv to dsv, both of which should of type SVt_REGEXP or SVt_PVLV,
21627     except that dsv will be created if NULL.
21628
21629     This function is used in two main ways. First to implement
21630         $r = qr/....; $s = $$r;
21631
21632     Secondly, it is used as a hacky workaround to the structural issue of
21633     match results
21634     being stored in the regexp structure which is in turn stored in
21635     PL_curpm/PL_reg_curpm. The problem is that due to qr// the pattern
21636     could be PL_curpm in multiple contexts, and could require multiple
21637     result sets being associated with the pattern simultaneously, such
21638     as when doing a recursive match with (??{$qr})
21639
21640     The solution is to make a lightweight copy of the regexp structure
21641     when a qr// is returned from the code executed by (??{$qr}) this
21642     lightweight copy doesn't actually own any of its data except for
21643     the starp/end and the actual regexp structure itself.
21644
21645 */
21646
21647
21648 REGEXP *
21649 Perl_reg_temp_copy(pTHX_ REGEXP *dsv, REGEXP *ssv)
21650 {
21651     struct regexp *drx;
21652     struct regexp *const srx = ReANY(ssv);
21653     const bool islv = dsv && SvTYPE(dsv) == SVt_PVLV;
21654
21655     PERL_ARGS_ASSERT_REG_TEMP_COPY;
21656
21657     if (!dsv)
21658         dsv = (REGEXP*) newSV_type(SVt_REGEXP);
21659     else {
21660         assert(SvTYPE(dsv) == SVt_REGEXP || (SvTYPE(dsv) == SVt_PVLV));
21661
21662         /* our only valid caller, sv_setsv_flags(), should have done
21663          * a SV_CHECK_THINKFIRST_COW_DROP() by now */
21664         assert(!SvOOK(dsv));
21665         assert(!SvIsCOW(dsv));
21666         assert(!SvROK(dsv));
21667
21668         if (SvPVX_const(dsv)) {
21669             if (SvLEN(dsv))
21670                 Safefree(SvPVX(dsv));
21671             SvPVX(dsv) = NULL;
21672         }
21673         SvLEN_set(dsv, 0);
21674         SvCUR_set(dsv, 0);
21675         SvOK_off((SV *)dsv);
21676
21677         if (islv) {
21678             /* For PVLVs, the head (sv_any) points to an XPVLV, while
21679              * the LV's xpvlenu_rx will point to a regexp body, which
21680              * we allocate here */
21681             REGEXP *temp = (REGEXP *)newSV_type(SVt_REGEXP);
21682             assert(!SvPVX(dsv));
21683             ((XPV*)SvANY(dsv))->xpv_len_u.xpvlenu_rx = temp->sv_any;
21684             temp->sv_any = NULL;
21685             SvFLAGS(temp) = (SvFLAGS(temp) & ~SVTYPEMASK) | SVt_NULL;
21686             SvREFCNT_dec_NN(temp);
21687             /* SvCUR still resides in the xpvlv struct, so the regexp copy-
21688                ing below will not set it. */
21689             SvCUR_set(dsv, SvCUR(ssv));
21690         }
21691     }
21692     /* This ensures that SvTHINKFIRST(sv) is true, and hence that
21693        sv_force_normal(sv) is called.  */
21694     SvFAKE_on(dsv);
21695     drx = ReANY(dsv);
21696
21697     SvFLAGS(dsv) |= SvFLAGS(ssv) & (SVf_POK|SVp_POK|SVf_UTF8);
21698     SvPV_set(dsv, RX_WRAPPED(ssv));
21699     /* We share the same string buffer as the original regexp, on which we
21700        hold a reference count, incremented when mother_re is set below.
21701        The string pointer is copied here, being part of the regexp struct.
21702      */
21703     memcpy(&(drx->xpv_cur), &(srx->xpv_cur),
21704            sizeof(regexp) - STRUCT_OFFSET(regexp, xpv_cur));
21705     if (!islv)
21706         SvLEN_set(dsv, 0);
21707     if (srx->offs) {
21708         const I32 npar = srx->nparens+1;
21709         Newx(drx->offs, npar, regexp_paren_pair);
21710         Copy(srx->offs, drx->offs, npar, regexp_paren_pair);
21711     }
21712     if (srx->substrs) {
21713         int i;
21714         Newx(drx->substrs, 1, struct reg_substr_data);
21715         StructCopy(srx->substrs, drx->substrs, struct reg_substr_data);
21716
21717         for (i = 0; i < 2; i++) {
21718             SvREFCNT_inc_void(drx->substrs->data[i].substr);
21719             SvREFCNT_inc_void(drx->substrs->data[i].utf8_substr);
21720         }
21721
21722         /* check_substr and check_utf8, if non-NULL, point to either their
21723            anchored or float namesakes, and don't hold a second reference.  */
21724     }
21725     RX_MATCH_COPIED_off(dsv);
21726 #ifdef PERL_ANY_COW
21727     drx->saved_copy = NULL;
21728 #endif
21729     drx->mother_re = ReREFCNT_inc(srx->mother_re ? srx->mother_re : ssv);
21730     SvREFCNT_inc_void(drx->qr_anoncv);
21731     if (srx->recurse_locinput)
21732         Newx(drx->recurse_locinput, srx->nparens + 1, char *);
21733
21734     return dsv;
21735 }
21736 #endif
21737
21738
21739 /* regfree_internal()
21740
21741    Free the private data in a regexp. This is overloadable by
21742    extensions. Perl takes care of the regexp structure in pregfree(),
21743    this covers the *pprivate pointer which technically perl doesn't
21744    know about, however of course we have to handle the
21745    regexp_internal structure when no extension is in use.
21746
21747    Note this is called before freeing anything in the regexp
21748    structure.
21749  */
21750
21751 void
21752 Perl_regfree_internal(pTHX_ REGEXP * const rx)
21753 {
21754     struct regexp *const r = ReANY(rx);
21755     RXi_GET_DECL(r, ri);
21756     DECLARE_AND_GET_RE_DEBUG_FLAGS;
21757
21758     PERL_ARGS_ASSERT_REGFREE_INTERNAL;
21759
21760     if (! ri) {
21761         return;
21762     }
21763
21764     DEBUG_COMPILE_r({
21765         if (!PL_colorset)
21766             reginitcolors();
21767         {
21768             SV *dsv= sv_newmortal();
21769             RE_PV_QUOTED_DECL(s, RX_UTF8(rx),
21770                 dsv, RX_PRECOMP(rx), RX_PRELEN(rx), PL_dump_re_max_len);
21771             Perl_re_printf( aTHX_ "%sFreeing REx:%s %s\n",
21772                 PL_colors[4], PL_colors[5], s);
21773         }
21774     });
21775
21776 #ifdef RE_TRACK_PATTERN_OFFSETS
21777     if (ri->u.offsets)
21778         Safefree(ri->u.offsets);             /* 20010421 MJD */
21779 #endif
21780     if (ri->code_blocks)
21781         S_free_codeblocks(aTHX_ ri->code_blocks);
21782
21783     if (ri->data) {
21784         int n = ri->data->count;
21785
21786         while (--n >= 0) {
21787           /* If you add a ->what type here, update the comment in regcomp.h */
21788             switch (ri->data->what[n]) {
21789             case 'a':
21790             case 'r':
21791             case 's':
21792             case 'S':
21793             case 'u':
21794                 SvREFCNT_dec(MUTABLE_SV(ri->data->data[n]));
21795                 break;
21796             case 'f':
21797                 Safefree(ri->data->data[n]);
21798                 break;
21799             case 'l':
21800             case 'L':
21801                 break;
21802             case 'T':
21803                 { /* Aho Corasick add-on structure for a trie node.
21804                      Used in stclass optimization only */
21805                     U32 refcount;
21806                     reg_ac_data *aho=(reg_ac_data*)ri->data->data[n];
21807 #ifdef USE_ITHREADS
21808 #endif
21809                     OP_REFCNT_LOCK;
21810                     refcount = --aho->refcount;
21811                     OP_REFCNT_UNLOCK;
21812                     if ( !refcount ) {
21813                         PerlMemShared_free(aho->states);
21814                         PerlMemShared_free(aho->fail);
21815                          /* do this last!!!! */
21816                         PerlMemShared_free(ri->data->data[n]);
21817                         /* we should only ever get called once, so
21818                          * assert as much, and also guard the free
21819                          * which /might/ happen twice. At the least
21820                          * it will make code anlyzers happy and it
21821                          * doesn't cost much. - Yves */
21822                         assert(ri->regstclass);
21823                         if (ri->regstclass) {
21824                             PerlMemShared_free(ri->regstclass);
21825                             ri->regstclass = 0;
21826                         }
21827                     }
21828                 }
21829                 break;
21830             case 't':
21831                 {
21832                     /* trie structure. */
21833                     U32 refcount;
21834                     reg_trie_data *trie=(reg_trie_data*)ri->data->data[n];
21835 #ifdef USE_ITHREADS
21836 #endif
21837                     OP_REFCNT_LOCK;
21838                     refcount = --trie->refcount;
21839                     OP_REFCNT_UNLOCK;
21840                     if ( !refcount ) {
21841                         PerlMemShared_free(trie->charmap);
21842                         PerlMemShared_free(trie->states);
21843                         PerlMemShared_free(trie->trans);
21844                         if (trie->bitmap)
21845                             PerlMemShared_free(trie->bitmap);
21846                         if (trie->jump)
21847                             PerlMemShared_free(trie->jump);
21848                         PerlMemShared_free(trie->wordinfo);
21849                         /* do this last!!!! */
21850                         PerlMemShared_free(ri->data->data[n]);
21851                     }
21852                 }
21853                 break;
21854             default:
21855                 Perl_croak(aTHX_ "panic: regfree data code '%c'",
21856                                                     ri->data->what[n]);
21857             }
21858         }
21859         Safefree(ri->data->what);
21860         Safefree(ri->data);
21861     }
21862
21863     Safefree(ri);
21864 }
21865
21866 #define av_dup_inc(s, t)        MUTABLE_AV(sv_dup_inc((const SV *)s, t))
21867 #define hv_dup_inc(s, t)        MUTABLE_HV(sv_dup_inc((const SV *)s, t))
21868 #define SAVEPVN(p, n)   ((p) ? savepvn(p, n) : NULL)
21869
21870 /*
21871 =for apidoc re_dup_guts
21872 Duplicate a regexp.
21873
21874 This routine is expected to clone a given regexp structure. It is only
21875 compiled under USE_ITHREADS.
21876
21877 After all of the core data stored in struct regexp is duplicated
21878 the C<regexp_engine.dupe> method is used to copy any private data
21879 stored in the *pprivate pointer. This allows extensions to handle
21880 any duplication they need to do.
21881
21882 =cut
21883
21884    See pregfree() and regfree_internal() if you change anything here.
21885 */
21886 #if defined(USE_ITHREADS)
21887 #ifndef PERL_IN_XSUB_RE
21888 void
21889 Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param)
21890 {
21891     I32 npar;
21892     const struct regexp *r = ReANY(sstr);
21893     struct regexp *ret = ReANY(dstr);
21894
21895     PERL_ARGS_ASSERT_RE_DUP_GUTS;
21896
21897     npar = r->nparens+1;
21898     Newx(ret->offs, npar, regexp_paren_pair);
21899     Copy(r->offs, ret->offs, npar, regexp_paren_pair);
21900
21901     if (ret->substrs) {
21902         /* Do it this way to avoid reading from *r after the StructCopy().
21903            That way, if any of the sv_dup_inc()s dislodge *r from the L1
21904            cache, it doesn't matter.  */
21905         int i;
21906         const bool anchored = r->check_substr
21907             ? r->check_substr == r->substrs->data[0].substr
21908             : r->check_utf8   == r->substrs->data[0].utf8_substr;
21909         Newx(ret->substrs, 1, struct reg_substr_data);
21910         StructCopy(r->substrs, ret->substrs, struct reg_substr_data);
21911
21912         for (i = 0; i < 2; i++) {
21913             ret->substrs->data[i].substr =
21914                         sv_dup_inc(ret->substrs->data[i].substr, param);
21915             ret->substrs->data[i].utf8_substr =
21916                         sv_dup_inc(ret->substrs->data[i].utf8_substr, param);
21917         }
21918
21919         /* check_substr and check_utf8, if non-NULL, point to either their
21920            anchored or float namesakes, and don't hold a second reference.  */
21921
21922         if (ret->check_substr) {
21923             if (anchored) {
21924                 assert(r->check_utf8 == r->substrs->data[0].utf8_substr);
21925
21926                 ret->check_substr = ret->substrs->data[0].substr;
21927                 ret->check_utf8   = ret->substrs->data[0].utf8_substr;
21928             } else {
21929                 assert(r->check_substr == r->substrs->data[1].substr);
21930                 assert(r->check_utf8   == r->substrs->data[1].utf8_substr);
21931
21932                 ret->check_substr = ret->substrs->data[1].substr;
21933                 ret->check_utf8   = ret->substrs->data[1].utf8_substr;
21934             }
21935         } else if (ret->check_utf8) {
21936             if (anchored) {
21937                 ret->check_utf8 = ret->substrs->data[0].utf8_substr;
21938             } else {
21939                 ret->check_utf8 = ret->substrs->data[1].utf8_substr;
21940             }
21941         }
21942     }
21943
21944     RXp_PAREN_NAMES(ret) = hv_dup_inc(RXp_PAREN_NAMES(ret), param);
21945     ret->qr_anoncv = MUTABLE_CV(sv_dup_inc((const SV *)ret->qr_anoncv, param));
21946     if (r->recurse_locinput)
21947         Newx(ret->recurse_locinput, r->nparens + 1, char *);
21948
21949     if (ret->pprivate)
21950         RXi_SET(ret, CALLREGDUPE_PVT(dstr, param));
21951
21952     if (RX_MATCH_COPIED(dstr))
21953         ret->subbeg  = SAVEPVN(ret->subbeg, ret->sublen);
21954     else
21955         ret->subbeg = NULL;
21956 #ifdef PERL_ANY_COW
21957     ret->saved_copy = NULL;
21958 #endif
21959
21960     /* Whether mother_re be set or no, we need to copy the string.  We
21961        cannot refrain from copying it when the storage points directly to
21962        our mother regexp, because that's
21963                1: a buffer in a different thread
21964                2: something we no longer hold a reference on
21965                so we need to copy it locally.  */
21966     RX_WRAPPED(dstr) = SAVEPVN(RX_WRAPPED_const(sstr), SvCUR(sstr)+1);
21967     /* set malloced length to a non-zero value so it will be freed
21968      * (otherwise in combination with SVf_FAKE it looks like an alien
21969      * buffer). It doesn't have to be the actual malloced size, since it
21970      * should never be grown */
21971     SvLEN_set(dstr, SvCUR(sstr)+1);
21972     ret->mother_re   = NULL;
21973 }
21974 #endif /* PERL_IN_XSUB_RE */
21975
21976 /*
21977    regdupe_internal()
21978
21979    This is the internal complement to regdupe() which is used to copy
21980    the structure pointed to by the *pprivate pointer in the regexp.
21981    This is the core version of the extension overridable cloning hook.
21982    The regexp structure being duplicated will be copied by perl prior
21983    to this and will be provided as the regexp *r argument, however
21984    with the /old/ structures pprivate pointer value. Thus this routine
21985    may override any copying normally done by perl.
21986
21987    It returns a pointer to the new regexp_internal structure.
21988 */
21989
21990 void *
21991 Perl_regdupe_internal(pTHX_ REGEXP * const rx, CLONE_PARAMS *param)
21992 {
21993     struct regexp *const r = ReANY(rx);
21994     regexp_internal *reti;
21995     int len;
21996     RXi_GET_DECL(r, ri);
21997
21998     PERL_ARGS_ASSERT_REGDUPE_INTERNAL;
21999
22000     len = ProgLen(ri);
22001
22002     Newxc(reti, sizeof(regexp_internal) + len*sizeof(regnode),
22003           char, regexp_internal);
22004     Copy(ri->program, reti->program, len+1, regnode);
22005
22006
22007     if (ri->code_blocks) {
22008         int n;
22009         Newx(reti->code_blocks, 1, struct reg_code_blocks);
22010         Newx(reti->code_blocks->cb, ri->code_blocks->count,
22011                     struct reg_code_block);
22012         Copy(ri->code_blocks->cb, reti->code_blocks->cb,
22013              ri->code_blocks->count, struct reg_code_block);
22014         for (n = 0; n < ri->code_blocks->count; n++)
22015              reti->code_blocks->cb[n].src_regex = (REGEXP*)
22016                     sv_dup_inc((SV*)(ri->code_blocks->cb[n].src_regex), param);
22017         reti->code_blocks->count = ri->code_blocks->count;
22018         reti->code_blocks->refcnt = 1;
22019     }
22020     else
22021         reti->code_blocks = NULL;
22022
22023     reti->regstclass = NULL;
22024
22025     if (ri->data) {
22026         struct reg_data *d;
22027         const int count = ri->data->count;
22028         int i;
22029
22030         Newxc(d, sizeof(struct reg_data) + count*sizeof(void *),
22031                 char, struct reg_data);
22032         Newx(d->what, count, U8);
22033
22034         d->count = count;
22035         for (i = 0; i < count; i++) {
22036             d->what[i] = ri->data->what[i];
22037             switch (d->what[i]) {
22038                 /* see also regcomp.h and regfree_internal() */
22039             case 'a': /* actually an AV, but the dup function is identical.
22040                          values seem to be "plain sv's" generally. */
22041             case 'r': /* a compiled regex (but still just another SV) */
22042             case 's': /* an RV (currently only used for an RV to an AV by the ANYOF code)
22043                          this use case should go away, the code could have used
22044                          'a' instead - see S_set_ANYOF_arg() for array contents. */
22045             case 'S': /* actually an SV, but the dup function is identical.  */
22046             case 'u': /* actually an HV, but the dup function is identical.
22047                          values are "plain sv's" */
22048                 d->data[i] = sv_dup_inc((const SV *)ri->data->data[i], param);
22049                 break;
22050             case 'f':
22051                 /* Synthetic Start Class - "Fake" charclass we generate to optimize
22052                  * patterns which could start with several different things. Pre-TRIE
22053                  * this was more important than it is now, however this still helps
22054                  * in some places, for instance /x?a+/ might produce a SSC equivalent
22055                  * to [xa]. This is used by Perl_re_intuit_start() and S_find_byclass()
22056                  * in regexec.c
22057                  */
22058                 /* This is cheating. */
22059                 Newx(d->data[i], 1, regnode_ssc);
22060                 StructCopy(ri->data->data[i], d->data[i], regnode_ssc);
22061                 reti->regstclass = (regnode*)d->data[i];
22062                 break;
22063             case 'T':
22064                 /* AHO-CORASICK fail table */
22065                 /* Trie stclasses are readonly and can thus be shared
22066                  * without duplication. We free the stclass in pregfree
22067                  * when the corresponding reg_ac_data struct is freed.
22068                  */
22069                 reti->regstclass= ri->regstclass;
22070                 /* FALLTHROUGH */
22071             case 't':
22072                 /* TRIE transition table */
22073                 OP_REFCNT_LOCK;
22074                 ((reg_trie_data*)ri->data->data[i])->refcount++;
22075                 OP_REFCNT_UNLOCK;
22076                 /* FALLTHROUGH */
22077             case 'l': /* (?{...}) or (??{ ... }) code (cb->block) */
22078             case 'L': /* same when RExC_pm_flags & PMf_HAS_CV and code
22079                          is not from another regexp */
22080                 d->data[i] = ri->data->data[i];
22081                 break;
22082             default:
22083                 Perl_croak(aTHX_ "panic: re_dup_guts unknown data code '%c'",
22084                                                            ri->data->what[i]);
22085             }
22086         }
22087
22088         reti->data = d;
22089     }
22090     else
22091         reti->data = NULL;
22092
22093     reti->name_list_idx = ri->name_list_idx;
22094
22095 #ifdef RE_TRACK_PATTERN_OFFSETS
22096     if (ri->u.offsets) {
22097         Newx(reti->u.offsets, 2*len+1, U32);
22098         Copy(ri->u.offsets, reti->u.offsets, 2*len+1, U32);
22099     }
22100 #else
22101     SetProgLen(reti, len);
22102 #endif
22103
22104     return (void*)reti;
22105 }
22106
22107 #endif    /* USE_ITHREADS */
22108
22109 #ifndef PERL_IN_XSUB_RE
22110
22111 /*
22112  - regnext - dig the "next" pointer out of a node
22113  */
22114 regnode *
22115 Perl_regnext(pTHX_ regnode *p)
22116 {
22117     I32 offset;
22118
22119     if (!p)
22120         return(NULL);
22121
22122     if (OP(p) > REGNODE_MAX) {          /* regnode.type is unsigned */
22123         Perl_croak(aTHX_ "Corrupted regexp opcode %d > %d",
22124                                                 (int)OP(p), (int)REGNODE_MAX);
22125     }
22126
22127     offset = (reg_off_by_arg[OP(p)] ? ARG(p) : NEXT_OFF(p));
22128     if (offset == 0)
22129         return(NULL);
22130
22131     return(p+offset);
22132 }
22133
22134 #endif
22135
22136 STATIC void
22137 S_re_croak(pTHX_ bool utf8, const char* pat,...)
22138 {
22139     va_list args;
22140     STRLEN len = strlen(pat);
22141     char buf[512];
22142     SV *msv;
22143     const char *message;
22144
22145     PERL_ARGS_ASSERT_RE_CROAK;
22146
22147     if (len > 510)
22148         len = 510;
22149     Copy(pat, buf, len , char);
22150     buf[len] = '\n';
22151     buf[len + 1] = '\0';
22152     va_start(args, pat);
22153     msv = vmess(buf, &args);
22154     va_end(args);
22155     message = SvPV_const(msv, len);
22156     if (len > 512)
22157         len = 512;
22158     Copy(message, buf, len , char);
22159     /* len-1 to avoid \n */
22160     Perl_croak(aTHX_ "%" UTF8f, UTF8fARG(utf8, len-1, buf));
22161 }
22162
22163 /* XXX Here's a total kludge.  But we need to re-enter for swash routines. */
22164
22165 #ifndef PERL_IN_XSUB_RE
22166 void
22167 Perl_save_re_context(pTHX)
22168 {
22169     I32 nparens = -1;
22170     I32 i;
22171
22172     /* Save $1..$n (#18107: UTF-8 s/(\w+)/uc($1)/e); AMS 20021106. */
22173
22174     if (PL_curpm) {
22175         const REGEXP * const rx = PM_GETRE(PL_curpm);
22176         if (rx)
22177             nparens = RX_NPARENS(rx);
22178     }
22179
22180     /* RT #124109. This is a complete hack; in the SWASHNEW case we know
22181      * that PL_curpm will be null, but that utf8.pm and the modules it
22182      * loads will only use $1..$3.
22183      * The t/porting/re_context.t test file checks this assumption.
22184      */
22185     if (nparens == -1)
22186         nparens = 3;
22187
22188     for (i = 1; i <= nparens; i++) {
22189         char digits[TYPE_CHARS(long)];
22190         const STRLEN len = my_snprintf(digits, sizeof(digits),
22191                                        "%lu", (long)i);
22192         GV *const *const gvp
22193             = (GV**)hv_fetch(PL_defstash, digits, len, 0);
22194
22195         if (gvp) {
22196             GV * const gv = *gvp;
22197             if (SvTYPE(gv) == SVt_PVGV && GvSV(gv))
22198                 save_scalar(gv);
22199         }
22200     }
22201 }
22202 #endif
22203
22204 #ifdef DEBUGGING
22205
22206 STATIC void
22207 S_put_code_point(pTHX_ SV *sv, UV c)
22208 {
22209     PERL_ARGS_ASSERT_PUT_CODE_POINT;
22210
22211     if (c > 255) {
22212         Perl_sv_catpvf(aTHX_ sv, "\\x{%04" UVXf "}", c);
22213     }
22214     else if (isPRINT(c)) {
22215         const char string = (char) c;
22216
22217         /* We use {phrase} as metanotation in the class, so also escape literal
22218          * braces */
22219         if (isBACKSLASHED_PUNCT(c) || c == '{' || c == '}')
22220             sv_catpvs(sv, "\\");
22221         sv_catpvn(sv, &string, 1);
22222     }
22223     else if (isMNEMONIC_CNTRL(c)) {
22224         Perl_sv_catpvf(aTHX_ sv, "%s", cntrl_to_mnemonic((U8) c));
22225     }
22226     else {
22227         Perl_sv_catpvf(aTHX_ sv, "\\x%02X", (U8) c);
22228     }
22229 }
22230
22231 STATIC void
22232 S_put_range(pTHX_ SV *sv, UV start, const UV end, const bool allow_literals)
22233 {
22234     /* Appends to 'sv' a displayable version of the range of code points from
22235      * 'start' to 'end'.  Mnemonics (like '\r') are used for the few controls
22236      * that have them, when they occur at the beginning or end of the range.
22237      * It uses hex to output the remaining code points, unless 'allow_literals'
22238      * is true, in which case the printable ASCII ones are output as-is (though
22239      * some of these will be escaped by put_code_point()).
22240      *
22241      * NOTE:  This is designed only for printing ranges of code points that fit
22242      *        inside an ANYOF bitmap.  Higher code points are simply suppressed
22243      */
22244
22245     const unsigned int min_range_count = 3;
22246
22247     assert(start <= end);
22248
22249     PERL_ARGS_ASSERT_PUT_RANGE;
22250
22251     while (start <= end) {
22252         UV this_end;
22253         const char * format;
22254
22255         if (    end - start < min_range_count
22256             && (end - start <= 2 || (isPRINT_A(start) && isPRINT_A(end))))
22257         {
22258             /* Output a range of 1 or 2 chars individually, or longer ranges
22259              * when printable */
22260             for (; start <= end; start++) {
22261                 put_code_point(sv, start);
22262             }
22263             break;
22264         }
22265
22266         /* If permitted by the input options, and there is a possibility that
22267          * this range contains a printable literal, look to see if there is
22268          * one. */
22269         if (allow_literals && start <= MAX_PRINT_A) {
22270
22271             /* If the character at the beginning of the range isn't an ASCII
22272              * printable, effectively split the range into two parts:
22273              *  1) the portion before the first such printable,
22274              *  2) the rest
22275              * and output them separately. */
22276             if (! isPRINT_A(start)) {
22277                 UV temp_end = start + 1;
22278
22279                 /* There is no point looking beyond the final possible
22280                  * printable, in MAX_PRINT_A */
22281                 UV max = MIN(end, MAX_PRINT_A);
22282
22283                 while (temp_end <= max && ! isPRINT_A(temp_end)) {
22284                     temp_end++;
22285                 }
22286
22287                 /* Here, temp_end points to one beyond the first printable if
22288                  * found, or to one beyond 'max' if not.  If none found, make
22289                  * sure that we use the entire range */
22290                 if (temp_end > MAX_PRINT_A) {
22291                     temp_end = end + 1;
22292                 }
22293
22294                 /* Output the first part of the split range: the part that
22295                  * doesn't have printables, with the parameter set to not look
22296                  * for literals (otherwise we would infinitely recurse) */
22297                 put_range(sv, start, temp_end - 1, FALSE);
22298
22299                 /* The 2nd part of the range (if any) starts here. */
22300                 start = temp_end;
22301
22302                 /* We do a continue, instead of dropping down, because even if
22303                  * the 2nd part is non-empty, it could be so short that we want
22304                  * to output it as individual characters, as tested for at the
22305                  * top of this loop.  */
22306                 continue;
22307             }
22308
22309             /* Here, 'start' is a printable ASCII.  If it is an alphanumeric,
22310              * output a sub-range of just the digits or letters, then process
22311              * the remaining portion as usual. */
22312             if (isALPHANUMERIC_A(start)) {
22313                 UV mask = (isDIGIT_A(start))
22314                            ? _CC_DIGIT
22315                              : isUPPER_A(start)
22316                                ? _CC_UPPER
22317                                : _CC_LOWER;
22318                 UV temp_end = start + 1;
22319
22320                 /* Find the end of the sub-range that includes just the
22321                  * characters in the same class as the first character in it */
22322                 while (temp_end <= end && _generic_isCC_A(temp_end, mask)) {
22323                     temp_end++;
22324                 }
22325                 temp_end--;
22326
22327                 /* For short ranges, don't duplicate the code above to output
22328                  * them; just call recursively */
22329                 if (temp_end - start < min_range_count) {
22330                     put_range(sv, start, temp_end, FALSE);
22331                 }
22332                 else {  /* Output as a range */
22333                     put_code_point(sv, start);
22334                     sv_catpvs(sv, "-");
22335                     put_code_point(sv, temp_end);
22336                 }
22337                 start = temp_end + 1;
22338                 continue;
22339             }
22340
22341             /* We output any other printables as individual characters */
22342             if (isPUNCT_A(start) || isSPACE_A(start)) {
22343                 while (start <= end && (isPUNCT_A(start)
22344                                         || isSPACE_A(start)))
22345                 {
22346                     put_code_point(sv, start);
22347                     start++;
22348                 }
22349                 continue;
22350             }
22351         } /* End of looking for literals */
22352
22353         /* Here is not to output as a literal.  Some control characters have
22354          * mnemonic names.  Split off any of those at the beginning and end of
22355          * the range to print mnemonically.  It isn't possible for many of
22356          * these to be in a row, so this won't overwhelm with output */
22357         if (   start <= end
22358             && (isMNEMONIC_CNTRL(start) || isMNEMONIC_CNTRL(end)))
22359         {
22360             while (isMNEMONIC_CNTRL(start) && start <= end) {
22361                 put_code_point(sv, start);
22362                 start++;
22363             }
22364
22365             /* If this didn't take care of the whole range ... */
22366             if (start <= end) {
22367
22368                 /* Look backwards from the end to find the final non-mnemonic
22369                  * */
22370                 UV temp_end = end;
22371                 while (isMNEMONIC_CNTRL(temp_end)) {
22372                     temp_end--;
22373                 }
22374
22375                 /* And separately output the interior range that doesn't start
22376                  * or end with mnemonics */
22377                 put_range(sv, start, temp_end, FALSE);
22378
22379                 /* Then output the mnemonic trailing controls */
22380                 start = temp_end + 1;
22381                 while (start <= end) {
22382                     put_code_point(sv, start);
22383                     start++;
22384                 }
22385                 break;
22386             }
22387         }
22388
22389         /* As a final resort, output the range or subrange as hex. */
22390
22391         if (start >= NUM_ANYOF_CODE_POINTS) {
22392             this_end = end;
22393         }
22394         else {  /* Have to split range at the bitmap boundary */
22395             this_end = (end < NUM_ANYOF_CODE_POINTS)
22396                         ? end
22397                         : NUM_ANYOF_CODE_POINTS - 1;
22398         }
22399 #if NUM_ANYOF_CODE_POINTS > 256
22400         format = (this_end < 256)
22401                  ? "\\x%02" UVXf "-\\x%02" UVXf
22402                  : "\\x{%04" UVXf "}-\\x{%04" UVXf "}";
22403 #else
22404         format = "\\x%02" UVXf "-\\x%02" UVXf;
22405 #endif
22406         GCC_DIAG_IGNORE_STMT(-Wformat-nonliteral);
22407         Perl_sv_catpvf(aTHX_ sv, format, start, this_end);
22408         GCC_DIAG_RESTORE_STMT;
22409         break;
22410     }
22411 }
22412
22413 STATIC void
22414 S_put_charclass_bitmap_innards_invlist(pTHX_ SV *sv, SV* invlist)
22415 {
22416     /* Concatenate onto the PV in 'sv' a displayable form of the inversion list
22417      * 'invlist' */
22418
22419     UV start, end;
22420     bool allow_literals = TRUE;
22421
22422     PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_INVLIST;
22423
22424     /* Generally, it is more readable if printable characters are output as
22425      * literals, but if a range (nearly) spans all of them, it's best to output
22426      * it as a single range.  This code will use a single range if all but 2
22427      * ASCII printables are in it */
22428     invlist_iterinit(invlist);
22429     while (invlist_iternext(invlist, &start, &end)) {
22430
22431         /* If the range starts beyond the final printable, it doesn't have any
22432          * in it */
22433         if (start > MAX_PRINT_A) {
22434             break;
22435         }
22436
22437         /* In both ASCII and EBCDIC, a SPACE is the lowest printable.  To span
22438          * all but two, the range must start and end no later than 2 from
22439          * either end */
22440         if (start < ' ' + 2 && end > MAX_PRINT_A - 2) {
22441             if (end > MAX_PRINT_A) {
22442                 end = MAX_PRINT_A;
22443             }
22444             if (start < ' ') {
22445                 start = ' ';
22446             }
22447             if (end - start >= MAX_PRINT_A - ' ' - 2) {
22448                 allow_literals = FALSE;
22449             }
22450             break;
22451         }
22452     }
22453     invlist_iterfinish(invlist);
22454
22455     /* Here we have figured things out.  Output each range */
22456     invlist_iterinit(invlist);
22457     while (invlist_iternext(invlist, &start, &end)) {
22458         if (start >= NUM_ANYOF_CODE_POINTS) {
22459             break;
22460         }
22461         put_range(sv, start, end, allow_literals);
22462     }
22463     invlist_iterfinish(invlist);
22464
22465     return;
22466 }
22467
22468 STATIC SV*
22469 S_put_charclass_bitmap_innards_common(pTHX_
22470         SV* invlist,            /* The bitmap */
22471         SV* posixes,            /* Under /l, things like [:word:], \S */
22472         SV* only_utf8,          /* Under /d, matches iff the target is UTF-8 */
22473         SV* not_utf8,           /* /d, matches iff the target isn't UTF-8 */
22474         SV* only_utf8_locale,   /* Under /l, matches if the locale is UTF-8 */
22475         const bool invert       /* Is the result to be inverted? */
22476 )
22477 {
22478     /* Create and return an SV containing a displayable version of the bitmap
22479      * and associated information determined by the input parameters.  If the
22480      * output would have been only the inversion indicator '^', NULL is instead
22481      * returned. */
22482
22483     SV * output;
22484
22485     PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_COMMON;
22486
22487     if (invert) {
22488         output = newSVpvs("^");
22489     }
22490     else {
22491         output = newSVpvs("");
22492     }
22493
22494     /* First, the code points in the bitmap that are unconditionally there */
22495     put_charclass_bitmap_innards_invlist(output, invlist);
22496
22497     /* Traditionally, these have been placed after the main code points */
22498     if (posixes) {
22499         sv_catsv(output, posixes);
22500     }
22501
22502     if (only_utf8 && _invlist_len(only_utf8)) {
22503         Perl_sv_catpvf(aTHX_ output, "%s{utf8}%s", PL_colors[1], PL_colors[0]);
22504         put_charclass_bitmap_innards_invlist(output, only_utf8);
22505     }
22506
22507     if (not_utf8 && _invlist_len(not_utf8)) {
22508         Perl_sv_catpvf(aTHX_ output, "%s{not utf8}%s", PL_colors[1], PL_colors[0]);
22509         put_charclass_bitmap_innards_invlist(output, not_utf8);
22510     }
22511
22512     if (only_utf8_locale && _invlist_len(only_utf8_locale)) {
22513         Perl_sv_catpvf(aTHX_ output, "%s{utf8 locale}%s", PL_colors[1], PL_colors[0]);
22514         put_charclass_bitmap_innards_invlist(output, only_utf8_locale);
22515
22516         /* This is the only list in this routine that can legally contain code
22517          * points outside the bitmap range.  The call just above to
22518          * 'put_charclass_bitmap_innards_invlist' will simply suppress them, so
22519          * output them here.  There's about a half-dozen possible, and none in
22520          * contiguous ranges longer than 2 */
22521         if (invlist_highest(only_utf8_locale) >= NUM_ANYOF_CODE_POINTS) {
22522             UV start, end;
22523             SV* above_bitmap = NULL;
22524
22525             _invlist_subtract(only_utf8_locale, PL_InBitmap, &above_bitmap);
22526
22527             invlist_iterinit(above_bitmap);
22528             while (invlist_iternext(above_bitmap, &start, &end)) {
22529                 UV i;
22530
22531                 for (i = start; i <= end; i++) {
22532                     put_code_point(output, i);
22533                 }
22534             }
22535             invlist_iterfinish(above_bitmap);
22536             SvREFCNT_dec_NN(above_bitmap);
22537         }
22538     }
22539
22540     if (invert && SvCUR(output) == 1) {
22541         return NULL;
22542     }
22543
22544     return output;
22545 }
22546
22547 STATIC bool
22548 S_put_charclass_bitmap_innards(pTHX_ SV *sv,
22549                                      char *bitmap,
22550                                      SV *nonbitmap_invlist,
22551                                      SV *only_utf8_locale_invlist,
22552                                      const regnode * const node,
22553                                      const U8 flags,
22554                                      const bool force_as_is_display)
22555 {
22556     /* Appends to 'sv' a displayable version of the innards of the bracketed
22557      * character class defined by the other arguments:
22558      *  'bitmap' points to the bitmap, or NULL if to ignore that.
22559      *  'nonbitmap_invlist' is an inversion list of the code points that are in
22560      *      the bitmap range, but for some reason aren't in the bitmap; NULL if
22561      *      none.  The reasons for this could be that they require some
22562      *      condition such as the target string being or not being in UTF-8
22563      *      (under /d), or because they came from a user-defined property that
22564      *      was not resolved at the time of the regex compilation (under /u)
22565      *  'only_utf8_locale_invlist' is an inversion list of the code points that
22566      *      are valid only if the runtime locale is a UTF-8 one; NULL if none
22567      *  'node' is the regex pattern ANYOF node.  It is needed only when the
22568      *      above two parameters are not null, and is passed so that this
22569      *      routine can tease apart the various reasons for them.
22570      *  'flags' is the flags field of 'node'
22571      *  'force_as_is_display' is TRUE if this routine should definitely NOT try
22572      *      to invert things to see if that leads to a cleaner display.  If
22573      *      FALSE, this routine is free to use its judgment about doing this.
22574      *
22575      * It returns TRUE if there was actually something output.  (It may be that
22576      * the bitmap, etc is empty.)
22577      *
22578      * When called for outputting the bitmap of a non-ANYOF node, just pass the
22579      * bitmap, with the succeeding parameters set to NULL, and the final one to
22580      * FALSE.
22581      */
22582
22583     /* In general, it tries to display the 'cleanest' representation of the
22584      * innards, choosing whether to display them inverted or not, regardless of
22585      * whether the class itself is to be inverted.  However,  there are some
22586      * cases where it can't try inverting, as what actually matches isn't known
22587      * until runtime, and hence the inversion isn't either. */
22588
22589     bool inverting_allowed = ! force_as_is_display;
22590
22591     int i;
22592     STRLEN orig_sv_cur = SvCUR(sv);
22593
22594     SV* invlist;            /* Inversion list we accumulate of code points that
22595                                are unconditionally matched */
22596     SV* only_utf8 = NULL;   /* Under /d, list of matches iff the target is
22597                                UTF-8 */
22598     SV* not_utf8 =  NULL;   /* /d, list of matches iff the target isn't UTF-8
22599                              */
22600     SV* posixes = NULL;     /* Under /l, string of things like [:word:], \D */
22601     SV* only_utf8_locale = NULL;    /* Under /l, list of matches if the locale
22602                                        is UTF-8 */
22603
22604     SV* as_is_display;      /* The output string when we take the inputs
22605                                literally */
22606     SV* inverted_display;   /* The output string when we invert the inputs */
22607
22608     bool invert = cBOOL(flags & ANYOF_INVERT);  /* Is the input to be inverted
22609                                                    to match? */
22610     /* We are biased in favor of displaying things without them being inverted,
22611      * as that is generally easier to understand */
22612     const int bias = 5;
22613
22614     PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS;
22615
22616     /* Start off with whatever code points are passed in.  (We clone, so we
22617      * don't change the caller's list) */
22618     if (nonbitmap_invlist) {
22619         assert(invlist_highest(nonbitmap_invlist) < NUM_ANYOF_CODE_POINTS);
22620         invlist = invlist_clone(nonbitmap_invlist, NULL);
22621     }
22622     else {  /* Worst case size is every other code point is matched */
22623         invlist = _new_invlist(NUM_ANYOF_CODE_POINTS / 2);
22624     }
22625
22626     if (flags) {
22627         if (OP(node) == ANYOFD) {
22628
22629             /* This flag indicates that the code points below 0x100 in the
22630              * nonbitmap list are precisely the ones that match only when the
22631              * target is UTF-8 (they should all be non-ASCII). */
22632             if (flags & ANYOF_SHARED_d_UPPER_LATIN1_UTF8_STRING_MATCHES_non_d_RUNTIME_USER_PROP)
22633             {
22634                 _invlist_intersection(invlist, PL_UpperLatin1, &only_utf8);
22635                 _invlist_subtract(invlist, only_utf8, &invlist);
22636             }
22637
22638             /* And this flag for matching all non-ASCII 0xFF and below */
22639             if (flags & ANYOF_SHARED_d_MATCHES_ALL_NON_UTF8_NON_ASCII_non_d_WARN_SUPER)
22640             {
22641                 not_utf8 = invlist_clone(PL_UpperLatin1, NULL);
22642             }
22643         }
22644         else if (OP(node) == ANYOFL || OP(node) == ANYOFPOSIXL) {
22645
22646             /* If either of these flags are set, what matches isn't
22647              * determinable except during execution, so don't know enough here
22648              * to invert */
22649             if (flags & (ANYOFL_FOLD|ANYOF_MATCHES_POSIXL)) {
22650                 inverting_allowed = FALSE;
22651             }
22652
22653             /* What the posix classes match also varies at runtime, so these
22654              * will be output symbolically. */
22655             if (ANYOF_POSIXL_TEST_ANY_SET(node)) {
22656                 int i;
22657
22658                 posixes = newSVpvs("");
22659                 for (i = 0; i < ANYOF_POSIXL_MAX; i++) {
22660                     if (ANYOF_POSIXL_TEST(node, i)) {
22661                         sv_catpv(posixes, anyofs[i]);
22662                     }
22663                 }
22664             }
22665         }
22666     }
22667
22668     /* Accumulate the bit map into the unconditional match list */
22669     if (bitmap) {
22670         for (i = 0; i < NUM_ANYOF_CODE_POINTS; i++) {
22671             if (BITMAP_TEST(bitmap, i)) {
22672                 int start = i++;
22673                 for (;
22674                      i < NUM_ANYOF_CODE_POINTS && BITMAP_TEST(bitmap, i);
22675                      i++)
22676                 { /* empty */ }
22677                 invlist = _add_range_to_invlist(invlist, start, i-1);
22678             }
22679         }
22680     }
22681
22682     /* Make sure that the conditional match lists don't have anything in them
22683      * that match unconditionally; otherwise the output is quite confusing.
22684      * This could happen if the code that populates these misses some
22685      * duplication. */
22686     if (only_utf8) {
22687         _invlist_subtract(only_utf8, invlist, &only_utf8);
22688     }
22689     if (not_utf8) {
22690         _invlist_subtract(not_utf8, invlist, &not_utf8);
22691     }
22692
22693     if (only_utf8_locale_invlist) {
22694
22695         /* Since this list is passed in, we have to make a copy before
22696          * modifying it */
22697         only_utf8_locale = invlist_clone(only_utf8_locale_invlist, NULL);
22698
22699         _invlist_subtract(only_utf8_locale, invlist, &only_utf8_locale);
22700
22701         /* And, it can get really weird for us to try outputting an inverted
22702          * form of this list when it has things above the bitmap, so don't even
22703          * try */
22704         if (invlist_highest(only_utf8_locale) >= NUM_ANYOF_CODE_POINTS) {
22705             inverting_allowed = FALSE;
22706         }
22707     }
22708
22709     /* Calculate what the output would be if we take the input as-is */
22710     as_is_display = put_charclass_bitmap_innards_common(invlist,
22711                                                     posixes,
22712                                                     only_utf8,
22713                                                     not_utf8,
22714                                                     only_utf8_locale,
22715                                                     invert);
22716
22717     /* If have to take the output as-is, just do that */
22718     if (! inverting_allowed) {
22719         if (as_is_display) {
22720             sv_catsv(sv, as_is_display);
22721             SvREFCNT_dec_NN(as_is_display);
22722         }
22723     }
22724     else { /* But otherwise, create the output again on the inverted input, and
22725               use whichever version is shorter */
22726
22727         int inverted_bias, as_is_bias;
22728
22729         /* We will apply our bias to whichever of the results doesn't have
22730          * the '^' */
22731         if (invert) {
22732             invert = FALSE;
22733             as_is_bias = bias;
22734             inverted_bias = 0;
22735         }
22736         else {
22737             invert = TRUE;
22738             as_is_bias = 0;
22739             inverted_bias = bias;
22740         }
22741
22742         /* Now invert each of the lists that contribute to the output,
22743          * excluding from the result things outside the possible range */
22744
22745         /* For the unconditional inversion list, we have to add in all the
22746          * conditional code points, so that when inverted, they will be gone
22747          * from it */
22748         _invlist_union(only_utf8, invlist, &invlist);
22749         _invlist_union(not_utf8, invlist, &invlist);
22750         _invlist_union(only_utf8_locale, invlist, &invlist);
22751         _invlist_invert(invlist);
22752         _invlist_intersection(invlist, PL_InBitmap, &invlist);
22753
22754         if (only_utf8) {
22755             _invlist_invert(only_utf8);
22756             _invlist_intersection(only_utf8, PL_UpperLatin1, &only_utf8);
22757         }
22758         else if (not_utf8) {
22759
22760             /* If a code point matches iff the target string is not in UTF-8,
22761              * then complementing the result has it not match iff not in UTF-8,
22762              * which is the same thing as matching iff it is UTF-8. */
22763             only_utf8 = not_utf8;
22764             not_utf8 = NULL;
22765         }
22766
22767         if (only_utf8_locale) {
22768             _invlist_invert(only_utf8_locale);
22769             _invlist_intersection(only_utf8_locale,
22770                                   PL_InBitmap,
22771                                   &only_utf8_locale);
22772         }
22773
22774         inverted_display = put_charclass_bitmap_innards_common(
22775                                             invlist,
22776                                             posixes,
22777                                             only_utf8,
22778                                             not_utf8,
22779                                             only_utf8_locale, invert);
22780
22781         /* Use the shortest representation, taking into account our bias
22782          * against showing it inverted */
22783         if (   inverted_display
22784             && (   ! as_is_display
22785                 || (  SvCUR(inverted_display) + inverted_bias
22786                     < SvCUR(as_is_display)    + as_is_bias)))
22787         {
22788             sv_catsv(sv, inverted_display);
22789         }
22790         else if (as_is_display) {
22791             sv_catsv(sv, as_is_display);
22792         }
22793
22794         SvREFCNT_dec(as_is_display);
22795         SvREFCNT_dec(inverted_display);
22796     }
22797
22798     SvREFCNT_dec_NN(invlist);
22799     SvREFCNT_dec(only_utf8);
22800     SvREFCNT_dec(not_utf8);
22801     SvREFCNT_dec(posixes);
22802     SvREFCNT_dec(only_utf8_locale);
22803
22804     return SvCUR(sv) > orig_sv_cur;
22805 }
22806
22807 #define CLEAR_OPTSTART                                                       \
22808     if (optstart) STMT_START {                                               \
22809         DEBUG_OPTIMISE_r(Perl_re_printf( aTHX_                                           \
22810                               " (%" IVdf " nodes)\n", (IV)(node - optstart))); \
22811         optstart=NULL;                                                       \
22812     } STMT_END
22813
22814 #define DUMPUNTIL(b,e)                                                       \
22815                     CLEAR_OPTSTART;                                          \
22816                     node=dumpuntil(r,start,(b),(e),last,sv,indent+1,depth+1);
22817
22818 STATIC const regnode *
22819 S_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node,
22820             const regnode *last, const regnode *plast,
22821             SV* sv, I32 indent, U32 depth)
22822 {
22823     U8 op = PSEUDO;     /* Arbitrary non-END op. */
22824     const regnode *next;
22825     const regnode *optstart= NULL;
22826
22827     RXi_GET_DECL(r, ri);
22828     DECLARE_AND_GET_RE_DEBUG_FLAGS;
22829
22830     PERL_ARGS_ASSERT_DUMPUNTIL;
22831
22832 #ifdef DEBUG_DUMPUNTIL
22833     Perl_re_printf( aTHX_  "--- %d : %d - %d - %d\n", indent, node-start,
22834         last ? last-start : 0, plast ? plast-start : 0);
22835 #endif
22836
22837     if (plast && plast < last)
22838         last= plast;
22839
22840     while (PL_regkind[op] != END && (!last || node < last)) {
22841         assert(node);
22842         /* While that wasn't END last time... */
22843         NODE_ALIGN(node);
22844         op = OP(node);
22845         if (op == CLOSE || op == SRCLOSE || op == WHILEM)
22846             indent--;
22847         next = regnext((regnode *)node);
22848
22849         /* Where, what. */
22850         if (OP(node) == OPTIMIZED) {
22851             if (!optstart && RE_DEBUG_FLAG(RE_DEBUG_COMPILE_OPTIMISE))
22852                 optstart = node;
22853             else
22854                 goto after_print;
22855         } else
22856             CLEAR_OPTSTART;
22857
22858         regprop(r, sv, node, NULL, NULL);
22859         Perl_re_printf( aTHX_  "%4" IVdf ":%*s%s", (IV)(node - start),
22860                       (int)(2*indent + 1), "", SvPVX_const(sv));
22861
22862         if (OP(node) != OPTIMIZED) {
22863             if (next == NULL)           /* Next ptr. */
22864                 Perl_re_printf( aTHX_  " (0)");
22865             else if (PL_regkind[(U8)op] == BRANCH
22866                      && PL_regkind[OP(next)] != BRANCH )
22867                 Perl_re_printf( aTHX_  " (FAIL)");
22868             else
22869                 Perl_re_printf( aTHX_  " (%" IVdf ")", (IV)(next - start));
22870             Perl_re_printf( aTHX_ "\n");
22871         }
22872
22873       after_print:
22874         if (PL_regkind[(U8)op] == BRANCHJ) {
22875             assert(next);
22876             {
22877                 const regnode *nnode = (OP(next) == LONGJMP
22878                                        ? regnext((regnode *)next)
22879                                        : next);
22880                 if (last && nnode > last)
22881                     nnode = last;
22882                 DUMPUNTIL(NEXTOPER(NEXTOPER(node)), nnode);
22883             }
22884         }
22885         else if (PL_regkind[(U8)op] == BRANCH) {
22886             assert(next);
22887             DUMPUNTIL(NEXTOPER(node), next);
22888         }
22889         else if ( PL_regkind[(U8)op]  == TRIE ) {
22890             const regnode *this_trie = node;
22891             const char op = OP(node);
22892             const U32 n = ARG(node);
22893             const reg_ac_data * const ac = op>=AHOCORASICK ?
22894                (reg_ac_data *)ri->data->data[n] :
22895                NULL;
22896             const reg_trie_data * const trie =
22897                 (reg_trie_data*)ri->data->data[op<AHOCORASICK ? n : ac->trie];
22898 #ifdef DEBUGGING
22899             AV *const trie_words
22900                            = MUTABLE_AV(ri->data->data[n + TRIE_WORDS_OFFSET]);
22901 #endif
22902             const regnode *nextbranch= NULL;
22903             I32 word_idx;
22904             SvPVCLEAR(sv);
22905             for (word_idx= 0; word_idx < (I32)trie->wordcount; word_idx++) {
22906                 SV ** const elem_ptr = av_fetch(trie_words, word_idx, 0);
22907
22908                 Perl_re_indentf( aTHX_  "%s ",
22909                     indent+3,
22910                     elem_ptr
22911                     ? pv_pretty(sv, SvPV_nolen_const(*elem_ptr),
22912                                 SvCUR(*elem_ptr), PL_dump_re_max_len,
22913                                 PL_colors[0], PL_colors[1],
22914                                 (SvUTF8(*elem_ptr)
22915                                  ? PERL_PV_ESCAPE_UNI
22916                                  : 0)
22917                                 | PERL_PV_PRETTY_ELLIPSES
22918                                 | PERL_PV_PRETTY_LTGT
22919                             )
22920                     : "???"
22921                 );
22922                 if (trie->jump) {
22923                     U16 dist= trie->jump[word_idx+1];
22924                     Perl_re_printf( aTHX_  "(%" UVuf ")\n",
22925                                (UV)((dist ? this_trie + dist : next) - start));
22926                     if (dist) {
22927                         if (!nextbranch)
22928                             nextbranch= this_trie + trie->jump[0];
22929                         DUMPUNTIL(this_trie + dist, nextbranch);
22930                     }
22931                     if (nextbranch && PL_regkind[OP(nextbranch)]==BRANCH)
22932                         nextbranch= regnext((regnode *)nextbranch);
22933                 } else {
22934                     Perl_re_printf( aTHX_  "\n");
22935                 }
22936             }
22937             if (last && next > last)
22938                 node= last;
22939             else
22940                 node= next;
22941         }
22942         else if ( op == CURLY ) {   /* "next" might be very big: optimizer */
22943             DUMPUNTIL(NEXTOPER(node) + EXTRA_STEP_2ARGS,
22944                     NEXTOPER(node) + EXTRA_STEP_2ARGS + 1);
22945         }
22946         else if (PL_regkind[(U8)op] == CURLY && op != CURLYX) {
22947             assert(next);
22948             DUMPUNTIL(NEXTOPER(node) + EXTRA_STEP_2ARGS, next);
22949         }
22950         else if ( op == PLUS || op == STAR) {
22951             DUMPUNTIL(NEXTOPER(node), NEXTOPER(node) + 1);
22952         }
22953         else if (PL_regkind[(U8)op] == EXACT || op == ANYOFHs) {
22954             /* Literal string, where present. */
22955             node += NODE_SZ_STR(node) - 1;
22956             node = NEXTOPER(node);
22957         }
22958         else {
22959             node = NEXTOPER(node);
22960             node += regarglen[(U8)op];
22961         }
22962         if (op == CURLYX || op == OPEN || op == SROPEN)
22963             indent++;
22964     }
22965     CLEAR_OPTSTART;
22966 #ifdef DEBUG_DUMPUNTIL
22967     Perl_re_printf( aTHX_  "--- %d\n", (int)indent);
22968 #endif
22969     return node;
22970 }
22971
22972 #endif  /* DEBUGGING */
22973
22974 #ifndef PERL_IN_XSUB_RE
22975
22976 #  include "uni_keywords.h"
22977
22978 void
22979 Perl_init_uniprops(pTHX)
22980 {
22981
22982 #  ifdef DEBUGGING
22983     char * dump_len_string;
22984
22985     dump_len_string = PerlEnv_getenv("PERL_DUMP_RE_MAX_LEN");
22986     if (   ! dump_len_string
22987         || ! grok_atoUV(dump_len_string, (UV *)&PL_dump_re_max_len, NULL))
22988     {
22989         PL_dump_re_max_len = 60;    /* A reasonable default */
22990     }
22991 #  endif
22992
22993     PL_user_def_props = newHV();
22994
22995 #  ifdef USE_ITHREADS
22996
22997     HvSHAREKEYS_off(PL_user_def_props);
22998     PL_user_def_props_aTHX = aTHX;
22999
23000 #  endif
23001
23002     /* Set up the inversion list interpreter-level variables */
23003
23004     PL_XPosix_ptrs[_CC_ASCII] = _new_invlist_C_array(uni_prop_ptrs[UNI_ASCII]);
23005     PL_XPosix_ptrs[_CC_ALPHANUMERIC] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXALNUM]);
23006     PL_XPosix_ptrs[_CC_ALPHA] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXALPHA]);
23007     PL_XPosix_ptrs[_CC_BLANK] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXBLANK]);
23008     PL_XPosix_ptrs[_CC_CASED] =  _new_invlist_C_array(uni_prop_ptrs[UNI_CASED]);
23009     PL_XPosix_ptrs[_CC_CNTRL] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXCNTRL]);
23010     PL_XPosix_ptrs[_CC_DIGIT] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXDIGIT]);
23011     PL_XPosix_ptrs[_CC_GRAPH] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXGRAPH]);
23012     PL_XPosix_ptrs[_CC_LOWER] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXLOWER]);
23013     PL_XPosix_ptrs[_CC_PRINT] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXPRINT]);
23014     PL_XPosix_ptrs[_CC_PUNCT] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXPUNCT]);
23015     PL_XPosix_ptrs[_CC_SPACE] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXSPACE]);
23016     PL_XPosix_ptrs[_CC_UPPER] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXUPPER]);
23017     PL_XPosix_ptrs[_CC_VERTSPACE] = _new_invlist_C_array(uni_prop_ptrs[UNI_VERTSPACE]);
23018     PL_XPosix_ptrs[_CC_WORDCHAR] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXWORD]);
23019     PL_XPosix_ptrs[_CC_XDIGIT] = _new_invlist_C_array(uni_prop_ptrs[UNI_XPOSIXXDIGIT]);
23020
23021     PL_Posix_ptrs[_CC_ASCII] = _new_invlist_C_array(uni_prop_ptrs[UNI_ASCII]);
23022     PL_Posix_ptrs[_CC_ALPHANUMERIC] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXALNUM]);
23023     PL_Posix_ptrs[_CC_ALPHA] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXALPHA]);
23024     PL_Posix_ptrs[_CC_BLANK] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXBLANK]);
23025     PL_Posix_ptrs[_CC_CASED] = PL_Posix_ptrs[_CC_ALPHA];
23026     PL_Posix_ptrs[_CC_CNTRL] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXCNTRL]);
23027     PL_Posix_ptrs[_CC_DIGIT] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXDIGIT]);
23028     PL_Posix_ptrs[_CC_GRAPH] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXGRAPH]);
23029     PL_Posix_ptrs[_CC_LOWER] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXLOWER]);
23030     PL_Posix_ptrs[_CC_PRINT] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXPRINT]);
23031     PL_Posix_ptrs[_CC_PUNCT] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXPUNCT]);
23032     PL_Posix_ptrs[_CC_SPACE] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXSPACE]);
23033     PL_Posix_ptrs[_CC_UPPER] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXUPPER]);
23034     PL_Posix_ptrs[_CC_VERTSPACE] = NULL;
23035     PL_Posix_ptrs[_CC_WORDCHAR] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXWORD]);
23036     PL_Posix_ptrs[_CC_XDIGIT] = _new_invlist_C_array(uni_prop_ptrs[UNI_POSIXXDIGIT]);
23037
23038     PL_GCB_invlist = _new_invlist_C_array(_Perl_GCB_invlist);
23039     PL_SB_invlist = _new_invlist_C_array(_Perl_SB_invlist);
23040     PL_WB_invlist = _new_invlist_C_array(_Perl_WB_invlist);
23041     PL_LB_invlist = _new_invlist_C_array(_Perl_LB_invlist);
23042     PL_SCX_invlist = _new_invlist_C_array(_Perl_SCX_invlist);
23043
23044     PL_InBitmap = _new_invlist_C_array(InBitmap_invlist);
23045     PL_AboveLatin1 = _new_invlist_C_array(AboveLatin1_invlist);
23046     PL_Latin1 = _new_invlist_C_array(Latin1_invlist);
23047     PL_UpperLatin1 = _new_invlist_C_array(UpperLatin1_invlist);
23048
23049     PL_Assigned_invlist = _new_invlist_C_array(uni_prop_ptrs[UNI_ASSIGNED]);
23050
23051     PL_utf8_perl_idstart = _new_invlist_C_array(uni_prop_ptrs[UNI__PERL_IDSTART]);
23052     PL_utf8_perl_idcont = _new_invlist_C_array(uni_prop_ptrs[UNI__PERL_IDCONT]);
23053
23054     PL_utf8_charname_begin = _new_invlist_C_array(uni_prop_ptrs[UNI__PERL_CHARNAME_BEGIN]);
23055     PL_utf8_charname_continue = _new_invlist_C_array(uni_prop_ptrs[UNI__PERL_CHARNAME_CONTINUE]);
23056
23057     PL_in_some_fold = _new_invlist_C_array(uni_prop_ptrs[UNI__PERL_ANY_FOLDS]);
23058     PL_HasMultiCharFold = _new_invlist_C_array(uni_prop_ptrs[
23059                                             UNI__PERL_FOLDS_TO_MULTI_CHAR]);
23060     PL_InMultiCharFold = _new_invlist_C_array(uni_prop_ptrs[
23061                                             UNI__PERL_IS_IN_MULTI_CHAR_FOLD]);
23062     PL_utf8_toupper = _new_invlist_C_array(Uppercase_Mapping_invlist);
23063     PL_utf8_tolower = _new_invlist_C_array(Lowercase_Mapping_invlist);
23064     PL_utf8_totitle = _new_invlist_C_array(Titlecase_Mapping_invlist);
23065     PL_utf8_tofold = _new_invlist_C_array(Case_Folding_invlist);
23066     PL_utf8_tosimplefold = _new_invlist_C_array(Simple_Case_Folding_invlist);
23067     PL_utf8_foldclosures = _new_invlist_C_array(_Perl_IVCF_invlist);
23068     PL_utf8_mark = _new_invlist_C_array(uni_prop_ptrs[UNI_M]);
23069     PL_CCC_non0_non230 = _new_invlist_C_array(_Perl_CCC_non0_non230_invlist);
23070     PL_Private_Use = _new_invlist_C_array(uni_prop_ptrs[UNI_CO]);
23071
23072 #  ifdef UNI_XIDC
23073     /* The below are used only by deprecated functions.  They could be removed */
23074     PL_utf8_xidcont  = _new_invlist_C_array(uni_prop_ptrs[UNI_XIDC]);
23075     PL_utf8_idcont   = _new_invlist_C_array(uni_prop_ptrs[UNI_IDC]);
23076     PL_utf8_xidstart = _new_invlist_C_array(uni_prop_ptrs[UNI_XIDS]);
23077 #  endif
23078 }
23079
23080 /* These four functions are compiled only in regcomp.c, where they have access
23081  * to the data they return.  They are a way for re_comp.c to get access to that
23082  * data without having to compile the whole data structures. */
23083
23084 I16
23085 Perl_do_uniprop_match(const char * const key, const U16 key_len)
23086 {
23087     PERL_ARGS_ASSERT_DO_UNIPROP_MATCH;
23088
23089     return match_uniprop((U8 *) key, key_len);
23090 }
23091
23092 SV *
23093 Perl_get_prop_definition(pTHX_ const int table_index)
23094 {
23095     PERL_ARGS_ASSERT_GET_PROP_DEFINITION;
23096
23097     /* Create and return the inversion list */
23098     return _new_invlist_C_array(uni_prop_ptrs[table_index]);
23099 }
23100
23101 const char * const *
23102 Perl_get_prop_values(const int table_index)
23103 {
23104     PERL_ARGS_ASSERT_GET_PROP_VALUES;
23105
23106     return UNI_prop_value_ptrs[table_index];
23107 }
23108
23109 const char *
23110 Perl_get_deprecated_property_msg(const Size_t warning_offset)
23111 {
23112     PERL_ARGS_ASSERT_GET_DEPRECATED_PROPERTY_MSG;
23113
23114     return deprecated_property_msgs[warning_offset];
23115 }
23116
23117 #  if 0
23118
23119 This code was mainly added for backcompat to give a warning for non-portable
23120 code points in user-defined properties.  But experiments showed that the
23121 warning in earlier perls were only omitted on overflow, which should be an
23122 error, so there really isnt a backcompat issue, and actually adding the
23123 warning when none was present before might cause breakage, for little gain.  So
23124 khw left this code in, but not enabled.  Tests were never added.
23125
23126 embed.fnc entry:
23127 Ei      |const char *|get_extended_utf8_msg|const UV cp
23128
23129 PERL_STATIC_INLINE const char *
23130 S_get_extended_utf8_msg(pTHX_ const UV cp)
23131 {
23132     U8 dummy[UTF8_MAXBYTES + 1];
23133     HV *msgs;
23134     SV **msg;
23135
23136     uvchr_to_utf8_flags_msgs(dummy, cp, UNICODE_WARN_PERL_EXTENDED,
23137                              &msgs);
23138
23139     msg = hv_fetchs(msgs, "text", 0);
23140     assert(msg);
23141
23142     (void) sv_2mortal((SV *) msgs);
23143
23144     return SvPVX(*msg);
23145 }
23146
23147 #  endif
23148 #endif /* end of ! PERL_IN_XSUB_RE */
23149
23150 STATIC REGEXP *
23151 S_compile_wildcard(pTHX_ const char * subpattern, const STRLEN len,
23152                          const bool ignore_case)
23153 {
23154     /* Pretends that the input subpattern is qr/subpattern/aam, compiling it
23155      * possibly with /i if the 'ignore_case' parameter is true.  Use /aa
23156      * because nothing outside of ASCII will match.  Use /m because the input
23157      * string may be a bunch of lines strung together.
23158      *
23159      * Also sets up the debugging info */
23160
23161     U32 flags = PMf_MULTILINE|PMf_WILDCARD;
23162     U32 rx_flags;
23163     SV * subpattern_sv = sv_2mortal(newSVpvn(subpattern, len));
23164     REGEXP * subpattern_re;
23165     DECLARE_AND_GET_RE_DEBUG_FLAGS;
23166
23167     PERL_ARGS_ASSERT_COMPILE_WILDCARD;
23168
23169     if (ignore_case) {
23170         flags |= PMf_FOLD;
23171     }
23172     set_regex_charset(&flags, REGEX_ASCII_MORE_RESTRICTED_CHARSET);
23173
23174     /* Like in op.c, we copy the compile time pm flags to the rx ones */
23175     rx_flags = flags & RXf_PMf_COMPILETIME;
23176
23177 #ifndef PERL_IN_XSUB_RE
23178     /* Use the core engine if this file is regcomp.c.  That means no
23179      * 'use re "Debug ..." is in effect, so the core engine is sufficient */
23180     subpattern_re = Perl_re_op_compile(aTHX_ &subpattern_sv, 1, NULL,
23181                                              &PL_core_reg_engine,
23182                                              NULL, NULL,
23183                                              rx_flags, flags);
23184 #else
23185     if (isDEBUG_WILDCARD) {
23186         /* Use the special debugging engine if this file is re_comp.c and wants
23187          * to output the wildcard matching.  This uses whatever
23188          * 'use re "Debug ..." is in effect */
23189         subpattern_re = Perl_re_op_compile(aTHX_ &subpattern_sv, 1, NULL,
23190                                                  &my_reg_engine,
23191                                                  NULL, NULL,
23192                                                  rx_flags, flags);
23193     }
23194     else {
23195         /* Use the special wildcard engine if this file is re_comp.c and
23196          * doesn't want to output the wildcard matching.  This uses whatever
23197          * 'use re "Debug ..." is in effect for compilation, but this engine
23198          * structure has been set up so that it uses the core engine for
23199          * execution, so no execution debugging as a result of re.pm will be
23200          * displayed. */
23201         subpattern_re = Perl_re_op_compile(aTHX_ &subpattern_sv, 1, NULL,
23202                                                  &wild_reg_engine,
23203                                                  NULL, NULL,
23204                                                  rx_flags, flags);
23205         /* XXX The above has the effect that any user-supplied regex engine
23206          * won't be called for matching wildcards.  That might be good, or bad.
23207          * It could be changed in several ways.  The reason it is done the
23208          * current way is to avoid having to save and restore
23209          * ^{^RE_DEBUG_FLAGS} around the execution.  save_scalar() perhaps
23210          * could be used.  Another suggestion is to keep the authoritative
23211          * value of the debug flags in a thread-local variable and add set/get
23212          * magic to ${^RE_DEBUG_FLAGS} to keep the C level variable up to date.
23213          * Still another is to pass a flag, say in the engine's intflags that
23214          * would be checked each time before doing the debug output */
23215     }
23216 #endif
23217
23218     assert(subpattern_re);  /* Should have died if didn't compile successfully */
23219     return subpattern_re;
23220 }
23221
23222 STATIC I32
23223 S_execute_wildcard(pTHX_ REGEXP * const prog, char* stringarg, char *strend,
23224          char *strbeg, SSize_t minend, SV *screamer, U32 nosave)
23225 {
23226     I32 result;
23227     DECLARE_AND_GET_RE_DEBUG_FLAGS;
23228
23229     PERL_ARGS_ASSERT_EXECUTE_WILDCARD;
23230
23231     ENTER;
23232
23233     /* The compilation has set things up so that if the program doesn't want to
23234      * see the wildcard matching procedure, it will get the core execution
23235      * engine, which is subject only to -Dr.  So we have to turn that off
23236      * around this procedure */
23237     if (! isDEBUG_WILDCARD) {
23238         /* Note! Casts away 'volatile' */
23239         SAVEI32(PL_debug);
23240         PL_debug &= ~ DEBUG_r_FLAG;
23241     }
23242
23243     result = CALLREGEXEC(prog, stringarg, strend, strbeg, minend, screamer,
23244                          NULL, nosave);
23245     LEAVE;
23246
23247     return result;
23248 }
23249
23250 SV *
23251 S_handle_user_defined_property(pTHX_
23252
23253     /* Parses the contents of a user-defined property definition; returning the
23254      * expanded definition if possible.  If so, the return is an inversion
23255      * list.
23256      *
23257      * If there are subroutines that are part of the expansion and which aren't
23258      * known at the time of the call to this function, this returns what
23259      * parse_uniprop_string() returned for the first one encountered.
23260      *
23261      * If an error was found, NULL is returned, and 'msg' gets a suitable
23262      * message appended to it.  (Appending allows the back trace of how we got
23263      * to the faulty definition to be displayed through nested calls of
23264      * user-defined subs.)
23265      *
23266      * The caller IS responsible for freeing any returned SV.
23267      *
23268      * The syntax of the contents is pretty much described in perlunicode.pod,
23269      * but we also allow comments on each line */
23270
23271     const char * name,          /* Name of property */
23272     const STRLEN name_len,      /* The name's length in bytes */
23273     const bool is_utf8,         /* ? Is 'name' encoded in UTF-8 */
23274     const bool to_fold,         /* ? Is this under /i */
23275     const bool runtime,         /* ? Are we in compile- or run-time */
23276     const bool deferrable,      /* Is it ok for this property's full definition
23277                                    to be deferred until later? */
23278     SV* contents,               /* The property's definition */
23279     bool *user_defined_ptr,     /* This will be set TRUE as we wouldn't be
23280                                    getting called unless this is thought to be
23281                                    a user-defined property */
23282     SV * msg,                   /* Any error or warning msg(s) are appended to
23283                                    this */
23284     const STRLEN level)         /* Recursion level of this call */
23285 {
23286     STRLEN len;
23287     const char * string         = SvPV_const(contents, len);
23288     const char * const e        = string + len;
23289     const bool is_contents_utf8 = cBOOL(SvUTF8(contents));
23290     const STRLEN msgs_length_on_entry = SvCUR(msg);
23291
23292     const char * s0 = string;   /* Points to first byte in the current line
23293                                    being parsed in 'string' */
23294     const char overflow_msg[] = "Code point too large in \"";
23295     SV* running_definition = NULL;
23296
23297     PERL_ARGS_ASSERT_HANDLE_USER_DEFINED_PROPERTY;
23298
23299     *user_defined_ptr = TRUE;
23300
23301     /* Look at each line */
23302     while (s0 < e) {
23303         const char * s;     /* Current byte */
23304         char op = '+';      /* Default operation is 'union' */
23305         IV   min = 0;       /* range begin code point */
23306         IV   max = -1;      /* and range end */
23307         SV* this_definition;
23308
23309         /* Skip comment lines */
23310         if (*s0 == '#') {
23311             s0 = strchr(s0, '\n');
23312             if (s0 == NULL) {
23313                 break;
23314             }
23315             s0++;
23316             continue;
23317         }
23318
23319         /* For backcompat, allow an empty first line */
23320         if (*s0 == '\n') {
23321             s0++;
23322             continue;
23323         }
23324
23325         /* First character in the line may optionally be the operation */
23326         if (   *s0 == '+'
23327             || *s0 == '!'
23328             || *s0 == '-'
23329             || *s0 == '&')
23330         {
23331             op = *s0++;
23332         }
23333
23334         /* If the line is one or two hex digits separated by blank space, its
23335          * a range; otherwise it is either another user-defined property or an
23336          * error */
23337
23338         s = s0;
23339
23340         if (! isXDIGIT(*s)) {
23341             goto check_if_property;
23342         }
23343
23344         do { /* Each new hex digit will add 4 bits. */
23345             if (min > ( (IV) MAX_LEGAL_CP >> 4)) {
23346                 s = strchr(s, '\n');
23347                 if (s == NULL) {
23348                     s = e;
23349                 }
23350                 if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
23351                 sv_catpv(msg, overflow_msg);
23352                 Perl_sv_catpvf(aTHX_ msg, "%" UTF8f,
23353                                      UTF8fARG(is_contents_utf8, s - s0, s0));
23354                 sv_catpvs(msg, "\"");
23355                 goto return_failure;
23356             }
23357
23358             /* Accumulate this digit into the value */
23359             min = (min << 4) + READ_XDIGIT(s);
23360         } while (isXDIGIT(*s));
23361
23362         while (isBLANK(*s)) { s++; }
23363
23364         /* We allow comments at the end of the line */
23365         if (*s == '#') {
23366             s = strchr(s, '\n');
23367             if (s == NULL) {
23368                 s = e;
23369             }
23370             s++;
23371         }
23372         else if (s < e && *s != '\n') {
23373             if (! isXDIGIT(*s)) {
23374                 goto check_if_property;
23375             }
23376
23377             /* Look for the high point of the range */
23378             max = 0;
23379             do {
23380                 if (max > ( (IV) MAX_LEGAL_CP >> 4)) {
23381                     s = strchr(s, '\n');
23382                     if (s == NULL) {
23383                         s = e;
23384                     }
23385                     if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
23386                     sv_catpv(msg, overflow_msg);
23387                     Perl_sv_catpvf(aTHX_ msg, "%" UTF8f,
23388                                       UTF8fARG(is_contents_utf8, s - s0, s0));
23389                     sv_catpvs(msg, "\"");
23390                     goto return_failure;
23391                 }
23392
23393                 max = (max << 4) + READ_XDIGIT(s);
23394             } while (isXDIGIT(*s));
23395
23396             while (isBLANK(*s)) { s++; }
23397
23398             if (*s == '#') {
23399                 s = strchr(s, '\n');
23400                 if (s == NULL) {
23401                     s = e;
23402                 }
23403             }
23404             else if (s < e && *s != '\n') {
23405                 goto check_if_property;
23406             }
23407         }
23408
23409         if (max == -1) {    /* The line only had one entry */
23410             max = min;
23411         }
23412         else if (max < min) {
23413             if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
23414             sv_catpvs(msg, "Illegal range in \"");
23415             Perl_sv_catpvf(aTHX_ msg, "%" UTF8f,
23416                                 UTF8fARG(is_contents_utf8, s - s0, s0));
23417             sv_catpvs(msg, "\"");
23418             goto return_failure;
23419         }
23420
23421 #  if 0   /* See explanation at definition above of get_extended_utf8_msg() */
23422
23423         if (   UNICODE_IS_PERL_EXTENDED(min)
23424             || UNICODE_IS_PERL_EXTENDED(max))
23425         {
23426             if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
23427
23428             /* If both code points are non-portable, warn only on the lower
23429              * one. */
23430             sv_catpv(msg, get_extended_utf8_msg(
23431                                             (UNICODE_IS_PERL_EXTENDED(min))
23432                                             ? min : max));
23433             sv_catpvs(msg, " in \"");
23434             Perl_sv_catpvf(aTHX_ msg, "%" UTF8f,
23435                                  UTF8fARG(is_contents_utf8, s - s0, s0));
23436             sv_catpvs(msg, "\"");
23437         }
23438
23439 #  endif
23440
23441         /* Here, this line contains a legal range */
23442         this_definition = sv_2mortal(_new_invlist(2));
23443         this_definition = _add_range_to_invlist(this_definition, min, max);
23444         goto calculate;
23445
23446       check_if_property:
23447
23448         /* Here it isn't a legal range line.  See if it is a legal property
23449          * line.  First find the end of the meat of the line */
23450         s = strpbrk(s, "#\n");
23451         if (s == NULL) {
23452             s = e;
23453         }
23454
23455         /* Ignore trailing blanks in keeping with the requirements of
23456          * parse_uniprop_string() */
23457         s--;
23458         while (s > s0 && isBLANK_A(*s)) {
23459             s--;
23460         }
23461         s++;
23462
23463         this_definition = parse_uniprop_string(s0, s - s0,
23464                                                is_utf8, to_fold, runtime,
23465                                                deferrable,
23466                                                NULL,
23467                                                user_defined_ptr, msg,
23468                                                (name_len == 0)
23469                                                 ? level /* Don't increase level
23470                                                            if input is empty */
23471                                                 : level + 1
23472                                               );
23473         if (this_definition == NULL) {
23474             goto return_failure;    /* 'msg' should have had the reason
23475                                        appended to it by the above call */
23476         }
23477
23478         if (! is_invlist(this_definition)) {    /* Unknown at this time */
23479             return newSVsv(this_definition);
23480         }
23481
23482         if (*s != '\n') {
23483             s = strchr(s, '\n');
23484             if (s == NULL) {
23485                 s = e;
23486             }
23487         }
23488
23489       calculate:
23490
23491         switch (op) {
23492             case '+':
23493                 _invlist_union(running_definition, this_definition,
23494                                                         &running_definition);
23495                 break;
23496             case '-':
23497                 _invlist_subtract(running_definition, this_definition,
23498                                                         &running_definition);
23499                 break;
23500             case '&':
23501                 _invlist_intersection(running_definition, this_definition,
23502                                                         &running_definition);
23503                 break;
23504             case '!':
23505                 _invlist_union_complement_2nd(running_definition,
23506                                         this_definition, &running_definition);
23507                 break;
23508             default:
23509                 Perl_croak(aTHX_ "panic: %s: %d: Unexpected operation %d",
23510                                  __FILE__, __LINE__, op);
23511                 break;
23512         }
23513
23514         /* Position past the '\n' */
23515         s0 = s + 1;
23516     }   /* End of loop through the lines of 'contents' */
23517
23518     /* Here, we processed all the lines in 'contents' without error.  If we
23519      * didn't add any warnings, simply return success */
23520     if (msgs_length_on_entry == SvCUR(msg)) {
23521
23522         /* If the expansion was empty, the answer isn't nothing: its an empty
23523          * inversion list */
23524         if (running_definition == NULL) {
23525             running_definition = _new_invlist(1);
23526         }
23527
23528         return running_definition;
23529     }
23530
23531     /* Otherwise, add some explanatory text, but we will return success */
23532     goto return_msg;
23533
23534   return_failure:
23535     running_definition = NULL;
23536
23537   return_msg:
23538
23539     if (name_len > 0) {
23540         sv_catpvs(msg, " in expansion of ");
23541         Perl_sv_catpvf(aTHX_ msg, "%" UTF8f, UTF8fARG(is_utf8, name_len, name));
23542     }
23543
23544     return running_definition;
23545 }
23546
23547 /* As explained below, certain operations need to take place in the first
23548  * thread created.  These macros switch contexts */
23549 #  ifdef USE_ITHREADS
23550 #    define DECLARATION_FOR_GLOBAL_CONTEXT                                  \
23551                                         PerlInterpreter * save_aTHX = aTHX;
23552 #    define SWITCH_TO_GLOBAL_CONTEXT                                        \
23553                            PERL_SET_CONTEXT((aTHX = PL_user_def_props_aTHX))
23554 #    define RESTORE_CONTEXT  PERL_SET_CONTEXT((aTHX = save_aTHX));
23555 #    define CUR_CONTEXT      aTHX
23556 #    define ORIGINAL_CONTEXT save_aTHX
23557 #  else
23558 #    define DECLARATION_FOR_GLOBAL_CONTEXT    dNOOP
23559 #    define SWITCH_TO_GLOBAL_CONTEXT          NOOP
23560 #    define RESTORE_CONTEXT                   NOOP
23561 #    define CUR_CONTEXT                       NULL
23562 #    define ORIGINAL_CONTEXT                  NULL
23563 #  endif
23564
23565 STATIC void
23566 S_delete_recursion_entry(pTHX_ void *key)
23567 {
23568     /* Deletes the entry used to detect recursion when expanding user-defined
23569      * properties.  This is a function so it can be set up to be called even if
23570      * the program unexpectedly quits */
23571
23572     SV ** current_entry;
23573     const STRLEN key_len = strlen((const char *) key);
23574     DECLARATION_FOR_GLOBAL_CONTEXT;
23575
23576     SWITCH_TO_GLOBAL_CONTEXT;
23577
23578     /* If the entry is one of these types, it is a permanent entry, and not the
23579      * one used to detect recursions.  This function should delete only the
23580      * recursion entry */
23581     current_entry = hv_fetch(PL_user_def_props, (const char *) key, key_len, 0);
23582     if (     current_entry
23583         && ! is_invlist(*current_entry)
23584         && ! SvPOK(*current_entry))
23585     {
23586         (void) hv_delete(PL_user_def_props, (const char *) key, key_len,
23587                                                                     G_DISCARD);
23588     }
23589
23590     RESTORE_CONTEXT;
23591 }
23592
23593 STATIC SV *
23594 S_get_fq_name(pTHX_
23595               const char * const name,    /* The first non-blank in the \p{}, \P{} */
23596               const Size_t name_len,      /* Its length in bytes, not including any trailing space */
23597               const bool is_utf8,         /* ? Is 'name' encoded in UTF-8 */
23598               const bool has_colon_colon
23599              )
23600 {
23601     /* Returns a mortal SV containing the fully qualified version of the input
23602      * name */
23603
23604     SV * fq_name;
23605
23606     fq_name = newSVpvs_flags("", SVs_TEMP);
23607
23608     /* Use the current package if it wasn't included in our input */
23609     if (! has_colon_colon) {
23610         const HV * pkg = (IN_PERL_COMPILETIME)
23611                          ? PL_curstash
23612                          : CopSTASH(PL_curcop);
23613         const char* pkgname = HvNAME(pkg);
23614
23615         Perl_sv_catpvf(aTHX_ fq_name, "%" UTF8f,
23616                       UTF8fARG(is_utf8, strlen(pkgname), pkgname));
23617         sv_catpvs(fq_name, "::");
23618     }
23619
23620     Perl_sv_catpvf(aTHX_ fq_name, "%" UTF8f,
23621                          UTF8fARG(is_utf8, name_len, name));
23622     return fq_name;
23623 }
23624
23625 STATIC SV *
23626 S_parse_uniprop_string(pTHX_
23627
23628     /* Parse the interior of a \p{}, \P{}.  Returns its definition if knowable
23629      * now.  If so, the return is an inversion list.
23630      *
23631      * If the property is user-defined, it is a subroutine, which in turn
23632      * may call other subroutines.  This function will call the whole nest of
23633      * them to get the definition they return; if some aren't known at the time
23634      * of the call to this function, the fully qualified name of the highest
23635      * level sub is returned.  It is an error to call this function at runtime
23636      * without every sub defined.
23637      *
23638      * If an error was found, NULL is returned, and 'msg' gets a suitable
23639      * message appended to it.  (Appending allows the back trace of how we got
23640      * to the faulty definition to be displayed through nested calls of
23641      * user-defined subs.)
23642      *
23643      * The caller should NOT try to free any returned inversion list.
23644      *
23645      * Other parameters will be set on return as described below */
23646
23647     const char * const name,    /* The first non-blank in the \p{}, \P{} */
23648     Size_t name_len,            /* Its length in bytes, not including any
23649                                    trailing space */
23650     const bool is_utf8,         /* ? Is 'name' encoded in UTF-8 */
23651     const bool to_fold,         /* ? Is this under /i */
23652     const bool runtime,         /* TRUE if this is being called at run time */
23653     const bool deferrable,      /* TRUE if it's ok for the definition to not be
23654                                    known at this call */
23655     AV ** strings,              /* To return string property values, like named
23656                                    sequences */
23657     bool *user_defined_ptr,     /* Upon return from this function it will be
23658                                    set to TRUE if any component is a
23659                                    user-defined property */
23660     SV * msg,                   /* Any error or warning msg(s) are appended to
23661                                    this */
23662     const STRLEN level)         /* Recursion level of this call */
23663 {
23664     char* lookup_name;          /* normalized name for lookup in our tables */
23665     unsigned lookup_len;        /* Its length */
23666     enum { Not_Strict = 0,      /* Some properties have stricter name */
23667            Strict,              /* normalization rules, which we decide */
23668            As_Is                /* upon based on parsing */
23669          } stricter = Not_Strict;
23670
23671     /* nv= or numeric_value=, or possibly one of the cjk numeric properties
23672      * (though it requires extra effort to download them from Unicode and
23673      * compile perl to know about them) */
23674     bool is_nv_type = FALSE;
23675
23676     unsigned int i, j = 0;
23677     int equals_pos = -1;    /* Where the '=' is found, or negative if none */
23678     int slash_pos  = -1;    /* Where the '/' is found, or negative if none */
23679     int table_index = 0;    /* The entry number for this property in the table
23680                                of all Unicode property names */
23681     bool starts_with_Is = FALSE;  /* ? Does the name start with 'Is' */
23682     Size_t lookup_offset = 0;   /* Used to ignore the first few characters of
23683                                    the normalized name in certain situations */
23684     Size_t non_pkg_begin = 0;   /* Offset of first byte in 'name' that isn't
23685                                    part of a package name */
23686     Size_t lun_non_pkg_begin = 0;   /* Similarly for 'lookup_name' */
23687     bool could_be_user_defined = TRUE;  /* ? Could this be a user-defined
23688                                              property rather than a Unicode
23689                                              one. */
23690     SV * prop_definition = NULL;  /* The returned definition of 'name' or NULL
23691                                      if an error.  If it is an inversion list,
23692                                      it is the definition.  Otherwise it is a
23693                                      string containing the fully qualified sub
23694                                      name of 'name' */
23695     SV * fq_name = NULL;        /* For user-defined properties, the fully
23696                                    qualified name */
23697     bool invert_return = FALSE; /* ? Do we need to complement the result before
23698                                      returning it */
23699     bool stripped_utf8_pkg = FALSE; /* Set TRUE if the input includes an
23700                                        explicit utf8:: package that we strip
23701                                        off  */
23702     /* The expansion of properties that could be either user-defined or
23703      * official unicode ones is deferred until runtime, including a marker for
23704      * those that might be in the latter category.  This boolean indicates if
23705      * we've seen that marker.  If not, what we're parsing can't be such an
23706      * official Unicode property whose expansion was deferred */
23707     bool could_be_deferred_official = FALSE;
23708
23709     PERL_ARGS_ASSERT_PARSE_UNIPROP_STRING;
23710
23711     /* The input will be normalized into 'lookup_name' */
23712     Newx(lookup_name, name_len, char);
23713     SAVEFREEPV(lookup_name);
23714
23715     /* Parse the input. */
23716     for (i = 0; i < name_len; i++) {
23717         char cur = name[i];
23718
23719         /* Most of the characters in the input will be of this ilk, being parts
23720          * of a name */
23721         if (isIDCONT_A(cur)) {
23722
23723             /* Case differences are ignored.  Our lookup routine assumes
23724              * everything is lowercase, so normalize to that */
23725             if (isUPPER_A(cur)) {
23726                 lookup_name[j++] = toLOWER_A(cur);
23727                 continue;
23728             }
23729
23730             if (cur == '_') { /* Don't include these in the normalized name */
23731                 continue;
23732             }
23733
23734             lookup_name[j++] = cur;
23735
23736             /* The first character in a user-defined name must be of this type.
23737              * */
23738             if (i - non_pkg_begin == 0 && ! isIDFIRST_A(cur)) {
23739                 could_be_user_defined = FALSE;
23740             }
23741
23742             continue;
23743         }
23744
23745         /* Here, the character is not something typically in a name,  But these
23746          * two types of characters (and the '_' above) can be freely ignored in
23747          * most situations.  Later it may turn out we shouldn't have ignored
23748          * them, and we have to reparse, but we don't have enough information
23749          * yet to make that decision */
23750         if (cur == '-' || isSPACE_A(cur)) {
23751             could_be_user_defined = FALSE;
23752             continue;
23753         }
23754
23755         /* An equals sign or single colon mark the end of the first part of
23756          * the property name */
23757         if (    cur == '='
23758             || (cur == ':' && (i >= name_len - 1 || name[i+1] != ':')))
23759         {
23760             lookup_name[j++] = '='; /* Treat the colon as an '=' */
23761             equals_pos = j; /* Note where it occurred in the input */
23762             could_be_user_defined = FALSE;
23763             break;
23764         }
23765
23766         /* If this looks like it is a marker we inserted at compile time,
23767          * set a flag and otherwise ignore it.  If it isn't in the final
23768          * position, keep it as it would have been user input. */
23769         if (     UNLIKELY(cur == DEFERRED_COULD_BE_OFFICIAL_MARKERc)
23770             && ! deferrable
23771             &&   could_be_user_defined
23772             &&   i == name_len - 1)
23773         {
23774             name_len--;
23775             could_be_deferred_official = TRUE;
23776             continue;
23777         }
23778
23779         /* Otherwise, this character is part of the name. */
23780         lookup_name[j++] = cur;
23781
23782         /* Here it isn't a single colon, so if it is a colon, it must be a
23783          * double colon */
23784         if (cur == ':') {
23785
23786             /* A double colon should be a package qualifier.  We note its
23787              * position and continue.  Note that one could have
23788              *      pkg1::pkg2::...::foo
23789              * so that the position at the end of the loop will be just after
23790              * the final qualifier */
23791
23792             i++;
23793             non_pkg_begin = i + 1;
23794             lookup_name[j++] = ':';
23795             lun_non_pkg_begin = j;
23796         }
23797         else { /* Only word chars (and '::') can be in a user-defined name */
23798             could_be_user_defined = FALSE;
23799         }
23800     } /* End of parsing through the lhs of the property name (or all of it if
23801          no rhs) */
23802
23803 #  define STRLENs(s)  (sizeof("" s "") - 1)
23804
23805     /* If there is a single package name 'utf8::', it is ambiguous.  It could
23806      * be for a user-defined property, or it could be a Unicode property, as
23807      * all of them are considered to be for that package.  For the purposes of
23808      * parsing the rest of the property, strip it off */
23809     if (non_pkg_begin == STRLENs("utf8::") && memBEGINPs(name, name_len, "utf8::")) {
23810         lookup_name +=  STRLENs("utf8::");
23811         j -=  STRLENs("utf8::");
23812         equals_pos -=  STRLENs("utf8::");
23813         stripped_utf8_pkg = TRUE;
23814     }
23815
23816     /* Here, we are either done with the whole property name, if it was simple;
23817      * or are positioned just after the '=' if it is compound. */
23818
23819     if (equals_pos >= 0) {
23820         assert(stricter == Not_Strict); /* We shouldn't have set this yet */
23821
23822         /* Space immediately after the '=' is ignored */
23823         i++;
23824         for (; i < name_len; i++) {
23825             if (! isSPACE_A(name[i])) {
23826                 break;
23827             }
23828         }
23829
23830         /* Most punctuation after the equals indicates a subpattern, like
23831          * \p{foo=/bar/} */
23832         if (   isPUNCT_A(name[i])
23833             &&  name[i] != '-'
23834             &&  name[i] != '+'
23835             &&  name[i] != '_'
23836             &&  name[i] != '{'
23837                 /* A backslash means the real delimitter is the next character,
23838                  * but it must be punctuation */
23839             && (name[i] != '\\' || (i < name_len && isPUNCT_A(name[i+1]))))
23840         {
23841             bool special_property = memEQs(lookup_name, j - 1, "name")
23842                                  || memEQs(lookup_name, j - 1, "na");
23843             if (! special_property) {
23844                 /* Find the property.  The table includes the equals sign, so
23845                  * we use 'j' as-is */
23846                 table_index = do_uniprop_match(lookup_name, j);
23847             }
23848             if (special_property || table_index) {
23849                 REGEXP * subpattern_re;
23850                 char open = name[i++];
23851                 char close;
23852                 const char * pos_in_brackets;
23853                 const char * const * prop_values;
23854                 bool escaped = 0;
23855
23856                 /* Backslash => delimitter is the character following.  We
23857                  * already checked that it is punctuation */
23858                 if (open == '\\') {
23859                     open = name[i++];
23860                     escaped = 1;
23861                 }
23862
23863                 /* This data structure is constructed so that the matching
23864                  * closing bracket is 3 past its matching opening.  The second
23865                  * set of closing is so that if the opening is something like
23866                  * ']', the closing will be that as well.  Something similar is
23867                  * done in toke.c */
23868                 pos_in_brackets = memCHRs("([<)]>)]>", open);
23869                 close = (pos_in_brackets) ? pos_in_brackets[3] : open;
23870
23871                 if (    i >= name_len
23872                     ||  name[name_len-1] != close
23873                     || (escaped && name[name_len-2] != '\\')
23874                         /* Also make sure that there are enough characters.
23875                          * e.g., '\\\' would show up incorrectly as legal even
23876                          * though it is too short */
23877                     || (SSize_t) (name_len - i - 1 - escaped) < 0)
23878                 {
23879                     sv_catpvs(msg, "Unicode property wildcard not terminated");
23880                     goto append_name_to_msg;
23881                 }
23882
23883                 Perl_ck_warner_d(aTHX_
23884                     packWARN(WARN_EXPERIMENTAL__UNIPROP_WILDCARDS),
23885                     "The Unicode property wildcards feature is experimental");
23886
23887                 if (special_property) {
23888                     const char * error_msg;
23889                     const char * revised_name = name + i;
23890                     Size_t revised_name_len = name_len - (i + 1 + escaped);
23891
23892                     /* Currently, the only 'special_property' is name, which we
23893                      * lookup in _charnames.pm */
23894
23895                     if (! load_charnames(newSVpvs("placeholder"),
23896                                          revised_name, revised_name_len,
23897                                          &error_msg))
23898                     {
23899                         sv_catpv(msg, error_msg);
23900                         goto append_name_to_msg;
23901                     }
23902
23903                     /* Farm this out to a function just to make the current
23904                      * function less unwieldy */
23905                     if (handle_names_wildcard(revised_name, revised_name_len,
23906                                               &prop_definition,
23907                                               strings))
23908                     {
23909                         return prop_definition;
23910                     }
23911
23912                     goto failed;
23913                 }
23914
23915                 prop_values = get_prop_values(table_index);
23916
23917                 /* Now create and compile the wildcard subpattern.  Use /i
23918                  * because the property values are supposed to match with case
23919                  * ignored. */
23920                 subpattern_re = compile_wildcard(name + i,
23921                                                  name_len - i - 1 - escaped,
23922                                                  TRUE /* /i */
23923                                                 );
23924
23925                 /* For each legal property value, see if the supplied pattern
23926                  * matches it. */
23927                 while (*prop_values) {
23928                     const char * const entry = *prop_values;
23929                     const Size_t len = strlen(entry);
23930                     SV* entry_sv = newSVpvn_flags(entry, len, SVs_TEMP);
23931
23932                     if (execute_wildcard(subpattern_re,
23933                                  (char *) entry,
23934                                  (char *) entry + len,
23935                                  (char *) entry, 0,
23936                                  entry_sv,
23937                                  0))
23938                     { /* Here, matched.  Add to the returned list */
23939                         Size_t total_len = j + len;
23940                         SV * sub_invlist = NULL;
23941                         char * this_string;
23942
23943                         /* We know this is a legal \p{property=value}.  Call
23944                          * the function to return the list of code points that
23945                          * match it */
23946                         Newxz(this_string, total_len + 1, char);
23947                         Copy(lookup_name, this_string, j, char);
23948                         my_strlcat(this_string, entry, total_len + 1);
23949                         SAVEFREEPV(this_string);
23950                         sub_invlist = parse_uniprop_string(this_string,
23951                                                            total_len,
23952                                                            is_utf8,
23953                                                            to_fold,
23954                                                            runtime,
23955                                                            deferrable,
23956                                                            NULL,
23957                                                            user_defined_ptr,
23958                                                            msg,
23959                                                            level + 1);
23960                         _invlist_union(prop_definition, sub_invlist,
23961                                        &prop_definition);
23962                     }
23963
23964                     prop_values++;  /* Next iteration, look at next propvalue */
23965                 } /* End of looking through property values; (the data
23966                      structure is terminated by a NULL ptr) */
23967
23968                 SvREFCNT_dec_NN(subpattern_re);
23969
23970                 if (prop_definition) {
23971                     return prop_definition;
23972                 }
23973
23974                 sv_catpvs(msg, "No Unicode property value wildcard matches:");
23975                 goto append_name_to_msg;
23976             }
23977
23978             /* Here's how khw thinks we should proceed to handle the properties
23979              * not yet done:    Bidi Mirroring Glyph        can map to ""
23980                                 Bidi Paired Bracket         can map to ""
23981                                 Case Folding  (both full and simple)
23982                                             Shouldn't /i be good enough for Full
23983                                 Decomposition Mapping
23984                                 Equivalent Unified Ideograph    can map to ""
23985                                 Lowercase Mapping  (both full and simple)
23986                                 NFKC Case Fold                  can map to ""
23987                                 Titlecase Mapping  (both full and simple)
23988                                 Uppercase Mapping  (both full and simple)
23989              * Handle these the same way Name is done, using say, _wild.pm, but
23990              * having both loose and full, like in charclass_invlists.h.
23991              * Perhaps move block and script to that as they are somewhat large
23992              * in charclass_invlists.h.
23993              * For properties where the default is the code point itself, such
23994              * as any of the case changing mappings, the string would otherwise
23995              * consist of all Unicode code points in UTF-8 strung together.
23996              * This would be impractical.  So instead, examine their compiled
23997              * pattern, looking at the ssc.  If none, reject the pattern as an
23998              * error.  Otherwise run the pattern against every code point in
23999              * the ssc.  The ssc is kind of like tr18's 3.9 Possible Match Sets
24000              * And it might be good to create an API to return the ssc.
24001              * Or handle them like the algorithmic names are done
24002              */
24003         } /* End of is a wildcard subppattern */
24004
24005         /* \p{name=...} is handled specially.  Instead of using the normal
24006          * mechanism involving charclass_invlists.h, it uses _charnames.pm
24007          * which has the necessary (huge) data accessible to it, and which
24008          * doesn't get loaded unless necessary.  The legal syntax for names is
24009          * somewhat different than other properties due both to the vagaries of
24010          * a few outlier official names, and the fact that only a few ASCII
24011          * characters are permitted in them */
24012         if (   memEQs(lookup_name, j - 1, "name")
24013             || memEQs(lookup_name, j - 1, "na"))
24014         {
24015             dSP;
24016             HV * table;
24017             SV * character;
24018             const char * error_msg;
24019             CV* lookup_loose;
24020             SV * character_name;
24021             STRLEN character_len;
24022             UV cp;
24023
24024             stricter = As_Is;
24025
24026             /* Since the RHS (after skipping initial space) is passed unchanged
24027              * to charnames, and there are different criteria for what are
24028              * legal characters in the name, just parse it here.  A character
24029              * name must begin with an ASCII alphabetic */
24030             if (! isALPHA(name[i])) {
24031                 goto failed;
24032             }
24033             lookup_name[j++] = name[i];
24034
24035             for (++i; i < name_len; i++) {
24036                 /* Official names can only be in the ASCII range, and only
24037                  * certain characters */
24038                 if (! isASCII(name[i]) || ! isCHARNAME_CONT(name[i])) {
24039                     goto failed;
24040                 }
24041                 lookup_name[j++] = name[i];
24042             }
24043
24044             /* Finished parsing, save the name into an SV */
24045             character_name = newSVpvn(lookup_name + equals_pos, j - equals_pos);
24046
24047             /* Make sure _charnames is loaded.  (The parameters give context
24048              * for any errors generated */
24049             table = load_charnames(character_name, name, name_len, &error_msg);
24050             if (table == NULL) {
24051                 sv_catpv(msg, error_msg);
24052                 goto append_name_to_msg;
24053             }
24054
24055             lookup_loose = get_cvs("_charnames::_loose_regcomp_lookup", 0);
24056             if (! lookup_loose) {
24057                 Perl_croak(aTHX_
24058                        "panic: Can't find '_charnames::_loose_regcomp_lookup");
24059             }
24060
24061             PUSHSTACKi(PERLSI_REGCOMP);
24062             ENTER ;
24063             SAVETMPS;
24064             save_re_context();
24065
24066             PUSHMARK(SP) ;
24067             XPUSHs(character_name);
24068             PUTBACK;
24069             call_sv(MUTABLE_SV(lookup_loose), G_SCALAR);
24070
24071             SPAGAIN ;
24072
24073             character = POPs;
24074             SvREFCNT_inc_simple_void_NN(character);
24075
24076             PUTBACK ;
24077             FREETMPS ;
24078             LEAVE ;
24079             POPSTACK;
24080
24081             if (! SvOK(character)) {
24082                 goto failed;
24083             }
24084
24085             cp = valid_utf8_to_uvchr((U8 *) SvPVX(character), &character_len);
24086             if (character_len == SvCUR(character)) {
24087                 prop_definition = add_cp_to_invlist(NULL, cp);
24088             }
24089             else {
24090                 AV * this_string;
24091
24092                 /* First of the remaining characters in the string. */
24093                 char * remaining = SvPVX(character) + character_len;
24094
24095                 if (strings == NULL) {
24096                     goto failed;    /* XXX Perhaps a specific msg instead, like
24097                                        'not available here' */
24098                 }
24099
24100                 if (*strings == NULL) {
24101                     *strings = newAV();
24102                 }
24103
24104                 this_string = newAV();
24105                 av_push(this_string, newSVuv(cp));
24106
24107                 do {
24108                     cp = valid_utf8_to_uvchr((U8 *) remaining, &character_len);
24109                     av_push(this_string, newSVuv(cp));
24110                     remaining += character_len;
24111                 } while (remaining < SvEND(character));
24112
24113                 av_push(*strings, (SV *) this_string);
24114             }
24115
24116             return prop_definition;
24117         }
24118
24119         /* Certain properties whose values are numeric need special handling.
24120          * They may optionally be prefixed by 'is'.  Ignore that prefix for the
24121          * purposes of checking if this is one of those properties */
24122         if (memBEGINPs(lookup_name, j, "is")) {
24123             lookup_offset = 2;
24124         }
24125
24126         /* Then check if it is one of these specially-handled properties.  The
24127          * possibilities are hard-coded because easier this way, and the list
24128          * is unlikely to change.
24129          *
24130          * All numeric value type properties are of this ilk, and are also
24131          * special in a different way later on.  So find those first.  There
24132          * are several numeric value type properties in the Unihan DB (which is
24133          * unlikely to be compiled with perl, but we handle it here in case it
24134          * does get compiled).  They all end with 'numeric'.  The interiors
24135          * aren't checked for the precise property.  This would stop working if
24136          * a cjk property were to be created that ended with 'numeric' and
24137          * wasn't a numeric type */
24138         is_nv_type = memEQs(lookup_name + lookup_offset,
24139                        j - 1 - lookup_offset, "numericvalue")
24140                   || memEQs(lookup_name + lookup_offset,
24141                       j - 1 - lookup_offset, "nv")
24142                   || (   memENDPs(lookup_name + lookup_offset,
24143                             j - 1 - lookup_offset, "numeric")
24144                       && (   memBEGINPs(lookup_name + lookup_offset,
24145                                       j - 1 - lookup_offset, "cjk")
24146                           || memBEGINPs(lookup_name + lookup_offset,
24147                                       j - 1 - lookup_offset, "k")));
24148         if (   is_nv_type
24149             || memEQs(lookup_name + lookup_offset,
24150                       j - 1 - lookup_offset, "canonicalcombiningclass")
24151             || memEQs(lookup_name + lookup_offset,
24152                       j - 1 - lookup_offset, "ccc")
24153             || memEQs(lookup_name + lookup_offset,
24154                       j - 1 - lookup_offset, "age")
24155             || memEQs(lookup_name + lookup_offset,
24156                       j - 1 - lookup_offset, "in")
24157             || memEQs(lookup_name + lookup_offset,
24158                       j - 1 - lookup_offset, "presentin"))
24159         {
24160             unsigned int k;
24161
24162             /* Since the stuff after the '=' is a number, we can't throw away
24163              * '-' willy-nilly, as those could be a minus sign.  Other stricter
24164              * rules also apply.  However, these properties all can have the
24165              * rhs not be a number, in which case they contain at least one
24166              * alphabetic.  In those cases, the stricter rules don't apply.
24167              * But the numeric type properties can have the alphas [Ee] to
24168              * signify an exponent, and it is still a number with stricter
24169              * rules.  So look for an alpha that signifies not-strict */
24170             stricter = Strict;
24171             for (k = i; k < name_len; k++) {
24172                 if (   isALPHA_A(name[k])
24173                     && (! is_nv_type || ! isALPHA_FOLD_EQ(name[k], 'E')))
24174                 {
24175                     stricter = Not_Strict;
24176                     break;
24177                 }
24178             }
24179         }
24180
24181         if (stricter) {
24182
24183             /* A number may have a leading '+' or '-'.  The latter is retained
24184              * */
24185             if (name[i] == '+') {
24186                 i++;
24187             }
24188             else if (name[i] == '-') {
24189                 lookup_name[j++] = '-';
24190                 i++;
24191             }
24192
24193             /* Skip leading zeros including single underscores separating the
24194              * zeros, or between the final leading zero and the first other
24195              * digit */
24196             for (; i < name_len - 1; i++) {
24197                 if (    name[i] != '0'
24198                     && (name[i] != '_' || ! isDIGIT_A(name[i+1])))
24199                 {
24200                     break;
24201                 }
24202             }
24203         }
24204     }
24205     else {  /* No '=' */
24206
24207        /* Only a few properties without an '=' should be parsed with stricter
24208         * rules.  The list is unlikely to change. */
24209         if (   memBEGINPs(lookup_name, j, "perl")
24210             && memNEs(lookup_name + 4, j - 4, "space")
24211             && memNEs(lookup_name + 4, j - 4, "word"))
24212         {
24213             stricter = Strict;
24214
24215             /* We set the inputs back to 0 and the code below will reparse,
24216              * using strict */
24217             i = j = 0;
24218         }
24219     }
24220
24221     /* Here, we have either finished the property, or are positioned to parse
24222      * the remainder, and we know if stricter rules apply.  Finish out, if not
24223      * already done */
24224     for (; i < name_len; i++) {
24225         char cur = name[i];
24226
24227         /* In all instances, case differences are ignored, and we normalize to
24228          * lowercase */
24229         if (isUPPER_A(cur)) {
24230             lookup_name[j++] = toLOWER(cur);
24231             continue;
24232         }
24233
24234         /* An underscore is skipped, but not under strict rules unless it
24235          * separates two digits */
24236         if (cur == '_') {
24237             if (    stricter
24238                 && (     i == 0 || (int) i == equals_pos || i == name_len- 1
24239                     || ! isDIGIT_A(name[i-1]) || ! isDIGIT_A(name[i+1])))
24240             {
24241                 lookup_name[j++] = '_';
24242             }
24243             continue;
24244         }
24245
24246         /* Hyphens are skipped except under strict */
24247         if (cur == '-' && ! stricter) {
24248             continue;
24249         }
24250
24251         /* XXX Bug in documentation.  It says white space skipped adjacent to
24252          * non-word char.  Maybe we should, but shouldn't skip it next to a dot
24253          * in a number */
24254         if (isSPACE_A(cur) && ! stricter) {
24255             continue;
24256         }
24257
24258         lookup_name[j++] = cur;
24259
24260         /* Unless this is a non-trailing slash, we are done with it */
24261         if (i >= name_len - 1 || cur != '/') {
24262             continue;
24263         }
24264
24265         slash_pos = j;
24266
24267         /* A slash in the 'numeric value' property indicates that what follows
24268          * is a denominator.  It can have a leading '+' and '0's that should be
24269          * skipped.  But we have never allowed a negative denominator, so treat
24270          * a minus like every other character.  (No need to rule out a second
24271          * '/', as that won't match anything anyway */
24272         if (is_nv_type) {
24273             i++;
24274             if (i < name_len && name[i] == '+') {
24275                 i++;
24276             }
24277
24278             /* Skip leading zeros including underscores separating digits */
24279             for (; i < name_len - 1; i++) {
24280                 if (   name[i] != '0'
24281                     && (name[i] != '_' || ! isDIGIT_A(name[i+1])))
24282                 {
24283                     break;
24284                 }
24285             }
24286
24287             /* Store the first real character in the denominator */
24288             if (i < name_len) {
24289                 lookup_name[j++] = name[i];
24290             }
24291         }
24292     }
24293
24294     /* Here are completely done parsing the input 'name', and 'lookup_name'
24295      * contains a copy, normalized.
24296      *
24297      * This special case is grandfathered in: 'L_' and 'GC=L_' are accepted and
24298      * different from without the underscores.  */
24299     if (  (   UNLIKELY(memEQs(lookup_name, j, "l"))
24300            || UNLIKELY(memEQs(lookup_name, j, "gc=l")))
24301         && UNLIKELY(name[name_len-1] == '_'))
24302     {
24303         lookup_name[j++] = '&';
24304     }
24305
24306     /* If the original input began with 'In' or 'Is', it could be a subroutine
24307      * call to a user-defined property instead of a Unicode property name. */
24308     if (    name_len - non_pkg_begin > 2
24309         &&  name[non_pkg_begin+0] == 'I'
24310         && (name[non_pkg_begin+1] == 'n' || name[non_pkg_begin+1] == 's'))
24311     {
24312         /* Names that start with In have different characterstics than those
24313          * that start with Is */
24314         if (name[non_pkg_begin+1] == 's') {
24315             starts_with_Is = TRUE;
24316         }
24317     }
24318     else {
24319         could_be_user_defined = FALSE;
24320     }
24321
24322     if (could_be_user_defined) {
24323         CV* user_sub;
24324
24325         /* If the user defined property returns the empty string, it could
24326          * easily be because the pattern is being compiled before the data it
24327          * actually needs to compile is available.  This could be argued to be
24328          * a bug in the perl code, but this is a change of behavior for Perl,
24329          * so we handle it.  This means that intentionally returning nothing
24330          * will not be resolved until runtime */
24331         bool empty_return = FALSE;
24332
24333         /* Here, the name could be for a user defined property, which are
24334          * implemented as subs. */
24335         user_sub = get_cvn_flags(name, name_len, 0);
24336         if (! user_sub) {
24337
24338             /* Here, the property name could be a user-defined one, but there
24339              * is no subroutine to handle it (as of now).   Defer handling it
24340              * until runtime.  Otherwise, a block defined by Unicode in a later
24341              * release would get the synonym InFoo added for it, and existing
24342              * code that used that name would suddenly break if it referred to
24343              * the property before the sub was declared.  See [perl #134146] */
24344             if (deferrable) {
24345                 goto definition_deferred;
24346             }
24347
24348             /* Here, we are at runtime, and didn't find the user property.  It
24349              * could be an official property, but only if no package was
24350              * specified, or just the utf8:: package. */
24351             if (could_be_deferred_official) {
24352                 lookup_name += lun_non_pkg_begin;
24353                 j -= lun_non_pkg_begin;
24354             }
24355             else if (! stripped_utf8_pkg) {
24356                 goto unknown_user_defined;
24357             }
24358
24359             /* Drop down to look up in the official properties */
24360         }
24361         else {
24362             const char insecure[] = "Insecure user-defined property";
24363
24364             /* Here, there is a sub by the correct name.  Normally we call it
24365              * to get the property definition */
24366             dSP;
24367             SV * user_sub_sv = MUTABLE_SV(user_sub);
24368             SV * error;     /* Any error returned by calling 'user_sub' */
24369             SV * key;       /* The key into the hash of user defined sub names
24370                              */
24371             SV * placeholder;
24372             SV ** saved_user_prop_ptr;      /* Hash entry for this property */
24373
24374             /* How many times to retry when another thread is in the middle of
24375              * expanding the same definition we want */
24376             PERL_INT_FAST8_T retry_countdown = 10;
24377
24378             DECLARATION_FOR_GLOBAL_CONTEXT;
24379
24380             /* If we get here, we know this property is user-defined */
24381             *user_defined_ptr = TRUE;
24382
24383             /* We refuse to call a potentially tainted subroutine; returning an
24384              * error instead */
24385             if (TAINT_get) {
24386                 if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
24387                 sv_catpvn(msg, insecure, sizeof(insecure) - 1);
24388                 goto append_name_to_msg;
24389             }
24390
24391             /* In principal, we only call each subroutine property definition
24392              * once during the life of the program.  This guarantees that the
24393              * property definition never changes.  The results of the single
24394              * sub call are stored in a hash, which is used instead for future
24395              * references to this property.  The property definition is thus
24396              * immutable.  But, to allow the user to have a /i-dependent
24397              * definition, we call the sub once for non-/i, and once for /i,
24398              * should the need arise, passing the /i status as a parameter.
24399              *
24400              * We start by constructing the hash key name, consisting of the
24401              * fully qualified subroutine name, preceded by the /i status, so
24402              * that there is a key for /i and a different key for non-/i */
24403             key = newSVpvn(((to_fold) ? "1" : "0"), 1);
24404             fq_name = S_get_fq_name(aTHX_ name, name_len, is_utf8,
24405                                           non_pkg_begin != 0);
24406             sv_catsv(key, fq_name);
24407             sv_2mortal(key);
24408
24409             /* We only call the sub once throughout the life of the program
24410              * (with the /i, non-/i exception noted above).  That means the
24411              * hash must be global and accessible to all threads.  It is
24412              * created at program start-up, before any threads are created, so
24413              * is accessible to all children.  But this creates some
24414              * complications.
24415              *
24416              * 1) The keys can't be shared, or else problems arise; sharing is
24417              *    turned off at hash creation time
24418              * 2) All SVs in it are there for the remainder of the life of the
24419              *    program, and must be created in the same interpreter context
24420              *    as the hash, or else they will be freed from the wrong pool
24421              *    at global destruction time.  This is handled by switching to
24422              *    the hash's context to create each SV going into it, and then
24423              *    immediately switching back
24424              * 3) All accesses to the hash must be controlled by a mutex, to
24425              *    prevent two threads from getting an unstable state should
24426              *    they simultaneously be accessing it.  The code below is
24427              *    crafted so that the mutex is locked whenever there is an
24428              *    access and unlocked only when the next stable state is
24429              *    achieved.
24430              *
24431              * The hash stores either the definition of the property if it was
24432              * valid, or, if invalid, the error message that was raised.  We
24433              * use the type of SV to distinguish.
24434              *
24435              * There's also the need to guard against the definition expansion
24436              * from infinitely recursing.  This is handled by storing the aTHX
24437              * of the expanding thread during the expansion.  Again the SV type
24438              * is used to distinguish this from the other two cases.  If we
24439              * come to here and the hash entry for this property is our aTHX,
24440              * it means we have recursed, and the code assumes that we would
24441              * infinitely recurse, so instead stops and raises an error.
24442              * (Any recursion has always been treated as infinite recursion in
24443              * this feature.)
24444              *
24445              * If instead, the entry is for a different aTHX, it means that
24446              * that thread has gotten here first, and hasn't finished expanding
24447              * the definition yet.  We just have to wait until it is done.  We
24448              * sleep and retry a few times, returning an error if the other
24449              * thread doesn't complete. */
24450
24451           re_fetch:
24452             USER_PROP_MUTEX_LOCK;
24453
24454             /* If we have an entry for this key, the subroutine has already
24455              * been called once with this /i status. */
24456             saved_user_prop_ptr = hv_fetch(PL_user_def_props,
24457                                                    SvPVX(key), SvCUR(key), 0);
24458             if (saved_user_prop_ptr) {
24459
24460                 /* If the saved result is an inversion list, it is the valid
24461                  * definition of this property */
24462                 if (is_invlist(*saved_user_prop_ptr)) {
24463                     prop_definition = *saved_user_prop_ptr;
24464
24465                     /* The SV in the hash won't be removed until global
24466                      * destruction, so it is stable and we can unlock */
24467                     USER_PROP_MUTEX_UNLOCK;
24468
24469                     /* The caller shouldn't try to free this SV */
24470                     return prop_definition;
24471                 }
24472
24473                 /* Otherwise, if it is a string, it is the error message
24474                  * that was returned when we first tried to evaluate this
24475                  * property.  Fail, and append the message */
24476                 if (SvPOK(*saved_user_prop_ptr)) {
24477                     if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
24478                     sv_catsv(msg, *saved_user_prop_ptr);
24479
24480                     /* The SV in the hash won't be removed until global
24481                      * destruction, so it is stable and we can unlock */
24482                     USER_PROP_MUTEX_UNLOCK;
24483
24484                     return NULL;
24485                 }
24486
24487                 assert(SvIOK(*saved_user_prop_ptr));
24488
24489                 /* Here, we have an unstable entry in the hash.  Either another
24490                  * thread is in the middle of expanding the property's
24491                  * definition, or we are ourselves recursing.  We use the aTHX
24492                  * in it to distinguish */
24493                 if (SvIV(*saved_user_prop_ptr) != PTR2IV(CUR_CONTEXT)) {
24494
24495                     /* Here, it's another thread doing the expanding.  We've
24496                      * looked as much as we are going to at the contents of the
24497                      * hash entry.  It's safe to unlock. */
24498                     USER_PROP_MUTEX_UNLOCK;
24499
24500                     /* Retry a few times */
24501                     if (retry_countdown-- > 0) {
24502                         PerlProc_sleep(1);
24503                         goto re_fetch;
24504                     }
24505
24506                     if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
24507                     sv_catpvs(msg, "Timeout waiting for another thread to "
24508                                    "define");
24509                     goto append_name_to_msg;
24510                 }
24511
24512                 /* Here, we are recursing; don't dig any deeper */
24513                 USER_PROP_MUTEX_UNLOCK;
24514
24515                 if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
24516                 sv_catpvs(msg,
24517                           "Infinite recursion in user-defined property");
24518                 goto append_name_to_msg;
24519             }
24520
24521             /* Here, this thread has exclusive control, and there is no entry
24522              * for this property in the hash.  So we have the go ahead to
24523              * expand the definition ourselves. */
24524
24525             PUSHSTACKi(PERLSI_REGCOMP);
24526             ENTER;
24527
24528             /* Create a temporary placeholder in the hash to detect recursion
24529              * */
24530             SWITCH_TO_GLOBAL_CONTEXT;
24531             placeholder= newSVuv(PTR2IV(ORIGINAL_CONTEXT));
24532             (void) hv_store_ent(PL_user_def_props, key, placeholder, 0);
24533             RESTORE_CONTEXT;
24534
24535             /* Now that we have a placeholder, we can let other threads
24536              * continue */
24537             USER_PROP_MUTEX_UNLOCK;
24538
24539             /* Make sure the placeholder always gets destroyed */
24540             SAVEDESTRUCTOR_X(S_delete_recursion_entry, SvPVX(key));
24541
24542             PUSHMARK(SP);
24543             SAVETMPS;
24544
24545             /* Call the user's function, with the /i status as a parameter.
24546              * Note that we have gone to a lot of trouble to keep this call
24547              * from being within the locked mutex region. */
24548             XPUSHs(boolSV(to_fold));
24549             PUTBACK;
24550
24551             /* The following block was taken from swash_init().  Presumably
24552              * they apply to here as well, though we no longer use a swash --
24553              * khw */
24554             SAVEHINTS();
24555             save_re_context();
24556             /* We might get here via a subroutine signature which uses a utf8
24557              * parameter name, at which point PL_subname will have been set
24558              * but not yet used. */
24559             save_item(PL_subname);
24560
24561             /* G_SCALAR guarantees a single return value */
24562             (void) call_sv(user_sub_sv, G_EVAL|G_SCALAR);
24563
24564             SPAGAIN;
24565
24566             error = ERRSV;
24567             if (TAINT_get || SvTRUE(error)) {
24568                 if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
24569                 if (SvTRUE(error)) {
24570                     sv_catpvs(msg, "Error \"");
24571                     sv_catsv(msg, error);
24572                     sv_catpvs(msg, "\"");
24573                 }
24574                 if (TAINT_get) {
24575                     if (SvTRUE(error)) sv_catpvs(msg, "; ");
24576                     sv_catpvn(msg, insecure, sizeof(insecure) - 1);
24577                 }
24578
24579                 if (name_len > 0) {
24580                     sv_catpvs(msg, " in expansion of ");
24581                     Perl_sv_catpvf(aTHX_ msg, "%" UTF8f, UTF8fARG(is_utf8,
24582                                                                   name_len,
24583                                                                   name));
24584                 }
24585
24586                 (void) POPs;
24587                 prop_definition = NULL;
24588             }
24589             else {
24590                 SV * contents = POPs;
24591
24592                 /* The contents is supposed to be the expansion of the property
24593                  * definition.  If the definition is deferrable, and we got an
24594                  * empty string back, set a flag to later defer it (after clean
24595                  * up below). */
24596                 if (      deferrable
24597                     && (! SvPOK(contents) || SvCUR(contents) == 0))
24598                 {
24599                         empty_return = TRUE;
24600                 }
24601                 else { /* Otherwise, call a function to check for valid syntax,
24602                           and handle it */
24603
24604                     prop_definition = handle_user_defined_property(
24605                                                     name, name_len,
24606                                                     is_utf8, to_fold, runtime,
24607                                                     deferrable,
24608                                                     contents, user_defined_ptr,
24609                                                     msg,
24610                                                     level);
24611                 }
24612             }
24613
24614             /* Here, we have the results of the expansion.  Delete the
24615              * placeholder, and if the definition is now known, replace it with
24616              * that definition.  We need exclusive access to the hash, and we
24617              * can't let anyone else in, between when we delete the placeholder
24618              * and add the permanent entry */
24619             USER_PROP_MUTEX_LOCK;
24620
24621             S_delete_recursion_entry(aTHX_ SvPVX(key));
24622
24623             if (    ! empty_return
24624                 && (! prop_definition || is_invlist(prop_definition)))
24625             {
24626                 /* If we got success we use the inversion list defining the
24627                  * property; otherwise use the error message */
24628                 SWITCH_TO_GLOBAL_CONTEXT;
24629                 (void) hv_store_ent(PL_user_def_props,
24630                                     key,
24631                                     ((prop_definition)
24632                                      ? newSVsv(prop_definition)
24633                                      : newSVsv(msg)),
24634                                     0);
24635                 RESTORE_CONTEXT;
24636             }
24637
24638             /* All done, and the hash now has a permanent entry for this
24639              * property.  Give up exclusive control */
24640             USER_PROP_MUTEX_UNLOCK;
24641
24642             FREETMPS;
24643             LEAVE;
24644             POPSTACK;
24645
24646             if (empty_return) {
24647                 goto definition_deferred;
24648             }
24649
24650             if (prop_definition) {
24651
24652                 /* If the definition is for something not known at this time,
24653                  * we toss it, and go return the main property name, as that's
24654                  * the one the user will be aware of */
24655                 if (! is_invlist(prop_definition)) {
24656                     SvREFCNT_dec_NN(prop_definition);
24657                     goto definition_deferred;
24658                 }
24659
24660                 sv_2mortal(prop_definition);
24661             }
24662
24663             /* And return */
24664             return prop_definition;
24665
24666         }   /* End of calling the subroutine for the user-defined property */
24667     }       /* End of it could be a user-defined property */
24668
24669     /* Here it wasn't a user-defined property that is known at this time.  See
24670      * if it is a Unicode property */
24671
24672     lookup_len = j;     /* This is a more mnemonic name than 'j' */
24673
24674     /* Get the index into our pointer table of the inversion list corresponding
24675      * to the property */
24676     table_index = do_uniprop_match(lookup_name, lookup_len);
24677
24678     /* If it didn't find the property ... */
24679     if (table_index == 0) {
24680
24681         /* Try again stripping off any initial 'Is'.  This is because we
24682          * promise that an initial Is is optional.  The same isn't true of
24683          * names that start with 'In'.  Those can match only blocks, and the
24684          * lookup table already has those accounted for.  The lookup table also
24685          * has already accounted for Perl extensions (without and = sign)
24686          * starting with 'i's'. */
24687         if (starts_with_Is && equals_pos >= 0) {
24688             lookup_name += 2;
24689             lookup_len -= 2;
24690             equals_pos -= 2;
24691             slash_pos -= 2;
24692
24693             table_index = do_uniprop_match(lookup_name, lookup_len);
24694         }
24695
24696         if (table_index == 0) {
24697             char * canonical;
24698
24699             /* Here, we didn't find it.  If not a numeric type property, and
24700              * can't be a user-defined one, it isn't a legal property */
24701             if (! is_nv_type) {
24702                 if (! could_be_user_defined) {
24703                     goto failed;
24704                 }
24705
24706                 /* Here, the property name is legal as a user-defined one.   At
24707                  * compile time, it might just be that the subroutine for that
24708                  * property hasn't been encountered yet, but at runtime, it's
24709                  * an error to try to use an undefined one */
24710                 if (! deferrable) {
24711                     goto unknown_user_defined;;
24712                 }
24713
24714                 goto definition_deferred;
24715             } /* End of isn't a numeric type property */
24716
24717             /* The numeric type properties need more work to decide.  What we
24718              * do is make sure we have the number in canonical form and look
24719              * that up. */
24720
24721             if (slash_pos < 0) {    /* No slash */
24722
24723                 /* When it isn't a rational, take the input, convert it to a
24724                  * NV, then create a canonical string representation of that
24725                  * NV. */
24726
24727                 NV value;
24728                 SSize_t value_len = lookup_len - equals_pos;
24729
24730                 /* Get the value */
24731                 if (   value_len <= 0
24732                     || my_atof3(lookup_name + equals_pos, &value,
24733                                 value_len)
24734                           != lookup_name + lookup_len)
24735                 {
24736                     goto failed;
24737                 }
24738
24739                 /* If the value is an integer, the canonical value is integral
24740                  * */
24741                 if (Perl_ceil(value) == value) {
24742                     canonical = Perl_form(aTHX_ "%.*s%.0" NVff,
24743                                             equals_pos, lookup_name, value);
24744                 }
24745                 else {  /* Otherwise, it is %e with a known precision */
24746                     char * exp_ptr;
24747
24748                     canonical = Perl_form(aTHX_ "%.*s%.*" NVef,
24749                                                 equals_pos, lookup_name,
24750                                                 PL_E_FORMAT_PRECISION, value);
24751
24752                     /* The exponent generated is expecting two digits, whereas
24753                      * %e on some systems will generate three.  Remove leading
24754                      * zeros in excess of 2 from the exponent.  We start
24755                      * looking for them after the '=' */
24756                     exp_ptr = strchr(canonical + equals_pos, 'e');
24757                     if (exp_ptr) {
24758                         char * cur_ptr = exp_ptr + 2; /* past the 'e[+-]' */
24759                         SSize_t excess_exponent_len = strlen(cur_ptr) - 2;
24760
24761                         assert(*(cur_ptr - 1) == '-' || *(cur_ptr - 1) == '+');
24762
24763                         if (excess_exponent_len > 0) {
24764                             SSize_t leading_zeros = strspn(cur_ptr, "0");
24765                             SSize_t excess_leading_zeros
24766                                     = MIN(leading_zeros, excess_exponent_len);
24767                             if (excess_leading_zeros > 0) {
24768                                 Move(cur_ptr + excess_leading_zeros,
24769                                      cur_ptr,
24770                                      strlen(cur_ptr) - excess_leading_zeros
24771                                        + 1,  /* Copy the NUL as well */
24772                                      char);
24773                             }
24774                         }
24775                     }
24776                 }
24777             }
24778             else {  /* Has a slash.  Create a rational in canonical form  */
24779                 UV numerator, denominator, gcd, trial;
24780                 const char * end_ptr;
24781                 const char * sign = "";
24782
24783                 /* We can't just find the numerator, denominator, and do the
24784                  * division, then use the method above, because that is
24785                  * inexact.  And the input could be a rational that is within
24786                  * epsilon (given our precision) of a valid rational, and would
24787                  * then incorrectly compare valid.
24788                  *
24789                  * We're only interested in the part after the '=' */
24790                 const char * this_lookup_name = lookup_name + equals_pos;
24791                 lookup_len -= equals_pos;
24792                 slash_pos -= equals_pos;
24793
24794                 /* Handle any leading minus */
24795                 if (this_lookup_name[0] == '-') {
24796                     sign = "-";
24797                     this_lookup_name++;
24798                     lookup_len--;
24799                     slash_pos--;
24800                 }
24801
24802                 /* Convert the numerator to numeric */
24803                 end_ptr = this_lookup_name + slash_pos;
24804                 if (! grok_atoUV(this_lookup_name, &numerator, &end_ptr)) {
24805                     goto failed;
24806                 }
24807
24808                 /* It better have included all characters before the slash */
24809                 if (*end_ptr != '/') {
24810                     goto failed;
24811                 }
24812
24813                 /* Set to look at just the denominator */
24814                 this_lookup_name += slash_pos;
24815                 lookup_len -= slash_pos;
24816                 end_ptr = this_lookup_name + lookup_len;
24817
24818                 /* Convert the denominator to numeric */
24819                 if (! grok_atoUV(this_lookup_name, &denominator, &end_ptr)) {
24820                     goto failed;
24821                 }
24822
24823                 /* It better be the rest of the characters, and don't divide by
24824                  * 0 */
24825                 if (   end_ptr != this_lookup_name + lookup_len
24826                     || denominator == 0)
24827                 {
24828                     goto failed;
24829                 }
24830
24831                 /* Get the greatest common denominator using
24832                    http://en.wikipedia.org/wiki/Euclidean_algorithm */
24833                 gcd = numerator;
24834                 trial = denominator;
24835                 while (trial != 0) {
24836                     UV temp = trial;
24837                     trial = gcd % trial;
24838                     gcd = temp;
24839                 }
24840
24841                 /* If already in lowest possible terms, we have already tried
24842                  * looking this up */
24843                 if (gcd == 1) {
24844                     goto failed;
24845                 }
24846
24847                 /* Reduce the rational, which should put it in canonical form
24848                  * */
24849                 numerator /= gcd;
24850                 denominator /= gcd;
24851
24852                 canonical = Perl_form(aTHX_ "%.*s%s%" UVuf "/%" UVuf,
24853                         equals_pos, lookup_name, sign, numerator, denominator);
24854             }
24855
24856             /* Here, we have the number in canonical form.  Try that */
24857             table_index = do_uniprop_match(canonical, strlen(canonical));
24858             if (table_index == 0) {
24859                 goto failed;
24860             }
24861         }   /* End of still didn't find the property in our table */
24862     }       /* End of       didn't find the property in our table */
24863
24864     /* Here, we have a non-zero return, which is an index into a table of ptrs.
24865      * A negative return signifies that the real index is the absolute value,
24866      * but the result needs to be inverted */
24867     if (table_index < 0) {
24868         invert_return = TRUE;
24869         table_index = -table_index;
24870     }
24871
24872     /* Out-of band indices indicate a deprecated property.  The proper index is
24873      * modulo it with the table size.  And dividing by the table size yields
24874      * an offset into a table constructed by regen/mk_invlists.pl to contain
24875      * the corresponding warning message */
24876     if (table_index > MAX_UNI_KEYWORD_INDEX) {
24877         Size_t warning_offset = table_index / MAX_UNI_KEYWORD_INDEX;
24878         table_index %= MAX_UNI_KEYWORD_INDEX;
24879         Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
24880                 "Use of '%.*s' in \\p{} or \\P{} is deprecated because: %s",
24881                 (int) name_len, name,
24882                 get_deprecated_property_msg(warning_offset));
24883     }
24884
24885     /* In a few properties, a different property is used under /i.  These are
24886      * unlikely to change, so are hard-coded here. */
24887     if (to_fold) {
24888         if (   table_index == UNI_XPOSIXUPPER
24889             || table_index == UNI_XPOSIXLOWER
24890             || table_index == UNI_TITLE)
24891         {
24892             table_index = UNI_CASED;
24893         }
24894         else if (   table_index == UNI_UPPERCASELETTER
24895                  || table_index == UNI_LOWERCASELETTER
24896 #  ifdef UNI_TITLECASELETTER   /* Missing from early Unicodes */
24897                  || table_index == UNI_TITLECASELETTER
24898 #  endif
24899         ) {
24900             table_index = UNI_CASEDLETTER;
24901         }
24902         else if (  table_index == UNI_POSIXUPPER
24903                 || table_index == UNI_POSIXLOWER)
24904         {
24905             table_index = UNI_POSIXALPHA;
24906         }
24907     }
24908
24909     /* Create and return the inversion list */
24910     prop_definition = get_prop_definition(table_index);
24911     sv_2mortal(prop_definition);
24912
24913     /* See if there is a private use override to add to this definition */
24914     {
24915         COPHH * hinthash = (IN_PERL_COMPILETIME)
24916                            ? CopHINTHASH_get(&PL_compiling)
24917                            : CopHINTHASH_get(PL_curcop);
24918         SV * pu_overrides = cophh_fetch_pv(hinthash, "private_use", 0, 0);
24919
24920         if (UNLIKELY(pu_overrides && SvPOK(pu_overrides))) {
24921
24922             /* See if there is an element in the hints hash for this table */
24923             SV * pu_lookup = Perl_newSVpvf(aTHX_ "%d=", table_index);
24924             const char * pos = strstr(SvPVX(pu_overrides), SvPVX(pu_lookup));
24925
24926             if (pos) {
24927                 bool dummy;
24928                 SV * pu_definition;
24929                 SV * pu_invlist;
24930                 SV * expanded_prop_definition =
24931                             sv_2mortal(invlist_clone(prop_definition, NULL));
24932
24933                 /* If so, it's definition is the string from here to the next
24934                  * \a character.  And its format is the same as a user-defined
24935                  * property */
24936                 pos += SvCUR(pu_lookup);
24937                 pu_definition = newSVpvn(pos, strchr(pos, '\a') - pos);
24938                 pu_invlist = handle_user_defined_property(lookup_name,
24939                                                           lookup_len,
24940                                                           0, /* Not UTF-8 */
24941                                                           0, /* Not folded */
24942                                                           runtime,
24943                                                           deferrable,
24944                                                           pu_definition,
24945                                                           &dummy,
24946                                                           msg,
24947                                                           level);
24948                 if (TAINT_get) {
24949                     if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
24950                     sv_catpvs(msg, "Insecure private-use override");
24951                     goto append_name_to_msg;
24952                 }
24953
24954                 /* For now, as a safety measure, make sure that it doesn't
24955                  * override non-private use code points */
24956                 _invlist_intersection(pu_invlist, PL_Private_Use, &pu_invlist);
24957
24958                 /* Add it to the list to be returned */
24959                 _invlist_union(prop_definition, pu_invlist,
24960                                &expanded_prop_definition);
24961                 prop_definition = expanded_prop_definition;
24962                 Perl_ck_warner_d(aTHX_ packWARN(WARN_EXPERIMENTAL__PRIVATE_USE), "The private_use feature is experimental");
24963             }
24964         }
24965     }
24966
24967     if (invert_return) {
24968         _invlist_invert(prop_definition);
24969     }
24970     return prop_definition;
24971
24972   unknown_user_defined:
24973     if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
24974     sv_catpvs(msg, "Unknown user-defined property name");
24975     goto append_name_to_msg;
24976
24977   failed:
24978     if (non_pkg_begin != 0) {
24979         if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
24980         sv_catpvs(msg, "Illegal user-defined property name");
24981     }
24982     else {
24983         if (SvCUR(msg) > 0) sv_catpvs(msg, "; ");
24984         sv_catpvs(msg, "Can't find Unicode property definition");
24985     }
24986     /* FALLTHROUGH */
24987
24988   append_name_to_msg:
24989     {
24990         const char * prefix = (runtime && level == 0) ?  " \\p{" : " \"";
24991         const char * suffix = (runtime && level == 0) ?  "}" : "\"";
24992
24993         sv_catpv(msg, prefix);
24994         Perl_sv_catpvf(aTHX_ msg, "%" UTF8f, UTF8fARG(is_utf8, name_len, name));
24995         sv_catpv(msg, suffix);
24996     }
24997
24998     return NULL;
24999
25000   definition_deferred:
25001
25002     {
25003         bool is_qualified = non_pkg_begin != 0;  /* If has "::" */
25004
25005         /* Here it could yet to be defined, so defer evaluation of this until
25006          * its needed at runtime.  We need the fully qualified property name to
25007          * avoid ambiguity */
25008         if (! fq_name) {
25009             fq_name = S_get_fq_name(aTHX_ name, name_len, is_utf8,
25010                                                                 is_qualified);
25011         }
25012
25013         /* If it didn't come with a package, or the package is utf8::, this
25014          * actually could be an official Unicode property whose inclusion we
25015          * are deferring until runtime to make sure that it isn't overridden by
25016          * a user-defined property of the same name (which we haven't
25017          * encountered yet).  Add a marker to indicate this possibility, for
25018          * use at such time when we first need the definition during pattern
25019          * matching execution */
25020         if (! is_qualified || memBEGINPs(name, non_pkg_begin, "utf8::")) {
25021             sv_catpvs(fq_name, DEFERRED_COULD_BE_OFFICIAL_MARKERs);
25022         }
25023
25024         /* We also need a trailing newline */
25025         sv_catpvs(fq_name, "\n");
25026
25027         *user_defined_ptr = TRUE;
25028         return fq_name;
25029     }
25030 }
25031
25032 STATIC bool
25033 S_handle_names_wildcard(pTHX_ const char * wname, /* wildcard name to match */
25034                               const STRLEN wname_len, /* Its length */
25035                               SV ** prop_definition,
25036                               AV ** strings)
25037 {
25038     /* Deal with Name property wildcard subpatterns; returns TRUE if there were
25039      * any matches, adding them to prop_definition */
25040
25041     dSP;
25042
25043     CV * get_names_info;        /* entry to charnames.pm to get info we need */
25044     SV * names_string;          /* Contains all character names, except algo */
25045     SV * algorithmic_names;     /* Contains info about algorithmically
25046                                    generated character names */
25047     REGEXP * subpattern_re;     /* The user's pattern to match with */
25048     struct regexp * prog;       /* The compiled pattern */
25049     char * all_names_start;     /* lib/unicore/Name.pl string of every
25050                                    (non-algorithmic) character name */
25051     char * cur_pos;             /* We match, effectively using /gc; this is
25052                                    where we are now */
25053     bool found_matches = FALSE; /* Did any name match so far? */
25054     SV * empty;                 /* For matching zero length names */
25055     SV * must_sv;               /* Contains the substring, if any, that must be
25056                                    in a name for the subpattern to match */
25057     const char * must;          /* The PV of 'must' */
25058     STRLEN must_len;            /* And its length */
25059     SV * syllable_name = NULL;  /* For Hangul syllables */
25060     const char hangul_prefix[] = "HANGUL SYLLABLE ";
25061     const STRLEN hangul_prefix_len = sizeof(hangul_prefix) - 1;
25062
25063     /* By inspection, there are a maximum of 7 bytes in the suffix of a hangul
25064      * syllable name, and these are immutable and guaranteed by the Unicode
25065      * standard to never be extended */
25066     const STRLEN syl_max_len = hangul_prefix_len + 7;
25067
25068     IV i;
25069
25070     PERL_ARGS_ASSERT_HANDLE_NAMES_WILDCARD;
25071
25072     /* Make sure _charnames is loaded.  (The parameters give context
25073      * for any errors generated */
25074     get_names_info = get_cv("_charnames::_get_names_info", 0);
25075     if (! get_names_info) {
25076         Perl_croak(aTHX_ "panic: Can't find '_charnames::_get_names_info");
25077     }
25078
25079     /* Get the charnames data */
25080     PUSHSTACKi(PERLSI_REGCOMP);
25081     ENTER ;
25082     SAVETMPS;
25083     save_re_context();
25084
25085     PUSHMARK(SP) ;
25086     PUTBACK;
25087
25088     /* Special _charnames entry point that returns the info this routine
25089      * requires */
25090     call_sv(MUTABLE_SV(get_names_info), G_ARRAY);
25091
25092     SPAGAIN ;
25093
25094     /* Data structure for names which end in their very own code points */
25095     algorithmic_names = POPs;
25096     SvREFCNT_inc_simple_void_NN(algorithmic_names);
25097
25098     /* The lib/unicore/Name.pl string */
25099     names_string = POPs;
25100     SvREFCNT_inc_simple_void_NN(names_string);
25101
25102     PUTBACK ;
25103     FREETMPS ;
25104     LEAVE ;
25105     POPSTACK;
25106
25107     if (   ! SvROK(names_string)
25108         || ! SvROK(algorithmic_names))
25109     {   /* Perhaps should panic instead XXX */
25110         SvREFCNT_dec(names_string);
25111         SvREFCNT_dec(algorithmic_names);
25112         return FALSE;
25113     }
25114
25115     names_string = sv_2mortal(SvRV(names_string));
25116     all_names_start = SvPVX(names_string);
25117     cur_pos = all_names_start;
25118
25119     algorithmic_names= sv_2mortal(SvRV(algorithmic_names));
25120
25121     /* Compile the subpattern consisting of the name being looked for */
25122     subpattern_re = compile_wildcard(wname, wname_len, FALSE /* /-i */ );
25123
25124     must_sv = re_intuit_string(subpattern_re);
25125     if (must_sv) {
25126         /* regexec.c can free the re_intuit_string() return. GH #17734 */
25127         must_sv = sv_2mortal(newSVsv(must_sv));
25128         must = SvPV(must_sv, must_len);
25129     }
25130     else {
25131         must = "";
25132         must_len = 0;
25133     }
25134
25135     /* (Note: 'must' could contain a NUL.  And yet we use strspn() below on it.
25136      * This works because the NUL causes the function to return early, thus
25137      * showing that there are characters in it other than the acceptable ones,
25138      * which is our desired result.) */
25139
25140     prog = ReANY(subpattern_re);
25141
25142     /* If only nothing is matched, skip to where empty names are looked for */
25143     if (prog->maxlen == 0) {
25144         goto check_empty;
25145     }
25146
25147     /* And match against the string of all names /gc.  Don't even try if it
25148      * must match a character not found in any name. */
25149     if (strspn(must, "\n -0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ()") == must_len)
25150     {
25151         while (execute_wildcard(subpattern_re,
25152                                 cur_pos,
25153                                 SvEND(names_string),
25154                                 all_names_start, 0,
25155                                 names_string,
25156                                 0))
25157         { /* Here, matched. */
25158
25159             /* Note the string entries look like
25160              *      00001\nSTART OF HEADING\n\n
25161              * so we could match anywhere in that string.  We have to rule out
25162              * matching a code point line */
25163             char * this_name_start = all_names_start
25164                                                 + RX_OFFS(subpattern_re)->start;
25165             char * this_name_end   = all_names_start
25166                                                 + RX_OFFS(subpattern_re)->end;
25167             char * cp_start;
25168             char * cp_end;
25169             UV cp = 0;      /* Silences some compilers */
25170             AV * this_string = NULL;
25171             bool is_multi = FALSE;
25172
25173             /* If matched nothing, advance to next possible match */
25174             if (this_name_start == this_name_end) {
25175                 cur_pos = (char *) memchr(this_name_end + 1, '\n',
25176                                           SvEND(names_string) - this_name_end);
25177                 if (cur_pos == NULL) {
25178                     break;
25179                 }
25180             }
25181             else {
25182                 /* Position the next match to start beyond the current returned
25183                  * entry */
25184                 cur_pos = (char *) memchr(this_name_end, '\n',
25185                                           SvEND(names_string) - this_name_end);
25186             }
25187
25188             /* Back up to the \n just before the beginning of the character. */
25189             cp_end = (char *) my_memrchr(all_names_start,
25190                                          '\n',
25191                                          this_name_start - all_names_start);
25192
25193             /* If we didn't find a \n, it means it matched somewhere in the
25194              * initial '00000' in the string, so isn't a real match */
25195             if (cp_end == NULL) {
25196                 continue;
25197             }
25198
25199             this_name_start = cp_end + 1;   /* The name starts just after */
25200             cp_end--;                       /* the \n, and the code point */
25201                                             /* ends just before it */
25202
25203             /* All code points are 5 digits long */
25204             cp_start = cp_end - 4;
25205
25206             /* This shouldn't happen, as we found a \n, and the first \n is
25207              * further along than what we subtracted */
25208             assert(cp_start >= all_names_start);
25209
25210             if (cp_start == all_names_start) {
25211                 *prop_definition = add_cp_to_invlist(*prop_definition, 0);
25212                 continue;
25213             }
25214
25215             /* If the character is a blank, we either have a named sequence, or
25216              * something is wrong */
25217             if (*(cp_start - 1) == ' ') {
25218                 cp_start = (char *) my_memrchr(all_names_start,
25219                                                '\n',
25220                                                cp_start - all_names_start);
25221                 cp_start++;
25222             }
25223
25224             assert(cp_start != NULL && cp_start >= all_names_start + 2);
25225
25226             /* Except for the first line in the string, the sequence before the
25227              * code point is \n\n.  If that isn't the case here, we didn't
25228              * match the name of a character.  (We could have matched a named
25229              * sequence, not currently handled */
25230             if (*(cp_start - 1) != '\n' || *(cp_start - 2) != '\n') {
25231                 continue;
25232             }
25233
25234             /* We matched!  Add this to the list */
25235             found_matches = TRUE;
25236
25237             /* Loop through all the code points in the sequence */
25238             while (cp_start < cp_end) {
25239
25240                 /* Calculate this code point from its 5 digits */
25241                 cp = (XDIGIT_VALUE(cp_start[0]) << 16)
25242                    + (XDIGIT_VALUE(cp_start[1]) << 12)
25243                    + (XDIGIT_VALUE(cp_start[2]) << 8)
25244                    + (XDIGIT_VALUE(cp_start[3]) << 4)
25245                    +  XDIGIT_VALUE(cp_start[4]);
25246
25247                 cp_start += 6;  /* Go past any blank */
25248
25249                 if (cp_start < cp_end || is_multi) {
25250                     if (this_string == NULL) {
25251                         this_string = newAV();
25252                     }
25253
25254                     is_multi = TRUE;
25255                     av_push(this_string, newSVuv(cp));
25256                 }
25257             }
25258
25259             if (is_multi) { /* Was more than one code point */
25260                 if (*strings == NULL) {
25261                     *strings = newAV();
25262                 }
25263
25264                 av_push(*strings, (SV *) this_string);
25265             }
25266             else {  /* Only a single code point */
25267                 *prop_definition = add_cp_to_invlist(*prop_definition, cp);
25268             }
25269         } /* End of loop through the non-algorithmic names string */
25270     }
25271
25272     /* There are also character names not in 'names_string'.  These are
25273      * algorithmically generatable.  Try this pattern on each possible one.
25274      * (khw originally planned to leave this out given the large number of
25275      * matches attempted; but the speed turned out to be quite acceptable
25276      *
25277      * There are plenty of opportunities to optimize to skip many of the tests.
25278      * beyond the rudimentary ones already here */
25279
25280     /* First see if the subpattern matches any of the algorithmic generatable
25281      * Hangul syllable names.
25282      *
25283      * We know none of these syllable names will match if the input pattern
25284      * requires more bytes than any syllable has, or if the input pattern only
25285      * matches an empty name, or if the pattern has something it must match and
25286      * one of the characters in that isn't in any Hangul syllable. */
25287     if (    prog->minlen <= (SSize_t) syl_max_len
25288         &&  prog->maxlen > 0
25289         && (strspn(must, "\n ABCDEGHIJKLMNOPRSTUWY") == must_len))
25290     {
25291         /* These constants, names, values, and algorithm are adapted from the
25292          * Unicode standard, version 5.1, section 3.12, and should never
25293          * change. */
25294         const char * JamoL[] = {
25295             "G", "GG", "N", "D", "DD", "R", "M", "B", "BB",
25296             "S", "SS", "", "J", "JJ", "C", "K", "T", "P", "H"
25297         };
25298         const int LCount = C_ARRAY_LENGTH(JamoL);
25299
25300         const char * JamoV[] = {
25301             "A", "AE", "YA", "YAE", "EO", "E", "YEO", "YE", "O", "WA",
25302             "WAE", "OE", "YO", "U", "WEO", "WE", "WI", "YU", "EU", "YI",
25303             "I"
25304         };
25305         const int VCount = C_ARRAY_LENGTH(JamoV);
25306
25307         const char * JamoT[] = {
25308             "", "G", "GG", "GS", "N", "NJ", "NH", "D", "L",
25309             "LG", "LM", "LB", "LS", "LT", "LP", "LH", "M", "B",
25310             "BS", "S", "SS", "NG", "J", "C", "K", "T", "P", "H"
25311         };
25312         const int TCount = C_ARRAY_LENGTH(JamoT);
25313
25314         int L, V, T;
25315
25316         /* This is the initial Hangul syllable code point; each time through the
25317          * inner loop, it maps to the next higher code point.  For more info,
25318          * see the Hangul syllable section of the Unicode standard. */
25319         int cp = 0xAC00;
25320
25321         syllable_name = sv_2mortal(newSV(syl_max_len));
25322         sv_setpvn(syllable_name, hangul_prefix, hangul_prefix_len);
25323
25324         for (L = 0; L < LCount; L++) {
25325             for (V = 0; V < VCount; V++) {
25326                 for (T = 0; T < TCount; T++) {
25327
25328                     /* Truncate back to the prefix, which is unvarying */
25329                     SvCUR_set(syllable_name, hangul_prefix_len);
25330
25331                     sv_catpv(syllable_name, JamoL[L]);
25332                     sv_catpv(syllable_name, JamoV[V]);
25333                     sv_catpv(syllable_name, JamoT[T]);
25334
25335                     if (execute_wildcard(subpattern_re,
25336                                 SvPVX(syllable_name),
25337                                 SvEND(syllable_name),
25338                                 SvPVX(syllable_name), 0,
25339                                 syllable_name,
25340                                 0))
25341                     {
25342                         *prop_definition = add_cp_to_invlist(*prop_definition,
25343                                                              cp);
25344                         found_matches = TRUE;
25345                     }
25346
25347                     cp++;
25348                 }
25349             }
25350         }
25351     }
25352
25353     /* The rest of the algorithmically generatable names are of the form
25354      * "PREFIX-code_point".  The prefixes and the code point limits of each
25355      * were returned to us in the array 'algorithmic_names' from data in
25356      * lib/unicore/Name.pm.  'code_point' in the name is expressed in hex. */
25357     for (i = 0; i <= av_top_index((AV *) algorithmic_names); i++) {
25358         IV j;
25359
25360         /* Each element of the array is a hash, giving the details for the
25361          * series of names it covers.  There is the base name of the characters
25362          * in the series, and the low and high code points in the series.  And,
25363          * for optimization purposes a string containing all the legal
25364          * characters that could possibly be in a name in this series. */
25365         HV * this_series = (HV *) SvRV(* av_fetch((AV *) algorithmic_names, i, 0));
25366         SV * prefix = * hv_fetchs(this_series, "name", 0);
25367         IV low = SvIV(* hv_fetchs(this_series, "low", 0));
25368         IV high = SvIV(* hv_fetchs(this_series, "high", 0));
25369         char * legal = SvPVX(* hv_fetchs(this_series, "legal", 0));
25370
25371         /* Pre-allocate an SV with enough space */
25372         SV * algo_name = sv_2mortal(Perl_newSVpvf(aTHX_ "%s-0000",
25373                                                         SvPVX(prefix)));
25374         if (high >= 0x10000) {
25375             sv_catpvs(algo_name, "0");
25376         }
25377
25378         /* This series can be skipped entirely if the pattern requires
25379          * something longer than any name in the series, or can only match an
25380          * empty name, or contains a character not found in any name in the
25381          * series */
25382         if (    prog->minlen <= (SSize_t) SvCUR(algo_name)
25383             &&  prog->maxlen > 0
25384             && (strspn(must, legal) == must_len))
25385         {
25386             for (j = low; j <= high; j++) { /* For each code point in the series */
25387
25388                 /* Get its name, and see if it matches the subpattern */
25389                 Perl_sv_setpvf(aTHX_ algo_name, "%s-%X", SvPVX(prefix),
25390                                      (unsigned) j);
25391
25392                 if (execute_wildcard(subpattern_re,
25393                                     SvPVX(algo_name),
25394                                     SvEND(algo_name),
25395                                     SvPVX(algo_name), 0,
25396                                     algo_name,
25397                                     0))
25398                 {
25399                     *prop_definition = add_cp_to_invlist(*prop_definition, j);
25400                     found_matches = TRUE;
25401                 }
25402             }
25403         }
25404     }
25405
25406   check_empty:
25407     /* Finally, see if the subpattern matches an empty string */
25408     empty = newSVpvs("");
25409     if (execute_wildcard(subpattern_re,
25410                          SvPVX(empty),
25411                          SvEND(empty),
25412                          SvPVX(empty), 0,
25413                          empty,
25414                          0))
25415     {
25416         /* Many code points have empty names.  Currently these are the \p{GC=C}
25417          * ones, minus CC and CF */
25418
25419         SV * empty_names_ref = get_prop_definition(UNI_C);
25420         SV * empty_names = invlist_clone(empty_names_ref, NULL);
25421
25422         SV * subtract = get_prop_definition(UNI_CC);
25423
25424         _invlist_subtract(empty_names, subtract, &empty_names);
25425         SvREFCNT_dec_NN(empty_names_ref);
25426         SvREFCNT_dec_NN(subtract);
25427
25428         subtract = get_prop_definition(UNI_CF);
25429         _invlist_subtract(empty_names, subtract, &empty_names);
25430         SvREFCNT_dec_NN(subtract);
25431
25432         _invlist_union(*prop_definition, empty_names, prop_definition);
25433         found_matches = TRUE;
25434         SvREFCNT_dec_NN(empty_names);
25435     }
25436     SvREFCNT_dec_NN(empty);
25437
25438 #if 0
25439     /* If we ever were to accept aliases for, say private use names, we would
25440      * need to do something fancier to find empty names.  The code below works
25441      * (at the time it was written), and is slower than the above */
25442     const char empties_pat[] = "^.";
25443     if (strNE(name, empties_pat)) {
25444         SV * empty = newSVpvs("");
25445         if (execute_wildcard(subpattern_re,
25446                     SvPVX(empty),
25447                     SvEND(empty),
25448                     SvPVX(empty), 0,
25449                     empty,
25450                     0))
25451         {
25452             SV * empties = NULL;
25453
25454             (void) handle_names_wildcard(empties_pat, strlen(empties_pat), &empties);
25455
25456             _invlist_union_complement_2nd(*prop_definition, empties, prop_definition);
25457             SvREFCNT_dec_NN(empties);
25458
25459             found_matches = TRUE;
25460         }
25461         SvREFCNT_dec_NN(empty);
25462     }
25463 #endif
25464
25465     SvREFCNT_dec_NN(subpattern_re);
25466     return found_matches;
25467 }
25468
25469 /*
25470  * ex: set ts=8 sts=4 sw=4 et:
25471  */