]> git.vpit.fr Git - perl/modules/re-engine-Hooks.git/blob - src/5014001/orig/regcomp.c
Add support for perl 5.23.[01]
[perl/modules/re-engine-Hooks.git] / src / 5014001 / orig / regcomp.c
1 /*    regcomp.c
2  */
3
4 /*
5  * 'A fair jaw-cracker dwarf-language must be.'            --Samwise Gamgee
6  *
7  *     [p.285 of _The Lord of the Rings_, II/iii: "The Ring Goes South"]
8  */
9
10 /* This file contains functions for compiling a regular expression.  See
11  * also regexec.c which funnily enough, contains functions for executing
12  * a regular expression.
13  *
14  * This file is also copied at build time to ext/re/re_comp.c, where
15  * it's built with -DPERL_EXT_RE_BUILD -DPERL_EXT_RE_DEBUG -DPERL_EXT.
16  * This causes the main functions to be compiled under new names and with
17  * debugging support added, which makes "use re 'debug'" work.
18  */
19
20 /* NOTE: this is derived from Henry Spencer's regexp code, and should not
21  * confused with the original package (see point 3 below).  Thanks, Henry!
22  */
23
24 /* Additional note: this code is very heavily munged from Henry's version
25  * in places.  In some spots I've traded clarity for efficiency, so don't
26  * blame Henry for some of the lack of readability.
27  */
28
29 /* The names of the functions have been changed from regcomp and
30  * regexec to pregcomp and pregexec in order to avoid conflicts
31  * with the POSIX routines of the same names.
32 */
33
34 #ifdef PERL_EXT_RE_BUILD
35 #include "re_top.h"
36 #endif
37
38 /*
39  * pregcomp and pregexec -- regsub and regerror are not used in perl
40  *
41  *      Copyright (c) 1986 by University of Toronto.
42  *      Written by Henry Spencer.  Not derived from licensed software.
43  *
44  *      Permission is granted to anyone to use this software for any
45  *      purpose on any computer system, and to redistribute it freely,
46  *      subject to the following restrictions:
47  *
48  *      1. The author is not responsible for the consequences of use of
49  *              this software, no matter how awful, even if they arise
50  *              from defects in it.
51  *
52  *      2. The origin of this software must not be misrepresented, either
53  *              by explicit claim or by omission.
54  *
55  *      3. Altered versions must be plainly marked as such, and must not
56  *              be misrepresented as being the original software.
57  *
58  *
59  ****    Alterations to Henry's code are...
60  ****
61  ****    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
62  ****    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
63  ****    by Larry Wall and others
64  ****
65  ****    You may distribute under the terms of either the GNU General Public
66  ****    License or the Artistic License, as specified in the README file.
67
68  *
69  * Beware that some of this code is subtly aware of the way operator
70  * precedence is structured in regular expressions.  Serious changes in
71  * regular-expression syntax might require a total rethink.
72  */
73 #include "EXTERN.h"
74 #define PERL_IN_REGCOMP_C
75 #include "perl.h"
76
77 #ifndef PERL_IN_XSUB_RE
78 #  include "INTERN.h"
79 #endif
80
81 #define REG_COMP_C
82 #ifdef PERL_IN_XSUB_RE
83 #  include "re_comp.h"
84 #else
85 #  include "regcomp.h"
86 #endif
87
88 #include "dquote_static.c"
89
90 #ifdef op
91 #undef op
92 #endif /* op */
93
94 #ifdef MSDOS
95 #  if defined(BUGGY_MSC6)
96  /* MSC 6.00A breaks on op/regexp.t test 85 unless we turn this off */
97 #    pragma optimize("a",off)
98  /* But MSC 6.00A is happy with 'w', for aliases only across function calls*/
99 #    pragma optimize("w",on )
100 #  endif /* BUGGY_MSC6 */
101 #endif /* MSDOS */
102
103 #ifndef STATIC
104 #define STATIC  static
105 #endif
106
107 typedef struct RExC_state_t {
108     U32         flags;                  /* are we folding, multilining? */
109     char        *precomp;               /* uncompiled string. */
110     REGEXP      *rx_sv;                 /* The SV that is the regexp. */
111     regexp      *rx;                    /* perl core regexp structure */
112     regexp_internal     *rxi;           /* internal data for regexp object pprivate field */        
113     char        *start;                 /* Start of input for compile */
114     char        *end;                   /* End of input for compile */
115     char        *parse;                 /* Input-scan pointer. */
116     I32         whilem_seen;            /* number of WHILEM in this expr */
117     regnode     *emit_start;            /* Start of emitted-code area */
118     regnode     *emit_bound;            /* First regnode outside of the allocated space */
119     regnode     *emit;                  /* Code-emit pointer; &regdummy = don't = compiling */
120     I32         naughty;                /* How bad is this pattern? */
121     I32         sawback;                /* Did we see \1, ...? */
122     U32         seen;
123     I32         size;                   /* Code size. */
124     I32         npar;                   /* Capture buffer count, (OPEN). */
125     I32         cpar;                   /* Capture buffer count, (CLOSE). */
126     I32         nestroot;               /* root parens we are in - used by accept */
127     I32         extralen;
128     I32         seen_zerolen;
129     I32         seen_evals;
130     regnode     **open_parens;          /* pointers to open parens */
131     regnode     **close_parens;         /* pointers to close parens */
132     regnode     *opend;                 /* END node in program */
133     I32         utf8;           /* whether the pattern is utf8 or not */
134     I32         orig_utf8;      /* whether the pattern was originally in utf8 */
135                                 /* XXX use this for future optimisation of case
136                                  * where pattern must be upgraded to utf8. */
137     I32         uni_semantics;  /* If a d charset modifier should use unicode
138                                    rules, even if the pattern is not in
139                                    utf8 */
140     HV          *paren_names;           /* Paren names */
141     
142     regnode     **recurse;              /* Recurse regops */
143     I32         recurse_count;          /* Number of recurse regops */
144     I32         in_lookbehind;
145     I32         contains_locale;
146     I32         override_recoding;
147 #if ADD_TO_REGEXEC
148     char        *starttry;              /* -Dr: where regtry was called. */
149 #define RExC_starttry   (pRExC_state->starttry)
150 #endif
151 #ifdef DEBUGGING
152     const char  *lastparse;
153     I32         lastnum;
154     AV          *paren_name_list;       /* idx -> name */
155 #define RExC_lastparse  (pRExC_state->lastparse)
156 #define RExC_lastnum    (pRExC_state->lastnum)
157 #define RExC_paren_name_list    (pRExC_state->paren_name_list)
158 #endif
159 } RExC_state_t;
160
161 #define RExC_flags      (pRExC_state->flags)
162 #define RExC_precomp    (pRExC_state->precomp)
163 #define RExC_rx_sv      (pRExC_state->rx_sv)
164 #define RExC_rx         (pRExC_state->rx)
165 #define RExC_rxi        (pRExC_state->rxi)
166 #define RExC_start      (pRExC_state->start)
167 #define RExC_end        (pRExC_state->end)
168 #define RExC_parse      (pRExC_state->parse)
169 #define RExC_whilem_seen        (pRExC_state->whilem_seen)
170 #ifdef RE_TRACK_PATTERN_OFFSETS
171 #define RExC_offsets    (pRExC_state->rxi->u.offsets) /* I am not like the others */
172 #endif
173 #define RExC_emit       (pRExC_state->emit)
174 #define RExC_emit_start (pRExC_state->emit_start)
175 #define RExC_emit_bound (pRExC_state->emit_bound)
176 #define RExC_naughty    (pRExC_state->naughty)
177 #define RExC_sawback    (pRExC_state->sawback)
178 #define RExC_seen       (pRExC_state->seen)
179 #define RExC_size       (pRExC_state->size)
180 #define RExC_npar       (pRExC_state->npar)
181 #define RExC_nestroot   (pRExC_state->nestroot)
182 #define RExC_extralen   (pRExC_state->extralen)
183 #define RExC_seen_zerolen       (pRExC_state->seen_zerolen)
184 #define RExC_seen_evals (pRExC_state->seen_evals)
185 #define RExC_utf8       (pRExC_state->utf8)
186 #define RExC_uni_semantics      (pRExC_state->uni_semantics)
187 #define RExC_orig_utf8  (pRExC_state->orig_utf8)
188 #define RExC_open_parens        (pRExC_state->open_parens)
189 #define RExC_close_parens       (pRExC_state->close_parens)
190 #define RExC_opend      (pRExC_state->opend)
191 #define RExC_paren_names        (pRExC_state->paren_names)
192 #define RExC_recurse    (pRExC_state->recurse)
193 #define RExC_recurse_count      (pRExC_state->recurse_count)
194 #define RExC_in_lookbehind      (pRExC_state->in_lookbehind)
195 #define RExC_contains_locale    (pRExC_state->contains_locale)
196 #define RExC_override_recoding  (pRExC_state->override_recoding)
197
198
199 #define ISMULT1(c)      ((c) == '*' || (c) == '+' || (c) == '?')
200 #define ISMULT2(s)      ((*s) == '*' || (*s) == '+' || (*s) == '?' || \
201         ((*s) == '{' && regcurly(s)))
202
203 #ifdef SPSTART
204 #undef SPSTART          /* dratted cpp namespace... */
205 #endif
206 /*
207  * Flags to be passed up and down.
208  */
209 #define WORST           0       /* Worst case. */
210 #define HASWIDTH        0x01    /* Known to match non-null strings. */
211
212 /* Simple enough to be STAR/PLUS operand, in an EXACT node must be a single
213  * character, and if utf8, must be invariant.  Note that this is not the same thing as REGNODE_SIMPLE */
214 #define SIMPLE          0x02
215 #define SPSTART         0x04    /* Starts with * or +. */
216 #define TRYAGAIN        0x08    /* Weeded out a declaration. */
217 #define POSTPONED       0x10    /* (?1),(?&name), (??{...}) or similar */
218
219 #define REG_NODE_NUM(x) ((x) ? (int)((x)-RExC_emit_start) : -1)
220
221 /* whether trie related optimizations are enabled */
222 #if PERL_ENABLE_EXTENDED_TRIE_OPTIMISATION
223 #define TRIE_STUDY_OPT
224 #define FULL_TRIE_STUDY
225 #define TRIE_STCLASS
226 #endif
227
228
229
230 #define PBYTE(u8str,paren) ((U8*)(u8str))[(paren) >> 3]
231 #define PBITVAL(paren) (1 << ((paren) & 7))
232 #define PAREN_TEST(u8str,paren) ( PBYTE(u8str,paren) & PBITVAL(paren))
233 #define PAREN_SET(u8str,paren) PBYTE(u8str,paren) |= PBITVAL(paren)
234 #define PAREN_UNSET(u8str,paren) PBYTE(u8str,paren) &= (~PBITVAL(paren))
235
236 /* If not already in utf8, do a longjmp back to the beginning */
237 #define UTF8_LONGJMP 42 /* Choose a value not likely to ever conflict */
238 #define REQUIRE_UTF8    STMT_START {                                       \
239                                      if (! UTF) JMPENV_JUMP(UTF8_LONGJMP); \
240                         } STMT_END
241
242 /* About scan_data_t.
243
244   During optimisation we recurse through the regexp program performing
245   various inplace (keyhole style) optimisations. In addition study_chunk
246   and scan_commit populate this data structure with information about
247   what strings MUST appear in the pattern. We look for the longest 
248   string that must appear at a fixed location, and we look for the
249   longest string that may appear at a floating location. So for instance
250   in the pattern:
251   
252     /FOO[xX]A.*B[xX]BAR/
253     
254   Both 'FOO' and 'A' are fixed strings. Both 'B' and 'BAR' are floating
255   strings (because they follow a .* construct). study_chunk will identify
256   both FOO and BAR as being the longest fixed and floating strings respectively.
257   
258   The strings can be composites, for instance
259   
260      /(f)(o)(o)/
261      
262   will result in a composite fixed substring 'foo'.
263   
264   For each string some basic information is maintained:
265   
266   - offset or min_offset
267     This is the position the string must appear at, or not before.
268     It also implicitly (when combined with minlenp) tells us how many
269     characters must match before the string we are searching for.
270     Likewise when combined with minlenp and the length of the string it
271     tells us how many characters must appear after the string we have 
272     found.
273   
274   - max_offset
275     Only used for floating strings. This is the rightmost point that
276     the string can appear at. If set to I32 max it indicates that the
277     string can occur infinitely far to the right.
278   
279   - minlenp
280     A pointer to the minimum length of the pattern that the string 
281     was found inside. This is important as in the case of positive 
282     lookahead or positive lookbehind we can have multiple patterns 
283     involved. Consider
284     
285     /(?=FOO).*F/
286     
287     The minimum length of the pattern overall is 3, the minimum length
288     of the lookahead part is 3, but the minimum length of the part that
289     will actually match is 1. So 'FOO's minimum length is 3, but the 
290     minimum length for the F is 1. This is important as the minimum length
291     is used to determine offsets in front of and behind the string being 
292     looked for.  Since strings can be composites this is the length of the
293     pattern at the time it was committed with a scan_commit. Note that
294     the length is calculated by study_chunk, so that the minimum lengths
295     are not known until the full pattern has been compiled, thus the 
296     pointer to the value.
297   
298   - lookbehind
299   
300     In the case of lookbehind the string being searched for can be
301     offset past the start point of the final matching string. 
302     If this value was just blithely removed from the min_offset it would
303     invalidate some of the calculations for how many chars must match
304     before or after (as they are derived from min_offset and minlen and
305     the length of the string being searched for). 
306     When the final pattern is compiled and the data is moved from the
307     scan_data_t structure into the regexp structure the information
308     about lookbehind is factored in, with the information that would 
309     have been lost precalculated in the end_shift field for the 
310     associated string.
311
312   The fields pos_min and pos_delta are used to store the minimum offset
313   and the delta to the maximum offset at the current point in the pattern.    
314
315 */
316
317 typedef struct scan_data_t {
318     /*I32 len_min;      unused */
319     /*I32 len_delta;    unused */
320     I32 pos_min;
321     I32 pos_delta;
322     SV *last_found;
323     I32 last_end;           /* min value, <0 unless valid. */
324     I32 last_start_min;
325     I32 last_start_max;
326     SV **longest;           /* Either &l_fixed, or &l_float. */
327     SV *longest_fixed;      /* longest fixed string found in pattern */
328     I32 offset_fixed;       /* offset where it starts */
329     I32 *minlen_fixed;      /* pointer to the minlen relevant to the string */
330     I32 lookbehind_fixed;   /* is the position of the string modfied by LB */
331     SV *longest_float;      /* longest floating string found in pattern */
332     I32 offset_float_min;   /* earliest point in string it can appear */
333     I32 offset_float_max;   /* latest point in string it can appear */
334     I32 *minlen_float;      /* pointer to the minlen relevant to the string */
335     I32 lookbehind_float;   /* is the position of the string modified by LB */
336     I32 flags;
337     I32 whilem_c;
338     I32 *last_closep;
339     struct regnode_charclass_class *start_class;
340 } scan_data_t;
341
342 /*
343  * Forward declarations for pregcomp()'s friends.
344  */
345
346 static const scan_data_t zero_scan_data =
347   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0};
348
349 #define SF_BEFORE_EOL           (SF_BEFORE_SEOL|SF_BEFORE_MEOL)
350 #define SF_BEFORE_SEOL          0x0001
351 #define SF_BEFORE_MEOL          0x0002
352 #define SF_FIX_BEFORE_EOL       (SF_FIX_BEFORE_SEOL|SF_FIX_BEFORE_MEOL)
353 #define SF_FL_BEFORE_EOL        (SF_FL_BEFORE_SEOL|SF_FL_BEFORE_MEOL)
354
355 #ifdef NO_UNARY_PLUS
356 #  define SF_FIX_SHIFT_EOL      (0+2)
357 #  define SF_FL_SHIFT_EOL               (0+4)
358 #else
359 #  define SF_FIX_SHIFT_EOL      (+2)
360 #  define SF_FL_SHIFT_EOL               (+4)
361 #endif
362
363 #define SF_FIX_BEFORE_SEOL      (SF_BEFORE_SEOL << SF_FIX_SHIFT_EOL)
364 #define SF_FIX_BEFORE_MEOL      (SF_BEFORE_MEOL << SF_FIX_SHIFT_EOL)
365
366 #define SF_FL_BEFORE_SEOL       (SF_BEFORE_SEOL << SF_FL_SHIFT_EOL)
367 #define SF_FL_BEFORE_MEOL       (SF_BEFORE_MEOL << SF_FL_SHIFT_EOL) /* 0x20 */
368 #define SF_IS_INF               0x0040
369 #define SF_HAS_PAR              0x0080
370 #define SF_IN_PAR               0x0100
371 #define SF_HAS_EVAL             0x0200
372 #define SCF_DO_SUBSTR           0x0400
373 #define SCF_DO_STCLASS_AND      0x0800
374 #define SCF_DO_STCLASS_OR       0x1000
375 #define SCF_DO_STCLASS          (SCF_DO_STCLASS_AND|SCF_DO_STCLASS_OR)
376 #define SCF_WHILEM_VISITED_POS  0x2000
377
378 #define SCF_TRIE_RESTUDY        0x4000 /* Do restudy? */
379 #define SCF_SEEN_ACCEPT         0x8000 
380
381 #define UTF cBOOL(RExC_utf8)
382 #define LOC (get_regex_charset(RExC_flags) == REGEX_LOCALE_CHARSET)
383 #define UNI_SEMANTICS (get_regex_charset(RExC_flags) == REGEX_UNICODE_CHARSET)
384 #define DEPENDS_SEMANTICS (get_regex_charset(RExC_flags) == REGEX_DEPENDS_CHARSET)
385 #define AT_LEAST_UNI_SEMANTICS (get_regex_charset(RExC_flags) >= REGEX_UNICODE_CHARSET)
386 #define ASCII_RESTRICTED (get_regex_charset(RExC_flags) == REGEX_ASCII_RESTRICTED_CHARSET)
387 #define MORE_ASCII_RESTRICTED (get_regex_charset(RExC_flags) == REGEX_ASCII_MORE_RESTRICTED_CHARSET)
388 #define AT_LEAST_ASCII_RESTRICTED (get_regex_charset(RExC_flags) >= REGEX_ASCII_RESTRICTED_CHARSET)
389
390 #define FOLD cBOOL(RExC_flags & RXf_PMf_FOLD)
391
392 #define OOB_UNICODE             12345678
393 #define OOB_NAMEDCLASS          -1
394
395 #define CHR_SVLEN(sv) (UTF ? sv_len_utf8(sv) : SvCUR(sv))
396 #define CHR_DIST(a,b) (UTF ? utf8_distance(a,b) : a - b)
397
398
399 /* length of regex to show in messages that don't mark a position within */
400 #define RegexLengthToShowInErrorMessages 127
401
402 /*
403  * If MARKER[12] are adjusted, be sure to adjust the constants at the top
404  * of t/op/regmesg.t, the tests in t/op/re_tests, and those in
405  * op/pragma/warn/regcomp.
406  */
407 #define MARKER1 "<-- HERE"    /* marker as it appears in the description */
408 #define MARKER2 " <-- HERE "  /* marker as it appears within the regex */
409
410 #define REPORT_LOCATION " in regex; marked by " MARKER1 " in m/%.*s" MARKER2 "%s/"
411
412 /*
413  * Calls SAVEDESTRUCTOR_X if needed, then calls Perl_croak with the given
414  * arg. Show regex, up to a maximum length. If it's too long, chop and add
415  * "...".
416  */
417 #define _FAIL(code) STMT_START {                                        \
418     const char *ellipses = "";                                          \
419     IV len = RExC_end - RExC_precomp;                                   \
420                                                                         \
421     if (!SIZE_ONLY)                                                     \
422         SAVEDESTRUCTOR_X(clear_re,(void*)RExC_rx_sv);                   \
423     if (len > RegexLengthToShowInErrorMessages) {                       \
424         /* chop 10 shorter than the max, to ensure meaning of "..." */  \
425         len = RegexLengthToShowInErrorMessages - 10;                    \
426         ellipses = "...";                                               \
427     }                                                                   \
428     code;                                                               \
429 } STMT_END
430
431 #define FAIL(msg) _FAIL(                            \
432     Perl_croak(aTHX_ "%s in regex m/%.*s%s/",       \
433             msg, (int)len, RExC_precomp, ellipses))
434
435 #define FAIL2(msg,arg) _FAIL(                       \
436     Perl_croak(aTHX_ msg " in regex m/%.*s%s/",     \
437             arg, (int)len, RExC_precomp, ellipses))
438
439 /*
440  * Simple_vFAIL -- like FAIL, but marks the current location in the scan
441  */
442 #define Simple_vFAIL(m) STMT_START {                                    \
443     const IV offset = RExC_parse - RExC_precomp;                        \
444     Perl_croak(aTHX_ "%s" REPORT_LOCATION,                              \
445             m, (int)offset, RExC_precomp, RExC_precomp + offset);       \
446 } STMT_END
447
448 /*
449  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL()
450  */
451 #define vFAIL(m) STMT_START {                           \
452     if (!SIZE_ONLY)                                     \
453         SAVEDESTRUCTOR_X(clear_re,(void*)RExC_rx_sv);   \
454     Simple_vFAIL(m);                                    \
455 } STMT_END
456
457 /*
458  * Like Simple_vFAIL(), but accepts two arguments.
459  */
460 #define Simple_vFAIL2(m,a1) STMT_START {                        \
461     const IV offset = RExC_parse - RExC_precomp;                        \
462     S_re_croak2(aTHX_ m, REPORT_LOCATION, a1,                   \
463             (int)offset, RExC_precomp, RExC_precomp + offset);  \
464 } STMT_END
465
466 /*
467  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL2().
468  */
469 #define vFAIL2(m,a1) STMT_START {                       \
470     if (!SIZE_ONLY)                                     \
471         SAVEDESTRUCTOR_X(clear_re,(void*)RExC_rx_sv);   \
472     Simple_vFAIL2(m, a1);                               \
473 } STMT_END
474
475
476 /*
477  * Like Simple_vFAIL(), but accepts three arguments.
478  */
479 #define Simple_vFAIL3(m, a1, a2) STMT_START {                   \
480     const IV offset = RExC_parse - RExC_precomp;                \
481     S_re_croak2(aTHX_ m, REPORT_LOCATION, a1, a2,               \
482             (int)offset, RExC_precomp, RExC_precomp + offset);  \
483 } STMT_END
484
485 /*
486  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL3().
487  */
488 #define vFAIL3(m,a1,a2) STMT_START {                    \
489     if (!SIZE_ONLY)                                     \
490         SAVEDESTRUCTOR_X(clear_re,(void*)RExC_rx_sv);   \
491     Simple_vFAIL3(m, a1, a2);                           \
492 } STMT_END
493
494 /*
495  * Like Simple_vFAIL(), but accepts four arguments.
496  */
497 #define Simple_vFAIL4(m, a1, a2, a3) STMT_START {               \
498     const IV offset = RExC_parse - RExC_precomp;                \
499     S_re_croak2(aTHX_ m, REPORT_LOCATION, a1, a2, a3,           \
500             (int)offset, RExC_precomp, RExC_precomp + offset);  \
501 } STMT_END
502
503 #define ckWARNreg(loc,m) STMT_START {                                   \
504     const IV offset = loc - RExC_precomp;                               \
505     Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,      \
506             (int)offset, RExC_precomp, RExC_precomp + offset);          \
507 } STMT_END
508
509 #define ckWARNregdep(loc,m) STMT_START {                                \
510     const IV offset = loc - RExC_precomp;                               \
511     Perl_ck_warner_d(aTHX_ packWARN2(WARN_DEPRECATED, WARN_REGEXP),     \
512             m REPORT_LOCATION,                                          \
513             (int)offset, RExC_precomp, RExC_precomp + offset);          \
514 } STMT_END
515
516 #define ckWARN2regdep(loc,m, a1) STMT_START {                           \
517     const IV offset = loc - RExC_precomp;                               \
518     Perl_ck_warner_d(aTHX_ packWARN2(WARN_DEPRECATED, WARN_REGEXP),     \
519             m REPORT_LOCATION,                                          \
520             a1, (int)offset, RExC_precomp, RExC_precomp + offset);      \
521 } STMT_END
522
523 #define ckWARN2reg(loc, m, a1) STMT_START {                             \
524     const IV offset = loc - RExC_precomp;                               \
525     Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,      \
526             a1, (int)offset, RExC_precomp, RExC_precomp + offset);      \
527 } STMT_END
528
529 #define vWARN3(loc, m, a1, a2) STMT_START {                             \
530     const IV offset = loc - RExC_precomp;                               \
531     Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,         \
532             a1, a2, (int)offset, RExC_precomp, RExC_precomp + offset);  \
533 } STMT_END
534
535 #define ckWARN3reg(loc, m, a1, a2) STMT_START {                         \
536     const IV offset = loc - RExC_precomp;                               \
537     Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,      \
538             a1, a2, (int)offset, RExC_precomp, RExC_precomp + offset);  \
539 } STMT_END
540
541 #define vWARN4(loc, m, a1, a2, a3) STMT_START {                         \
542     const IV offset = loc - RExC_precomp;                               \
543     Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,         \
544             a1, a2, a3, (int)offset, RExC_precomp, RExC_precomp + offset); \
545 } STMT_END
546
547 #define ckWARN4reg(loc, m, a1, a2, a3) STMT_START {                     \
548     const IV offset = loc - RExC_precomp;                               \
549     Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,      \
550             a1, a2, a3, (int)offset, RExC_precomp, RExC_precomp + offset); \
551 } STMT_END
552
553 #define vWARN5(loc, m, a1, a2, a3, a4) STMT_START {                     \
554     const IV offset = loc - RExC_precomp;                               \
555     Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,         \
556             a1, a2, a3, a4, (int)offset, RExC_precomp, RExC_precomp + offset); \
557 } STMT_END
558
559
560 /* Allow for side effects in s */
561 #define REGC(c,s) STMT_START {                  \
562     if (!SIZE_ONLY) *(s) = (c); else (void)(s); \
563 } STMT_END
564
565 /* Macros for recording node offsets.   20001227 mjd@plover.com 
566  * Nodes are numbered 1, 2, 3, 4.  Node #n's position is recorded in
567  * element 2*n-1 of the array.  Element #2n holds the byte length node #n.
568  * Element 0 holds the number n.
569  * Position is 1 indexed.
570  */
571 #ifndef RE_TRACK_PATTERN_OFFSETS
572 #define Set_Node_Offset_To_R(node,byte)
573 #define Set_Node_Offset(node,byte)
574 #define Set_Cur_Node_Offset
575 #define Set_Node_Length_To_R(node,len)
576 #define Set_Node_Length(node,len)
577 #define Set_Node_Cur_Length(node)
578 #define Node_Offset(n) 
579 #define Node_Length(n) 
580 #define Set_Node_Offset_Length(node,offset,len)
581 #define ProgLen(ri) ri->u.proglen
582 #define SetProgLen(ri,x) ri->u.proglen = x
583 #else
584 #define ProgLen(ri) ri->u.offsets[0]
585 #define SetProgLen(ri,x) ri->u.offsets[0] = x
586 #define Set_Node_Offset_To_R(node,byte) STMT_START {                    \
587     if (! SIZE_ONLY) {                                                  \
588         MJD_OFFSET_DEBUG(("** (%d) offset of node %d is %d.\n",         \
589                     __LINE__, (int)(node), (int)(byte)));               \
590         if((node) < 0) {                                                \
591             Perl_croak(aTHX_ "value of node is %d in Offset macro", (int)(node)); \
592         } else {                                                        \
593             RExC_offsets[2*(node)-1] = (byte);                          \
594         }                                                               \
595     }                                                                   \
596 } STMT_END
597
598 #define Set_Node_Offset(node,byte) \
599     Set_Node_Offset_To_R((node)-RExC_emit_start, (byte)-RExC_start)
600 #define Set_Cur_Node_Offset Set_Node_Offset(RExC_emit, RExC_parse)
601
602 #define Set_Node_Length_To_R(node,len) STMT_START {                     \
603     if (! SIZE_ONLY) {                                                  \
604         MJD_OFFSET_DEBUG(("** (%d) size of node %d is %d.\n",           \
605                 __LINE__, (int)(node), (int)(len)));                    \
606         if((node) < 0) {                                                \
607             Perl_croak(aTHX_ "value of node is %d in Length macro", (int)(node)); \
608         } else {                                                        \
609             RExC_offsets[2*(node)] = (len);                             \
610         }                                                               \
611     }                                                                   \
612 } STMT_END
613
614 #define Set_Node_Length(node,len) \
615     Set_Node_Length_To_R((node)-RExC_emit_start, len)
616 #define Set_Cur_Node_Length(len) Set_Node_Length(RExC_emit, len)
617 #define Set_Node_Cur_Length(node) \
618     Set_Node_Length(node, RExC_parse - parse_start)
619
620 /* Get offsets and lengths */
621 #define Node_Offset(n) (RExC_offsets[2*((n)-RExC_emit_start)-1])
622 #define Node_Length(n) (RExC_offsets[2*((n)-RExC_emit_start)])
623
624 #define Set_Node_Offset_Length(node,offset,len) STMT_START {    \
625     Set_Node_Offset_To_R((node)-RExC_emit_start, (offset));     \
626     Set_Node_Length_To_R((node)-RExC_emit_start, (len));        \
627 } STMT_END
628 #endif
629
630 #if PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS
631 #define EXPERIMENTAL_INPLACESCAN
632 #endif /*PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS*/
633
634 #define DEBUG_STUDYDATA(str,data,depth)                              \
635 DEBUG_OPTIMISE_MORE_r(if(data){                                      \
636     PerlIO_printf(Perl_debug_log,                                    \
637         "%*s" str "Pos:%"IVdf"/%"IVdf                                \
638         " Flags: 0x%"UVXf" Whilem_c: %"IVdf" Lcp: %"IVdf" %s",       \
639         (int)(depth)*2, "",                                          \
640         (IV)((data)->pos_min),                                       \
641         (IV)((data)->pos_delta),                                     \
642         (UV)((data)->flags),                                         \
643         (IV)((data)->whilem_c),                                      \
644         (IV)((data)->last_closep ? *((data)->last_closep) : -1),     \
645         is_inf ? "INF " : ""                                         \
646     );                                                               \
647     if ((data)->last_found)                                          \
648         PerlIO_printf(Perl_debug_log,                                \
649             "Last:'%s' %"IVdf":%"IVdf"/%"IVdf" %sFixed:'%s' @ %"IVdf \
650             " %sFloat: '%s' @ %"IVdf"/%"IVdf"",                      \
651             SvPVX_const((data)->last_found),                         \
652             (IV)((data)->last_end),                                  \
653             (IV)((data)->last_start_min),                            \
654             (IV)((data)->last_start_max),                            \
655             ((data)->longest &&                                      \
656              (data)->longest==&((data)->longest_fixed)) ? "*" : "",  \
657             SvPVX_const((data)->longest_fixed),                      \
658             (IV)((data)->offset_fixed),                              \
659             ((data)->longest &&                                      \
660              (data)->longest==&((data)->longest_float)) ? "*" : "",  \
661             SvPVX_const((data)->longest_float),                      \
662             (IV)((data)->offset_float_min),                          \
663             (IV)((data)->offset_float_max)                           \
664         );                                                           \
665     PerlIO_printf(Perl_debug_log,"\n");                              \
666 });
667
668 static void clear_re(pTHX_ void *r);
669
670 /* Mark that we cannot extend a found fixed substring at this point.
671    Update the longest found anchored substring and the longest found
672    floating substrings if needed. */
673
674 STATIC void
675 S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, scan_data_t *data, I32 *minlenp, int is_inf)
676 {
677     const STRLEN l = CHR_SVLEN(data->last_found);
678     const STRLEN old_l = CHR_SVLEN(*data->longest);
679     GET_RE_DEBUG_FLAGS_DECL;
680
681     PERL_ARGS_ASSERT_SCAN_COMMIT;
682
683     if ((l >= old_l) && ((l > old_l) || (data->flags & SF_BEFORE_EOL))) {
684         SvSetMagicSV(*data->longest, data->last_found);
685         if (*data->longest == data->longest_fixed) {
686             data->offset_fixed = l ? data->last_start_min : data->pos_min;
687             if (data->flags & SF_BEFORE_EOL)
688                 data->flags
689                     |= ((data->flags & SF_BEFORE_EOL) << SF_FIX_SHIFT_EOL);
690             else
691                 data->flags &= ~SF_FIX_BEFORE_EOL;
692             data->minlen_fixed=minlenp; 
693             data->lookbehind_fixed=0;
694         }
695         else { /* *data->longest == data->longest_float */
696             data->offset_float_min = l ? data->last_start_min : data->pos_min;
697             data->offset_float_max = (l
698                                       ? data->last_start_max
699                                       : data->pos_min + data->pos_delta);
700             if (is_inf || (U32)data->offset_float_max > (U32)I32_MAX)
701                 data->offset_float_max = I32_MAX;
702             if (data->flags & SF_BEFORE_EOL)
703                 data->flags
704                     |= ((data->flags & SF_BEFORE_EOL) << SF_FL_SHIFT_EOL);
705             else
706                 data->flags &= ~SF_FL_BEFORE_EOL;
707             data->minlen_float=minlenp;
708             data->lookbehind_float=0;
709         }
710     }
711     SvCUR_set(data->last_found, 0);
712     {
713         SV * const sv = data->last_found;
714         if (SvUTF8(sv) && SvMAGICAL(sv)) {
715             MAGIC * const mg = mg_find(sv, PERL_MAGIC_utf8);
716             if (mg)
717                 mg->mg_len = 0;
718         }
719     }
720     data->last_end = -1;
721     data->flags &= ~SF_BEFORE_EOL;
722     DEBUG_STUDYDATA("commit: ",data,0);
723 }
724
725 /* Can match anything (initialization) */
726 STATIC void
727 S_cl_anything(const RExC_state_t *pRExC_state, struct regnode_charclass_class *cl)
728 {
729     PERL_ARGS_ASSERT_CL_ANYTHING;
730
731     ANYOF_BITMAP_SETALL(cl);
732     cl->flags = ANYOF_CLASS|ANYOF_EOS|ANYOF_UNICODE_ALL
733                 |ANYOF_LOC_NONBITMAP_FOLD|ANYOF_NON_UTF8_LATIN1_ALL;
734
735     /* If any portion of the regex is to operate under locale rules,
736      * initialization includes it.  The reason this isn't done for all regexes
737      * is that the optimizer was written under the assumption that locale was
738      * all-or-nothing.  Given the complexity and lack of documentation in the
739      * optimizer, and that there are inadequate test cases for locale, so many
740      * parts of it may not work properly, it is safest to avoid locale unless
741      * necessary. */
742     if (RExC_contains_locale) {
743         ANYOF_CLASS_SETALL(cl);     /* /l uses class */
744         cl->flags |= ANYOF_LOCALE;
745     }
746     else {
747         ANYOF_CLASS_ZERO(cl);       /* Only /l uses class now */
748     }
749 }
750
751 /* Can match anything (initialization) */
752 STATIC int
753 S_cl_is_anything(const struct regnode_charclass_class *cl)
754 {
755     int value;
756
757     PERL_ARGS_ASSERT_CL_IS_ANYTHING;
758
759     for (value = 0; value <= ANYOF_MAX; value += 2)
760         if (ANYOF_CLASS_TEST(cl, value) && ANYOF_CLASS_TEST(cl, value + 1))
761             return 1;
762     if (!(cl->flags & ANYOF_UNICODE_ALL))
763         return 0;
764     if (!ANYOF_BITMAP_TESTALLSET((const void*)cl))
765         return 0;
766     return 1;
767 }
768
769 /* Can match anything (initialization) */
770 STATIC void
771 S_cl_init(const RExC_state_t *pRExC_state, struct regnode_charclass_class *cl)
772 {
773     PERL_ARGS_ASSERT_CL_INIT;
774
775     Zero(cl, 1, struct regnode_charclass_class);
776     cl->type = ANYOF;
777     cl_anything(pRExC_state, cl);
778     ARG_SET(cl, ANYOF_NONBITMAP_EMPTY);
779 }
780
781 /* These two functions currently do the exact same thing */
782 #define cl_init_zero            S_cl_init
783
784 /* 'AND' a given class with another one.  Can create false positives.  'cl'
785  * should not be inverted.  'and_with->flags & ANYOF_CLASS' should be 0 if
786  * 'and_with' is a regnode_charclass instead of a regnode_charclass_class. */
787 STATIC void
788 S_cl_and(struct regnode_charclass_class *cl,
789         const struct regnode_charclass_class *and_with)
790 {
791     PERL_ARGS_ASSERT_CL_AND;
792
793     assert(and_with->type == ANYOF);
794
795     /* I (khw) am not sure all these restrictions are necessary XXX */
796     if (!(ANYOF_CLASS_TEST_ANY_SET(and_with))
797         && !(ANYOF_CLASS_TEST_ANY_SET(cl))
798         && (and_with->flags & ANYOF_LOCALE) == (cl->flags & ANYOF_LOCALE)
799         && !(and_with->flags & ANYOF_LOC_NONBITMAP_FOLD)
800         && !(cl->flags & ANYOF_LOC_NONBITMAP_FOLD)) {
801         int i;
802
803         if (and_with->flags & ANYOF_INVERT)
804             for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
805                 cl->bitmap[i] &= ~and_with->bitmap[i];
806         else
807             for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
808                 cl->bitmap[i] &= and_with->bitmap[i];
809     } /* XXXX: logic is complicated otherwise, leave it along for a moment. */
810
811     if (and_with->flags & ANYOF_INVERT) {
812
813         /* Here, the and'ed node is inverted.  Get the AND of the flags that
814          * aren't affected by the inversion.  Those that are affected are
815          * handled individually below */
816         U8 affected_flags = cl->flags & ~INVERSION_UNAFFECTED_FLAGS;
817         cl->flags &= (and_with->flags & INVERSION_UNAFFECTED_FLAGS);
818         cl->flags |= affected_flags;
819
820         /* We currently don't know how to deal with things that aren't in the
821          * bitmap, but we know that the intersection is no greater than what
822          * is already in cl, so let there be false positives that get sorted
823          * out after the synthetic start class succeeds, and the node is
824          * matched for real. */
825
826         /* The inversion of these two flags indicate that the resulting
827          * intersection doesn't have them */
828         if (and_with->flags & ANYOF_UNICODE_ALL) {
829             cl->flags &= ~ANYOF_UNICODE_ALL;
830         }
831         if (and_with->flags & ANYOF_NON_UTF8_LATIN1_ALL) {
832             cl->flags &= ~ANYOF_NON_UTF8_LATIN1_ALL;
833         }
834     }
835     else {   /* and'd node is not inverted */
836         U8 outside_bitmap_but_not_utf8; /* Temp variable */
837
838         if (! ANYOF_NONBITMAP(and_with)) {
839
840             /* Here 'and_with' doesn't match anything outside the bitmap
841              * (except possibly ANYOF_UNICODE_ALL), which means the
842              * intersection can't either, except for ANYOF_UNICODE_ALL, in
843              * which case we don't know what the intersection is, but it's no
844              * greater than what cl already has, so can just leave it alone,
845              * with possible false positives */
846             if (! (and_with->flags & ANYOF_UNICODE_ALL)) {
847                 ARG_SET(cl, ANYOF_NONBITMAP_EMPTY);
848                 cl->flags &= ~ANYOF_NONBITMAP_NON_UTF8;
849             }
850         }
851         else if (! ANYOF_NONBITMAP(cl)) {
852
853             /* Here, 'and_with' does match something outside the bitmap, and cl
854              * doesn't have a list of things to match outside the bitmap.  If
855              * cl can match all code points above 255, the intersection will
856              * be those above-255 code points that 'and_with' matches.  If cl
857              * can't match all Unicode code points, it means that it can't
858              * match anything outside the bitmap (since the 'if' that got us
859              * into this block tested for that), so we leave the bitmap empty.
860              */
861             if (cl->flags & ANYOF_UNICODE_ALL) {
862                 ARG_SET(cl, ARG(and_with));
863
864                 /* and_with's ARG may match things that don't require UTF8.
865                  * And now cl's will too, in spite of this being an 'and'.  See
866                  * the comments below about the kludge */
867                 cl->flags |= and_with->flags & ANYOF_NONBITMAP_NON_UTF8;
868             }
869         }
870         else {
871             /* Here, both 'and_with' and cl match something outside the
872              * bitmap.  Currently we do not do the intersection, so just match
873              * whatever cl had at the beginning.  */
874         }
875
876
877         /* Take the intersection of the two sets of flags.  However, the
878          * ANYOF_NONBITMAP_NON_UTF8 flag is treated as an 'or'.  This is a
879          * kludge around the fact that this flag is not treated like the others
880          * which are initialized in cl_anything().  The way the optimizer works
881          * is that the synthetic start class (SSC) is initialized to match
882          * anything, and then the first time a real node is encountered, its
883          * values are AND'd with the SSC's with the result being the values of
884          * the real node.  However, there are paths through the optimizer where
885          * the AND never gets called, so those initialized bits are set
886          * inappropriately, which is not usually a big deal, as they just cause
887          * false positives in the SSC, which will just mean a probably
888          * imperceptible slow down in execution.  However this bit has a
889          * higher false positive consequence in that it can cause utf8.pm,
890          * utf8_heavy.pl ... to be loaded when not necessary, which is a much
891          * bigger slowdown and also causes significant extra memory to be used.
892          * In order to prevent this, the code now takes a different tack.  The
893          * bit isn't set unless some part of the regular expression needs it,
894          * but once set it won't get cleared.  This means that these extra
895          * modules won't get loaded unless there was some path through the
896          * pattern that would have required them anyway, and  so any false
897          * positives that occur by not ANDing them out when they could be
898          * aren't as severe as they would be if we treated this bit like all
899          * the others */
900         outside_bitmap_but_not_utf8 = (cl->flags | and_with->flags)
901                                       & ANYOF_NONBITMAP_NON_UTF8;
902         cl->flags &= and_with->flags;
903         cl->flags |= outside_bitmap_but_not_utf8;
904     }
905 }
906
907 /* 'OR' a given class with another one.  Can create false positives.  'cl'
908  * should not be inverted.  'or_with->flags & ANYOF_CLASS' should be 0 if
909  * 'or_with' is a regnode_charclass instead of a regnode_charclass_class. */
910 STATIC void
911 S_cl_or(const RExC_state_t *pRExC_state, struct regnode_charclass_class *cl, const struct regnode_charclass_class *or_with)
912 {
913     PERL_ARGS_ASSERT_CL_OR;
914
915     if (or_with->flags & ANYOF_INVERT) {
916
917         /* Here, the or'd node is to be inverted.  This means we take the
918          * complement of everything not in the bitmap, but currently we don't
919          * know what that is, so give up and match anything */
920         if (ANYOF_NONBITMAP(or_with)) {
921             cl_anything(pRExC_state, cl);
922         }
923         /* We do not use
924          * (B1 | CL1) | (!B2 & !CL2) = (B1 | !B2 & !CL2) | (CL1 | (!B2 & !CL2))
925          *   <= (B1 | !B2) | (CL1 | !CL2)
926          * which is wasteful if CL2 is small, but we ignore CL2:
927          *   (B1 | CL1) | (!B2 & !CL2) <= (B1 | CL1) | !B2 = (B1 | !B2) | CL1
928          * XXXX Can we handle case-fold?  Unclear:
929          *   (OK1(i) | OK1(i')) | !(OK1(i) | OK1(i')) =
930          *   (OK1(i) | OK1(i')) | (!OK1(i) & !OK1(i'))
931          */
932         else if ( (or_with->flags & ANYOF_LOCALE) == (cl->flags & ANYOF_LOCALE)
933              && !(or_with->flags & ANYOF_LOC_NONBITMAP_FOLD)
934              && !(cl->flags & ANYOF_LOC_NONBITMAP_FOLD) ) {
935             int i;
936
937             for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
938                 cl->bitmap[i] |= ~or_with->bitmap[i];
939         } /* XXXX: logic is complicated otherwise */
940         else {
941             cl_anything(pRExC_state, cl);
942         }
943
944         /* And, we can just take the union of the flags that aren't affected
945          * by the inversion */
946         cl->flags |= or_with->flags & INVERSION_UNAFFECTED_FLAGS;
947
948         /* For the remaining flags:
949             ANYOF_UNICODE_ALL and inverted means to not match anything above
950                     255, which means that the union with cl should just be
951                     what cl has in it, so can ignore this flag
952             ANYOF_NON_UTF8_LATIN1_ALL and inverted means if not utf8 and ord
953                     is 127-255 to match them, but then invert that, so the
954                     union with cl should just be what cl has in it, so can
955                     ignore this flag
956          */
957     } else {    /* 'or_with' is not inverted */
958         /* (B1 | CL1) | (B2 | CL2) = (B1 | B2) | (CL1 | CL2)) */
959         if ( (or_with->flags & ANYOF_LOCALE) == (cl->flags & ANYOF_LOCALE)
960              && (!(or_with->flags & ANYOF_LOC_NONBITMAP_FOLD)
961                  || (cl->flags & ANYOF_LOC_NONBITMAP_FOLD)) ) {
962             int i;
963
964             /* OR char bitmap and class bitmap separately */
965             for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
966                 cl->bitmap[i] |= or_with->bitmap[i];
967             if (ANYOF_CLASS_TEST_ANY_SET(or_with)) {
968                 for (i = 0; i < ANYOF_CLASSBITMAP_SIZE; i++)
969                     cl->classflags[i] |= or_with->classflags[i];
970                 cl->flags |= ANYOF_CLASS;
971             }
972         }
973         else { /* XXXX: logic is complicated, leave it along for a moment. */
974             cl_anything(pRExC_state, cl);
975         }
976
977         if (ANYOF_NONBITMAP(or_with)) {
978
979             /* Use the added node's outside-the-bit-map match if there isn't a
980              * conflict.  If there is a conflict (both nodes match something
981              * outside the bitmap, but what they match outside is not the same
982              * pointer, and hence not easily compared until XXX we extend
983              * inversion lists this far), give up and allow the start class to
984              * match everything outside the bitmap.  If that stuff is all above
985              * 255, can just set UNICODE_ALL, otherwise caould be anything. */
986             if (! ANYOF_NONBITMAP(cl)) {
987                 ARG_SET(cl, ARG(or_with));
988             }
989             else if (ARG(cl) != ARG(or_with)) {
990
991                 if ((or_with->flags & ANYOF_NONBITMAP_NON_UTF8)) {
992                     cl_anything(pRExC_state, cl);
993                 }
994                 else {
995                     cl->flags |= ANYOF_UNICODE_ALL;
996                 }
997             }
998         }
999
1000         /* Take the union */
1001         cl->flags |= or_with->flags;
1002     }
1003 }
1004
1005 #define TRIE_LIST_ITEM(state,idx) (trie->states[state].trans.list)[ idx ]
1006 #define TRIE_LIST_CUR(state)  ( TRIE_LIST_ITEM( state, 0 ).forid )
1007 #define TRIE_LIST_LEN(state) ( TRIE_LIST_ITEM( state, 0 ).newstate )
1008 #define TRIE_LIST_USED(idx)  ( trie->states[state].trans.list ? (TRIE_LIST_CUR( idx ) - 1) : 0 )
1009
1010
1011 #ifdef DEBUGGING
1012 /*
1013    dump_trie(trie,widecharmap,revcharmap)
1014    dump_trie_interim_list(trie,widecharmap,revcharmap,next_alloc)
1015    dump_trie_interim_table(trie,widecharmap,revcharmap,next_alloc)
1016
1017    These routines dump out a trie in a somewhat readable format.
1018    The _interim_ variants are used for debugging the interim
1019    tables that are used to generate the final compressed
1020    representation which is what dump_trie expects.
1021
1022    Part of the reason for their existence is to provide a form
1023    of documentation as to how the different representations function.
1024
1025 */
1026
1027 /*
1028   Dumps the final compressed table form of the trie to Perl_debug_log.
1029   Used for debugging make_trie().
1030 */
1031
1032 STATIC void
1033 S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap,
1034             AV *revcharmap, U32 depth)
1035 {
1036     U32 state;
1037     SV *sv=sv_newmortal();
1038     int colwidth= widecharmap ? 6 : 4;
1039     U16 word;
1040     GET_RE_DEBUG_FLAGS_DECL;
1041
1042     PERL_ARGS_ASSERT_DUMP_TRIE;
1043
1044     PerlIO_printf( Perl_debug_log, "%*sChar : %-6s%-6s%-4s ",
1045         (int)depth * 2 + 2,"",
1046         "Match","Base","Ofs" );
1047
1048     for( state = 0 ; state < trie->uniquecharcount ; state++ ) {
1049         SV ** const tmp = av_fetch( revcharmap, state, 0);
1050         if ( tmp ) {
1051             PerlIO_printf( Perl_debug_log, "%*s", 
1052                 colwidth,
1053                 pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), colwidth, 
1054                             PL_colors[0], PL_colors[1],
1055                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
1056                             PERL_PV_ESCAPE_FIRSTCHAR 
1057                 ) 
1058             );
1059         }
1060     }
1061     PerlIO_printf( Perl_debug_log, "\n%*sState|-----------------------",
1062         (int)depth * 2 + 2,"");
1063
1064     for( state = 0 ; state < trie->uniquecharcount ; state++ )
1065         PerlIO_printf( Perl_debug_log, "%.*s", colwidth, "--------");
1066     PerlIO_printf( Perl_debug_log, "\n");
1067
1068     for( state = 1 ; state < trie->statecount ; state++ ) {
1069         const U32 base = trie->states[ state ].trans.base;
1070
1071         PerlIO_printf( Perl_debug_log, "%*s#%4"UVXf"|", (int)depth * 2 + 2,"", (UV)state);
1072
1073         if ( trie->states[ state ].wordnum ) {
1074             PerlIO_printf( Perl_debug_log, " W%4X", trie->states[ state ].wordnum );
1075         } else {
1076             PerlIO_printf( Perl_debug_log, "%6s", "" );
1077         }
1078
1079         PerlIO_printf( Perl_debug_log, " @%4"UVXf" ", (UV)base );
1080
1081         if ( base ) {
1082             U32 ofs = 0;
1083
1084             while( ( base + ofs  < trie->uniquecharcount ) ||
1085                    ( base + ofs - trie->uniquecharcount < trie->lasttrans
1086                      && trie->trans[ base + ofs - trie->uniquecharcount ].check != state))
1087                     ofs++;
1088
1089             PerlIO_printf( Perl_debug_log, "+%2"UVXf"[ ", (UV)ofs);
1090
1091             for ( ofs = 0 ; ofs < trie->uniquecharcount ; ofs++ ) {
1092                 if ( ( base + ofs >= trie->uniquecharcount ) &&
1093                      ( base + ofs - trie->uniquecharcount < trie->lasttrans ) &&
1094                      trie->trans[ base + ofs - trie->uniquecharcount ].check == state )
1095                 {
1096                    PerlIO_printf( Perl_debug_log, "%*"UVXf,
1097                     colwidth,
1098                     (UV)trie->trans[ base + ofs - trie->uniquecharcount ].next );
1099                 } else {
1100                     PerlIO_printf( Perl_debug_log, "%*s",colwidth,"   ." );
1101                 }
1102             }
1103
1104             PerlIO_printf( Perl_debug_log, "]");
1105
1106         }
1107         PerlIO_printf( Perl_debug_log, "\n" );
1108     }
1109     PerlIO_printf(Perl_debug_log, "%*sword_info N:(prev,len)=", (int)depth*2, "");
1110     for (word=1; word <= trie->wordcount; word++) {
1111         PerlIO_printf(Perl_debug_log, " %d:(%d,%d)",
1112             (int)word, (int)(trie->wordinfo[word].prev),
1113             (int)(trie->wordinfo[word].len));
1114     }
1115     PerlIO_printf(Perl_debug_log, "\n" );
1116 }    
1117 /*
1118   Dumps a fully constructed but uncompressed trie in list form.
1119   List tries normally only are used for construction when the number of 
1120   possible chars (trie->uniquecharcount) is very high.
1121   Used for debugging make_trie().
1122 */
1123 STATIC void
1124 S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie,
1125                          HV *widecharmap, AV *revcharmap, U32 next_alloc,
1126                          U32 depth)
1127 {
1128     U32 state;
1129     SV *sv=sv_newmortal();
1130     int colwidth= widecharmap ? 6 : 4;
1131     GET_RE_DEBUG_FLAGS_DECL;
1132
1133     PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST;
1134
1135     /* print out the table precompression.  */
1136     PerlIO_printf( Perl_debug_log, "%*sState :Word | Transition Data\n%*s%s",
1137         (int)depth * 2 + 2,"", (int)depth * 2 + 2,"",
1138         "------:-----+-----------------\n" );
1139     
1140     for( state=1 ; state < next_alloc ; state ++ ) {
1141         U16 charid;
1142     
1143         PerlIO_printf( Perl_debug_log, "%*s %4"UVXf" :",
1144             (int)depth * 2 + 2,"", (UV)state  );
1145         if ( ! trie->states[ state ].wordnum ) {
1146             PerlIO_printf( Perl_debug_log, "%5s| ","");
1147         } else {
1148             PerlIO_printf( Perl_debug_log, "W%4x| ",
1149                 trie->states[ state ].wordnum
1150             );
1151         }
1152         for( charid = 1 ; charid <= TRIE_LIST_USED( state ) ; charid++ ) {
1153             SV ** const tmp = av_fetch( revcharmap, TRIE_LIST_ITEM(state,charid).forid, 0);
1154             if ( tmp ) {
1155                 PerlIO_printf( Perl_debug_log, "%*s:%3X=%4"UVXf" | ",
1156                     colwidth,
1157                     pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), colwidth, 
1158                             PL_colors[0], PL_colors[1],
1159                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
1160                             PERL_PV_ESCAPE_FIRSTCHAR 
1161                     ) ,
1162                     TRIE_LIST_ITEM(state,charid).forid,
1163                     (UV)TRIE_LIST_ITEM(state,charid).newstate
1164                 );
1165                 if (!(charid % 10)) 
1166                     PerlIO_printf(Perl_debug_log, "\n%*s| ",
1167                         (int)((depth * 2) + 14), "");
1168             }
1169         }
1170         PerlIO_printf( Perl_debug_log, "\n");
1171     }
1172 }    
1173
1174 /*
1175   Dumps a fully constructed but uncompressed trie in table form.
1176   This is the normal DFA style state transition table, with a few 
1177   twists to facilitate compression later. 
1178   Used for debugging make_trie().
1179 */
1180 STATIC void
1181 S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie,
1182                           HV *widecharmap, AV *revcharmap, U32 next_alloc,
1183                           U32 depth)
1184 {
1185     U32 state;
1186     U16 charid;
1187     SV *sv=sv_newmortal();
1188     int colwidth= widecharmap ? 6 : 4;
1189     GET_RE_DEBUG_FLAGS_DECL;
1190
1191     PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE;
1192     
1193     /*
1194        print out the table precompression so that we can do a visual check
1195        that they are identical.
1196      */
1197     
1198     PerlIO_printf( Perl_debug_log, "%*sChar : ",(int)depth * 2 + 2,"" );
1199
1200     for( charid = 0 ; charid < trie->uniquecharcount ; charid++ ) {
1201         SV ** const tmp = av_fetch( revcharmap, charid, 0);
1202         if ( tmp ) {
1203             PerlIO_printf( Perl_debug_log, "%*s", 
1204                 colwidth,
1205                 pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), colwidth, 
1206                             PL_colors[0], PL_colors[1],
1207                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
1208                             PERL_PV_ESCAPE_FIRSTCHAR 
1209                 ) 
1210             );
1211         }
1212     }
1213
1214     PerlIO_printf( Perl_debug_log, "\n%*sState+-",(int)depth * 2 + 2,"" );
1215
1216     for( charid=0 ; charid < trie->uniquecharcount ; charid++ ) {
1217         PerlIO_printf( Perl_debug_log, "%.*s", colwidth,"--------");
1218     }
1219
1220     PerlIO_printf( Perl_debug_log, "\n" );
1221
1222     for( state=1 ; state < next_alloc ; state += trie->uniquecharcount ) {
1223
1224         PerlIO_printf( Perl_debug_log, "%*s%4"UVXf" : ", 
1225             (int)depth * 2 + 2,"",
1226             (UV)TRIE_NODENUM( state ) );
1227
1228         for( charid = 0 ; charid < trie->uniquecharcount ; charid++ ) {
1229             UV v=(UV)SAFE_TRIE_NODENUM( trie->trans[ state + charid ].next );
1230             if (v)
1231                 PerlIO_printf( Perl_debug_log, "%*"UVXf, colwidth, v );
1232             else
1233                 PerlIO_printf( Perl_debug_log, "%*s", colwidth, "." );
1234         }
1235         if ( ! trie->states[ TRIE_NODENUM( state ) ].wordnum ) {
1236             PerlIO_printf( Perl_debug_log, " (%4"UVXf")\n", (UV)trie->trans[ state ].check );
1237         } else {
1238             PerlIO_printf( Perl_debug_log, " (%4"UVXf") W%4X\n", (UV)trie->trans[ state ].check,
1239             trie->states[ TRIE_NODENUM( state ) ].wordnum );
1240         }
1241     }
1242 }
1243
1244 #endif
1245
1246
1247 /* make_trie(startbranch,first,last,tail,word_count,flags,depth)
1248   startbranch: the first branch in the whole branch sequence
1249   first      : start branch of sequence of branch-exact nodes.
1250                May be the same as startbranch
1251   last       : Thing following the last branch.
1252                May be the same as tail.
1253   tail       : item following the branch sequence
1254   count      : words in the sequence
1255   flags      : currently the OP() type we will be building one of /EXACT(|F|Fl)/
1256   depth      : indent depth
1257
1258 Inplace optimizes a sequence of 2 or more Branch-Exact nodes into a TRIE node.
1259
1260 A trie is an N'ary tree where the branches are determined by digital
1261 decomposition of the key. IE, at the root node you look up the 1st character and
1262 follow that branch repeat until you find the end of the branches. Nodes can be
1263 marked as "accepting" meaning they represent a complete word. Eg:
1264
1265   /he|she|his|hers/
1266
1267 would convert into the following structure. Numbers represent states, letters
1268 following numbers represent valid transitions on the letter from that state, if
1269 the number is in square brackets it represents an accepting state, otherwise it
1270 will be in parenthesis.
1271
1272       +-h->+-e->[3]-+-r->(8)-+-s->[9]
1273       |    |
1274       |   (2)
1275       |    |
1276      (1)   +-i->(6)-+-s->[7]
1277       |
1278       +-s->(3)-+-h->(4)-+-e->[5]
1279
1280       Accept Word Mapping: 3=>1 (he),5=>2 (she), 7=>3 (his), 9=>4 (hers)
1281
1282 This shows that when matching against the string 'hers' we will begin at state 1
1283 read 'h' and move to state 2, read 'e' and move to state 3 which is accepting,
1284 then read 'r' and go to state 8 followed by 's' which takes us to state 9 which
1285 is also accepting. Thus we know that we can match both 'he' and 'hers' with a
1286 single traverse. We store a mapping from accepting to state to which word was
1287 matched, and then when we have multiple possibilities we try to complete the
1288 rest of the regex in the order in which they occured in the alternation.
1289
1290 The only prior NFA like behaviour that would be changed by the TRIE support is
1291 the silent ignoring of duplicate alternations which are of the form:
1292
1293  / (DUPE|DUPE) X? (?{ ... }) Y /x
1294
1295 Thus EVAL blocks following a trie may be called a different number of times with
1296 and without the optimisation. With the optimisations dupes will be silently
1297 ignored. This inconsistent behaviour of EVAL type nodes is well established as
1298 the following demonstrates:
1299
1300  'words'=~/(word|word|word)(?{ print $1 })[xyz]/
1301
1302 which prints out 'word' three times, but
1303
1304  'words'=~/(word|word|word)(?{ print $1 })S/
1305
1306 which doesnt print it out at all. This is due to other optimisations kicking in.
1307
1308 Example of what happens on a structural level:
1309
1310 The regexp /(ac|ad|ab)+/ will produce the following debug output:
1311
1312    1: CURLYM[1] {1,32767}(18)
1313    5:   BRANCH(8)
1314    6:     EXACT <ac>(16)
1315    8:   BRANCH(11)
1316    9:     EXACT <ad>(16)
1317   11:   BRANCH(14)
1318   12:     EXACT <ab>(16)
1319   16:   SUCCEED(0)
1320   17:   NOTHING(18)
1321   18: END(0)
1322
1323 This would be optimizable with startbranch=5, first=5, last=16, tail=16
1324 and should turn into:
1325
1326    1: CURLYM[1] {1,32767}(18)
1327    5:   TRIE(16)
1328         [Words:3 Chars Stored:6 Unique Chars:4 States:5 NCP:1]
1329           <ac>
1330           <ad>
1331           <ab>
1332   16:   SUCCEED(0)
1333   17:   NOTHING(18)
1334   18: END(0)
1335
1336 Cases where tail != last would be like /(?foo|bar)baz/:
1337
1338    1: BRANCH(4)
1339    2:   EXACT <foo>(8)
1340    4: BRANCH(7)
1341    5:   EXACT <bar>(8)
1342    7: TAIL(8)
1343    8: EXACT <baz>(10)
1344   10: END(0)
1345
1346 which would be optimizable with startbranch=1, first=1, last=7, tail=8
1347 and would end up looking like:
1348
1349     1: TRIE(8)
1350       [Words:2 Chars Stored:6 Unique Chars:5 States:7 NCP:1]
1351         <foo>
1352         <bar>
1353    7: TAIL(8)
1354    8: EXACT <baz>(10)
1355   10: END(0)
1356
1357     d = uvuni_to_utf8_flags(d, uv, 0);
1358
1359 is the recommended Unicode-aware way of saying
1360
1361     *(d++) = uv;
1362 */
1363
1364 #define TRIE_STORE_REVCHAR                                                 \
1365     STMT_START {                                                           \
1366         if (UTF) {                                                         \
1367             SV *zlopp = newSV(2);                                          \
1368             unsigned char *flrbbbbb = (unsigned char *) SvPVX(zlopp);      \
1369             unsigned const char *const kapow = uvuni_to_utf8(flrbbbbb, uvc & 0xFF); \
1370             SvCUR_set(zlopp, kapow - flrbbbbb);                            \
1371             SvPOK_on(zlopp);                                               \
1372             SvUTF8_on(zlopp);                                              \
1373             av_push(revcharmap, zlopp);                                    \
1374         } else {                                                           \
1375             char ooooff = (char)uvc;                                               \
1376             av_push(revcharmap, newSVpvn(&ooooff, 1));                     \
1377         }                                                                  \
1378         } STMT_END
1379
1380 #define TRIE_READ_CHAR STMT_START {                                           \
1381     wordlen++;                                                                \
1382     if ( UTF ) {                                                              \
1383         if ( folder ) {                                                       \
1384             if ( foldlen > 0 ) {                                              \
1385                uvc = utf8n_to_uvuni( scan, UTF8_MAXLEN, &len, uniflags );     \
1386                foldlen -= len;                                                \
1387                scan += len;                                                   \
1388                len = 0;                                                       \
1389             } else {                                                          \
1390                 uvc = utf8n_to_uvuni( (const U8*)uc, UTF8_MAXLEN, &len, uniflags);\
1391                 uvc = to_uni_fold( uvc, foldbuf, &foldlen );                  \
1392                 foldlen -= UNISKIP( uvc );                                    \
1393                 scan = foldbuf + UNISKIP( uvc );                              \
1394             }                                                                 \
1395         } else {                                                              \
1396             uvc = utf8n_to_uvuni( (const U8*)uc, UTF8_MAXLEN, &len, uniflags);\
1397         }                                                                     \
1398     } else {                                                                  \
1399         uvc = (U32)*uc;                                                       \
1400         len = 1;                                                              \
1401     }                                                                         \
1402 } STMT_END
1403
1404
1405
1406 #define TRIE_LIST_PUSH(state,fid,ns) STMT_START {               \
1407     if ( TRIE_LIST_CUR( state ) >=TRIE_LIST_LEN( state ) ) {    \
1408         U32 ging = TRIE_LIST_LEN( state ) *= 2;                 \
1409         Renew( trie->states[ state ].trans.list, ging, reg_trie_trans_le ); \
1410     }                                                           \
1411     TRIE_LIST_ITEM( state, TRIE_LIST_CUR( state ) ).forid = fid;     \
1412     TRIE_LIST_ITEM( state, TRIE_LIST_CUR( state ) ).newstate = ns;   \
1413     TRIE_LIST_CUR( state )++;                                   \
1414 } STMT_END
1415
1416 #define TRIE_LIST_NEW(state) STMT_START {                       \
1417     Newxz( trie->states[ state ].trans.list,               \
1418         4, reg_trie_trans_le );                                 \
1419      TRIE_LIST_CUR( state ) = 1;                                \
1420      TRIE_LIST_LEN( state ) = 4;                                \
1421 } STMT_END
1422
1423 #define TRIE_HANDLE_WORD(state) STMT_START {                    \
1424     U16 dupe= trie->states[ state ].wordnum;                    \
1425     regnode * const noper_next = regnext( noper );              \
1426                                                                 \
1427     DEBUG_r({                                                   \
1428         /* store the word for dumping */                        \
1429         SV* tmp;                                                \
1430         if (OP(noper) != NOTHING)                               \
1431             tmp = newSVpvn_utf8(STRING(noper), STR_LEN(noper), UTF);    \
1432         else                                                    \
1433             tmp = newSVpvn_utf8( "", 0, UTF );                  \
1434         av_push( trie_words, tmp );                             \
1435     });                                                         \
1436                                                                 \
1437     curword++;                                                  \
1438     trie->wordinfo[curword].prev   = 0;                         \
1439     trie->wordinfo[curword].len    = wordlen;                   \
1440     trie->wordinfo[curword].accept = state;                     \
1441                                                                 \
1442     if ( noper_next < tail ) {                                  \
1443         if (!trie->jump)                                        \
1444             trie->jump = (U16 *) PerlMemShared_calloc( word_count + 1, sizeof(U16) ); \
1445         trie->jump[curword] = (U16)(noper_next - convert);      \
1446         if (!jumper)                                            \
1447             jumper = noper_next;                                \
1448         if (!nextbranch)                                        \
1449             nextbranch= regnext(cur);                           \
1450     }                                                           \
1451                                                                 \
1452     if ( dupe ) {                                               \
1453         /* It's a dupe. Pre-insert into the wordinfo[].prev   */\
1454         /* chain, so that when the bits of chain are later    */\
1455         /* linked together, the dups appear in the chain      */\
1456         trie->wordinfo[curword].prev = trie->wordinfo[dupe].prev; \
1457         trie->wordinfo[dupe].prev = curword;                    \
1458     } else {                                                    \
1459         /* we haven't inserted this word yet.                */ \
1460         trie->states[ state ].wordnum = curword;                \
1461     }                                                           \
1462 } STMT_END
1463
1464
1465 #define TRIE_TRANS_STATE(state,base,ucharcount,charid,special)          \
1466      ( ( base + charid >=  ucharcount                                   \
1467          && base + charid < ubound                                      \
1468          && state == trie->trans[ base - ucharcount + charid ].check    \
1469          && trie->trans[ base - ucharcount + charid ].next )            \
1470            ? trie->trans[ base - ucharcount + charid ].next             \
1471            : ( state==1 ? special : 0 )                                 \
1472       )
1473
1474 #define MADE_TRIE       1
1475 #define MADE_JUMP_TRIE  2
1476 #define MADE_EXACT_TRIE 4
1477
1478 STATIC I32
1479 S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth)
1480 {
1481     dVAR;
1482     /* first pass, loop through and scan words */
1483     reg_trie_data *trie;
1484     HV *widecharmap = NULL;
1485     AV *revcharmap = newAV();
1486     regnode *cur;
1487     const U32 uniflags = UTF8_ALLOW_DEFAULT;
1488     STRLEN len = 0;
1489     UV uvc = 0;
1490     U16 curword = 0;
1491     U32 next_alloc = 0;
1492     regnode *jumper = NULL;
1493     regnode *nextbranch = NULL;
1494     regnode *convert = NULL;
1495     U32 *prev_states; /* temp array mapping each state to previous one */
1496     /* we just use folder as a flag in utf8 */
1497     const U8 * folder = NULL;
1498
1499 #ifdef DEBUGGING
1500     const U32 data_slot = add_data( pRExC_state, 4, "tuuu" );
1501     AV *trie_words = NULL;
1502     /* along with revcharmap, this only used during construction but both are
1503      * useful during debugging so we store them in the struct when debugging.
1504      */
1505 #else
1506     const U32 data_slot = add_data( pRExC_state, 2, "tu" );
1507     STRLEN trie_charcount=0;
1508 #endif
1509     SV *re_trie_maxbuff;
1510     GET_RE_DEBUG_FLAGS_DECL;
1511
1512     PERL_ARGS_ASSERT_MAKE_TRIE;
1513 #ifndef DEBUGGING
1514     PERL_UNUSED_ARG(depth);
1515 #endif
1516
1517     switch (flags) {
1518         case EXACTFA:
1519         case EXACTFU: folder = PL_fold_latin1; break;
1520         case EXACTF:  folder = PL_fold; break;
1521         case EXACTFL: folder = PL_fold_locale; break;
1522     }
1523
1524     trie = (reg_trie_data *) PerlMemShared_calloc( 1, sizeof(reg_trie_data) );
1525     trie->refcount = 1;
1526     trie->startstate = 1;
1527     trie->wordcount = word_count;
1528     RExC_rxi->data->data[ data_slot ] = (void*)trie;
1529     trie->charmap = (U16 *) PerlMemShared_calloc( 256, sizeof(U16) );
1530     if (!(UTF && folder))
1531         trie->bitmap = (char *) PerlMemShared_calloc( ANYOF_BITMAP_SIZE, 1 );
1532     trie->wordinfo = (reg_trie_wordinfo *) PerlMemShared_calloc(
1533                        trie->wordcount+1, sizeof(reg_trie_wordinfo));
1534
1535     DEBUG_r({
1536         trie_words = newAV();
1537     });
1538
1539     re_trie_maxbuff = get_sv(RE_TRIE_MAXBUF_NAME, 1);
1540     if (!SvIOK(re_trie_maxbuff)) {
1541         sv_setiv(re_trie_maxbuff, RE_TRIE_MAXBUF_INIT);
1542     }
1543     DEBUG_OPTIMISE_r({
1544                 PerlIO_printf( Perl_debug_log,
1545                   "%*smake_trie start==%d, first==%d, last==%d, tail==%d depth=%d\n",
1546                   (int)depth * 2 + 2, "", 
1547                   REG_NODE_NUM(startbranch),REG_NODE_NUM(first), 
1548                   REG_NODE_NUM(last), REG_NODE_NUM(tail),
1549                   (int)depth);
1550     });
1551    
1552    /* Find the node we are going to overwrite */
1553     if ( first == startbranch && OP( last ) != BRANCH ) {
1554         /* whole branch chain */
1555         convert = first;
1556     } else {
1557         /* branch sub-chain */
1558         convert = NEXTOPER( first );
1559     }
1560         
1561     /*  -- First loop and Setup --
1562
1563        We first traverse the branches and scan each word to determine if it
1564        contains widechars, and how many unique chars there are, this is
1565        important as we have to build a table with at least as many columns as we
1566        have unique chars.
1567
1568        We use an array of integers to represent the character codes 0..255
1569        (trie->charmap) and we use a an HV* to store Unicode characters. We use the
1570        native representation of the character value as the key and IV's for the
1571        coded index.
1572
1573        *TODO* If we keep track of how many times each character is used we can
1574        remap the columns so that the table compression later on is more
1575        efficient in terms of memory by ensuring the most common value is in the
1576        middle and the least common are on the outside.  IMO this would be better
1577        than a most to least common mapping as theres a decent chance the most
1578        common letter will share a node with the least common, meaning the node
1579        will not be compressible. With a middle is most common approach the worst
1580        case is when we have the least common nodes twice.
1581
1582      */
1583
1584     for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
1585         regnode * const noper = NEXTOPER( cur );
1586         const U8 *uc = (U8*)STRING( noper );
1587         const U8 * const e  = uc + STR_LEN( noper );
1588         STRLEN foldlen = 0;
1589         U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
1590         const U8 *scan = (U8*)NULL;
1591         U32 wordlen      = 0;         /* required init */
1592         STRLEN chars = 0;
1593         bool set_bit = trie->bitmap ? 1 : 0; /*store the first char in the bitmap?*/
1594
1595         if (OP(noper) == NOTHING) {
1596             trie->minlen= 0;
1597             continue;
1598         }
1599         if ( set_bit ) /* bitmap only alloced when !(UTF&&Folding) */
1600             TRIE_BITMAP_SET(trie,*uc); /* store the raw first byte
1601                                           regardless of encoding */
1602
1603         for ( ; uc < e ; uc += len ) {
1604             TRIE_CHARCOUNT(trie)++;
1605             TRIE_READ_CHAR;
1606             chars++;
1607             if ( uvc < 256 ) {
1608                 if ( !trie->charmap[ uvc ] ) {
1609                     trie->charmap[ uvc ]=( ++trie->uniquecharcount );
1610                     if ( folder )
1611                         trie->charmap[ folder[ uvc ] ] = trie->charmap[ uvc ];
1612                     TRIE_STORE_REVCHAR;
1613                 }
1614                 if ( set_bit ) {
1615                     /* store the codepoint in the bitmap, and its folded
1616                      * equivalent. */
1617                     TRIE_BITMAP_SET(trie,uvc);
1618
1619                     /* store the folded codepoint */
1620                     if ( folder ) TRIE_BITMAP_SET(trie,folder[ uvc ]);
1621
1622                     if ( !UTF ) {
1623                         /* store first byte of utf8 representation of
1624                            variant codepoints */
1625                         if (! UNI_IS_INVARIANT(uvc)) {
1626                             TRIE_BITMAP_SET(trie, UTF8_TWO_BYTE_HI(uvc));
1627                         }
1628                     }
1629                     set_bit = 0; /* We've done our bit :-) */
1630                 }
1631             } else {
1632                 SV** svpp;
1633                 if ( !widecharmap )
1634                     widecharmap = newHV();
1635
1636                 svpp = hv_fetch( widecharmap, (char*)&uvc, sizeof( UV ), 1 );
1637
1638                 if ( !svpp )
1639                     Perl_croak( aTHX_ "error creating/fetching widecharmap entry for 0x%"UVXf, uvc );
1640
1641                 if ( !SvTRUE( *svpp ) ) {
1642                     sv_setiv( *svpp, ++trie->uniquecharcount );
1643                     TRIE_STORE_REVCHAR;
1644                 }
1645             }
1646         }
1647         if( cur == first ) {
1648             trie->minlen=chars;
1649             trie->maxlen=chars;
1650         } else if (chars < trie->minlen) {
1651             trie->minlen=chars;
1652         } else if (chars > trie->maxlen) {
1653             trie->maxlen=chars;
1654         }
1655
1656     } /* end first pass */
1657     DEBUG_TRIE_COMPILE_r(
1658         PerlIO_printf( Perl_debug_log, "%*sTRIE(%s): W:%d C:%d Uq:%d Min:%d Max:%d\n",
1659                 (int)depth * 2 + 2,"",
1660                 ( widecharmap ? "UTF8" : "NATIVE" ), (int)word_count,
1661                 (int)TRIE_CHARCOUNT(trie), trie->uniquecharcount,
1662                 (int)trie->minlen, (int)trie->maxlen )
1663     );
1664
1665     /*
1666         We now know what we are dealing with in terms of unique chars and
1667         string sizes so we can calculate how much memory a naive
1668         representation using a flat table  will take. If it's over a reasonable
1669         limit (as specified by ${^RE_TRIE_MAXBUF}) we use a more memory
1670         conservative but potentially much slower representation using an array
1671         of lists.
1672
1673         At the end we convert both representations into the same compressed
1674         form that will be used in regexec.c for matching with. The latter
1675         is a form that cannot be used to construct with but has memory
1676         properties similar to the list form and access properties similar
1677         to the table form making it both suitable for fast searches and
1678         small enough that its feasable to store for the duration of a program.
1679
1680         See the comment in the code where the compressed table is produced
1681         inplace from the flat tabe representation for an explanation of how
1682         the compression works.
1683
1684     */
1685
1686
1687     Newx(prev_states, TRIE_CHARCOUNT(trie) + 2, U32);
1688     prev_states[1] = 0;
1689
1690     if ( (IV)( ( TRIE_CHARCOUNT(trie) + 1 ) * trie->uniquecharcount + 1) > SvIV(re_trie_maxbuff) ) {
1691         /*
1692             Second Pass -- Array Of Lists Representation
1693
1694             Each state will be represented by a list of charid:state records
1695             (reg_trie_trans_le) the first such element holds the CUR and LEN
1696             points of the allocated array. (See defines above).
1697
1698             We build the initial structure using the lists, and then convert
1699             it into the compressed table form which allows faster lookups
1700             (but cant be modified once converted).
1701         */
1702
1703         STRLEN transcount = 1;
1704
1705         DEBUG_TRIE_COMPILE_MORE_r( PerlIO_printf( Perl_debug_log, 
1706             "%*sCompiling trie using list compiler\n",
1707             (int)depth * 2 + 2, ""));
1708         
1709         trie->states = (reg_trie_state *)
1710             PerlMemShared_calloc( TRIE_CHARCOUNT(trie) + 2,
1711                                   sizeof(reg_trie_state) );
1712         TRIE_LIST_NEW(1);
1713         next_alloc = 2;
1714
1715         for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
1716
1717             regnode * const noper = NEXTOPER( cur );
1718             U8 *uc           = (U8*)STRING( noper );
1719             const U8 * const e = uc + STR_LEN( noper );
1720             U32 state        = 1;         /* required init */
1721             U16 charid       = 0;         /* sanity init */
1722             U8 *scan         = (U8*)NULL; /* sanity init */
1723             STRLEN foldlen   = 0;         /* required init */
1724             U32 wordlen      = 0;         /* required init */
1725             U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
1726
1727             if (OP(noper) != NOTHING) {
1728                 for ( ; uc < e ; uc += len ) {
1729
1730                     TRIE_READ_CHAR;
1731
1732                     if ( uvc < 256 ) {
1733                         charid = trie->charmap[ uvc ];
1734                     } else {
1735                         SV** const svpp = hv_fetch( widecharmap, (char*)&uvc, sizeof( UV ), 0);
1736                         if ( !svpp ) {
1737                             charid = 0;
1738                         } else {
1739                             charid=(U16)SvIV( *svpp );
1740                         }
1741                     }
1742                     /* charid is now 0 if we dont know the char read, or nonzero if we do */
1743                     if ( charid ) {
1744
1745                         U16 check;
1746                         U32 newstate = 0;
1747
1748                         charid--;
1749                         if ( !trie->states[ state ].trans.list ) {
1750                             TRIE_LIST_NEW( state );
1751                         }
1752                         for ( check = 1; check <= TRIE_LIST_USED( state ); check++ ) {
1753                             if ( TRIE_LIST_ITEM( state, check ).forid == charid ) {
1754                                 newstate = TRIE_LIST_ITEM( state, check ).newstate;
1755                                 break;
1756                             }
1757                         }
1758                         if ( ! newstate ) {
1759                             newstate = next_alloc++;
1760                             prev_states[newstate] = state;
1761                             TRIE_LIST_PUSH( state, charid, newstate );
1762                             transcount++;
1763                         }
1764                         state = newstate;
1765                     } else {
1766                         Perl_croak( aTHX_ "panic! In trie construction, no char mapping for %"IVdf, uvc );
1767                     }
1768                 }
1769             }
1770             TRIE_HANDLE_WORD(state);
1771
1772         } /* end second pass */
1773
1774         /* next alloc is the NEXT state to be allocated */
1775         trie->statecount = next_alloc; 
1776         trie->states = (reg_trie_state *)
1777             PerlMemShared_realloc( trie->states,
1778                                    next_alloc
1779                                    * sizeof(reg_trie_state) );
1780
1781         /* and now dump it out before we compress it */
1782         DEBUG_TRIE_COMPILE_MORE_r(dump_trie_interim_list(trie, widecharmap,
1783                                                          revcharmap, next_alloc,
1784                                                          depth+1)
1785         );
1786
1787         trie->trans = (reg_trie_trans *)
1788             PerlMemShared_calloc( transcount, sizeof(reg_trie_trans) );
1789         {
1790             U32 state;
1791             U32 tp = 0;
1792             U32 zp = 0;
1793
1794
1795             for( state=1 ; state < next_alloc ; state ++ ) {
1796                 U32 base=0;
1797
1798                 /*
1799                 DEBUG_TRIE_COMPILE_MORE_r(
1800                     PerlIO_printf( Perl_debug_log, "tp: %d zp: %d ",tp,zp)
1801                 );
1802                 */
1803
1804                 if (trie->states[state].trans.list) {
1805                     U16 minid=TRIE_LIST_ITEM( state, 1).forid;
1806                     U16 maxid=minid;
1807                     U16 idx;
1808
1809                     for( idx = 2 ; idx <= TRIE_LIST_USED( state ) ; idx++ ) {
1810                         const U16 forid = TRIE_LIST_ITEM( state, idx).forid;
1811                         if ( forid < minid ) {
1812                             minid=forid;
1813                         } else if ( forid > maxid ) {
1814                             maxid=forid;
1815                         }
1816                     }
1817                     if ( transcount < tp + maxid - minid + 1) {
1818                         transcount *= 2;
1819                         trie->trans = (reg_trie_trans *)
1820                             PerlMemShared_realloc( trie->trans,
1821                                                      transcount
1822                                                      * sizeof(reg_trie_trans) );
1823                         Zero( trie->trans + (transcount / 2), transcount / 2 , reg_trie_trans );
1824                     }
1825                     base = trie->uniquecharcount + tp - minid;
1826                     if ( maxid == minid ) {
1827                         U32 set = 0;
1828                         for ( ; zp < tp ; zp++ ) {
1829                             if ( ! trie->trans[ zp ].next ) {
1830                                 base = trie->uniquecharcount + zp - minid;
1831                                 trie->trans[ zp ].next = TRIE_LIST_ITEM( state, 1).newstate;
1832                                 trie->trans[ zp ].check = state;
1833                                 set = 1;
1834                                 break;
1835                             }
1836                         }
1837                         if ( !set ) {
1838                             trie->trans[ tp ].next = TRIE_LIST_ITEM( state, 1).newstate;
1839                             trie->trans[ tp ].check = state;
1840                             tp++;
1841                             zp = tp;
1842                         }
1843                     } else {
1844                         for ( idx=1; idx <= TRIE_LIST_USED( state ) ; idx++ ) {
1845                             const U32 tid = base -  trie->uniquecharcount + TRIE_LIST_ITEM( state, idx ).forid;
1846                             trie->trans[ tid ].next = TRIE_LIST_ITEM( state, idx ).newstate;
1847                             trie->trans[ tid ].check = state;
1848                         }
1849                         tp += ( maxid - minid + 1 );
1850                     }
1851                     Safefree(trie->states[ state ].trans.list);
1852                 }
1853                 /*
1854                 DEBUG_TRIE_COMPILE_MORE_r(
1855                     PerlIO_printf( Perl_debug_log, " base: %d\n",base);
1856                 );
1857                 */
1858                 trie->states[ state ].trans.base=base;
1859             }
1860             trie->lasttrans = tp + 1;
1861         }
1862     } else {
1863         /*
1864            Second Pass -- Flat Table Representation.
1865
1866            we dont use the 0 slot of either trans[] or states[] so we add 1 to each.
1867            We know that we will need Charcount+1 trans at most to store the data
1868            (one row per char at worst case) So we preallocate both structures
1869            assuming worst case.
1870
1871            We then construct the trie using only the .next slots of the entry
1872            structs.
1873
1874            We use the .check field of the first entry of the node temporarily to
1875            make compression both faster and easier by keeping track of how many non
1876            zero fields are in the node.
1877
1878            Since trans are numbered from 1 any 0 pointer in the table is a FAIL
1879            transition.
1880
1881            There are two terms at use here: state as a TRIE_NODEIDX() which is a
1882            number representing the first entry of the node, and state as a
1883            TRIE_NODENUM() which is the trans number. state 1 is TRIE_NODEIDX(1) and
1884            TRIE_NODENUM(1), state 2 is TRIE_NODEIDX(2) and TRIE_NODENUM(3) if there
1885            are 2 entrys per node. eg:
1886
1887              A B       A B
1888           1. 2 4    1. 3 7
1889           2. 0 3    3. 0 5
1890           3. 0 0    5. 0 0
1891           4. 0 0    7. 0 0
1892
1893            The table is internally in the right hand, idx form. However as we also
1894            have to deal with the states array which is indexed by nodenum we have to
1895            use TRIE_NODENUM() to convert.
1896
1897         */
1898         DEBUG_TRIE_COMPILE_MORE_r( PerlIO_printf( Perl_debug_log, 
1899             "%*sCompiling trie using table compiler\n",
1900             (int)depth * 2 + 2, ""));
1901
1902         trie->trans = (reg_trie_trans *)
1903             PerlMemShared_calloc( ( TRIE_CHARCOUNT(trie) + 1 )
1904                                   * trie->uniquecharcount + 1,
1905                                   sizeof(reg_trie_trans) );
1906         trie->states = (reg_trie_state *)
1907             PerlMemShared_calloc( TRIE_CHARCOUNT(trie) + 2,
1908                                   sizeof(reg_trie_state) );
1909         next_alloc = trie->uniquecharcount + 1;
1910
1911
1912         for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
1913
1914             regnode * const noper   = NEXTOPER( cur );
1915             const U8 *uc     = (U8*)STRING( noper );
1916             const U8 * const e = uc + STR_LEN( noper );
1917
1918             U32 state        = 1;         /* required init */
1919
1920             U16 charid       = 0;         /* sanity init */
1921             U32 accept_state = 0;         /* sanity init */
1922             U8 *scan         = (U8*)NULL; /* sanity init */
1923
1924             STRLEN foldlen   = 0;         /* required init */
1925             U32 wordlen      = 0;         /* required init */
1926             U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
1927
1928             if ( OP(noper) != NOTHING ) {
1929                 for ( ; uc < e ; uc += len ) {
1930
1931                     TRIE_READ_CHAR;
1932
1933                     if ( uvc < 256 ) {
1934                         charid = trie->charmap[ uvc ];
1935                     } else {
1936                         SV* const * const svpp = hv_fetch( widecharmap, (char*)&uvc, sizeof( UV ), 0);
1937                         charid = svpp ? (U16)SvIV(*svpp) : 0;
1938                     }
1939                     if ( charid ) {
1940                         charid--;
1941                         if ( !trie->trans[ state + charid ].next ) {
1942                             trie->trans[ state + charid ].next = next_alloc;
1943                             trie->trans[ state ].check++;
1944                             prev_states[TRIE_NODENUM(next_alloc)]
1945                                     = TRIE_NODENUM(state);
1946                             next_alloc += trie->uniquecharcount;
1947                         }
1948                         state = trie->trans[ state + charid ].next;
1949                     } else {
1950                         Perl_croak( aTHX_ "panic! In trie construction, no char mapping for %"IVdf, uvc );
1951                     }
1952                     /* charid is now 0 if we dont know the char read, or nonzero if we do */
1953                 }
1954             }
1955             accept_state = TRIE_NODENUM( state );
1956             TRIE_HANDLE_WORD(accept_state);
1957
1958         } /* end second pass */
1959
1960         /* and now dump it out before we compress it */
1961         DEBUG_TRIE_COMPILE_MORE_r(dump_trie_interim_table(trie, widecharmap,
1962                                                           revcharmap,
1963                                                           next_alloc, depth+1));
1964
1965         {
1966         /*
1967            * Inplace compress the table.*
1968
1969            For sparse data sets the table constructed by the trie algorithm will
1970            be mostly 0/FAIL transitions or to put it another way mostly empty.
1971            (Note that leaf nodes will not contain any transitions.)
1972
1973            This algorithm compresses the tables by eliminating most such
1974            transitions, at the cost of a modest bit of extra work during lookup:
1975
1976            - Each states[] entry contains a .base field which indicates the
1977            index in the state[] array wheres its transition data is stored.
1978
1979            - If .base is 0 there are no valid transitions from that node.
1980
1981            - If .base is nonzero then charid is added to it to find an entry in
1982            the trans array.
1983
1984            -If trans[states[state].base+charid].check!=state then the
1985            transition is taken to be a 0/Fail transition. Thus if there are fail
1986            transitions at the front of the node then the .base offset will point
1987            somewhere inside the previous nodes data (or maybe even into a node
1988            even earlier), but the .check field determines if the transition is
1989            valid.
1990
1991            XXX - wrong maybe?
1992            The following process inplace converts the table to the compressed
1993            table: We first do not compress the root node 1,and mark all its
1994            .check pointers as 1 and set its .base pointer as 1 as well. This
1995            allows us to do a DFA construction from the compressed table later,
1996            and ensures that any .base pointers we calculate later are greater
1997            than 0.
1998
1999            - We set 'pos' to indicate the first entry of the second node.
2000
2001            - We then iterate over the columns of the node, finding the first and
2002            last used entry at l and m. We then copy l..m into pos..(pos+m-l),
2003            and set the .check pointers accordingly, and advance pos
2004            appropriately and repreat for the next node. Note that when we copy
2005            the next pointers we have to convert them from the original
2006            NODEIDX form to NODENUM form as the former is not valid post
2007            compression.
2008
2009            - If a node has no transitions used we mark its base as 0 and do not
2010            advance the pos pointer.
2011
2012            - If a node only has one transition we use a second pointer into the
2013            structure to fill in allocated fail transitions from other states.
2014            This pointer is independent of the main pointer and scans forward
2015            looking for null transitions that are allocated to a state. When it
2016            finds one it writes the single transition into the "hole".  If the
2017            pointer doesnt find one the single transition is appended as normal.
2018
2019            - Once compressed we can Renew/realloc the structures to release the
2020            excess space.
2021
2022            See "Table-Compression Methods" in sec 3.9 of the Red Dragon,
2023            specifically Fig 3.47 and the associated pseudocode.
2024
2025            demq
2026         */
2027         const U32 laststate = TRIE_NODENUM( next_alloc );
2028         U32 state, charid;
2029         U32 pos = 0, zp=0;
2030         trie->statecount = laststate;
2031
2032         for ( state = 1 ; state < laststate ; state++ ) {
2033             U8 flag = 0;
2034             const U32 stateidx = TRIE_NODEIDX( state );
2035             const U32 o_used = trie->trans[ stateidx ].check;
2036             U32 used = trie->trans[ stateidx ].check;
2037             trie->trans[ stateidx ].check = 0;
2038
2039             for ( charid = 0 ; used && charid < trie->uniquecharcount ; charid++ ) {
2040                 if ( flag || trie->trans[ stateidx + charid ].next ) {
2041                     if ( trie->trans[ stateidx + charid ].next ) {
2042                         if (o_used == 1) {
2043                             for ( ; zp < pos ; zp++ ) {
2044                                 if ( ! trie->trans[ zp ].next ) {
2045                                     break;
2046                                 }
2047                             }
2048                             trie->states[ state ].trans.base = zp + trie->uniquecharcount - charid ;
2049                             trie->trans[ zp ].next = SAFE_TRIE_NODENUM( trie->trans[ stateidx + charid ].next );
2050                             trie->trans[ zp ].check = state;
2051                             if ( ++zp > pos ) pos = zp;
2052                             break;
2053                         }
2054                         used--;
2055                     }
2056                     if ( !flag ) {
2057                         flag = 1;
2058                         trie->states[ state ].trans.base = pos + trie->uniquecharcount - charid ;
2059                     }
2060                     trie->trans[ pos ].next = SAFE_TRIE_NODENUM( trie->trans[ stateidx + charid ].next );
2061                     trie->trans[ pos ].check = state;
2062                     pos++;
2063                 }
2064             }
2065         }
2066         trie->lasttrans = pos + 1;
2067         trie->states = (reg_trie_state *)
2068             PerlMemShared_realloc( trie->states, laststate
2069                                    * sizeof(reg_trie_state) );
2070         DEBUG_TRIE_COMPILE_MORE_r(
2071                 PerlIO_printf( Perl_debug_log,
2072                     "%*sAlloc: %d Orig: %"IVdf" elements, Final:%"IVdf". Savings of %%%5.2f\n",
2073                     (int)depth * 2 + 2,"",
2074                     (int)( ( TRIE_CHARCOUNT(trie) + 1 ) * trie->uniquecharcount + 1 ),
2075                     (IV)next_alloc,
2076                     (IV)pos,
2077                     ( ( next_alloc - pos ) * 100 ) / (double)next_alloc );
2078             );
2079
2080         } /* end table compress */
2081     }
2082     DEBUG_TRIE_COMPILE_MORE_r(
2083             PerlIO_printf(Perl_debug_log, "%*sStatecount:%"UVxf" Lasttrans:%"UVxf"\n",
2084                 (int)depth * 2 + 2, "",
2085                 (UV)trie->statecount,
2086                 (UV)trie->lasttrans)
2087     );
2088     /* resize the trans array to remove unused space */
2089     trie->trans = (reg_trie_trans *)
2090         PerlMemShared_realloc( trie->trans, trie->lasttrans
2091                                * sizeof(reg_trie_trans) );
2092
2093     {   /* Modify the program and insert the new TRIE node */ 
2094         U8 nodetype =(U8)(flags & 0xFF);
2095         char *str=NULL;
2096         
2097 #ifdef DEBUGGING
2098         regnode *optimize = NULL;
2099 #ifdef RE_TRACK_PATTERN_OFFSETS
2100
2101         U32 mjd_offset = 0;
2102         U32 mjd_nodelen = 0;
2103 #endif /* RE_TRACK_PATTERN_OFFSETS */
2104 #endif /* DEBUGGING */
2105         /*
2106            This means we convert either the first branch or the first Exact,
2107            depending on whether the thing following (in 'last') is a branch
2108            or not and whther first is the startbranch (ie is it a sub part of
2109            the alternation or is it the whole thing.)
2110            Assuming its a sub part we convert the EXACT otherwise we convert
2111            the whole branch sequence, including the first.
2112          */
2113         /* Find the node we are going to overwrite */
2114         if ( first != startbranch || OP( last ) == BRANCH ) {
2115             /* branch sub-chain */
2116             NEXT_OFF( first ) = (U16)(last - first);
2117 #ifdef RE_TRACK_PATTERN_OFFSETS
2118             DEBUG_r({
2119                 mjd_offset= Node_Offset((convert));
2120                 mjd_nodelen= Node_Length((convert));
2121             });
2122 #endif
2123             /* whole branch chain */
2124         }
2125 #ifdef RE_TRACK_PATTERN_OFFSETS
2126         else {
2127             DEBUG_r({
2128                 const  regnode *nop = NEXTOPER( convert );
2129                 mjd_offset= Node_Offset((nop));
2130                 mjd_nodelen= Node_Length((nop));
2131             });
2132         }
2133         DEBUG_OPTIMISE_r(
2134             PerlIO_printf(Perl_debug_log, "%*sMJD offset:%"UVuf" MJD length:%"UVuf"\n",
2135                 (int)depth * 2 + 2, "",
2136                 (UV)mjd_offset, (UV)mjd_nodelen)
2137         );
2138 #endif
2139         /* But first we check to see if there is a common prefix we can 
2140            split out as an EXACT and put in front of the TRIE node.  */
2141         trie->startstate= 1;
2142         if ( trie->bitmap && !widecharmap && !trie->jump  ) {
2143             U32 state;
2144             for ( state = 1 ; state < trie->statecount-1 ; state++ ) {
2145                 U32 ofs = 0;
2146                 I32 idx = -1;
2147                 U32 count = 0;
2148                 const U32 base = trie->states[ state ].trans.base;
2149
2150                 if ( trie->states[state].wordnum )
2151                         count = 1;
2152
2153                 for ( ofs = 0 ; ofs < trie->uniquecharcount ; ofs++ ) {
2154                     if ( ( base + ofs >= trie->uniquecharcount ) &&
2155                          ( base + ofs - trie->uniquecharcount < trie->lasttrans ) &&
2156                          trie->trans[ base + ofs - trie->uniquecharcount ].check == state )
2157                     {
2158                         if ( ++count > 1 ) {
2159                             SV **tmp = av_fetch( revcharmap, ofs, 0);
2160                             const U8 *ch = (U8*)SvPV_nolen_const( *tmp );
2161                             if ( state == 1 ) break;
2162                             if ( count == 2 ) {
2163                                 Zero(trie->bitmap, ANYOF_BITMAP_SIZE, char);
2164                                 DEBUG_OPTIMISE_r(
2165                                     PerlIO_printf(Perl_debug_log,
2166                                         "%*sNew Start State=%"UVuf" Class: [",
2167                                         (int)depth * 2 + 2, "",
2168                                         (UV)state));
2169                                 if (idx >= 0) {
2170                                     SV ** const tmp = av_fetch( revcharmap, idx, 0);
2171                                     const U8 * const ch = (U8*)SvPV_nolen_const( *tmp );
2172
2173                                     TRIE_BITMAP_SET(trie,*ch);
2174                                     if ( folder )
2175                                         TRIE_BITMAP_SET(trie, folder[ *ch ]);
2176                                     DEBUG_OPTIMISE_r(
2177                                         PerlIO_printf(Perl_debug_log, "%s", (char*)ch)
2178                                     );
2179                                 }
2180                             }
2181                             TRIE_BITMAP_SET(trie,*ch);
2182                             if ( folder )
2183                                 TRIE_BITMAP_SET(trie,folder[ *ch ]);
2184                             DEBUG_OPTIMISE_r(PerlIO_printf( Perl_debug_log,"%s", ch));
2185                         }
2186                         idx = ofs;
2187                     }
2188                 }
2189                 if ( count == 1 ) {
2190                     SV **tmp = av_fetch( revcharmap, idx, 0);
2191                     STRLEN len;
2192                     char *ch = SvPV( *tmp, len );
2193                     DEBUG_OPTIMISE_r({
2194                         SV *sv=sv_newmortal();
2195                         PerlIO_printf( Perl_debug_log,
2196                             "%*sPrefix State: %"UVuf" Idx:%"UVuf" Char='%s'\n",
2197                             (int)depth * 2 + 2, "",
2198                             (UV)state, (UV)idx, 
2199                             pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), 6, 
2200                                 PL_colors[0], PL_colors[1],
2201                                 (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
2202                                 PERL_PV_ESCAPE_FIRSTCHAR 
2203                             )
2204                         );
2205                     });
2206                     if ( state==1 ) {
2207                         OP( convert ) = nodetype;
2208                         str=STRING(convert);
2209                         STR_LEN(convert)=0;
2210                     }
2211                     STR_LEN(convert) += len;
2212                     while (len--)
2213                         *str++ = *ch++;
2214                 } else {
2215 #ifdef DEBUGGING            
2216                     if (state>1)
2217                         DEBUG_OPTIMISE_r(PerlIO_printf( Perl_debug_log,"]\n"));
2218 #endif
2219                     break;
2220                 }
2221             }
2222             trie->prefixlen = (state-1);
2223             if (str) {
2224                 regnode *n = convert+NODE_SZ_STR(convert);
2225                 NEXT_OFF(convert) = NODE_SZ_STR(convert);
2226                 trie->startstate = state;
2227                 trie->minlen -= (state - 1);
2228                 trie->maxlen -= (state - 1);
2229 #ifdef DEBUGGING
2230                /* At least the UNICOS C compiler choked on this
2231                 * being argument to DEBUG_r(), so let's just have
2232                 * it right here. */
2233                if (
2234 #ifdef PERL_EXT_RE_BUILD
2235                    1
2236 #else
2237                    DEBUG_r_TEST
2238 #endif
2239                    ) {
2240                    regnode *fix = convert;
2241                    U32 word = trie->wordcount;
2242                    mjd_nodelen++;
2243                    Set_Node_Offset_Length(convert, mjd_offset, state - 1);
2244                    while( ++fix < n ) {
2245                        Set_Node_Offset_Length(fix, 0, 0);
2246                    }
2247                    while (word--) {
2248                        SV ** const tmp = av_fetch( trie_words, word, 0 );
2249                        if (tmp) {
2250                            if ( STR_LEN(convert) <= SvCUR(*tmp) )
2251                                sv_chop(*tmp, SvPV_nolen(*tmp) + STR_LEN(convert));
2252                            else
2253                                sv_chop(*tmp, SvPV_nolen(*tmp) + SvCUR(*tmp));
2254                        }
2255                    }
2256                }
2257 #endif
2258                 if (trie->maxlen) {
2259                     convert = n;
2260                 } else {
2261                     NEXT_OFF(convert) = (U16)(tail - convert);
2262                     DEBUG_r(optimize= n);
2263                 }
2264             }
2265         }
2266         if (!jumper) 
2267             jumper = last; 
2268         if ( trie->maxlen ) {
2269             NEXT_OFF( convert ) = (U16)(tail - convert);
2270             ARG_SET( convert, data_slot );
2271             /* Store the offset to the first unabsorbed branch in 
2272                jump[0], which is otherwise unused by the jump logic. 
2273                We use this when dumping a trie and during optimisation. */
2274             if (trie->jump) 
2275                 trie->jump[0] = (U16)(nextbranch - convert);
2276             
2277             /* If the start state is not accepting (meaning there is no empty string/NOTHING)
2278              *   and there is a bitmap
2279              *   and the first "jump target" node we found leaves enough room
2280              * then convert the TRIE node into a TRIEC node, with the bitmap
2281              * embedded inline in the opcode - this is hypothetically faster.
2282              */
2283             if ( !trie->states[trie->startstate].wordnum
2284                  && trie->bitmap
2285                  && ( (char *)jumper - (char *)convert) >= (int)sizeof(struct regnode_charclass) )
2286             {
2287                 OP( convert ) = TRIEC;
2288                 Copy(trie->bitmap, ((struct regnode_charclass *)convert)->bitmap, ANYOF_BITMAP_SIZE, char);
2289                 PerlMemShared_free(trie->bitmap);
2290                 trie->bitmap= NULL;
2291             } else 
2292                 OP( convert ) = TRIE;
2293
2294             /* store the type in the flags */
2295             convert->flags = nodetype;
2296             DEBUG_r({
2297             optimize = convert 
2298                       + NODE_STEP_REGNODE 
2299                       + regarglen[ OP( convert ) ];
2300             });
2301             /* XXX We really should free up the resource in trie now, 
2302                    as we won't use them - (which resources?) dmq */
2303         }
2304         /* needed for dumping*/
2305         DEBUG_r(if (optimize) {
2306             regnode *opt = convert;
2307
2308             while ( ++opt < optimize) {
2309                 Set_Node_Offset_Length(opt,0,0);
2310             }
2311             /* 
2312                 Try to clean up some of the debris left after the 
2313                 optimisation.
2314              */
2315             while( optimize < jumper ) {
2316                 mjd_nodelen += Node_Length((optimize));
2317                 OP( optimize ) = OPTIMIZED;
2318                 Set_Node_Offset_Length(optimize,0,0);
2319                 optimize++;
2320             }
2321             Set_Node_Offset_Length(convert,mjd_offset,mjd_nodelen);
2322         });
2323     } /* end node insert */
2324
2325     /*  Finish populating the prev field of the wordinfo array.  Walk back
2326      *  from each accept state until we find another accept state, and if
2327      *  so, point the first word's .prev field at the second word. If the
2328      *  second already has a .prev field set, stop now. This will be the
2329      *  case either if we've already processed that word's accept state,
2330      *  or that state had multiple words, and the overspill words were
2331      *  already linked up earlier.
2332      */
2333     {
2334         U16 word;
2335         U32 state;
2336         U16 prev;
2337
2338         for (word=1; word <= trie->wordcount; word++) {
2339             prev = 0;
2340             if (trie->wordinfo[word].prev)
2341                 continue;
2342             state = trie->wordinfo[word].accept;
2343             while (state) {
2344                 state = prev_states[state];
2345                 if (!state)
2346                     break;
2347                 prev = trie->states[state].wordnum;
2348                 if (prev)
2349                     break;
2350             }
2351             trie->wordinfo[word].prev = prev;
2352         }
2353         Safefree(prev_states);
2354     }
2355
2356
2357     /* and now dump out the compressed format */
2358     DEBUG_TRIE_COMPILE_r(dump_trie(trie, widecharmap, revcharmap, depth+1));
2359
2360     RExC_rxi->data->data[ data_slot + 1 ] = (void*)widecharmap;
2361 #ifdef DEBUGGING
2362     RExC_rxi->data->data[ data_slot + TRIE_WORDS_OFFSET ] = (void*)trie_words;
2363     RExC_rxi->data->data[ data_slot + 3 ] = (void*)revcharmap;
2364 #else
2365     SvREFCNT_dec(revcharmap);
2366 #endif
2367     return trie->jump 
2368            ? MADE_JUMP_TRIE 
2369            : trie->startstate>1 
2370              ? MADE_EXACT_TRIE 
2371              : MADE_TRIE;
2372 }
2373
2374 STATIC void
2375 S_make_trie_failtable(pTHX_ RExC_state_t *pRExC_state, regnode *source,  regnode *stclass, U32 depth)
2376 {
2377 /* The Trie is constructed and compressed now so we can build a fail array if it's needed
2378
2379    This is basically the Aho-Corasick algorithm. Its from exercise 3.31 and 3.32 in the
2380    "Red Dragon" -- Compilers, principles, techniques, and tools. Aho, Sethi, Ullman 1985/88
2381    ISBN 0-201-10088-6
2382
2383    We find the fail state for each state in the trie, this state is the longest proper
2384    suffix of the current state's 'word' that is also a proper prefix of another word in our
2385    trie. State 1 represents the word '' and is thus the default fail state. This allows
2386    the DFA not to have to restart after its tried and failed a word at a given point, it
2387    simply continues as though it had been matching the other word in the first place.
2388    Consider
2389       'abcdgu'=~/abcdefg|cdgu/
2390    When we get to 'd' we are still matching the first word, we would encounter 'g' which would
2391    fail, which would bring us to the state representing 'd' in the second word where we would
2392    try 'g' and succeed, proceeding to match 'cdgu'.
2393  */
2394  /* add a fail transition */
2395     const U32 trie_offset = ARG(source);
2396     reg_trie_data *trie=(reg_trie_data *)RExC_rxi->data->data[trie_offset];
2397     U32 *q;
2398     const U32 ucharcount = trie->uniquecharcount;
2399     const U32 numstates = trie->statecount;
2400     const U32 ubound = trie->lasttrans + ucharcount;
2401     U32 q_read = 0;
2402     U32 q_write = 0;
2403     U32 charid;
2404     U32 base = trie->states[ 1 ].trans.base;
2405     U32 *fail;
2406     reg_ac_data *aho;
2407     const U32 data_slot = add_data( pRExC_state, 1, "T" );
2408     GET_RE_DEBUG_FLAGS_DECL;
2409
2410     PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE;
2411 #ifndef DEBUGGING
2412     PERL_UNUSED_ARG(depth);
2413 #endif
2414
2415
2416     ARG_SET( stclass, data_slot );
2417     aho = (reg_ac_data *) PerlMemShared_calloc( 1, sizeof(reg_ac_data) );
2418     RExC_rxi->data->data[ data_slot ] = (void*)aho;
2419     aho->trie=trie_offset;
2420     aho->states=(reg_trie_state *)PerlMemShared_malloc( numstates * sizeof(reg_trie_state) );
2421     Copy( trie->states, aho->states, numstates, reg_trie_state );
2422     Newxz( q, numstates, U32);
2423     aho->fail = (U32 *) PerlMemShared_calloc( numstates, sizeof(U32) );
2424     aho->refcount = 1;
2425     fail = aho->fail;
2426     /* initialize fail[0..1] to be 1 so that we always have
2427        a valid final fail state */
2428     fail[ 0 ] = fail[ 1 ] = 1;
2429
2430     for ( charid = 0; charid < ucharcount ; charid++ ) {
2431         const U32 newstate = TRIE_TRANS_STATE( 1, base, ucharcount, charid, 0 );
2432         if ( newstate ) {
2433             q[ q_write ] = newstate;
2434             /* set to point at the root */
2435             fail[ q[ q_write++ ] ]=1;
2436         }
2437     }
2438     while ( q_read < q_write) {
2439         const U32 cur = q[ q_read++ % numstates ];
2440         base = trie->states[ cur ].trans.base;
2441
2442         for ( charid = 0 ; charid < ucharcount ; charid++ ) {
2443             const U32 ch_state = TRIE_TRANS_STATE( cur, base, ucharcount, charid, 1 );
2444             if (ch_state) {
2445                 U32 fail_state = cur;
2446                 U32 fail_base;
2447                 do {
2448                     fail_state = fail[ fail_state ];
2449                     fail_base = aho->states[ fail_state ].trans.base;
2450                 } while ( !TRIE_TRANS_STATE( fail_state, fail_base, ucharcount, charid, 1 ) );
2451
2452                 fail_state = TRIE_TRANS_STATE( fail_state, fail_base, ucharcount, charid, 1 );
2453                 fail[ ch_state ] = fail_state;
2454                 if ( !aho->states[ ch_state ].wordnum && aho->states[ fail_state ].wordnum )
2455                 {
2456                         aho->states[ ch_state ].wordnum =  aho->states[ fail_state ].wordnum;
2457                 }
2458                 q[ q_write++ % numstates] = ch_state;
2459             }
2460         }
2461     }
2462     /* restore fail[0..1] to 0 so that we "fall out" of the AC loop
2463        when we fail in state 1, this allows us to use the
2464        charclass scan to find a valid start char. This is based on the principle
2465        that theres a good chance the string being searched contains lots of stuff
2466        that cant be a start char.
2467      */
2468     fail[ 0 ] = fail[ 1 ] = 0;
2469     DEBUG_TRIE_COMPILE_r({
2470         PerlIO_printf(Perl_debug_log,
2471                       "%*sStclass Failtable (%"UVuf" states): 0", 
2472                       (int)(depth * 2), "", (UV)numstates
2473         );
2474         for( q_read=1; q_read<numstates; q_read++ ) {
2475             PerlIO_printf(Perl_debug_log, ", %"UVuf, (UV)fail[q_read]);
2476         }
2477         PerlIO_printf(Perl_debug_log, "\n");
2478     });
2479     Safefree(q);
2480     /*RExC_seen |= REG_SEEN_TRIEDFA;*/
2481 }
2482
2483
2484 /*
2485  * There are strange code-generation bugs caused on sparc64 by gcc-2.95.2.
2486  * These need to be revisited when a newer toolchain becomes available.
2487  */
2488 #if defined(__sparc64__) && defined(__GNUC__)
2489 #   if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
2490 #       undef  SPARC64_GCC_WORKAROUND
2491 #       define SPARC64_GCC_WORKAROUND 1
2492 #   endif
2493 #endif
2494
2495 #define DEBUG_PEEP(str,scan,depth) \
2496     DEBUG_OPTIMISE_r({if (scan){ \
2497        SV * const mysv=sv_newmortal(); \
2498        regnode *Next = regnext(scan); \
2499        regprop(RExC_rx, mysv, scan); \
2500        PerlIO_printf(Perl_debug_log, "%*s" str ">%3d: %s (%d)\n", \
2501        (int)depth*2, "", REG_NODE_NUM(scan), SvPV_nolen_const(mysv),\
2502        Next ? (REG_NODE_NUM(Next)) : 0 ); \
2503    }});
2504
2505
2506
2507
2508
2509 #define JOIN_EXACT(scan,min,flags) \
2510     if (PL_regkind[OP(scan)] == EXACT) \
2511         join_exact(pRExC_state,(scan),(min),(flags),NULL,depth+1)
2512
2513 STATIC U32
2514 S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, I32 *min, U32 flags,regnode *val, U32 depth) {
2515     /* Merge several consecutive EXACTish nodes into one. */
2516     regnode *n = regnext(scan);
2517     U32 stringok = 1;
2518     regnode *next = scan + NODE_SZ_STR(scan);
2519     U32 merged = 0;
2520     U32 stopnow = 0;
2521 #ifdef DEBUGGING
2522     regnode *stop = scan;
2523     GET_RE_DEBUG_FLAGS_DECL;
2524 #else
2525     PERL_UNUSED_ARG(depth);
2526 #endif
2527
2528     PERL_ARGS_ASSERT_JOIN_EXACT;
2529 #ifndef EXPERIMENTAL_INPLACESCAN
2530     PERL_UNUSED_ARG(flags);
2531     PERL_UNUSED_ARG(val);
2532 #endif
2533     DEBUG_PEEP("join",scan,depth);
2534     
2535     /* Skip NOTHING, merge EXACT*. */
2536     while (n &&
2537            ( PL_regkind[OP(n)] == NOTHING ||
2538              (stringok && (OP(n) == OP(scan))))
2539            && NEXT_OFF(n)
2540            && NEXT_OFF(scan) + NEXT_OFF(n) < I16_MAX) {
2541         
2542         if (OP(n) == TAIL || n > next)
2543             stringok = 0;
2544         if (PL_regkind[OP(n)] == NOTHING) {
2545             DEBUG_PEEP("skip:",n,depth);
2546             NEXT_OFF(scan) += NEXT_OFF(n);
2547             next = n + NODE_STEP_REGNODE;
2548 #ifdef DEBUGGING
2549             if (stringok)
2550                 stop = n;
2551 #endif
2552             n = regnext(n);
2553         }
2554         else if (stringok) {
2555             const unsigned int oldl = STR_LEN(scan);
2556             regnode * const nnext = regnext(n);
2557             
2558             DEBUG_PEEP("merg",n,depth);
2559             
2560             merged++;
2561             if (oldl + STR_LEN(n) > U8_MAX)
2562                 break;
2563             NEXT_OFF(scan) += NEXT_OFF(n);
2564             STR_LEN(scan) += STR_LEN(n);
2565             next = n + NODE_SZ_STR(n);
2566             /* Now we can overwrite *n : */
2567             Move(STRING(n), STRING(scan) + oldl, STR_LEN(n), char);
2568 #ifdef DEBUGGING
2569             stop = next - 1;
2570 #endif
2571             n = nnext;
2572             if (stopnow) break;
2573         }
2574
2575 #ifdef EXPERIMENTAL_INPLACESCAN
2576         if (flags && !NEXT_OFF(n)) {
2577             DEBUG_PEEP("atch", val, depth);
2578             if (reg_off_by_arg[OP(n)]) {
2579                 ARG_SET(n, val - n);
2580             }
2581             else {
2582                 NEXT_OFF(n) = val - n;
2583             }
2584             stopnow = 1;
2585         }
2586 #endif
2587     }
2588 #define GREEK_SMALL_LETTER_IOTA_WITH_DIALYTIKA_AND_TONOS   0x0390
2589 #define IOTA_D_T        GREEK_SMALL_LETTER_IOTA_WITH_DIALYTIKA_AND_TONOS
2590 #define GREEK_SMALL_LETTER_UPSILON_WITH_DIALYTIKA_AND_TONOS     0x03B0
2591 #define UPSILON_D_T     GREEK_SMALL_LETTER_UPSILON_WITH_DIALYTIKA_AND_TONOS
2592
2593     if (UTF
2594         && ( OP(scan) == EXACTF || OP(scan) == EXACTFU || OP(scan) == EXACTFA)
2595         && ( STR_LEN(scan) >= 6 ) )
2596     {
2597     /*
2598     Two problematic code points in Unicode casefolding of EXACT nodes:
2599     
2600     U+0390 - GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
2601     U+03B0 - GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
2602     
2603     which casefold to
2604     
2605     Unicode                      UTF-8
2606     
2607     U+03B9 U+0308 U+0301         0xCE 0xB9 0xCC 0x88 0xCC 0x81
2608     U+03C5 U+0308 U+0301         0xCF 0x85 0xCC 0x88 0xCC 0x81
2609     
2610     This means that in case-insensitive matching (or "loose matching",
2611     as Unicode calls it), an EXACTF of length six (the UTF-8 encoded byte
2612     length of the above casefolded versions) can match a target string
2613     of length two (the byte length of UTF-8 encoded U+0390 or U+03B0).
2614     This would rather mess up the minimum length computation.
2615     
2616     What we'll do is to look for the tail four bytes, and then peek
2617     at the preceding two bytes to see whether we need to decrease
2618     the minimum length by four (six minus two).
2619     
2620     Thanks to the design of UTF-8, there cannot be false matches:
2621     A sequence of valid UTF-8 bytes cannot be a subsequence of
2622     another valid sequence of UTF-8 bytes.
2623     
2624     */
2625          char * const s0 = STRING(scan), *s, *t;
2626          char * const s1 = s0 + STR_LEN(scan) - 1;
2627          char * const s2 = s1 - 4;
2628 #ifdef EBCDIC /* RD tunifold greek 0390 and 03B0 */
2629          const char t0[] = "\xaf\x49\xaf\x42";
2630 #else
2631          const char t0[] = "\xcc\x88\xcc\x81";
2632 #endif
2633          const char * const t1 = t0 + 3;
2634     
2635          for (s = s0 + 2;
2636               s < s2 && (t = ninstr(s, s1, t0, t1));
2637               s = t + 4) {
2638 #ifdef EBCDIC
2639               if (((U8)t[-1] == 0x68 && (U8)t[-2] == 0xB4) ||
2640                   ((U8)t[-1] == 0x46 && (U8)t[-2] == 0xB5))
2641 #else
2642               if (((U8)t[-1] == 0xB9 && (U8)t[-2] == 0xCE) ||
2643                   ((U8)t[-1] == 0x85 && (U8)t[-2] == 0xCF))
2644 #endif
2645                    *min -= 4;
2646          }
2647     }
2648     
2649 #ifdef DEBUGGING
2650     /* Allow dumping */
2651     n = scan + NODE_SZ_STR(scan);
2652     while (n <= stop) {
2653         if (PL_regkind[OP(n)] != NOTHING || OP(n) == NOTHING) {
2654             OP(n) = OPTIMIZED;
2655             NEXT_OFF(n) = 0;
2656         }
2657         n++;
2658     }
2659 #endif
2660     DEBUG_OPTIMISE_r(if (merged){DEBUG_PEEP("finl",scan,depth)});
2661     return stopnow;
2662 }
2663
2664 /* REx optimizer.  Converts nodes into quicker variants "in place".
2665    Finds fixed substrings.  */
2666
2667 /* Stops at toplevel WHILEM as well as at "last". At end *scanp is set
2668    to the position after last scanned or to NULL. */
2669
2670 #define INIT_AND_WITHP \
2671     assert(!and_withp); \
2672     Newx(and_withp,1,struct regnode_charclass_class); \
2673     SAVEFREEPV(and_withp)
2674
2675 /* this is a chain of data about sub patterns we are processing that
2676    need to be handled separately/specially in study_chunk. Its so
2677    we can simulate recursion without losing state.  */
2678 struct scan_frame;
2679 typedef struct scan_frame {
2680     regnode *last;  /* last node to process in this frame */
2681     regnode *next;  /* next node to process when last is reached */
2682     struct scan_frame *prev; /*previous frame*/
2683     I32 stop; /* what stopparen do we use */
2684 } scan_frame;
2685
2686
2687 #define SCAN_COMMIT(s, data, m) scan_commit(s, data, m, is_inf)
2688
2689 #define CASE_SYNST_FNC(nAmE)                                       \
2690 case nAmE:                                                         \
2691     if (flags & SCF_DO_STCLASS_AND) {                              \
2692             for (value = 0; value < 256; value++)                  \
2693                 if (!is_ ## nAmE ## _cp(value))                       \
2694                     ANYOF_BITMAP_CLEAR(data->start_class, value);  \
2695     }                                                              \
2696     else {                                                         \
2697             for (value = 0; value < 256; value++)                  \
2698                 if (is_ ## nAmE ## _cp(value))                        \
2699                     ANYOF_BITMAP_SET(data->start_class, value);    \
2700     }                                                              \
2701     break;                                                         \
2702 case N ## nAmE:                                                    \
2703     if (flags & SCF_DO_STCLASS_AND) {                              \
2704             for (value = 0; value < 256; value++)                   \
2705                 if (is_ ## nAmE ## _cp(value))                         \
2706                     ANYOF_BITMAP_CLEAR(data->start_class, value);   \
2707     }                                                               \
2708     else {                                                          \
2709             for (value = 0; value < 256; value++)                   \
2710                 if (!is_ ## nAmE ## _cp(value))                        \
2711                     ANYOF_BITMAP_SET(data->start_class, value);     \
2712     }                                                               \
2713     break
2714
2715
2716
2717 STATIC I32
2718 S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
2719                         I32 *minlenp, I32 *deltap,
2720                         regnode *last,
2721                         scan_data_t *data,
2722                         I32 stopparen,
2723                         U8* recursed,
2724                         struct regnode_charclass_class *and_withp,
2725                         U32 flags, U32 depth)
2726                         /* scanp: Start here (read-write). */
2727                         /* deltap: Write maxlen-minlen here. */
2728                         /* last: Stop before this one. */
2729                         /* data: string data about the pattern */
2730                         /* stopparen: treat close N as END */
2731                         /* recursed: which subroutines have we recursed into */
2732                         /* and_withp: Valid if flags & SCF_DO_STCLASS_OR */
2733 {
2734     dVAR;
2735     I32 min = 0, pars = 0, code;
2736     regnode *scan = *scanp, *next;
2737     I32 delta = 0;
2738     int is_inf = (flags & SCF_DO_SUBSTR) && (data->flags & SF_IS_INF);
2739     int is_inf_internal = 0;            /* The studied chunk is infinite */
2740     I32 is_par = OP(scan) == OPEN ? ARG(scan) : 0;
2741     scan_data_t data_fake;
2742     SV *re_trie_maxbuff = NULL;
2743     regnode *first_non_open = scan;
2744     I32 stopmin = I32_MAX;
2745     scan_frame *frame = NULL;
2746     GET_RE_DEBUG_FLAGS_DECL;
2747
2748     PERL_ARGS_ASSERT_STUDY_CHUNK;
2749
2750 #ifdef DEBUGGING
2751     StructCopy(&zero_scan_data, &data_fake, scan_data_t);
2752 #endif
2753
2754     if ( depth == 0 ) {
2755         while (first_non_open && OP(first_non_open) == OPEN)
2756             first_non_open=regnext(first_non_open);
2757     }
2758
2759
2760   fake_study_recurse:
2761     while ( scan && OP(scan) != END && scan < last ){
2762         /* Peephole optimizer: */
2763         DEBUG_STUDYDATA("Peep:", data,depth);
2764         DEBUG_PEEP("Peep",scan,depth);
2765         JOIN_EXACT(scan,&min,0);
2766
2767         /* Follow the next-chain of the current node and optimize
2768            away all the NOTHINGs from it.  */
2769         if (OP(scan) != CURLYX) {
2770             const int max = (reg_off_by_arg[OP(scan)]
2771                        ? I32_MAX
2772                        /* I32 may be smaller than U16 on CRAYs! */
2773                        : (I32_MAX < U16_MAX ? I32_MAX : U16_MAX));
2774             int off = (reg_off_by_arg[OP(scan)] ? ARG(scan) : NEXT_OFF(scan));
2775             int noff;
2776             regnode *n = scan;
2777         
2778             /* Skip NOTHING and LONGJMP. */
2779             while ((n = regnext(n))
2780                    && ((PL_regkind[OP(n)] == NOTHING && (noff = NEXT_OFF(n)))
2781                        || ((OP(n) == LONGJMP) && (noff = ARG(n))))
2782                    && off + noff < max)
2783                 off += noff;
2784             if (reg_off_by_arg[OP(scan)])
2785                 ARG(scan) = off;
2786             else
2787                 NEXT_OFF(scan) = off;
2788         }
2789
2790
2791
2792         /* The principal pseudo-switch.  Cannot be a switch, since we
2793            look into several different things.  */
2794         if (OP(scan) == BRANCH || OP(scan) == BRANCHJ
2795                    || OP(scan) == IFTHEN) {
2796             next = regnext(scan);
2797             code = OP(scan);
2798             /* demq: the op(next)==code check is to see if we have "branch-branch" AFAICT */
2799         
2800             if (OP(next) == code || code == IFTHEN) {
2801                 /* NOTE - There is similar code to this block below for handling
2802                    TRIE nodes on a re-study.  If you change stuff here check there
2803                    too. */
2804                 I32 max1 = 0, min1 = I32_MAX, num = 0;
2805                 struct regnode_charclass_class accum;
2806                 regnode * const startbranch=scan;
2807                 
2808                 if (flags & SCF_DO_SUBSTR)
2809                     SCAN_COMMIT(pRExC_state, data, minlenp); /* Cannot merge strings after this. */
2810                 if (flags & SCF_DO_STCLASS)
2811                     cl_init_zero(pRExC_state, &accum);
2812
2813                 while (OP(scan) == code) {
2814                     I32 deltanext, minnext, f = 0, fake;
2815                     struct regnode_charclass_class this_class;
2816
2817                     num++;
2818                     data_fake.flags = 0;
2819                     if (data) {
2820                         data_fake.whilem_c = data->whilem_c;
2821                         data_fake.last_closep = data->last_closep;
2822                     }
2823                     else
2824                         data_fake.last_closep = &fake;
2825
2826                     data_fake.pos_delta = delta;
2827                     next = regnext(scan);
2828                     scan = NEXTOPER(scan);
2829                     if (code != BRANCH)
2830                         scan = NEXTOPER(scan);
2831                     if (flags & SCF_DO_STCLASS) {
2832                         cl_init(pRExC_state, &this_class);
2833                         data_fake.start_class = &this_class;
2834                         f = SCF_DO_STCLASS_AND;
2835                     }
2836                     if (flags & SCF_WHILEM_VISITED_POS)
2837                         f |= SCF_WHILEM_VISITED_POS;
2838
2839                     /* we suppose the run is continuous, last=next...*/
2840                     minnext = study_chunk(pRExC_state, &scan, minlenp, &deltanext,
2841                                           next, &data_fake,
2842                                           stopparen, recursed, NULL, f,depth+1);
2843                     if (min1 > minnext)
2844                         min1 = minnext;
2845                     if (max1 < minnext + deltanext)
2846                         max1 = minnext + deltanext;
2847                     if (deltanext == I32_MAX)
2848                         is_inf = is_inf_internal = 1;
2849                     scan = next;
2850                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
2851                         pars++;
2852                     if (data_fake.flags & SCF_SEEN_ACCEPT) {
2853                         if ( stopmin > minnext) 
2854                             stopmin = min + min1;
2855                         flags &= ~SCF_DO_SUBSTR;
2856                         if (data)
2857                             data->flags |= SCF_SEEN_ACCEPT;
2858                     }
2859                     if (data) {
2860                         if (data_fake.flags & SF_HAS_EVAL)
2861                             data->flags |= SF_HAS_EVAL;
2862                         data->whilem_c = data_fake.whilem_c;
2863                     }
2864                     if (flags & SCF_DO_STCLASS)
2865                         cl_or(pRExC_state, &accum, &this_class);
2866                 }
2867                 if (code == IFTHEN && num < 2) /* Empty ELSE branch */
2868                     min1 = 0;
2869                 if (flags & SCF_DO_SUBSTR) {
2870                     data->pos_min += min1;
2871                     data->pos_delta += max1 - min1;
2872                     if (max1 != min1 || is_inf)
2873                         data->longest = &(data->longest_float);
2874                 }
2875                 min += min1;
2876                 delta += max1 - min1;
2877                 if (flags & SCF_DO_STCLASS_OR) {
2878                     cl_or(pRExC_state, data->start_class, &accum);
2879                     if (min1) {
2880                         cl_and(data->start_class, and_withp);
2881                         flags &= ~SCF_DO_STCLASS;
2882                     }
2883                 }
2884                 else if (flags & SCF_DO_STCLASS_AND) {
2885                     if (min1) {
2886                         cl_and(data->start_class, &accum);
2887                         flags &= ~SCF_DO_STCLASS;
2888                     }
2889                     else {
2890                         /* Switch to OR mode: cache the old value of
2891                          * data->start_class */
2892                         INIT_AND_WITHP;
2893                         StructCopy(data->start_class, and_withp,
2894                                    struct regnode_charclass_class);
2895                         flags &= ~SCF_DO_STCLASS_AND;
2896                         StructCopy(&accum, data->start_class,
2897                                    struct regnode_charclass_class);
2898                         flags |= SCF_DO_STCLASS_OR;
2899                         data->start_class->flags |= ANYOF_EOS;
2900                     }
2901                 }
2902
2903                 if (PERL_ENABLE_TRIE_OPTIMISATION && OP( startbranch ) == BRANCH ) {
2904                 /* demq.
2905
2906                    Assuming this was/is a branch we are dealing with: 'scan' now
2907                    points at the item that follows the branch sequence, whatever
2908                    it is. We now start at the beginning of the sequence and look
2909                    for subsequences of
2910
2911                    BRANCH->EXACT=>x1
2912                    BRANCH->EXACT=>x2
2913                    tail
2914
2915                    which would be constructed from a pattern like /A|LIST|OF|WORDS/
2916
2917                    If we can find such a subsequence we need to turn the first
2918                    element into a trie and then add the subsequent branch exact
2919                    strings to the trie.
2920
2921                    We have two cases
2922
2923                      1. patterns where the whole set of branches can be converted. 
2924
2925                      2. patterns where only a subset can be converted.
2926
2927                    In case 1 we can replace the whole set with a single regop
2928                    for the trie. In case 2 we need to keep the start and end
2929                    branches so
2930
2931                      'BRANCH EXACT; BRANCH EXACT; BRANCH X'
2932                      becomes BRANCH TRIE; BRANCH X;
2933
2934                   There is an additional case, that being where there is a 
2935                   common prefix, which gets split out into an EXACT like node
2936                   preceding the TRIE node.
2937
2938                   If x(1..n)==tail then we can do a simple trie, if not we make
2939                   a "jump" trie, such that when we match the appropriate word
2940                   we "jump" to the appropriate tail node. Essentially we turn
2941                   a nested if into a case structure of sorts.
2942
2943                 */
2944                 
2945                     int made=0;
2946                     if (!re_trie_maxbuff) {
2947                         re_trie_maxbuff = get_sv(RE_TRIE_MAXBUF_NAME, 1);
2948                         if (!SvIOK(re_trie_maxbuff))
2949                             sv_setiv(re_trie_maxbuff, RE_TRIE_MAXBUF_INIT);
2950                     }
2951                     if ( SvIV(re_trie_maxbuff)>=0  ) {
2952                         regnode *cur;
2953                         regnode *first = (regnode *)NULL;
2954                         regnode *last = (regnode *)NULL;
2955                         regnode *tail = scan;
2956                         U8 optype = 0;
2957                         U32 count=0;
2958
2959 #ifdef DEBUGGING
2960                         SV * const mysv = sv_newmortal();       /* for dumping */
2961 #endif
2962                         /* var tail is used because there may be a TAIL
2963                            regop in the way. Ie, the exacts will point to the
2964                            thing following the TAIL, but the last branch will
2965                            point at the TAIL. So we advance tail. If we
2966                            have nested (?:) we may have to move through several
2967                            tails.
2968                          */
2969
2970                         while ( OP( tail ) == TAIL ) {
2971                             /* this is the TAIL generated by (?:) */
2972                             tail = regnext( tail );
2973                         }
2974
2975                         
2976                         DEBUG_OPTIMISE_r({
2977                             regprop(RExC_rx, mysv, tail );
2978                             PerlIO_printf( Perl_debug_log, "%*s%s%s\n",
2979                                 (int)depth * 2 + 2, "", 
2980                                 "Looking for TRIE'able sequences. Tail node is: ", 
2981                                 SvPV_nolen_const( mysv )
2982                             );
2983                         });
2984                         
2985                         /*
2986
2987                            step through the branches, cur represents each
2988                            branch, noper is the first thing to be matched
2989                            as part of that branch and noper_next is the
2990                            regnext() of that node. if noper is an EXACT
2991                            and noper_next is the same as scan (our current
2992                            position in the regex) then the EXACT branch is
2993                            a possible optimization target. Once we have
2994                            two or more consecutive such branches we can
2995                            create a trie of the EXACT's contents and stich
2996                            it in place. If the sequence represents all of
2997                            the branches we eliminate the whole thing and
2998                            replace it with a single TRIE. If it is a
2999                            subsequence then we need to stitch it in. This
3000                            means the first branch has to remain, and needs
3001                            to be repointed at the item on the branch chain
3002                            following the last branch optimized. This could
3003                            be either a BRANCH, in which case the
3004                            subsequence is internal, or it could be the
3005                            item following the branch sequence in which
3006                            case the subsequence is at the end.
3007
3008                         */
3009
3010                         /* dont use tail as the end marker for this traverse */
3011                         for ( cur = startbranch ; cur != scan ; cur = regnext( cur ) ) {
3012                             regnode * const noper = NEXTOPER( cur );
3013 #if defined(DEBUGGING) || defined(NOJUMPTRIE)
3014                             regnode * const noper_next = regnext( noper );
3015 #endif
3016
3017                             DEBUG_OPTIMISE_r({
3018                                 regprop(RExC_rx, mysv, cur);
3019                                 PerlIO_printf( Perl_debug_log, "%*s- %s (%d)",
3020                                    (int)depth * 2 + 2,"", SvPV_nolen_const( mysv ), REG_NODE_NUM(cur) );
3021
3022                                 regprop(RExC_rx, mysv, noper);
3023                                 PerlIO_printf( Perl_debug_log, " -> %s",
3024                                     SvPV_nolen_const(mysv));
3025
3026                                 if ( noper_next ) {
3027                                   regprop(RExC_rx, mysv, noper_next );
3028                                   PerlIO_printf( Perl_debug_log,"\t=> %s\t",
3029                                     SvPV_nolen_const(mysv));
3030                                 }
3031                                 PerlIO_printf( Perl_debug_log, "(First==%d,Last==%d,Cur==%d)\n",
3032                                    REG_NODE_NUM(first), REG_NODE_NUM(last), REG_NODE_NUM(cur) );
3033                             });
3034                             if ( (((first && optype!=NOTHING) ? OP( noper ) == optype
3035                                          : PL_regkind[ OP( noper ) ] == EXACT )
3036                                   || OP(noper) == NOTHING )
3037 #ifdef NOJUMPTRIE
3038                                   && noper_next == tail
3039 #endif
3040                                   && count < U16_MAX)
3041                             {
3042                                 count++;
3043                                 if ( !first || optype == NOTHING ) {
3044                                     if (!first) first = cur;
3045                                     optype = OP( noper );
3046                                 } else {
3047                                     last = cur;
3048                                 }
3049                             } else {
3050 /* 
3051     Currently the trie logic handles case insensitive matching properly only
3052     when the pattern is UTF-8 and the node is EXACTFU (thus forcing unicode
3053     semantics).
3054
3055     If/when this is fixed the following define can be swapped
3056     in below to fully enable trie logic.
3057
3058 #define TRIE_TYPE_IS_SAFE 1
3059
3060 */
3061 #define TRIE_TYPE_IS_SAFE ((UTF && optype == EXACTFU) || optype==EXACT)
3062
3063                                 if ( last && TRIE_TYPE_IS_SAFE ) {
3064                                     make_trie( pRExC_state, 
3065                                             startbranch, first, cur, tail, count, 
3066                                             optype, depth+1 );
3067                                 }
3068                                 if ( PL_regkind[ OP( noper ) ] == EXACT
3069 #ifdef NOJUMPTRIE
3070                                      && noper_next == tail
3071 #endif
3072                                 ){
3073                                     count = 1;
3074                                     first = cur;
3075                                     optype = OP( noper );
3076                                 } else {
3077                                     count = 0;
3078                                     first = NULL;
3079                                     optype = 0;
3080                                 }
3081                                 last = NULL;
3082                             }
3083                         }
3084                         DEBUG_OPTIMISE_r({
3085                             regprop(RExC_rx, mysv, cur);
3086                             PerlIO_printf( Perl_debug_log,
3087                               "%*s- %s (%d) <SCAN FINISHED>\n", (int)depth * 2 + 2,
3088                               "", SvPV_nolen_const( mysv ),REG_NODE_NUM(cur));
3089
3090                         });
3091                         
3092                         if ( last && TRIE_TYPE_IS_SAFE ) {
3093                             made= make_trie( pRExC_state, startbranch, first, scan, tail, count, optype, depth+1 );
3094 #ifdef TRIE_STUDY_OPT   
3095                             if ( ((made == MADE_EXACT_TRIE && 
3096                                  startbranch == first) 
3097                                  || ( first_non_open == first )) && 
3098                                  depth==0 ) {
3099                                 flags |= SCF_TRIE_RESTUDY;
3100                                 if ( startbranch == first 
3101                                      && scan == tail ) 
3102                                 {
3103                                     RExC_seen &=~REG_TOP_LEVEL_BRANCHES;
3104                                 }
3105                             }
3106 #endif
3107                         }
3108                     }
3109                     
3110                 } /* do trie */
3111                 
3112             }
3113             else if ( code == BRANCHJ ) {  /* single branch is optimized. */
3114                 scan = NEXTOPER(NEXTOPER(scan));
3115             } else                      /* single branch is optimized. */
3116                 scan = NEXTOPER(scan);
3117             continue;
3118         } else if (OP(scan) == SUSPEND || OP(scan) == GOSUB || OP(scan) == GOSTART) {
3119             scan_frame *newframe = NULL;
3120             I32 paren;
3121             regnode *start;
3122             regnode *end;
3123
3124             if (OP(scan) != SUSPEND) {
3125             /* set the pointer */
3126                 if (OP(scan) == GOSUB) {
3127                     paren = ARG(scan);
3128                     RExC_recurse[ARG2L(scan)] = scan;
3129                     start = RExC_open_parens[paren-1];
3130                     end   = RExC_close_parens[paren-1];
3131                 } else {
3132                     paren = 0;
3133                     start = RExC_rxi->program + 1;
3134                     end   = RExC_opend;
3135                 }
3136                 if (!recursed) {
3137                     Newxz(recursed, (((RExC_npar)>>3) +1), U8);
3138                     SAVEFREEPV(recursed);
3139                 }
3140                 if (!PAREN_TEST(recursed,paren+1)) {
3141                     PAREN_SET(recursed,paren+1);
3142                     Newx(newframe,1,scan_frame);
3143                 } else {
3144                     if (flags & SCF_DO_SUBSTR) {
3145                         SCAN_COMMIT(pRExC_state,data,minlenp);
3146                         data->longest = &(data->longest_float);
3147                     }
3148                     is_inf = is_inf_internal = 1;
3149                     if (flags & SCF_DO_STCLASS_OR) /* Allow everything */
3150                         cl_anything(pRExC_state, data->start_class);
3151                     flags &= ~SCF_DO_STCLASS;
3152                 }
3153             } else {
3154                 Newx(newframe,1,scan_frame);
3155                 paren = stopparen;
3156                 start = scan+2;
3157                 end = regnext(scan);
3158             }
3159             if (newframe) {
3160                 assert(start);
3161                 assert(end);
3162                 SAVEFREEPV(newframe);
3163                 newframe->next = regnext(scan);
3164                 newframe->last = last;
3165                 newframe->stop = stopparen;
3166                 newframe->prev = frame;
3167
3168                 frame = newframe;
3169                 scan =  start;
3170                 stopparen = paren;
3171                 last = end;
3172
3173                 continue;
3174             }
3175         }
3176         else if (OP(scan) == EXACT) {
3177             I32 l = STR_LEN(scan);
3178             UV uc;
3179             if (UTF) {
3180                 const U8 * const s = (U8*)STRING(scan);
3181                 l = utf8_length(s, s + l);
3182                 uc = utf8_to_uvchr(s, NULL);
3183             } else {
3184                 uc = *((U8*)STRING(scan));
3185             }
3186             min += l;
3187             if (flags & SCF_DO_SUBSTR) { /* Update longest substr. */
3188                 /* The code below prefers earlier match for fixed
3189                    offset, later match for variable offset.  */
3190                 if (data->last_end == -1) { /* Update the start info. */
3191                     data->last_start_min = data->pos_min;
3192                     data->last_start_max = is_inf
3193                         ? I32_MAX : data->pos_min + data->pos_delta;
3194                 }
3195                 sv_catpvn(data->last_found, STRING(scan), STR_LEN(scan));
3196                 if (UTF)
3197                     SvUTF8_on(data->last_found);
3198                 {
3199                     SV * const sv = data->last_found;
3200                     MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ?
3201                         mg_find(sv, PERL_MAGIC_utf8) : NULL;
3202                     if (mg && mg->mg_len >= 0)
3203                         mg->mg_len += utf8_length((U8*)STRING(scan),
3204                                                   (U8*)STRING(scan)+STR_LEN(scan));
3205                 }
3206                 data->last_end = data->pos_min + l;
3207                 data->pos_min += l; /* As in the first entry. */
3208                 data->flags &= ~SF_BEFORE_EOL;
3209             }
3210             if (flags & SCF_DO_STCLASS_AND) {
3211                 /* Check whether it is compatible with what we know already! */
3212                 int compat = 1;
3213
3214
3215                 /* If compatible, we or it in below.  It is compatible if is
3216                  * in the bitmp and either 1) its bit or its fold is set, or 2)
3217                  * it's for a locale.  Even if there isn't unicode semantics
3218                  * here, at runtime there may be because of matching against a
3219                  * utf8 string, so accept a possible false positive for
3220                  * latin1-range folds */
3221                 if (uc >= 0x100 ||
3222                     (!(data->start_class->flags & (ANYOF_CLASS | ANYOF_LOCALE))
3223                     && !ANYOF_BITMAP_TEST(data->start_class, uc)
3224                     && (!(data->start_class->flags & ANYOF_LOC_NONBITMAP_FOLD)
3225                         || !ANYOF_BITMAP_TEST(data->start_class, PL_fold_latin1[uc])))
3226                     )
3227                 {
3228                     compat = 0;
3229                 }
3230                 ANYOF_CLASS_ZERO(data->start_class);
3231                 ANYOF_BITMAP_ZERO(data->start_class);
3232                 if (compat)
3233                     ANYOF_BITMAP_SET(data->start_class, uc);
3234                 else if (uc >= 0x100) {
3235                     int i;
3236
3237                     /* Some Unicode code points fold to the Latin1 range; as
3238                      * XXX temporary code, instead of figuring out if this is
3239                      * one, just assume it is and set all the start class bits
3240                      * that could be some such above 255 code point's fold
3241                      * which will generate fals positives.  As the code
3242                      * elsewhere that does compute the fold settles down, it
3243                      * can be extracted out and re-used here */
3244                     for (i = 0; i < 256; i++){
3245                         if (_HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(i)) {
3246                             ANYOF_BITMAP_SET(data->start_class, i);
3247                         }
3248                     }
3249                 }
3250                 data->start_class->flags &= ~ANYOF_EOS;
3251                 if (uc < 0x100)
3252                   data->start_class->flags &= ~ANYOF_UNICODE_ALL;
3253             }
3254             else if (flags & SCF_DO_STCLASS_OR) {
3255                 /* false positive possible if the class is case-folded */
3256                 if (uc < 0x100)
3257                     ANYOF_BITMAP_SET(data->start_class, uc);
3258                 else
3259                     data->start_class->flags |= ANYOF_UNICODE_ALL;
3260                 data->start_class->flags &= ~ANYOF_EOS;
3261                 cl_and(data->start_class, and_withp);
3262             }
3263             flags &= ~SCF_DO_STCLASS;
3264         }
3265         else if (PL_regkind[OP(scan)] == EXACT) { /* But OP != EXACT! */
3266             I32 l = STR_LEN(scan);
3267             UV uc = *((U8*)STRING(scan));
3268
3269             /* Search for fixed substrings supports EXACT only. */
3270             if (flags & SCF_DO_SUBSTR) {
3271                 assert(data);
3272                 SCAN_COMMIT(pRExC_state, data, minlenp);
3273             }
3274             if (UTF) {
3275                 const U8 * const s = (U8 *)STRING(scan);
3276                 l = utf8_length(s, s + l);
3277                 uc = utf8_to_uvchr(s, NULL);
3278             }
3279             min += l;
3280             if (flags & SCF_DO_SUBSTR)
3281                 data->pos_min += l;
3282             if (flags & SCF_DO_STCLASS_AND) {
3283                 /* Check whether it is compatible with what we know already! */
3284                 int compat = 1;
3285                 if (uc >= 0x100 ||
3286                  (!(data->start_class->flags & (ANYOF_CLASS | ANYOF_LOCALE))
3287                   && !ANYOF_BITMAP_TEST(data->start_class, uc)
3288                   && !ANYOF_BITMAP_TEST(data->start_class, PL_fold_latin1[uc])))
3289                 {
3290                     compat = 0;
3291                 }
3292                 ANYOF_CLASS_ZERO(data->start_class);
3293                 ANYOF_BITMAP_ZERO(data->start_class);
3294                 if (compat) {
3295                     ANYOF_BITMAP_SET(data->start_class, uc);
3296                     data->start_class->flags &= ~ANYOF_EOS;
3297                     data->start_class->flags |= ANYOF_LOC_NONBITMAP_FOLD;
3298                     if (OP(scan) == EXACTFL) {
3299                         /* XXX This set is probably no longer necessary, and
3300                          * probably wrong as LOCALE now is on in the initial
3301                          * state */
3302                         data->start_class->flags |= ANYOF_LOCALE;
3303                     }
3304                     else {
3305
3306                         /* Also set the other member of the fold pair.  In case
3307                          * that unicode semantics is called for at runtime, use
3308                          * the full latin1 fold.  (Can't do this for locale,
3309                          * because not known until runtime */
3310                         ANYOF_BITMAP_SET(data->start_class, PL_fold_latin1[uc]);
3311                     }
3312                 }
3313                 else if (uc >= 0x100) {
3314                     int i;
3315                     for (i = 0; i < 256; i++){
3316                         if (_HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(i)) {
3317                             ANYOF_BITMAP_SET(data->start_class, i);
3318                         }
3319                     }
3320                 }
3321             }
3322             else if (flags & SCF_DO_STCLASS_OR) {
3323                 if (data->start_class->flags & ANYOF_LOC_NONBITMAP_FOLD) {
3324                     /* false positive possible if the class is case-folded.
3325                        Assume that the locale settings are the same... */
3326                     if (uc < 0x100) {
3327                         ANYOF_BITMAP_SET(data->start_class, uc);
3328                         if (OP(scan) != EXACTFL) {
3329
3330                             /* And set the other member of the fold pair, but
3331                              * can't do that in locale because not known until
3332                              * run-time */
3333                             ANYOF_BITMAP_SET(data->start_class,
3334                                              PL_fold_latin1[uc]);
3335                         }
3336                     }
3337                     data->start_class->flags &= ~ANYOF_EOS;
3338                 }
3339                 cl_and(data->start_class, and_withp);
3340             }
3341             flags &= ~SCF_DO_STCLASS;
3342         }
3343         else if (REGNODE_VARIES(OP(scan))) {
3344             I32 mincount, maxcount, minnext, deltanext, fl = 0;
3345             I32 f = flags, pos_before = 0;
3346             regnode * const oscan = scan;
3347             struct regnode_charclass_class this_class;
3348             struct regnode_charclass_class *oclass = NULL;
3349             I32 next_is_eval = 0;
3350
3351             switch (PL_regkind[OP(scan)]) {
3352             case WHILEM:                /* End of (?:...)* . */
3353                 scan = NEXTOPER(scan);
3354                 goto finish;
3355             case PLUS:
3356                 if (flags & (SCF_DO_SUBSTR | SCF_DO_STCLASS)) {
3357                     next = NEXTOPER(scan);
3358                     if (OP(next) == EXACT || (flags & SCF_DO_STCLASS)) {
3359                         mincount = 1;
3360                         maxcount = REG_INFTY;
3361                         next = regnext(scan);
3362                         scan = NEXTOPER(scan);
3363                         goto do_curly;
3364                     }
3365                 }
3366                 if (flags & SCF_DO_SUBSTR)
3367                     data->pos_min++;
3368                 min++;
3369                 /* Fall through. */
3370             case STAR:
3371                 if (flags & SCF_DO_STCLASS) {
3372                     mincount = 0;
3373                     maxcount = REG_INFTY;
3374                     next = regnext(scan);
3375                     scan = NEXTOPER(scan);
3376                     goto do_curly;
3377                 }
3378                 is_inf = is_inf_internal = 1;
3379                 scan = regnext(scan);
3380                 if (flags & SCF_DO_SUBSTR) {
3381                     SCAN_COMMIT(pRExC_state, data, minlenp); /* Cannot extend fixed substrings */
3382                     data->longest = &(data->longest_float);
3383                 }
3384                 goto optimize_curly_tail;
3385             case CURLY:
3386                 if (stopparen>0 && (OP(scan)==CURLYN || OP(scan)==CURLYM)
3387                     && (scan->flags == stopparen))
3388                 {
3389                     mincount = 1;
3390                     maxcount = 1;
3391                 } else {
3392                     mincount = ARG1(scan);
3393                     maxcount = ARG2(scan);
3394                 }
3395                 next = regnext(scan);
3396                 if (OP(scan) == CURLYX) {
3397                     I32 lp = (data ? *(data->last_closep) : 0);
3398                     scan->flags = ((lp <= (I32)U8_MAX) ? (U8)lp : U8_MAX);
3399                 }
3400                 scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
3401                 next_is_eval = (OP(scan) == EVAL);
3402               do_curly:
3403                 if (flags & SCF_DO_SUBSTR) {
3404                     if (mincount == 0) SCAN_COMMIT(pRExC_state,data,minlenp); /* Cannot extend fixed substrings */
3405                     pos_before = data->pos_min;
3406                 }
3407                 if (data) {
3408                     fl = data->flags;
3409                     data->flags &= ~(SF_HAS_PAR|SF_IN_PAR|SF_HAS_EVAL);
3410                     if (is_inf)
3411                         data->flags |= SF_IS_INF;
3412                 }
3413                 if (flags & SCF_DO_STCLASS) {
3414                     cl_init(pRExC_state, &this_class);
3415                     oclass = data->start_class;
3416                     data->start_class = &this_class;
3417                     f |= SCF_DO_STCLASS_AND;
3418                     f &= ~SCF_DO_STCLASS_OR;
3419                 }
3420                 /* Exclude from super-linear cache processing any {n,m}
3421                    regops for which the combination of input pos and regex
3422                    pos is not enough information to determine if a match
3423                    will be possible.
3424
3425                    For example, in the regex /foo(bar\s*){4,8}baz/ with the
3426                    regex pos at the \s*, the prospects for a match depend not
3427                    only on the input position but also on how many (bar\s*)
3428                    repeats into the {4,8} we are. */
3429                if ((mincount > 1) || (maxcount > 1 && maxcount != REG_INFTY))
3430                     f &= ~SCF_WHILEM_VISITED_POS;
3431
3432                 /* This will finish on WHILEM, setting scan, or on NULL: */
3433                 minnext = study_chunk(pRExC_state, &scan, minlenp, &deltanext, 
3434                                       last, data, stopparen, recursed, NULL,
3435                                       (mincount == 0
3436                                         ? (f & ~SCF_DO_SUBSTR) : f),depth+1);
3437
3438                 if (flags & SCF_DO_STCLASS)
3439                     data->start_class = oclass;
3440                 if (mincount == 0 || minnext == 0) {
3441                     if (flags & SCF_DO_STCLASS_OR) {
3442                         cl_or(pRExC_state, data->start_class, &this_class);
3443                     }
3444                     else if (flags & SCF_DO_STCLASS_AND) {
3445                         /* Switch to OR mode: cache the old value of
3446                          * data->start_class */
3447                         INIT_AND_WITHP;
3448                         StructCopy(data->start_class, and_withp,
3449                                    struct regnode_charclass_class);
3450                         flags &= ~SCF_DO_STCLASS_AND;
3451                         StructCopy(&this_class, data->start_class,
3452                                    struct regnode_charclass_class);
3453                         flags |= SCF_DO_STCLASS_OR;
3454                         data->start_class->flags |= ANYOF_EOS;
3455                     }
3456                 } else {                /* Non-zero len */
3457                     if (flags & SCF_DO_STCLASS_OR) {
3458                         cl_or(pRExC_state, data->start_class, &this_class);
3459                         cl_and(data->start_class, and_withp);
3460                     }
3461                     else if (flags & SCF_DO_STCLASS_AND)
3462                         cl_and(data->start_class, &this_class);
3463                     flags &= ~SCF_DO_STCLASS;
3464                 }
3465                 if (!scan)              /* It was not CURLYX, but CURLY. */
3466                     scan = next;
3467                 if ( /* ? quantifier ok, except for (?{ ... }) */
3468                     (next_is_eval || !(mincount == 0 && maxcount == 1))
3469                     && (minnext == 0) && (deltanext == 0)
3470                     && data && !(data->flags & (SF_HAS_PAR|SF_IN_PAR))
3471                     && maxcount <= REG_INFTY/3) /* Complement check for big count */
3472                 {
3473                     ckWARNreg(RExC_parse,
3474                               "Quantifier unexpected on zero-length expression");
3475                 }
3476
3477                 min += minnext * mincount;
3478                 is_inf_internal |= ((maxcount == REG_INFTY
3479                                      && (minnext + deltanext) > 0)
3480                                     || deltanext == I32_MAX);
3481                 is_inf |= is_inf_internal;
3482                 delta += (minnext + deltanext) * maxcount - minnext * mincount;
3483
3484                 /* Try powerful optimization CURLYX => CURLYN. */
3485                 if (  OP(oscan) == CURLYX && data
3486                       && data->flags & SF_IN_PAR
3487                       && !(data->flags & SF_HAS_EVAL)
3488                       && !deltanext && minnext == 1 ) {
3489                     /* Try to optimize to CURLYN.  */
3490                     regnode *nxt = NEXTOPER(oscan) + EXTRA_STEP_2ARGS;
3491                     regnode * const nxt1 = nxt;
3492 #ifdef DEBUGGING
3493                     regnode *nxt2;
3494 #endif
3495
3496                     /* Skip open. */
3497                     nxt = regnext(nxt);
3498                     if (!REGNODE_SIMPLE(OP(nxt))
3499                         && !(PL_regkind[OP(nxt)] == EXACT
3500                              && STR_LEN(nxt) == 1))
3501                         goto nogo;
3502 #ifdef DEBUGGING
3503                     nxt2 = nxt;
3504 #endif
3505                     nxt = regnext(nxt);
3506                     if (OP(nxt) != CLOSE)
3507                         goto nogo;
3508                     if (RExC_open_parens) {
3509                         RExC_open_parens[ARG(nxt1)-1]=oscan; /*open->CURLYM*/
3510                         RExC_close_parens[ARG(nxt1)-1]=nxt+2; /*close->while*/
3511                     }
3512                     /* Now we know that nxt2 is the only contents: */
3513                     oscan->flags = (U8)ARG(nxt);
3514                     OP(oscan) = CURLYN;
3515                     OP(nxt1) = NOTHING; /* was OPEN. */
3516
3517 #ifdef DEBUGGING
3518                     OP(nxt1 + 1) = OPTIMIZED; /* was count. */
3519                     NEXT_OFF(nxt1+ 1) = 0; /* just for consistency. */
3520                     NEXT_OFF(nxt2) = 0; /* just for consistency with CURLY. */
3521                     OP(nxt) = OPTIMIZED;        /* was CLOSE. */
3522                     OP(nxt + 1) = OPTIMIZED; /* was count. */
3523                     NEXT_OFF(nxt+ 1) = 0; /* just for consistency. */
3524 #endif
3525                 }
3526               nogo:
3527
3528                 /* Try optimization CURLYX => CURLYM. */
3529                 if (  OP(oscan) == CURLYX && data
3530                       && !(data->flags & SF_HAS_PAR)
3531                       && !(data->flags & SF_HAS_EVAL)
3532                       && !deltanext     /* atom is fixed width */
3533                       && minnext != 0   /* CURLYM can't handle zero width */
3534                 ) {
3535                     /* XXXX How to optimize if data == 0? */
3536                     /* Optimize to a simpler form.  */
3537                     regnode *nxt = NEXTOPER(oscan) + EXTRA_STEP_2ARGS; /* OPEN */
3538                     regnode *nxt2;
3539
3540                     OP(oscan) = CURLYM;
3541                     while ( (nxt2 = regnext(nxt)) /* skip over embedded stuff*/
3542                             && (OP(nxt2) != WHILEM))
3543                         nxt = nxt2;
3544                     OP(nxt2)  = SUCCEED; /* Whas WHILEM */
3545                     /* Need to optimize away parenths. */
3546                     if ((data->flags & SF_IN_PAR) && OP(nxt) == CLOSE) {
3547                         /* Set the parenth number.  */
3548                         regnode *nxt1 = NEXTOPER(oscan) + EXTRA_STEP_2ARGS; /* OPEN*/
3549
3550                         oscan->flags = (U8)ARG(nxt);
3551                         if (RExC_open_parens) {
3552                             RExC_open_parens[ARG(nxt1)-1]=oscan; /*open->CURLYM*/
3553                             RExC_close_parens[ARG(nxt1)-1]=nxt2+1; /*close->NOTHING*/
3554                         }
3555                         OP(nxt1) = OPTIMIZED;   /* was OPEN. */
3556                         OP(nxt) = OPTIMIZED;    /* was CLOSE. */
3557
3558 #ifdef DEBUGGING
3559                         OP(nxt1 + 1) = OPTIMIZED; /* was count. */
3560                         OP(nxt + 1) = OPTIMIZED; /* was count. */
3561                         NEXT_OFF(nxt1 + 1) = 0; /* just for consistency. */
3562                         NEXT_OFF(nxt + 1) = 0; /* just for consistency. */
3563 #endif
3564 #if 0
3565                         while ( nxt1 && (OP(nxt1) != WHILEM)) {
3566                             regnode *nnxt = regnext(nxt1);
3567                             if (nnxt == nxt) {
3568                                 if (reg_off_by_arg[OP(nxt1)])
3569                                     ARG_SET(nxt1, nxt2 - nxt1);
3570                                 else if (nxt2 - nxt1 < U16_MAX)
3571                                     NEXT_OFF(nxt1) = nxt2 - nxt1;
3572                                 else
3573                                     OP(nxt) = NOTHING;  /* Cannot beautify */
3574                             }
3575                             nxt1 = nnxt;
3576                         }
3577 #endif
3578                         /* Optimize again: */
3579                         study_chunk(pRExC_state, &nxt1, minlenp, &deltanext, nxt,
3580                                     NULL, stopparen, recursed, NULL, 0,depth+1);
3581                     }
3582                     else
3583                         oscan->flags = 0;
3584                 }
3585                 else if ((OP(oscan) == CURLYX)
3586                          && (flags & SCF_WHILEM_VISITED_POS)
3587                          /* See the comment on a similar expression above.
3588                             However, this time it's not a subexpression
3589                             we care about, but the expression itself. */
3590                          && (maxcount == REG_INFTY)
3591                          && data && ++data->whilem_c < 16) {
3592                     /* This stays as CURLYX, we can put the count/of pair. */
3593                     /* Find WHILEM (as in regexec.c) */
3594                     regnode *nxt = oscan + NEXT_OFF(oscan);
3595
3596                     if (OP(PREVOPER(nxt)) == NOTHING) /* LONGJMP */
3597                         nxt += ARG(nxt);
3598                     PREVOPER(nxt)->flags = (U8)(data->whilem_c
3599                         | (RExC_whilem_seen << 4)); /* On WHILEM */
3600                 }
3601                 if (data && fl & (SF_HAS_PAR|SF_IN_PAR))
3602                     pars++;
3603                 if (flags & SCF_DO_SUBSTR) {
3604                     SV *last_str = NULL;
3605                     int counted = mincount != 0;
3606
3607                     if (data->last_end > 0 && mincount != 0) { /* Ends with a string. */
3608 #if defined(SPARC64_GCC_WORKAROUND)
3609                         I32 b = 0;
3610                         STRLEN l = 0;
3611                         const char *s = NULL;
3612                         I32 old = 0;
3613
3614                         if (pos_before >= data->last_start_min)
3615                             b = pos_before;
3616                         else
3617                             b = data->last_start_min;
3618
3619                         l = 0;
3620                         s = SvPV_const(data->last_found, l);
3621                         old = b - data->last_start_min;
3622
3623 #else
3624                         I32 b = pos_before >= data->last_start_min
3625                             ? pos_before : data->last_start_min;
3626                         STRLEN l;
3627                         const char * const s = SvPV_const(data->last_found, l);
3628                         I32 old = b - data->last_start_min;
3629 #endif
3630
3631                         if (UTF)
3632                             old = utf8_hop((U8*)s, old) - (U8*)s;
3633                         l -= old;
3634                         /* Get the added string: */
3635                         last_str = newSVpvn_utf8(s  + old, l, UTF);
3636                         if (deltanext == 0 && pos_before == b) {
3637                             /* What was added is a constant string */
3638                             if (mincount > 1) {
3639                                 SvGROW(last_str, (mincount * l) + 1);
3640                                 repeatcpy(SvPVX(last_str) + l,
3641                                           SvPVX_const(last_str), l, mincount - 1);
3642                                 SvCUR_set(last_str, SvCUR(last_str) * mincount);
3643                                 /* Add additional parts. */
3644                                 SvCUR_set(data->last_found,
3645                                           SvCUR(data->last_found) - l);
3646                                 sv_catsv(data->last_found, last_str);
3647                                 {
3648                                     SV * sv = data->last_found;
3649                                     MAGIC *mg =
3650                                         SvUTF8(sv) && SvMAGICAL(sv) ?
3651                                         mg_find(sv, PERL_MAGIC_utf8) : NULL;
3652                                     if (mg && mg->mg_len >= 0)
3653                                         mg->mg_len += CHR_SVLEN(last_str) - l;
3654                                 }
3655                                 data->last_end += l * (mincount - 1);
3656                             }
3657                         } else {
3658                             /* start offset must point into the last copy */
3659                             data->last_start_min += minnext * (mincount - 1);
3660                             data->last_start_max += is_inf ? I32_MAX
3661                                 : (maxcount - 1) * (minnext + data->pos_delta);
3662                         }
3663                     }
3664                     /* It is counted once already... */
3665                     data->pos_min += minnext * (mincount - counted);
3666                     data->pos_delta += - counted * deltanext +
3667                         (minnext + deltanext) * maxcount - minnext * mincount;
3668                     if (mincount != maxcount) {
3669                          /* Cannot extend fixed substrings found inside
3670                             the group.  */
3671                         SCAN_COMMIT(pRExC_state,data,minlenp);
3672                         if (mincount && last_str) {
3673                             SV * const sv = data->last_found;
3674                             MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ?
3675                                 mg_find(sv, PERL_MAGIC_utf8) : NULL;
3676
3677                             if (mg)
3678                                 mg->mg_len = -1;
3679                             sv_setsv(sv, last_str);
3680                             data->last_end = data->pos_min;
3681                             data->last_start_min =
3682                                 data->pos_min - CHR_SVLEN(last_str);
3683                             data->last_start_max = is_inf
3684                                 ? I32_MAX
3685                                 : data->pos_min + data->pos_delta
3686                                 - CHR_SVLEN(last_str);
3687                         }
3688                         data->longest = &(data->longest_float);
3689                     }
3690                     SvREFCNT_dec(last_str);
3691                 }
3692                 if (data && (fl & SF_HAS_EVAL))
3693                     data->flags |= SF_HAS_EVAL;
3694               optimize_curly_tail:
3695                 if (OP(oscan) != CURLYX) {
3696                     while (PL_regkind[OP(next = regnext(oscan))] == NOTHING
3697                            && NEXT_OFF(next))
3698                         NEXT_OFF(oscan) += NEXT_OFF(next);
3699                 }
3700                 continue;
3701             default:                    /* REF, ANYOFV, and CLUMP only? */
3702                 if (flags & SCF_DO_SUBSTR) {
3703                     SCAN_COMMIT(pRExC_state,data,minlenp);      /* Cannot expect anything... */
3704                     data->longest = &(data->longest_float);
3705                 }
3706                 is_inf = is_inf_internal = 1;
3707                 if (flags & SCF_DO_STCLASS_OR)
3708                     cl_anything(pRExC_state, data->start_class);
3709                 flags &= ~SCF_DO_STCLASS;
3710                 break;
3711             }
3712         }
3713         else if (OP(scan) == LNBREAK) {
3714             if (flags & SCF_DO_STCLASS) {
3715                 int value = 0;
3716                 data->start_class->flags &= ~ANYOF_EOS; /* No match on empty */
3717                 if (flags & SCF_DO_STCLASS_AND) {
3718                     for (value = 0; value < 256; value++)
3719                         if (!is_VERTWS_cp(value))
3720                             ANYOF_BITMAP_CLEAR(data->start_class, value);
3721                 }
3722                 else {
3723                     for (value = 0; value < 256; value++)
3724                         if (is_VERTWS_cp(value))
3725                             ANYOF_BITMAP_SET(data->start_class, value);
3726                 }
3727                 if (flags & SCF_DO_STCLASS_OR)
3728                     cl_and(data->start_class, and_withp);
3729                 flags &= ~SCF_DO_STCLASS;
3730             }
3731             min += 1;
3732             delta += 1;
3733             if (flags & SCF_DO_SUBSTR) {
3734                 SCAN_COMMIT(pRExC_state,data,minlenp);  /* Cannot expect anything... */
3735                 data->pos_min += 1;
3736                 data->pos_delta += 1;
3737                 data->longest = &(data->longest_float);
3738             }
3739         }
3740         else if (OP(scan) == FOLDCHAR) {
3741             int d = ARG(scan) == LATIN_SMALL_LETTER_SHARP_S ? 1 : 2;
3742             flags &= ~SCF_DO_STCLASS;
3743             min += 1;
3744             delta += d;
3745             if (flags & SCF_DO_SUBSTR) {
3746                 SCAN_COMMIT(pRExC_state,data,minlenp);  /* Cannot expect anything... */
3747                 data->pos_min += 1;
3748                 data->pos_delta += d;
3749                 data->longest = &(data->longest_float);
3750             }
3751         }
3752         else if (REGNODE_SIMPLE(OP(scan))) {
3753             int value = 0;
3754
3755             if (flags & SCF_DO_SUBSTR) {
3756                 SCAN_COMMIT(pRExC_state,data,minlenp);
3757                 data->pos_min++;
3758             }
3759             min++;
3760             if (flags & SCF_DO_STCLASS) {
3761                 data->start_class->flags &= ~ANYOF_EOS; /* No match on empty */
3762
3763                 /* Some of the logic below assumes that switching
3764                    locale on will only add false positives. */
3765                 switch (PL_regkind[OP(scan)]) {
3766                 case SANY:
3767                 default:
3768                   do_default:
3769                     /* Perl_croak(aTHX_ "panic: unexpected simple REx opcode %d", OP(scan)); */
3770                     if (flags & SCF_DO_STCLASS_OR) /* Allow everything */
3771                         cl_anything(pRExC_state, data->start_class);
3772                     break;
3773                 case REG_ANY:
3774                     if (OP(scan) == SANY)
3775                         goto do_default;
3776                     if (flags & SCF_DO_STCLASS_OR) { /* Everything but \n */
3777                         value = (ANYOF_BITMAP_TEST(data->start_class,'\n')
3778                                  || ANYOF_CLASS_TEST_ANY_SET(data->start_class));
3779                         cl_anything(pRExC_state, data->start_class);
3780                     }
3781                     if (flags & SCF_DO_STCLASS_AND || !value)
3782                         ANYOF_BITMAP_CLEAR(data->start_class,'\n');
3783                     break;
3784                 case ANYOF:
3785                     if (flags & SCF_DO_STCLASS_AND)
3786                         cl_and(data->start_class,
3787                                (struct regnode_charclass_class*)scan);
3788                     else
3789                         cl_or(pRExC_state, data->start_class,
3790                               (struct regnode_charclass_class*)scan);
3791                     break;
3792                 case ALNUM:
3793                     if (flags & SCF_DO_STCLASS_AND) {
3794                         if (!(data->start_class->flags & ANYOF_LOCALE)) {
3795                             ANYOF_CLASS_CLEAR(data->start_class,ANYOF_NALNUM);
3796                             if (OP(scan) == ALNUMU) {
3797                                 for (value = 0; value < 256; value++) {
3798                                     if (!isWORDCHAR_L1(value)) {
3799                                         ANYOF_BITMAP_CLEAR(data->start_class, value);
3800                                     }
3801                                 }
3802                             } else {
3803                                 for (value = 0; value < 256; value++) {
3804                                     if (!isALNUM(value)) {
3805                                         ANYOF_BITMAP_CLEAR(data->start_class, value);
3806                                     }
3807                                 }
3808                             }
3809                         }
3810                     }
3811                     else {
3812                         if (data->start_class->flags & ANYOF_LOCALE)
3813                             ANYOF_CLASS_SET(data->start_class,ANYOF_ALNUM);
3814
3815                         /* Even if under locale, set the bits for non-locale
3816                          * in case it isn't a true locale-node.  This will
3817                          * create false positives if it truly is locale */
3818                         if (OP(scan) == ALNUMU) {
3819                             for (value = 0; value < 256; value++) {
3820                                 if (isWORDCHAR_L1(value)) {
3821                                     ANYOF_BITMAP_SET(data->start_class, value);
3822                                 }
3823                             }
3824                         } else {
3825                             for (value = 0; value < 256; value++) {
3826                                 if (isALNUM(value)) {
3827                                     ANYOF_BITMAP_SET(data->start_class, value);
3828                                 }
3829                             }
3830                         }
3831                     }
3832                     break;
3833                 case NALNUM:
3834                     if (flags & SCF_DO_STCLASS_AND) {
3835                         if (!(data->start_class->flags & ANYOF_LOCALE)) {
3836                             ANYOF_CLASS_CLEAR(data->start_class,ANYOF_ALNUM);
3837                             if (OP(scan) == NALNUMU) {
3838                                 for (value = 0; value < 256; value++) {
3839                                     if (isWORDCHAR_L1(value)) {
3840                                         ANYOF_BITMAP_CLEAR(data->start_class, value);
3841                                     }
3842                                 }
3843                             } else {
3844                                 for (value = 0; value < 256; value++) {
3845                                     if (isALNUM(value)) {
3846                                         ANYOF_BITMAP_CLEAR(data->start_class, value);
3847                                     }
3848                                 }
3849                             }
3850                         }
3851                     }
3852                     else {
3853                         if (data->start_class->flags & ANYOF_LOCALE)
3854                             ANYOF_CLASS_SET(data->start_class,ANYOF_NALNUM);
3855
3856                         /* Even if under locale, set the bits for non-locale in
3857                          * case it isn't a true locale-node.  This will create
3858                          * false positives if it truly is locale */
3859                         if (OP(scan) == NALNUMU) {
3860                             for (value = 0; value < 256; value++) {
3861                                 if (! isWORDCHAR_L1(value)) {
3862                                     ANYOF_BITMAP_SET(data->start_class, value);
3863                                 }
3864                             }
3865                         } else {
3866                             for (value = 0; value < 256; value++) {
3867                                 if (! isALNUM(value)) {
3868                                     ANYOF_BITMAP_SET(data->start_class, value);
3869                                 }
3870                             }
3871                         }
3872                     }
3873                     break;
3874                 case SPACE:
3875                     if (flags & SCF_DO_STCLASS_AND) {
3876                         if (!(data->start_class->flags & ANYOF_LOCALE)) {
3877                             ANYOF_CLASS_CLEAR(data->start_class,ANYOF_NSPACE);
3878                             if (OP(scan) == SPACEU) {
3879                                 for (value = 0; value < 256; value++) {
3880                                     if (!isSPACE_L1(value)) {
3881                                         ANYOF_BITMAP_CLEAR(data->start_class, value);
3882                                     }
3883                                 }
3884                             } else {
3885                                 for (value = 0; value < 256; value++) {
3886                                     if (!isSPACE(value)) {
3887                                         ANYOF_BITMAP_CLEAR(data->start_class, value);
3888                                     }
3889                                 }
3890                             }
3891                         }
3892                     }
3893                     else {
3894                         if (data->start_class->flags & ANYOF_LOCALE) {
3895                             ANYOF_CLASS_SET(data->start_class,ANYOF_SPACE);
3896                         }
3897                         if (OP(scan) == SPACEU) {
3898                             for (value = 0; value < 256; value++) {
3899                                 if (isSPACE_L1(value)) {
3900                                     ANYOF_BITMAP_SET(data->start_class, value);
3901                                 }
3902                             }
3903                         } else {
3904                             for (value = 0; value < 256; value++) {
3905                                 if (isSPACE(value)) {
3906                                     ANYOF_BITMAP_SET(data->start_class, value);
3907                                 }
3908                             }
3909                         }
3910                     }
3911                     break;
3912                 case NSPACE:
3913                     if (flags & SCF_DO_STCLASS_AND) {
3914                         if (!(data->start_class->flags & ANYOF_LOCALE)) {
3915                             ANYOF_CLASS_CLEAR(data->start_class,ANYOF_SPACE);
3916                             if (OP(scan) == NSPACEU) {
3917                                 for (value = 0; value < 256; value++) {
3918                                     if (isSPACE_L1(value)) {
3919                                         ANYOF_BITMAP_CLEAR(data->start_class, value);
3920                                     }
3921                                 }
3922                             } else {
3923                                 for (value = 0; value < 256; value++) {
3924                                     if (isSPACE(value)) {
3925                                         ANYOF_BITMAP_CLEAR(data->start_class, value);
3926                                     }
3927                                 }
3928                             }
3929                         }
3930                     }
3931                     else {
3932                         if (data->start_class->flags & ANYOF_LOCALE)
3933                             ANYOF_CLASS_SET(data->start_class,ANYOF_NSPACE);
3934                         if (OP(scan) == NSPACEU) {
3935                             for (value = 0; value < 256; value++) {
3936                                 if (!isSPACE_L1(value)) {
3937                                     ANYOF_BITMAP_SET(data->start_class, value);
3938                                 }
3939                             }
3940                         }
3941                         else {
3942                             for (value = 0; value < 256; value++) {
3943                                 if (!isSPACE(value)) {
3944                                     ANYOF_BITMAP_SET(data->start_class, value);
3945                                 }
3946                             }
3947                         }
3948                     }
3949                     break;
3950                 case DIGIT:
3951                     if (flags & SCF_DO_STCLASS_AND) {
3952                         if (!(data->start_class->flags & ANYOF_LOCALE)) {
3953                             ANYOF_CLASS_CLEAR(data->start_class,ANYOF_NDIGIT);
3954                             for (value = 0; value < 256; value++)
3955                                 if (!isDIGIT(value))
3956                                     ANYOF_BITMAP_CLEAR(data->start_class, value);
3957                         }
3958                     }
3959                     else {
3960                         if (data->start_class->flags & ANYOF_LOCALE)
3961                             ANYOF_CLASS_SET(data->start_class,ANYOF_DIGIT);
3962                         for (value = 0; value < 256; value++)
3963                             if (isDIGIT(value))
3964                                 ANYOF_BITMAP_SET(data->start_class, value);
3965                     }
3966                     break;
3967                 case NDIGIT:
3968                     if (flags & SCF_DO_STCLASS_AND) {
3969                         if (!(data->start_class->flags & ANYOF_LOCALE))
3970                             ANYOF_CLASS_CLEAR(data->start_class,ANYOF_DIGIT);
3971                         for (value = 0; value < 256; value++)
3972                             if (isDIGIT(value))
3973                                 ANYOF_BITMAP_CLEAR(data->start_class, value);
3974                     }
3975                     else {
3976                         if (data->start_class->flags & ANYOF_LOCALE)
3977                             ANYOF_CLASS_SET(data->start_class,ANYOF_NDIGIT);
3978                         for (value = 0; value < 256; value++)
3979                             if (!isDIGIT(value))
3980                                 ANYOF_BITMAP_SET(data->start_class, value);
3981                     }
3982                     break;
3983                 CASE_SYNST_FNC(VERTWS);
3984                 CASE_SYNST_FNC(HORIZWS);
3985                 
3986                 }
3987                 if (flags & SCF_DO_STCLASS_OR)
3988                     cl_and(data->start_class, and_withp);
3989                 flags &= ~SCF_DO_STCLASS;
3990             }
3991         }
3992         else if (PL_regkind[OP(scan)] == EOL && flags & SCF_DO_SUBSTR) {
3993             data->flags |= (OP(scan) == MEOL
3994                             ? SF_BEFORE_MEOL
3995                             : SF_BEFORE_SEOL);
3996         }
3997         else if (  PL_regkind[OP(scan)] == BRANCHJ
3998                  /* Lookbehind, or need to calculate parens/evals/stclass: */
3999                    && (scan->flags || data || (flags & SCF_DO_STCLASS))
4000                    && (OP(scan) == IFMATCH || OP(scan) == UNLESSM)) {
4001             if ( !PERL_ENABLE_POSITIVE_ASSERTION_STUDY 
4002                 || OP(scan) == UNLESSM )
4003             {
4004                 /* Negative Lookahead/lookbehind
4005                    In this case we can't do fixed string optimisation.
4006                 */
4007
4008                 I32 deltanext, minnext, fake = 0;
4009                 regnode *nscan;
4010                 struct regnode_charclass_class intrnl;
4011                 int f = 0;
4012
4013                 data_fake.flags = 0;
4014                 if (data) {
4015                     data_fake.whilem_c = data->whilem_c;
4016                     data_fake.last_closep = data->last_closep;
4017                 }
4018                 else
4019                     data_fake.last_closep = &fake;
4020                 data_fake.pos_delta = delta;
4021                 if ( flags & SCF_DO_STCLASS && !scan->flags
4022                      && OP(scan) == IFMATCH ) { /* Lookahead */
4023                     cl_init(pRExC_state, &intrnl);
4024                     data_fake.start_class = &intrnl;
4025                     f |= SCF_DO_STCLASS_AND;
4026                 }
4027                 if (flags & SCF_WHILEM_VISITED_POS)
4028                     f |= SCF_WHILEM_VISITED_POS;
4029                 next = regnext(scan);
4030                 nscan = NEXTOPER(NEXTOPER(scan));
4031                 minnext = study_chunk(pRExC_state, &nscan, minlenp, &deltanext, 
4032                     last, &data_fake, stopparen, recursed, NULL, f, depth+1);
4033                 if (scan->flags) {
4034                     if (deltanext) {
4035                         FAIL("Variable length lookbehind not implemented");
4036                     }
4037                     else if (minnext > (I32)U8_MAX) {
4038                         FAIL2("Lookbehind longer than %"UVuf" not implemented", (UV)U8_MAX);
4039                     }
4040                     scan->flags = (U8)minnext;
4041                 }
4042                 if (data) {
4043                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
4044                         pars++;
4045                     if (data_fake.flags & SF_HAS_EVAL)
4046                         data->flags |= SF_HAS_EVAL;
4047                     data->whilem_c = data_fake.whilem_c;
4048                 }
4049                 if (f & SCF_DO_STCLASS_AND) {
4050                     if (flags & SCF_DO_STCLASS_OR) {
4051                         /* OR before, AND after: ideally we would recurse with
4052                          * data_fake to get the AND applied by study of the
4053                          * remainder of the pattern, and then derecurse;
4054                          * *** HACK *** for now just treat as "no information".
4055                          * See [perl #56690].
4056                          */
4057                         cl_init(pRExC_state, data->start_class);
4058                     }  else {
4059                         /* AND before and after: combine and continue */
4060                         const int was = (data->start_class->flags & ANYOF_EOS);
4061
4062                         cl_and(data->start_class, &intrnl);
4063                         if (was)
4064                             data->start_class->flags |= ANYOF_EOS;
4065                     }
4066                 }
4067             }
4068 #if PERL_ENABLE_POSITIVE_ASSERTION_STUDY
4069             else {
4070                 /* Positive Lookahead/lookbehind
4071                    In this case we can do fixed string optimisation,
4072                    but we must be careful about it. Note in the case of
4073                    lookbehind the positions will be offset by the minimum
4074                    length of the pattern, something we won't know about
4075                    until after the recurse.
4076                 */
4077                 I32 deltanext, fake = 0;
4078                 regnode *nscan;
4079                 struct regnode_charclass_class intrnl;
4080                 int f = 0;
4081                 /* We use SAVEFREEPV so that when the full compile 
4082                     is finished perl will clean up the allocated 
4083                     minlens when it's all done. This way we don't
4084                     have to worry about freeing them when we know
4085                     they wont be used, which would be a pain.
4086                  */
4087                 I32 *minnextp;
4088                 Newx( minnextp, 1, I32 );
4089                 SAVEFREEPV(minnextp);
4090
4091                 if (data) {
4092                     StructCopy(data, &data_fake, scan_data_t);
4093                     if ((flags & SCF_DO_SUBSTR) && data->last_found) {
4094                         f |= SCF_DO_SUBSTR;
4095                         if (scan->flags) 
4096                             SCAN_COMMIT(pRExC_state, &data_fake,minlenp);
4097                         data_fake.last_found=newSVsv(data->last_found);
4098                     }
4099                 }
4100                 else
4101                     data_fake.last_closep = &fake;
4102                 data_fake.flags = 0;
4103                 data_fake.pos_delta = delta;
4104                 if (is_inf)
4105                     data_fake.flags |= SF_IS_INF;
4106                 if ( flags & SCF_DO_STCLASS && !scan->flags
4107                      && OP(scan) == IFMATCH ) { /* Lookahead */
4108                     cl_init(pRExC_state, &intrnl);
4109                     data_fake.start_class = &intrnl;
4110                     f |= SCF_DO_STCLASS_AND;
4111                 }
4112                 if (flags & SCF_WHILEM_VISITED_POS)
4113                     f |= SCF_WHILEM_VISITED_POS;
4114                 next = regnext(scan);
4115                 nscan = NEXTOPER(NEXTOPER(scan));
4116
4117                 *minnextp = study_chunk(pRExC_state, &nscan, minnextp, &deltanext, 
4118                     last, &data_fake, stopparen, recursed, NULL, f,depth+1);
4119                 if (scan->flags) {
4120                     if (deltanext) {
4121                         FAIL("Variable length lookbehind not implemented");
4122                     }
4123                     else if (*minnextp > (I32)U8_MAX) {
4124                         FAIL2("Lookbehind longer than %"UVuf" not implemented", (UV)U8_MAX);
4125                     }
4126                     scan->flags = (U8)*minnextp;
4127                 }
4128
4129                 *minnextp += min;
4130
4131                 if (f & SCF_DO_STCLASS_AND) {
4132                     const int was = (data->start_class->flags & ANYOF_EOS);
4133
4134                     cl_and(data->start_class, &intrnl);
4135                     if (was)
4136                         data->start_class->flags |= ANYOF_EOS;
4137                 }
4138                 if (data) {
4139                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
4140                         pars++;
4141                     if (data_fake.flags & SF_HAS_EVAL)
4142                         data->flags |= SF_HAS_EVAL;
4143                     data->whilem_c = data_fake.whilem_c;
4144                     if ((flags & SCF_DO_SUBSTR) && data_fake.last_found) {
4145                         if (RExC_rx->minlen<*minnextp)
4146                             RExC_rx->minlen=*minnextp;
4147                         SCAN_COMMIT(pRExC_state, &data_fake, minnextp);
4148                         SvREFCNT_dec(data_fake.last_found);
4149                         
4150                         if ( data_fake.minlen_fixed != minlenp ) 
4151                         {
4152                             data->offset_fixed= data_fake.offset_fixed;
4153                             data->minlen_fixed= data_fake.minlen_fixed;
4154                             data->lookbehind_fixed+= scan->flags;
4155                         }
4156                         if ( data_fake.minlen_float != minlenp )
4157                         {
4158                             data->minlen_float= data_fake.minlen_float;
4159                             data->offset_float_min=data_fake.offset_float_min;
4160                             data->offset_float_max=data_fake.offset_float_max;
4161                             data->lookbehind_float+= scan->flags;
4162                         }
4163                     }
4164                 }
4165
4166
4167             }
4168 #endif
4169         }
4170         else if (OP(scan) == OPEN) {
4171             if (stopparen != (I32)ARG(scan))
4172                 pars++;
4173         }
4174         else if (OP(scan) == CLOSE) {
4175             if (stopparen == (I32)ARG(scan)) {
4176                 break;
4177             }
4178             if ((I32)ARG(scan) == is_par) {
4179                 next = regnext(scan);
4180
4181                 if ( next && (OP(next) != WHILEM) && next < last)
4182                     is_par = 0;         /* Disable optimization */
4183             }
4184             if (data)
4185                 *(data->last_closep) = ARG(scan);
4186         }
4187         else if (OP(scan) == EVAL) {
4188                 if (data)
4189                     data->flags |= SF_HAS_EVAL;
4190         }
4191         else if ( PL_regkind[OP(scan)] == ENDLIKE ) {
4192             if (flags & SCF_DO_SUBSTR) {
4193                 SCAN_COMMIT(pRExC_state,data,minlenp);
4194                 flags &= ~SCF_DO_SUBSTR;
4195             }
4196             if (data && OP(scan)==ACCEPT) {
4197                 data->flags |= SCF_SEEN_ACCEPT;
4198                 if (stopmin > min)
4199                     stopmin = min;
4200             }
4201         }
4202         else if (OP(scan) == LOGICAL && scan->flags == 2) /* Embedded follows */
4203         {
4204                 if (flags & SCF_DO_SUBSTR) {
4205                     SCAN_COMMIT(pRExC_state,data,minlenp);
4206                     data->longest = &(data->longest_float);
4207                 }
4208                 is_inf = is_inf_internal = 1;
4209                 if (flags & SCF_DO_STCLASS_OR) /* Allow everything */
4210                     cl_anything(pRExC_state, data->start_class);
4211                 flags &= ~SCF_DO_STCLASS;
4212         }
4213         else if (OP(scan) == GPOS) {
4214             if (!(RExC_rx->extflags & RXf_GPOS_FLOAT) &&
4215                 !(delta || is_inf || (data && data->pos_delta))) 
4216             {
4217                 if (!(RExC_rx->extflags & RXf_ANCH) && (flags & SCF_DO_SUBSTR))
4218                     RExC_rx->extflags |= RXf_ANCH_GPOS;
4219                 if (RExC_rx->gofs < (U32)min)
4220                     RExC_rx->gofs = min;
4221             } else {
4222                 RExC_rx->extflags |= RXf_GPOS_FLOAT;
4223                 RExC_rx->gofs = 0;
4224             }       
4225         }
4226 #ifdef TRIE_STUDY_OPT
4227 #ifdef FULL_TRIE_STUDY
4228         else if (PL_regkind[OP(scan)] == TRIE) {
4229             /* NOTE - There is similar code to this block above for handling
4230                BRANCH nodes on the initial study.  If you change stuff here
4231                check there too. */
4232             regnode *trie_node= scan;
4233             regnode *tail= regnext(scan);
4234             reg_trie_data *trie = (reg_trie_data*)RExC_rxi->data->data[ ARG(scan) ];
4235             I32 max1 = 0, min1 = I32_MAX;
4236             struct regnode_charclass_class accum;
4237
4238             if (flags & SCF_DO_SUBSTR) /* XXXX Add !SUSPEND? */
4239                 SCAN_COMMIT(pRExC_state, data,minlenp); /* Cannot merge strings after this. */
4240             if (flags & SCF_DO_STCLASS)
4241                 cl_init_zero(pRExC_state, &accum);
4242                 
4243             if (!trie->jump) {
4244                 min1= trie->minlen;
4245                 max1= trie->maxlen;
4246             } else {
4247                 const regnode *nextbranch= NULL;
4248                 U32 word;
4249                 
4250                 for ( word=1 ; word <= trie->wordcount ; word++) 
4251                 {
4252                     I32 deltanext=0, minnext=0, f = 0, fake;
4253                     struct regnode_charclass_class this_class;
4254                     
4255                     data_fake.flags = 0;
4256                     if (data) {
4257                         data_fake.whilem_c = data->whilem_c;
4258                         data_fake.last_closep = data->last_closep;
4259                     }
4260                     else
4261                         data_fake.last_closep = &fake;
4262                     data_fake.pos_delta = delta;
4263                     if (flags & SCF_DO_STCLASS) {
4264                         cl_init(pRExC_state, &this_class);
4265                         data_fake.start_class = &this_class;
4266                         f = SCF_DO_STCLASS_AND;
4267                     }
4268                     if (flags & SCF_WHILEM_VISITED_POS)
4269                         f |= SCF_WHILEM_VISITED_POS;
4270     
4271                     if (trie->jump[word]) {
4272                         if (!nextbranch)
4273                             nextbranch = trie_node + trie->jump[0];
4274                         scan= trie_node + trie->jump[word];
4275                         /* We go from the jump point to the branch that follows
4276                            it. Note this means we need the vestigal unused branches
4277                            even though they arent otherwise used.
4278                          */
4279                         minnext = study_chunk(pRExC_state, &scan, minlenp, 
4280                             &deltanext, (regnode *)nextbranch, &data_fake, 
4281                             stopparen, recursed, NULL, f,depth+1);
4282                     }
4283                     if (nextbranch && PL_regkind[OP(nextbranch)]==BRANCH)
4284                         nextbranch= regnext((regnode*)nextbranch);
4285                     
4286                     if (min1 > (I32)(minnext + trie->minlen))
4287                         min1 = minnext + trie->minlen;
4288                     if (max1 < (I32)(minnext + deltanext + trie->maxlen))
4289                         max1 = minnext + deltanext + trie->maxlen;
4290                     if (deltanext == I32_MAX)
4291                         is_inf = is_inf_internal = 1;
4292                     
4293                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
4294                         pars++;
4295                     if (data_fake.flags & SCF_SEEN_ACCEPT) {
4296                         if ( stopmin > min + min1) 
4297                             stopmin = min + min1;
4298                         flags &= ~SCF_DO_SUBSTR;
4299                         if (data)
4300                             data->flags |= SCF_SEEN_ACCEPT;
4301                     }
4302                     if (data) {
4303                         if (data_fake.flags & SF_HAS_EVAL)
4304                             data->flags |= SF_HAS_EVAL;
4305                         data->whilem_c = data_fake.whilem_c;
4306                     }
4307                     if (flags & SCF_DO_STCLASS)
4308                         cl_or(pRExC_state, &accum, &this_class);
4309                 }
4310             }
4311             if (flags & SCF_DO_SUBSTR) {
4312                 data->pos_min += min1;
4313                 data->pos_delta += max1 - min1;
4314                 if (max1 != min1 || is_inf)
4315                     data->longest = &(data->longest_float);
4316             }
4317             min += min1;
4318             delta += max1 - min1;
4319             if (flags & SCF_DO_STCLASS_OR) {
4320                 cl_or(pRExC_state, data->start_class, &accum);
4321                 if (min1) {
4322                     cl_and(data->start_class, and_withp);
4323                     flags &= ~SCF_DO_STCLASS;
4324                 }
4325             }
4326             else if (flags & SCF_DO_STCLASS_AND) {
4327                 if (min1) {
4328                     cl_and(data->start_class, &accum);
4329                     flags &= ~SCF_DO_STCLASS;
4330                 }
4331                 else {
4332                     /* Switch to OR mode: cache the old value of
4333                      * data->start_class */
4334                     INIT_AND_WITHP;
4335                     StructCopy(data->start_class, and_withp,
4336                                struct regnode_charclass_class);
4337                     flags &= ~SCF_DO_STCLASS_AND;
4338                     StructCopy(&accum, data->start_class,
4339                                struct regnode_charclass_class);
4340                     flags |= SCF_DO_STCLASS_OR;
4341                     data->start_class->flags |= ANYOF_EOS;
4342                 }
4343             }
4344             scan= tail;
4345             continue;
4346         }
4347 #else
4348         else if (PL_regkind[OP(scan)] == TRIE) {
4349             reg_trie_data *trie = (reg_trie_data*)RExC_rxi->data->data[ ARG(scan) ];
4350             U8*bang=NULL;
4351             
4352             min += trie->minlen;
4353             delta += (trie->maxlen - trie->minlen);
4354             flags &= ~SCF_DO_STCLASS; /* xxx */
4355             if (flags & SCF_DO_SUBSTR) {
4356                 SCAN_COMMIT(pRExC_state,data,minlenp);  /* Cannot expect anything... */
4357                 data->pos_min += trie->minlen;
4358                 data->pos_delta += (trie->maxlen - trie->minlen);
4359                 if (trie->maxlen != trie->minlen)
4360                     data->longest = &(data->longest_float);
4361             }
4362             if (trie->jump) /* no more substrings -- for now /grr*/
4363                 flags &= ~SCF_DO_SUBSTR; 
4364         }
4365 #endif /* old or new */
4366 #endif /* TRIE_STUDY_OPT */     
4367
4368         /* Else: zero-length, ignore. */
4369         scan = regnext(scan);
4370     }
4371     if (frame) {
4372         last = frame->last;
4373         scan = frame->next;
4374         stopparen = frame->stop;
4375         frame = frame->prev;
4376         goto fake_study_recurse;
4377     }
4378
4379   finish:
4380     assert(!frame);
4381     DEBUG_STUDYDATA("pre-fin:",data,depth);
4382
4383     *scanp = scan;
4384     *deltap = is_inf_internal ? I32_MAX : delta;
4385     if (flags & SCF_DO_SUBSTR && is_inf)
4386         data->pos_delta = I32_MAX - data->pos_min;
4387     if (is_par > (I32)U8_MAX)
4388         is_par = 0;
4389     if (is_par && pars==1 && data) {
4390         data->flags |= SF_IN_PAR;
4391         data->flags &= ~SF_HAS_PAR;
4392     }
4393     else if (pars && data) {
4394         data->flags |= SF_HAS_PAR;
4395         data->flags &= ~SF_IN_PAR;
4396     }
4397     if (flags & SCF_DO_STCLASS_OR)
4398         cl_and(data->start_class, and_withp);
4399     if (flags & SCF_TRIE_RESTUDY)
4400         data->flags |=  SCF_TRIE_RESTUDY;
4401     
4402     DEBUG_STUDYDATA("post-fin:",data,depth);
4403     
4404     return min < stopmin ? min : stopmin;
4405 }
4406
4407 STATIC U32
4408 S_add_data(RExC_state_t *pRExC_state, U32 n, const char *s)
4409 {
4410     U32 count = RExC_rxi->data ? RExC_rxi->data->count : 0;
4411
4412     PERL_ARGS_ASSERT_ADD_DATA;
4413
4414     Renewc(RExC_rxi->data,
4415            sizeof(*RExC_rxi->data) + sizeof(void*) * (count + n - 1),
4416            char, struct reg_data);
4417     if(count)
4418         Renew(RExC_rxi->data->what, count + n, U8);
4419     else
4420         Newx(RExC_rxi->data->what, n, U8);
4421     RExC_rxi->data->count = count + n;
4422     Copy(s, RExC_rxi->data->what + count, n, U8);
4423     return count;
4424 }
4425
4426 /*XXX: todo make this not included in a non debugging perl */
4427 #ifndef PERL_IN_XSUB_RE
4428 void
4429 Perl_reginitcolors(pTHX)
4430 {
4431     dVAR;
4432     const char * const s = PerlEnv_getenv("PERL_RE_COLORS");
4433     if (s) {
4434         char *t = savepv(s);
4435         int i = 0;
4436         PL_colors[0] = t;
4437         while (++i < 6) {
4438             t = strchr(t, '\t');
4439             if (t) {
4440                 *t = '\0';
4441                 PL_colors[i] = ++t;
4442             }
4443             else
4444                 PL_colors[i] = t = (char *)"";
4445         }
4446     } else {
4447         int i = 0;
4448         while (i < 6)
4449             PL_colors[i++] = (char *)"";
4450     }
4451     PL_colorset = 1;
4452 }
4453 #endif
4454
4455
4456 #ifdef TRIE_STUDY_OPT
4457 #define CHECK_RESTUDY_GOTO                                  \
4458         if (                                                \
4459               (data.flags & SCF_TRIE_RESTUDY)               \
4460               && ! restudied++                              \
4461         )     goto reStudy
4462 #else
4463 #define CHECK_RESTUDY_GOTO
4464 #endif        
4465
4466 /*
4467  - pregcomp - compile a regular expression into internal code
4468  *
4469  * We can't allocate space until we know how big the compiled form will be,
4470  * but we can't compile it (and thus know how big it is) until we've got a
4471  * place to put the code.  So we cheat:  we compile it twice, once with code
4472  * generation turned off and size counting turned on, and once "for real".
4473  * This also means that we don't allocate space until we are sure that the
4474  * thing really will compile successfully, and we never have to move the
4475  * code and thus invalidate pointers into it.  (Note that it has to be in
4476  * one piece because free() must be able to free it all.) [NB: not true in perl]
4477  *
4478  * Beware that the optimization-preparation code in here knows about some
4479  * of the structure of the compiled regexp.  [I'll say.]
4480  */
4481
4482
4483
4484 #ifndef PERL_IN_XSUB_RE
4485 #define RE_ENGINE_PTR &PL_core_reg_engine
4486 #else
4487 extern const struct regexp_engine my_reg_engine;
4488 #define RE_ENGINE_PTR &my_reg_engine
4489 #endif
4490
4491 #ifndef PERL_IN_XSUB_RE 
4492 REGEXP *
4493 Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags)
4494 {
4495     dVAR;
4496     HV * const table = GvHV(PL_hintgv);
4497
4498     PERL_ARGS_ASSERT_PREGCOMP;
4499
4500     /* Dispatch a request to compile a regexp to correct 
4501        regexp engine. */
4502     if (table) {
4503         SV **ptr= hv_fetchs(table, "regcomp", FALSE);
4504         GET_RE_DEBUG_FLAGS_DECL;
4505         if (ptr && SvIOK(*ptr) && SvIV(*ptr)) {
4506             const regexp_engine *eng=INT2PTR(regexp_engine*,SvIV(*ptr));
4507             DEBUG_COMPILE_r({
4508                 PerlIO_printf(Perl_debug_log, "Using engine %"UVxf"\n",
4509                     SvIV(*ptr));
4510             });            
4511             return CALLREGCOMP_ENG(eng, pattern, flags);
4512         } 
4513     }
4514     return Perl_re_compile(aTHX_ pattern, flags);
4515 }
4516 #endif
4517
4518 REGEXP *
4519 Perl_re_compile(pTHX_ SV * const pattern, U32 orig_pm_flags)
4520 {
4521     dVAR;
4522     REGEXP *rx;
4523     struct regexp *r;
4524     register regexp_internal *ri;
4525     STRLEN plen;
4526     char  *exp;
4527     char* xend;
4528     regnode *scan;
4529     I32 flags;
4530     I32 minlen = 0;
4531     U32 pm_flags;
4532
4533     /* these are all flags - maybe they should be turned
4534      * into a single int with different bit masks */
4535     I32 sawlookahead = 0;
4536     I32 sawplus = 0;
4537     I32 sawopen = 0;
4538     bool used_setjump = FALSE;
4539     regex_charset initial_charset = get_regex_charset(orig_pm_flags);
4540
4541     U8 jump_ret = 0;
4542     dJMPENV;
4543     scan_data_t data;
4544     RExC_state_t RExC_state;
4545     RExC_state_t * const pRExC_state = &RExC_state;
4546 #ifdef TRIE_STUDY_OPT    
4547     int restudied;
4548     RExC_state_t copyRExC_state;
4549 #endif    
4550     GET_RE_DEBUG_FLAGS_DECL;
4551
4552     PERL_ARGS_ASSERT_RE_COMPILE;
4553
4554     DEBUG_r(if (!PL_colorset) reginitcolors());
4555
4556     RExC_utf8 = RExC_orig_utf8 = SvUTF8(pattern);
4557     RExC_uni_semantics = 0;
4558     RExC_contains_locale = 0;
4559
4560     /****************** LONG JUMP TARGET HERE***********************/
4561     /* Longjmp back to here if have to switch in midstream to utf8 */
4562     if (! RExC_orig_utf8) {
4563         JMPENV_PUSH(jump_ret);
4564         used_setjump = TRUE;
4565     }
4566
4567     if (jump_ret == 0) {    /* First time through */
4568         exp = SvPV(pattern, plen);
4569         xend = exp + plen;
4570         /* ignore the utf8ness if the pattern is 0 length */
4571         if (plen == 0) {
4572             RExC_utf8 = RExC_orig_utf8 = 0;
4573         }
4574
4575         DEBUG_COMPILE_r({
4576             SV *dsv= sv_newmortal();
4577             RE_PV_QUOTED_DECL(s, RExC_utf8,
4578                 dsv, exp, plen, 60);
4579             PerlIO_printf(Perl_debug_log, "%sCompiling REx%s %s\n",
4580                            PL_colors[4],PL_colors[5],s);
4581         });
4582     }
4583     else {  /* longjumped back */
4584         STRLEN len = plen;
4585
4586         /* If the cause for the longjmp was other than changing to utf8, pop
4587          * our own setjmp, and longjmp to the correct handler */
4588         if (jump_ret != UTF8_LONGJMP) {
4589             JMPENV_POP;
4590             JMPENV_JUMP(jump_ret);
4591         }
4592
4593         GET_RE_DEBUG_FLAGS;
4594
4595         /* It's possible to write a regexp in ascii that represents Unicode
4596         codepoints outside of the byte range, such as via \x{100}. If we
4597         detect such a sequence we have to convert the entire pattern to utf8
4598         and then recompile, as our sizing calculation will have been based
4599         on 1 byte == 1 character, but we will need to use utf8 to encode
4600         at least some part of the pattern, and therefore must convert the whole
4601         thing.
4602         -- dmq */
4603         DEBUG_PARSE_r(PerlIO_printf(Perl_debug_log,
4604             "UTF8 mismatch! Converting to utf8 for resizing and compile\n"));
4605         exp = (char*)Perl_bytes_to_utf8(aTHX_ (U8*)SvPV(pattern, plen), &len);
4606         xend = exp + len;
4607         RExC_orig_utf8 = RExC_utf8 = 1;
4608         SAVEFREEPV(exp);
4609     }
4610
4611 #ifdef TRIE_STUDY_OPT
4612     restudied = 0;
4613 #endif
4614
4615     pm_flags = orig_pm_flags;
4616
4617     if (initial_charset == REGEX_LOCALE_CHARSET) {
4618         RExC_contains_locale = 1;
4619     }
4620     else if (RExC_utf8 && initial_charset == REGEX_DEPENDS_CHARSET) {
4621
4622         /* Set to use unicode semantics if the pattern is in utf8 and has the
4623          * 'depends' charset specified, as it means unicode when utf8  */
4624         set_regex_charset(&pm_flags, REGEX_UNICODE_CHARSET);
4625     }
4626
4627     RExC_precomp = exp;
4628     RExC_flags = pm_flags;
4629     RExC_sawback = 0;
4630
4631     RExC_seen = 0;
4632     RExC_in_lookbehind = 0;
4633     RExC_seen_zerolen = *exp == '^' ? -1 : 0;
4634     RExC_seen_evals = 0;
4635     RExC_extralen = 0;
4636     RExC_override_recoding = 0;
4637
4638     /* First pass: determine size, legality. */
4639     RExC_parse = exp;
4640     RExC_start = exp;
4641     RExC_end = xend;
4642     RExC_naughty = 0;
4643     RExC_npar = 1;
4644     RExC_nestroot = 0;
4645     RExC_size = 0L;
4646     RExC_emit = &PL_regdummy;
4647     RExC_whilem_seen = 0;
4648     RExC_open_parens = NULL;
4649     RExC_close_parens = NULL;
4650     RExC_opend = NULL;
4651     RExC_paren_names = NULL;
4652 #ifdef DEBUGGING
4653     RExC_paren_name_list = NULL;
4654 #endif
4655     RExC_recurse = NULL;
4656     RExC_recurse_count = 0;
4657
4658 #if 0 /* REGC() is (currently) a NOP at the first pass.
4659        * Clever compilers notice this and complain. --jhi */
4660     REGC((U8)REG_MAGIC, (char*)RExC_emit);
4661 #endif
4662     DEBUG_PARSE_r(PerlIO_printf(Perl_debug_log, "Starting first pass (sizing)\n"));
4663     if (reg(pRExC_state, 0, &flags,1) == NULL) {
4664         RExC_precomp = NULL;
4665         return(NULL);
4666     }
4667
4668     /* Here, finished first pass.  Get rid of any added setjmp */
4669     if (used_setjump) {
4670         JMPENV_POP;
4671     }
4672
4673     DEBUG_PARSE_r({
4674         PerlIO_printf(Perl_debug_log, 
4675             "Required size %"IVdf" nodes\n"
4676             "Starting second pass (creation)\n", 
4677             (IV)RExC_size);
4678         RExC_lastnum=0; 
4679         RExC_lastparse=NULL; 
4680     });
4681
4682     /* The first pass could have found things that force Unicode semantics */
4683     if ((RExC_utf8 || RExC_uni_semantics)
4684          && get_regex_charset(pm_flags) == REGEX_DEPENDS_CHARSET)
4685     {
4686         set_regex_charset(&pm_flags, REGEX_UNICODE_CHARSET);
4687     }
4688
4689     /* Small enough for pointer-storage convention?
4690        If extralen==0, this means that we will not need long jumps. */
4691     if (RExC_size >= 0x10000L && RExC_extralen)
4692         RExC_size += RExC_extralen;
4693     else
4694         RExC_extralen = 0;
4695     if (RExC_whilem_seen > 15)
4696         RExC_whilem_seen = 15;
4697
4698     /* Allocate space and zero-initialize. Note, the two step process 
4699        of zeroing when in debug mode, thus anything assigned has to 
4700        happen after that */
4701     rx = (REGEXP*) newSV_type(SVt_REGEXP);
4702     r = (struct regexp*)SvANY(rx);
4703     Newxc(ri, sizeof(regexp_internal) + (unsigned)RExC_size * sizeof(regnode),
4704          char, regexp_internal);
4705     if ( r == NULL || ri == NULL )
4706         FAIL("Regexp out of space");
4707 #ifdef DEBUGGING
4708     /* avoid reading uninitialized memory in DEBUGGING code in study_chunk() */
4709     Zero(ri, sizeof(regexp_internal) + (unsigned)RExC_size * sizeof(regnode), char);
4710 #else 
4711     /* bulk initialize base fields with 0. */
4712     Zero(ri, sizeof(regexp_internal), char);        
4713 #endif
4714
4715     /* non-zero initialization begins here */
4716     RXi_SET( r, ri );
4717     r->engine= RE_ENGINE_PTR;
4718     r->extflags = pm_flags;
4719     {
4720         bool has_p     = ((r->extflags & RXf_PMf_KEEPCOPY) == RXf_PMf_KEEPCOPY);
4721         bool has_charset = (get_regex_charset(r->extflags) != REGEX_DEPENDS_CHARSET);
4722
4723         /* The caret is output if there are any defaults: if not all the STD
4724          * flags are set, or if no character set specifier is needed */
4725         bool has_default =
4726                     (((r->extflags & RXf_PMf_STD_PMMOD) != RXf_PMf_STD_PMMOD)
4727                     || ! has_charset);
4728         bool has_runon = ((RExC_seen & REG_SEEN_RUN_ON_COMMENT)==REG_SEEN_RUN_ON_COMMENT);
4729         U16 reganch = (U16)((r->extflags & RXf_PMf_STD_PMMOD)
4730                             >> RXf_PMf_STD_PMMOD_SHIFT);
4731         const char *fptr = STD_PAT_MODS;        /*"msix"*/
4732         char *p;
4733         /* Allocate for the worst case, which is all the std flags are turned
4734          * on.  If more precision is desired, we could do a population count of
4735          * the flags set.  This could be done with a small lookup table, or by
4736          * shifting, masking and adding, or even, when available, assembly
4737          * language for a machine-language population count.
4738          * We never output a minus, as all those are defaults, so are
4739          * covered by the caret */
4740         const STRLEN wraplen = plen + has_p + has_runon
4741             + has_default       /* If needs a caret */
4742
4743                 /* If needs a character set specifier */
4744             + ((has_charset) ? MAX_CHARSET_NAME_LENGTH : 0)
4745             + (sizeof(STD_PAT_MODS) - 1)
4746             + (sizeof("(?:)") - 1);
4747
4748         p = sv_grow(MUTABLE_SV(rx), wraplen + 1); /* +1 for the ending NUL */
4749         SvPOK_on(rx);
4750         SvFLAGS(rx) |= SvUTF8(pattern);
4751         *p++='('; *p++='?';
4752
4753         /* If a default, cover it using the caret */
4754         if (has_default) {
4755             *p++= DEFAULT_PAT_MOD;
4756         }
4757         if (has_charset) {
4758             STRLEN len;
4759             const char* const name = get_regex_charset_name(r->extflags, &len);
4760             Copy(name, p, len, char);
4761             p += len;
4762         }
4763         if (has_p)
4764             *p++ = KEEPCOPY_PAT_MOD; /*'p'*/
4765         {
4766             char ch;
4767             while((ch = *fptr++)) {
4768                 if(reganch & 1)
4769                     *p++ = ch;
4770                 reganch >>= 1;
4771             }
4772         }
4773
4774         *p++ = ':';
4775         Copy(RExC_precomp, p, plen, char);
4776         assert ((RX_WRAPPED(rx) - p) < 16);
4777         r->pre_prefix = p - RX_WRAPPED(rx);
4778         p += plen;
4779         if (has_runon)
4780             *p++ = '\n';
4781         *p++ = ')';
4782         *p = 0;
4783         SvCUR_set(rx, p - SvPVX_const(rx));
4784     }
4785
4786     r->intflags = 0;
4787     r->nparens = RExC_npar - 1; /* set early to validate backrefs */
4788     
4789     if (RExC_seen & REG_SEEN_RECURSE) {
4790         Newxz(RExC_open_parens, RExC_npar,regnode *);
4791         SAVEFREEPV(RExC_open_parens);
4792         Newxz(RExC_close_parens,RExC_npar,regnode *);
4793         SAVEFREEPV(RExC_close_parens);
4794     }
4795
4796     /* Useful during FAIL. */
4797 #ifdef RE_TRACK_PATTERN_OFFSETS
4798     Newxz(ri->u.offsets, 2*RExC_size+1, U32); /* MJD 20001228 */
4799     DEBUG_OFFSETS_r(PerlIO_printf(Perl_debug_log,
4800                           "%s %"UVuf" bytes for offset annotations.\n",
4801                           ri->u.offsets ? "Got" : "Couldn't get",
4802                           (UV)((2*RExC_size+1) * sizeof(U32))));
4803 #endif
4804     SetProgLen(ri,RExC_size);
4805     RExC_rx_sv = rx;
4806     RExC_rx = r;
4807     RExC_rxi = ri;
4808
4809     /* Second pass: emit code. */
4810     RExC_flags = pm_flags;      /* don't let top level (?i) bleed */
4811     RExC_parse = exp;
4812     RExC_end = xend;
4813     RExC_naughty = 0;
4814     RExC_npar = 1;
4815     RExC_emit_start = ri->program;
4816     RExC_emit = ri->program;
4817     RExC_emit_bound = ri->program + RExC_size + 1;
4818
4819     /* Store the count of eval-groups for security checks: */
4820     RExC_rx->seen_evals = RExC_seen_evals;
4821     REGC((U8)REG_MAGIC, (char*) RExC_emit++);
4822     if (reg(pRExC_state, 0, &flags,1) == NULL) {
4823         ReREFCNT_dec(rx);   
4824         return(NULL);
4825     }
4826     /* XXXX To minimize changes to RE engine we always allocate
4827        3-units-long substrs field. */
4828     Newx(r->substrs, 1, struct reg_substr_data);
4829     if (RExC_recurse_count) {
4830         Newxz(RExC_recurse,RExC_recurse_count,regnode *);
4831         SAVEFREEPV(RExC_recurse);
4832     }
4833
4834 reStudy:
4835     r->minlen = minlen = sawlookahead = sawplus = sawopen = 0;
4836     Zero(r->substrs, 1, struct reg_substr_data);
4837
4838 #ifdef TRIE_STUDY_OPT
4839     if (!restudied) {
4840         StructCopy(&zero_scan_data, &data, scan_data_t);
4841         copyRExC_state = RExC_state;
4842     } else {
4843         U32 seen=RExC_seen;
4844         DEBUG_OPTIMISE_r(PerlIO_printf(Perl_debug_log,"Restudying\n"));
4845         
4846         RExC_state = copyRExC_state;
4847         if (seen & REG_TOP_LEVEL_BRANCHES) 
4848             RExC_seen |= REG_TOP_LEVEL_BRANCHES;
4849         else
4850             RExC_seen &= ~REG_TOP_LEVEL_BRANCHES;
4851         if (data.last_found) {
4852             SvREFCNT_dec(data.longest_fixed);
4853             SvREFCNT_dec(data.longest_float);
4854             SvREFCNT_dec(data.last_found);
4855         }
4856         StructCopy(&zero_scan_data, &data, scan_data_t);
4857     }
4858 #else
4859     StructCopy(&zero_scan_data, &data, scan_data_t);
4860 #endif    
4861
4862     /* Dig out information for optimizations. */
4863     r->extflags = RExC_flags; /* was pm_op */
4864     /*dmq: removed as part of de-PMOP: pm->op_pmflags = RExC_flags; */
4865  
4866     if (UTF)
4867         SvUTF8_on(rx);  /* Unicode in it? */
4868     ri->regstclass = NULL;
4869     if (RExC_naughty >= 10)     /* Probably an expensive pattern. */
4870         r->intflags |= PREGf_NAUGHTY;
4871     scan = ri->program + 1;             /* First BRANCH. */
4872
4873     /* testing for BRANCH here tells us whether there is "must appear"
4874        data in the pattern. If there is then we can use it for optimisations */
4875     if (!(RExC_seen & REG_TOP_LEVEL_BRANCHES)) { /*  Only one top-level choice. */
4876         I32 fake;
4877         STRLEN longest_float_length, longest_fixed_length;
4878         struct regnode_charclass_class ch_class; /* pointed to by data */
4879         int stclass_flag;
4880         I32 last_close = 0; /* pointed to by data */
4881         regnode *first= scan;
4882         regnode *first_next= regnext(first);
4883         /*
4884          * Skip introductions and multiplicators >= 1
4885          * so that we can extract the 'meat' of the pattern that must 
4886          * match in the large if() sequence following.
4887          * NOTE that EXACT is NOT covered here, as it is normally
4888          * picked up by the optimiser separately. 
4889          *
4890          * This is unfortunate as the optimiser isnt handling lookahead
4891          * properly currently.
4892          *
4893          */
4894         while ((OP(first) == OPEN && (sawopen = 1)) ||
4895                /* An OR of *one* alternative - should not happen now. */
4896             (OP(first) == BRANCH && OP(first_next) != BRANCH) ||
4897             /* for now we can't handle lookbehind IFMATCH*/
4898             (OP(first) == IFMATCH && !first->flags && (sawlookahead = 1)) ||
4899             (OP(first) == PLUS) ||
4900             (OP(first) == MINMOD) ||
4901                /* An {n,m} with n>0 */
4902             (PL_regkind[OP(first)] == CURLY && ARG1(first) > 0) ||
4903             (OP(first) == NOTHING && PL_regkind[OP(first_next)] != END ))
4904         {
4905                 /* 
4906                  * the only op that could be a regnode is PLUS, all the rest
4907                  * will be regnode_1 or regnode_2.
4908                  *
4909                  */
4910                 if (OP(first) == PLUS)
4911                     sawplus = 1;
4912                 else
4913                     first += regarglen[OP(first)];
4914                 
4915                 first = NEXTOPER(first);
4916                 first_next= regnext(first);
4917         }
4918
4919         /* Starting-point info. */
4920       again:
4921         DEBUG_PEEP("first:",first,0);
4922         /* Ignore EXACT as we deal with it later. */
4923         if (PL_regkind[OP(first)] == EXACT) {
4924             if (OP(first) == EXACT)
4925                 NOOP;   /* Empty, get anchored substr later. */
4926             else
4927                 ri->regstclass = first;
4928         }
4929 #ifdef TRIE_STCLASS     
4930         else if (PL_regkind[OP(first)] == TRIE &&
4931                 ((reg_trie_data *)ri->data->data[ ARG(first) ])->minlen>0) 
4932         {
4933             regnode *trie_op;
4934             /* this can happen only on restudy */
4935             if ( OP(first) == TRIE ) {
4936                 struct regnode_1 *trieop = (struct regnode_1 *)
4937                     PerlMemShared_calloc(1, sizeof(struct regnode_1));
4938                 StructCopy(first,trieop,struct regnode_1);
4939                 trie_op=(regnode *)trieop;
4940             } else {
4941                 struct regnode_charclass *trieop = (struct regnode_charclass *)
4942                     PerlMemShared_calloc(1, sizeof(struct regnode_charclass));
4943                 StructCopy(first,trieop,struct regnode_charclass);
4944                 trie_op=(regnode *)trieop;
4945             }
4946             OP(trie_op)+=2;
4947             make_trie_failtable(pRExC_state, (regnode *)first, trie_op, 0);
4948             ri->regstclass = trie_op;
4949         }
4950 #endif  
4951         else if (REGNODE_SIMPLE(OP(first)))
4952             ri->regstclass = first;
4953         else if (PL_regkind[OP(first)] == BOUND ||
4954                  PL_regkind[OP(first)] == NBOUND)
4955             ri->regstclass = first;
4956         else if (PL_regkind[OP(first)] == BOL) {
4957             r->extflags |= (OP(first) == MBOL
4958                            ? RXf_ANCH_MBOL
4959                            : (OP(first) == SBOL
4960                               ? RXf_ANCH_SBOL
4961                               : RXf_ANCH_BOL));
4962             first = NEXTOPER(first);
4963             goto again;
4964         }
4965         else if (OP(first) == GPOS) {
4966             r->extflags |= RXf_ANCH_GPOS;
4967             first = NEXTOPER(first);
4968             goto again;
4969         }
4970         else if ((!sawopen || !RExC_sawback) &&
4971             (OP(first) == STAR &&
4972             PL_regkind[OP(NEXTOPER(first))] == REG_ANY) &&
4973             !(r->extflags & RXf_ANCH) && !(RExC_seen & REG_SEEN_EVAL))
4974         {
4975             /* turn .* into ^.* with an implied $*=1 */
4976             const int type =
4977                 (OP(NEXTOPER(first)) == REG_ANY)
4978                     ? RXf_ANCH_MBOL
4979                     : RXf_ANCH_SBOL;
4980             r->extflags |= type;
4981             r->intflags |= PREGf_IMPLICIT;
4982             first = NEXTOPER(first);
4983             goto again;
4984         }
4985         if (sawplus && !sawlookahead && (!sawopen || !RExC_sawback)
4986             && !(RExC_seen & REG_SEEN_EVAL)) /* May examine pos and $& */
4987             /* x+ must match at the 1st pos of run of x's */
4988             r->intflags |= PREGf_SKIP;
4989
4990         /* Scan is after the zeroth branch, first is atomic matcher. */
4991 #ifdef TRIE_STUDY_OPT
4992         DEBUG_PARSE_r(
4993             if (!restudied)
4994                 PerlIO_printf(Perl_debug_log, "first at %"IVdf"\n",
4995                               (IV)(first - scan + 1))
4996         );
4997 #else
4998         DEBUG_PARSE_r(
4999             PerlIO_printf(Perl_debug_log, "first at %"IVdf"\n",
5000                 (IV)(first - scan + 1))
5001         );
5002 #endif
5003
5004
5005         /*
5006         * If there's something expensive in the r.e., find the
5007         * longest literal string that must appear and make it the
5008         * regmust.  Resolve ties in favor of later strings, since
5009         * the regstart check works with the beginning of the r.e.
5010         * and avoiding duplication strengthens checking.  Not a
5011         * strong reason, but sufficient in the absence of others.
5012         * [Now we resolve ties in favor of the earlier string if
5013         * it happens that c_offset_min has been invalidated, since the
5014         * earlier string may buy us something the later one won't.]
5015         */
5016         
5017         data.longest_fixed = newSVpvs("");
5018         data.longest_float = newSVpvs("");
5019         data.last_found = newSVpvs("");
5020         data.longest = &(data.longest_fixed);
5021         first = scan;
5022         if (!ri->regstclass) {
5023             cl_init(pRExC_state, &ch_class);
5024             data.start_class = &ch_class;
5025             stclass_flag = SCF_DO_STCLASS_AND;
5026         } else                          /* XXXX Check for BOUND? */
5027             stclass_flag = 0;
5028         data.last_closep = &last_close;
5029         
5030         minlen = study_chunk(pRExC_state, &first, &minlen, &fake, scan + RExC_size, /* Up to end */
5031             &data, -1, NULL, NULL,
5032             SCF_DO_SUBSTR | SCF_WHILEM_VISITED_POS | stclass_flag,0);
5033
5034         
5035         CHECK_RESTUDY_GOTO;
5036
5037
5038         if ( RExC_npar == 1 && data.longest == &(data.longest_fixed)
5039              && data.last_start_min == 0 && data.last_end > 0
5040              && !RExC_seen_zerolen
5041              && !(RExC_seen & REG_SEEN_VERBARG)
5042              && (!(RExC_seen & REG_SEEN_GPOS) || (r->extflags & RXf_ANCH_GPOS)))
5043             r->extflags |= RXf_CHECK_ALL;
5044         scan_commit(pRExC_state, &data,&minlen,0);
5045         SvREFCNT_dec(data.last_found);
5046
5047         /* Note that code very similar to this but for anchored string 
5048            follows immediately below, changes may need to be made to both. 
5049            Be careful. 
5050          */
5051         longest_float_length = CHR_SVLEN(data.longest_float);
5052         if (longest_float_length
5053             || (data.flags & SF_FL_BEFORE_EOL
5054                 && (!(data.flags & SF_FL_BEFORE_MEOL)
5055                     || (RExC_flags & RXf_PMf_MULTILINE)))) 
5056         {
5057             I32 t,ml;
5058
5059             if (SvCUR(data.longest_fixed)  /* ok to leave SvCUR */
5060                 && data.offset_fixed == data.offset_float_min
5061                 && SvCUR(data.longest_fixed) == SvCUR(data.longest_float))
5062                     goto remove_float;          /* As in (a)+. */
5063
5064             /* copy the information about the longest float from the reg_scan_data
5065                over to the program. */
5066             if (SvUTF8(data.longest_float)) {
5067                 r->float_utf8 = data.longest_float;
5068                 r->float_substr = NULL;
5069             } else {
5070                 r->float_substr = data.longest_float;
5071                 r->float_utf8 = NULL;
5072             }
5073             /* float_end_shift is how many chars that must be matched that 
5074                follow this item. We calculate it ahead of time as once the
5075                lookbehind offset is added in we lose the ability to correctly
5076                calculate it.*/
5077             ml = data.minlen_float ? *(data.minlen_float) 
5078                                    : (I32)longest_float_length;
5079             r->float_end_shift = ml - data.offset_float_min
5080                 - longest_float_length + (SvTAIL(data.longest_float) != 0)
5081                 + data.lookbehind_float;
5082             r->float_min_offset = data.offset_float_min - data.lookbehind_float;
5083             r->float_max_offset = data.offset_float_max;
5084             if (data.offset_float_max < I32_MAX) /* Don't offset infinity */
5085                 r->float_max_offset -= data.lookbehind_float;
5086             
5087             t = (data.flags & SF_FL_BEFORE_EOL /* Can't have SEOL and MULTI */
5088                        && (!(data.flags & SF_FL_BEFORE_MEOL)
5089                            || (RExC_flags & RXf_PMf_MULTILINE)));
5090             fbm_compile(data.longest_float, t ? FBMcf_TAIL : 0);
5091         }
5092         else {
5093           remove_float:
5094             r->float_substr = r->float_utf8 = NULL;
5095             SvREFCNT_dec(data.longest_float);
5096             longest_float_length = 0;
5097         }
5098
5099         /* Note that code very similar to this but for floating string 
5100            is immediately above, changes may need to be made to both. 
5101            Be careful. 
5102          */
5103         longest_fixed_length = CHR_SVLEN(data.longest_fixed);
5104         if (longest_fixed_length
5105             || (data.flags & SF_FIX_BEFORE_EOL /* Cannot have SEOL and MULTI */
5106                 && (!(data.flags & SF_FIX_BEFORE_MEOL)
5107                     || (RExC_flags & RXf_PMf_MULTILINE)))) 
5108         {
5109             I32 t,ml;
5110
5111             /* copy the information about the longest fixed 
5112                from the reg_scan_data over to the program. */
5113             if (SvUTF8(data.longest_fixed)) {
5114                 r->anchored_utf8 = data.longest_fixed;
5115                 r->anchored_substr = NULL;
5116             } else {
5117                 r->anchored_substr = data.longest_fixed;
5118                 r->anchored_utf8 = NULL;
5119             }
5120             /* fixed_end_shift is how many chars that must be matched that 
5121                follow this item. We calculate it ahead of time as once the
5122                lookbehind offset is added in we lose the ability to correctly
5123                calculate it.*/
5124             ml = data.minlen_fixed ? *(data.minlen_fixed) 
5125                                    : (I32)longest_fixed_length;
5126             r->anchored_end_shift = ml - data.offset_fixed
5127                 - longest_fixed_length + (SvTAIL(data.longest_fixed) != 0)
5128                 + data.lookbehind_fixed;
5129             r->anchored_offset = data.offset_fixed - data.lookbehind_fixed;
5130
5131             t = (data.flags & SF_FIX_BEFORE_EOL /* Can't have SEOL and MULTI */
5132                  && (!(data.flags & SF_FIX_BEFORE_MEOL)
5133                      || (RExC_flags & RXf_PMf_MULTILINE)));
5134             fbm_compile(data.longest_fixed, t ? FBMcf_TAIL : 0);
5135         }
5136         else {
5137             r->anchored_substr = r->anchored_utf8 = NULL;
5138             SvREFCNT_dec(data.longest_fixed);
5139             longest_fixed_length = 0;
5140         }
5141         if (ri->regstclass
5142             && (OP(ri->regstclass) == REG_ANY || OP(ri->regstclass) == SANY))
5143             ri->regstclass = NULL;
5144
5145         if ((!(r->anchored_substr || r->anchored_utf8) || r->anchored_offset)
5146             && stclass_flag
5147             && !(data.start_class->flags & ANYOF_EOS)
5148             && !cl_is_anything(data.start_class))
5149         {
5150             const U32 n = add_data(pRExC_state, 1, "f");
5151             data.start_class->flags |= ANYOF_IS_SYNTHETIC;
5152
5153             Newx(RExC_rxi->data->data[n], 1,
5154                 struct regnode_charclass_class);
5155             StructCopy(data.start_class,
5156                        (struct regnode_charclass_class*)RExC_rxi->data->data[n],
5157                        struct regnode_charclass_class);
5158             ri->regstclass = (regnode*)RExC_rxi->data->data[n];
5159             r->intflags &= ~PREGf_SKIP; /* Used in find_byclass(). */
5160             DEBUG_COMPILE_r({ SV *sv = sv_newmortal();
5161                       regprop(r, sv, (regnode*)data.start_class);
5162                       PerlIO_printf(Perl_debug_log,
5163                                     "synthetic stclass \"%s\".\n",
5164                                     SvPVX_const(sv));});
5165         }
5166
5167         /* A temporary algorithm prefers floated substr to fixed one to dig more info. */
5168         if (longest_fixed_length > longest_float_length) {
5169             r->check_end_shift = r->anchored_end_shift;
5170             r->check_substr = r->anchored_substr;
5171             r->check_utf8 = r->anchored_utf8;
5172             r->check_offset_min = r->check_offset_max = r->anchored_offset;
5173             if (r->extflags & RXf_ANCH_SINGLE)
5174                 r->extflags |= RXf_NOSCAN;
5175         }
5176         else {
5177             r->check_end_shift = r->float_end_shift;
5178             r->check_substr = r->float_substr;
5179             r->check_utf8 = r->float_utf8;
5180             r->check_offset_min = r->float_min_offset;
5181             r->check_offset_max = r->float_max_offset;
5182         }
5183         /* XXXX Currently intuiting is not compatible with ANCH_GPOS.
5184            This should be changed ASAP!  */
5185         if ((r->check_substr || r->check_utf8) && !(r->extflags & RXf_ANCH_GPOS)) {
5186             r->extflags |= RXf_USE_INTUIT;
5187             if (SvTAIL(r->check_substr ? r->check_substr : r->check_utf8))
5188                 r->extflags |= RXf_INTUIT_TAIL;
5189         }
5190         /* XXX Unneeded? dmq (shouldn't as this is handled elsewhere)
5191         if ( (STRLEN)minlen < longest_float_length )
5192             minlen= longest_float_length;
5193         if ( (STRLEN)minlen < longest_fixed_length )
5194             minlen= longest_fixed_length;     
5195         */
5196     }
5197     else {
5198         /* Several toplevels. Best we can is to set minlen. */
5199         I32 fake;
5200         struct regnode_charclass_class ch_class;
5201         I32 last_close = 0;
5202         
5203         DEBUG_PARSE_r(PerlIO_printf(Perl_debug_log, "\nMulti Top Level\n"));
5204
5205         scan = ri->program + 1;
5206         cl_init(pRExC_state, &ch_class);
5207         data.start_class = &ch_class;
5208         data.last_closep = &last_close;
5209
5210         
5211         minlen = study_chunk(pRExC_state, &scan, &minlen, &fake, scan + RExC_size,
5212             &data, -1, NULL, NULL, SCF_DO_STCLASS_AND|SCF_WHILEM_VISITED_POS,0);
5213         
5214         CHECK_RESTUDY_GOTO;
5215
5216         r->check_substr = r->check_utf8 = r->anchored_substr = r->anchored_utf8
5217                 = r->float_substr = r->float_utf8 = NULL;
5218
5219         if (!(data.start_class->flags & ANYOF_EOS)
5220             && !cl_is_anything(data.start_class))
5221         {
5222             const U32 n = add_data(pRExC_state, 1, "f");
5223             data.start_class->flags |= ANYOF_IS_SYNTHETIC;
5224
5225             Newx(RExC_rxi->data->data[n], 1,
5226                 struct regnode_charclass_class);
5227             StructCopy(data.start_class,
5228                        (struct regnode_charclass_class*)RExC_rxi->data->data[n],
5229                        struct regnode_charclass_class);
5230             ri->regstclass = (regnode*)RExC_rxi->data->data[n];
5231             r->intflags &= ~PREGf_SKIP; /* Used in find_byclass(). */
5232             DEBUG_COMPILE_r({ SV* sv = sv_newmortal();
5233                       regprop(r, sv, (regnode*)data.start_class);
5234                       PerlIO_printf(Perl_debug_log,
5235                                     "synthetic stclass \"%s\".\n",
5236                                     SvPVX_const(sv));});
5237         }
5238     }
5239
5240     /* Guard against an embedded (?=) or (?<=) with a longer minlen than
5241        the "real" pattern. */
5242     DEBUG_OPTIMISE_r({
5243         PerlIO_printf(Perl_debug_log,"minlen: %"IVdf" r->minlen:%"IVdf"\n",
5244                       (IV)minlen, (IV)r->minlen);
5245     });
5246     r->minlenret = minlen;
5247     if (r->minlen < minlen) 
5248         r->minlen = minlen;
5249     
5250     if (RExC_seen & REG_SEEN_GPOS)
5251         r->extflags |= RXf_GPOS_SEEN;
5252     if (RExC_seen & REG_SEEN_LOOKBEHIND)
5253         r->extflags |= RXf_LOOKBEHIND_SEEN;
5254     if (RExC_seen & REG_SEEN_EVAL)
5255         r->extflags |= RXf_EVAL_SEEN;
5256     if (RExC_seen & REG_SEEN_CANY)
5257         r->extflags |= RXf_CANY_SEEN;
5258     if (RExC_seen & REG_SEEN_VERBARG)
5259         r->intflags |= PREGf_VERBARG_SEEN;
5260     if (RExC_seen & REG_SEEN_CUTGROUP)
5261         r->intflags |= PREGf_CUTGROUP_SEEN;
5262     if (RExC_paren_names)
5263         RXp_PAREN_NAMES(r) = MUTABLE_HV(SvREFCNT_inc(RExC_paren_names));
5264     else
5265         RXp_PAREN_NAMES(r) = NULL;
5266
5267 #ifdef STUPID_PATTERN_CHECKS            
5268     if (RX_PRELEN(rx) == 0)
5269         r->extflags |= RXf_NULL;
5270     if (r->extflags & RXf_SPLIT && RX_PRELEN(rx) == 1 && RX_PRECOMP(rx)[0] == ' ')
5271         /* XXX: this should happen BEFORE we compile */
5272         r->extflags |= (RXf_SKIPWHITE|RXf_WHITE); 
5273     else if (RX_PRELEN(rx) == 3 && memEQ("\\s+", RX_PRECOMP(rx), 3))
5274         r->extflags |= RXf_WHITE;
5275     else if (RX_PRELEN(rx) == 1 && RXp_PRECOMP(rx)[0] == '^')
5276         r->extflags |= RXf_START_ONLY;
5277 #else
5278     if (r->extflags & RXf_SPLIT && RX_PRELEN(rx) == 1 && RX_PRECOMP(rx)[0] == ' ')
5279             /* XXX: this should happen BEFORE we compile */
5280             r->extflags |= (RXf_SKIPWHITE|RXf_WHITE); 
5281     else {
5282         regnode *first = ri->program + 1;
5283         U8 fop = OP(first);
5284
5285         if (PL_regkind[fop] == NOTHING && OP(NEXTOPER(first)) == END)
5286             r->extflags |= RXf_NULL;
5287         else if (PL_regkind[fop] == BOL && OP(NEXTOPER(first)) == END)
5288             r->extflags |= RXf_START_ONLY;
5289         else if (fop == PLUS && OP(NEXTOPER(first)) == SPACE
5290                              && OP(regnext(first)) == END)
5291             r->extflags |= RXf_WHITE;    
5292     }
5293 #endif
5294 #ifdef DEBUGGING
5295     if (RExC_paren_names) {
5296         ri->name_list_idx = add_data( pRExC_state, 1, "a" );
5297         ri->data->data[ri->name_list_idx] = (void*)SvREFCNT_inc(RExC_paren_name_list);
5298     } else
5299 #endif
5300         ri->name_list_idx = 0;
5301
5302     if (RExC_recurse_count) {
5303         for ( ; RExC_recurse_count ; RExC_recurse_count-- ) {
5304             const regnode *scan = RExC_recurse[RExC_recurse_count-1];
5305             ARG2L_SET( scan, RExC_open_parens[ARG(scan)-1] - scan );
5306         }
5307     }
5308     Newxz(r->offs, RExC_npar, regexp_paren_pair);
5309     /* assume we don't need to swap parens around before we match */
5310
5311     DEBUG_DUMP_r({
5312         PerlIO_printf(Perl_debug_log,"Final program:\n");
5313         regdump(r);
5314     });
5315 #ifdef RE_TRACK_PATTERN_OFFSETS
5316     DEBUG_OFFSETS_r(if (ri->u.offsets) {
5317         const U32 len = ri->u.offsets[0];
5318         U32 i;
5319         GET_RE_DEBUG_FLAGS_DECL;
5320         PerlIO_printf(Perl_debug_log, "Offsets: [%"UVuf"]\n\t", (UV)ri->u.offsets[0]);
5321         for (i = 1; i <= len; i++) {
5322             if (ri->u.offsets[i*2-1] || ri->u.offsets[i*2])
5323                 PerlIO_printf(Perl_debug_log, "%"UVuf":%"UVuf"[%"UVuf"] ",
5324                 (UV)i, (UV)ri->u.offsets[i*2-1], (UV)ri->u.offsets[i*2]);
5325             }
5326         PerlIO_printf(Perl_debug_log, "\n");
5327     });
5328 #endif
5329     return rx;
5330 }
5331
5332 #undef RE_ENGINE_PTR
5333
5334
5335 SV*
5336 Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value,
5337                     const U32 flags)
5338 {
5339     PERL_ARGS_ASSERT_REG_NAMED_BUFF;
5340
5341     PERL_UNUSED_ARG(value);
5342
5343     if (flags & RXapif_FETCH) {
5344         return reg_named_buff_fetch(rx, key, flags);
5345     } else if (flags & (RXapif_STORE | RXapif_DELETE | RXapif_CLEAR)) {
5346         Perl_croak_no_modify(aTHX);
5347         return NULL;
5348     } else if (flags & RXapif_EXISTS) {
5349         return reg_named_buff_exists(rx, key, flags)
5350             ? &PL_sv_yes
5351             : &PL_sv_no;
5352     } else if (flags & RXapif_REGNAMES) {
5353         return reg_named_buff_all(rx, flags);
5354     } else if (flags & (RXapif_SCALAR | RXapif_REGNAMES_COUNT)) {
5355         return reg_named_buff_scalar(rx, flags);
5356     } else {
5357         Perl_croak(aTHX_ "panic: Unknown flags %d in named_buff", (int)flags);
5358         return NULL;
5359     }
5360 }
5361
5362 SV*
5363 Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey,
5364                          const U32 flags)
5365 {
5366     PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER;
5367     PERL_UNUSED_ARG(lastkey);
5368
5369     if (flags & RXapif_FIRSTKEY)
5370         return reg_named_buff_firstkey(rx, flags);
5371     else if (flags & RXapif_NEXTKEY)
5372         return reg_named_buff_nextkey(rx, flags);
5373     else {
5374         Perl_croak(aTHX_ "panic: Unknown flags %d in named_buff_iter", (int)flags);
5375         return NULL;
5376     }
5377 }
5378
5379 SV*
5380 Perl_reg_named_buff_fetch(pTHX_ REGEXP * const r, SV * const namesv,
5381                           const U32 flags)
5382 {
5383     AV *retarray = NULL;
5384     SV *ret;
5385     struct regexp *const rx = (struct regexp *)SvANY(r);
5386
5387     PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH;
5388
5389     if (flags & RXapif_ALL)
5390         retarray=newAV();
5391
5392     if (rx && RXp_PAREN_NAMES(rx)) {
5393         HE *he_str = hv_fetch_ent( RXp_PAREN_NAMES(rx), namesv, 0, 0 );
5394         if (he_str) {
5395             IV i;
5396             SV* sv_dat=HeVAL(he_str);
5397             I32 *nums=(I32*)SvPVX(sv_dat);
5398             for ( i=0; i<SvIVX(sv_dat); i++ ) {
5399                 if ((I32)(rx->nparens) >= nums[i]
5400                     && rx->offs[nums[i]].start != -1
5401                     && rx->offs[nums[i]].end != -1)
5402                 {
5403                     ret = newSVpvs("");
5404                     CALLREG_NUMBUF_FETCH(r,nums[i],ret);
5405                     if (!retarray)
5406                         return ret;
5407                 } else {
5408                     ret = newSVsv(&PL_sv_undef);
5409                 }
5410                 if (retarray)
5411                     av_push(retarray, ret);
5412             }
5413             if (retarray)
5414                 return newRV_noinc(MUTABLE_SV(retarray));
5415         }
5416     }
5417     return NULL;
5418 }
5419
5420 bool
5421 Perl_reg_named_buff_exists(pTHX_ REGEXP * const r, SV * const key,
5422                            const U32 flags)
5423 {
5424     struct regexp *const rx = (struct regexp *)SvANY(r);
5425
5426     PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS;
5427
5428     if (rx && RXp_PAREN_NAMES(rx)) {
5429         if (flags & RXapif_ALL) {
5430             return hv_exists_ent(RXp_PAREN_NAMES(rx), key, 0);
5431         } else {
5432             SV *sv = CALLREG_NAMED_BUFF_FETCH(r, key, flags);
5433             if (sv) {
5434                 SvREFCNT_dec(sv);
5435                 return TRUE;
5436             } else {
5437                 return FALSE;
5438             }
5439         }
5440     } else {
5441         return FALSE;
5442     }
5443 }
5444
5445 SV*
5446 Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const r, const U32 flags)
5447 {
5448     struct regexp *const rx = (struct regexp *)SvANY(r);
5449
5450     PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY;
5451
5452     if ( rx && RXp_PAREN_NAMES(rx) ) {
5453         (void)hv_iterinit(RXp_PAREN_NAMES(rx));
5454
5455         return CALLREG_NAMED_BUFF_NEXTKEY(r, NULL, flags & ~RXapif_FIRSTKEY);
5456     } else {
5457         return FALSE;
5458     }
5459 }
5460
5461 SV*
5462 Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const r, const U32 flags)
5463 {
5464     struct regexp *const rx = (struct regexp *)SvANY(r);
5465     GET_RE_DEBUG_FLAGS_DECL;
5466
5467     PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY;
5468
5469     if (rx && RXp_PAREN_NAMES(rx)) {
5470         HV *hv = RXp_PAREN_NAMES(rx);
5471         HE *temphe;
5472         while ( (temphe = hv_iternext_flags(hv,0)) ) {
5473             IV i;
5474             IV parno = 0;
5475             SV* sv_dat = HeVAL(temphe);
5476             I32 *nums = (I32*)SvPVX(sv_dat);
5477             for ( i = 0; i < SvIVX(sv_dat); i++ ) {
5478                 if ((I32)(rx->lastparen) >= nums[i] &&
5479                     rx->offs[nums[i]].start != -1 &&
5480                     rx->offs[nums[i]].end != -1)
5481                 {
5482                     parno = nums[i];
5483                     break;
5484                 }
5485             }
5486             if (parno || flags & RXapif_ALL) {
5487                 return newSVhek(HeKEY_hek(temphe));
5488             }
5489         }
5490     }
5491     return NULL;
5492 }
5493
5494 SV*
5495 Perl_reg_named_buff_scalar(pTHX_ REGEXP * const r, const U32 flags)
5496 {
5497     SV *ret;
5498     AV *av;
5499     I32 length;
5500     struct regexp *const rx = (struct regexp *)SvANY(r);
5501
5502     PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR;
5503
5504     if (rx && RXp_PAREN_NAMES(rx)) {
5505         if (flags & (RXapif_ALL | RXapif_REGNAMES_COUNT)) {
5506             return newSViv(HvTOTALKEYS(RXp_PAREN_NAMES(rx)));
5507         } else if (flags & RXapif_ONE) {
5508             ret = CALLREG_NAMED_BUFF_ALL(r, (flags | RXapif_REGNAMES));
5509             av = MUTABLE_AV(SvRV(ret));
5510             length = av_len(av);
5511             SvREFCNT_dec(ret);
5512             return newSViv(length + 1);
5513         } else {
5514             Perl_croak(aTHX_ "panic: Unknown flags %d in named_buff_scalar", (int)flags);
5515             return NULL;
5516         }
5517     }
5518     return &PL_sv_undef;
5519 }
5520
5521 SV*
5522 Perl_reg_named_buff_all(pTHX_ REGEXP * const r, const U32 flags)
5523 {
5524     struct regexp *const rx = (struct regexp *)SvANY(r);
5525     AV *av = newAV();
5526
5527     PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL;
5528
5529     if (rx && RXp_PAREN_NAMES(rx)) {
5530         HV *hv= RXp_PAREN_NAMES(rx);
5531         HE *temphe;
5532         (void)hv_iterinit(hv);
5533         while ( (temphe = hv_iternext_flags(hv,0)) ) {
5534             IV i;
5535             IV parno = 0;
5536             SV* sv_dat = HeVAL(temphe);
5537             I32 *nums = (I32*)SvPVX(sv_dat);
5538             for ( i = 0; i < SvIVX(sv_dat); i++ ) {
5539                 if ((I32)(rx->lastparen) >= nums[i] &&
5540                     rx->offs[nums[i]].start != -1 &&
5541                     rx->offs[nums[i]].end != -1)
5542                 {
5543                     parno = nums[i];
5544                     break;
5545                 }
5546             }
5547             if (parno || flags & RXapif_ALL) {
5548                 av_push(av, newSVhek(HeKEY_hek(temphe)));
5549             }
5550         }
5551     }
5552
5553     return newRV_noinc(MUTABLE_SV(av));
5554 }
5555
5556 void
5557 Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const r, const I32 paren,
5558                              SV * const sv)
5559 {
5560     struct regexp *const rx = (struct regexp *)SvANY(r);
5561     char *s = NULL;
5562     I32 i = 0;
5563     I32 s1, t1;
5564
5565     PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH;
5566         
5567     if (!rx->subbeg) {
5568         sv_setsv(sv,&PL_sv_undef);
5569         return;
5570     } 
5571     else               
5572     if (paren == RX_BUFF_IDX_PREMATCH && rx->offs[0].start != -1) {
5573         /* $` */
5574         i = rx->offs[0].start;
5575         s = rx->subbeg;
5576     }
5577     else 
5578     if (paren == RX_BUFF_IDX_POSTMATCH && rx->offs[0].end != -1) {
5579         /* $' */
5580         s = rx->subbeg + rx->offs[0].end;
5581         i = rx->sublen - rx->offs[0].end;
5582     } 
5583     else
5584     if ( 0 <= paren && paren <= (I32)rx->nparens &&
5585         (s1 = rx->offs[paren].start) != -1 &&
5586         (t1 = rx->offs[paren].end) != -1)
5587     {
5588         /* $& $1 ... */
5589         i = t1 - s1;
5590         s = rx->subbeg + s1;
5591     } else {
5592         sv_setsv(sv,&PL_sv_undef);
5593         return;
5594     }          
5595     assert(rx->sublen >= (s - rx->subbeg) + i );
5596     if (i >= 0) {
5597         const int oldtainted = PL_tainted;
5598         TAINT_NOT;
5599         sv_setpvn(sv, s, i);
5600         PL_tainted = oldtainted;
5601         if ( (rx->extflags & RXf_CANY_SEEN)
5602             ? (RXp_MATCH_UTF8(rx)
5603                         && (!i || is_utf8_string((U8*)s, i)))
5604             : (RXp_MATCH_UTF8(rx)) )
5605         {
5606             SvUTF8_on(sv);
5607         }
5608         else
5609             SvUTF8_off(sv);
5610         if (PL_tainting) {
5611             if (RXp_MATCH_TAINTED(rx)) {
5612                 if (SvTYPE(sv) >= SVt_PVMG) {
5613                     MAGIC* const mg = SvMAGIC(sv);
5614                     MAGIC* mgt;
5615                     PL_tainted = 1;
5616                     SvMAGIC_set(sv, mg->mg_moremagic);
5617                     SvTAINT(sv);
5618                     if ((mgt = SvMAGIC(sv))) {
5619                         mg->mg_moremagic = mgt;
5620                         SvMAGIC_set(sv, mg);
5621                     }
5622                 } else {
5623                     PL_tainted = 1;
5624                     SvTAINT(sv);
5625                 }
5626             } else 
5627                 SvTAINTED_off(sv);
5628         }
5629     } else {
5630         sv_setsv(sv,&PL_sv_undef);
5631         return;
5632     }
5633 }
5634
5635 void
5636 Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren,
5637                                                          SV const * const value)
5638 {
5639     PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE;
5640
5641     PERL_UNUSED_ARG(rx);
5642     PERL_UNUSED_ARG(paren);
5643     PERL_UNUSED_ARG(value);
5644
5645     if (!PL_localizing)
5646         Perl_croak_no_modify(aTHX);
5647 }
5648
5649 I32
5650 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const r, const SV * const sv,
5651                               const I32 paren)
5652 {
5653     struct regexp *const rx = (struct regexp *)SvANY(r);
5654     I32 i;
5655     I32 s1, t1;
5656
5657     PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH;
5658
5659     /* Some of this code was originally in C<Perl_magic_len> in F<mg.c> */
5660         switch (paren) {
5661       /* $` / ${^PREMATCH} */
5662       case RX_BUFF_IDX_PREMATCH:
5663         if (rx->offs[0].start != -1) {
5664                         i = rx->offs[0].start;
5665                         if (i > 0) {
5666                                 s1 = 0;
5667                                 t1 = i;
5668                                 goto getlen;
5669                         }
5670             }
5671         return 0;
5672       /* $' / ${^POSTMATCH} */
5673       case RX_BUFF_IDX_POSTMATCH:
5674             if (rx->offs[0].end != -1) {
5675                         i = rx->sublen - rx->offs[0].end;
5676                         if (i > 0) {
5677                                 s1 = rx->offs[0].end;
5678                                 t1 = rx->sublen;
5679                                 goto getlen;
5680                         }
5681             }
5682         return 0;
5683       /* $& / ${^MATCH}, $1, $2, ... */
5684       default:
5685             if (paren <= (I32)rx->nparens &&
5686             (s1 = rx->offs[paren].start) != -1 &&
5687             (t1 = rx->offs[paren].end) != -1)
5688             {
5689             i = t1 - s1;
5690             goto getlen;
5691         } else {
5692             if (ckWARN(WARN_UNINITIALIZED))
5693                 report_uninit((const SV *)sv);
5694             return 0;
5695         }
5696     }
5697   getlen:
5698     if (i > 0 && RXp_MATCH_UTF8(rx)) {
5699         const char * const s = rx->subbeg + s1;
5700         const U8 *ep;
5701         STRLEN el;
5702
5703         i = t1 - s1;
5704         if (is_utf8_string_loclen((U8*)s, i, &ep, &el))
5705                         i = el;
5706     }
5707     return i;
5708 }
5709
5710 SV*
5711 Perl_reg_qr_package(pTHX_ REGEXP * const rx)
5712 {
5713     PERL_ARGS_ASSERT_REG_QR_PACKAGE;
5714         PERL_UNUSED_ARG(rx);
5715         if (0)
5716             return NULL;
5717         else
5718             return newSVpvs("Regexp");
5719 }
5720
5721 /* Scans the name of a named buffer from the pattern.
5722  * If flags is REG_RSN_RETURN_NULL returns null.
5723  * If flags is REG_RSN_RETURN_NAME returns an SV* containing the name
5724  * If flags is REG_RSN_RETURN_DATA returns the data SV* corresponding
5725  * to the parsed name as looked up in the RExC_paren_names hash.
5726  * If there is an error throws a vFAIL().. type exception.
5727  */
5728
5729 #define REG_RSN_RETURN_NULL    0
5730 #define REG_RSN_RETURN_NAME    1
5731 #define REG_RSN_RETURN_DATA    2
5732
5733 STATIC SV*
5734 S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags)
5735 {
5736     char *name_start = RExC_parse;
5737
5738     PERL_ARGS_ASSERT_REG_SCAN_NAME;
5739
5740     if (isIDFIRST_lazy_if(RExC_parse, UTF)) {
5741          /* skip IDFIRST by using do...while */
5742         if (UTF)
5743             do {
5744                 RExC_parse += UTF8SKIP(RExC_parse);
5745             } while (isALNUM_utf8((U8*)RExC_parse));
5746         else
5747             do {
5748                 RExC_parse++;
5749             } while (isALNUM(*RExC_parse));
5750     }
5751
5752     if ( flags ) {
5753         SV* sv_name
5754             = newSVpvn_flags(name_start, (int)(RExC_parse - name_start),
5755                              SVs_TEMP | (UTF ? SVf_UTF8 : 0));
5756         if ( flags == REG_RSN_RETURN_NAME)
5757             return sv_name;
5758         else if (flags==REG_RSN_RETURN_DATA) {
5759             HE *he_str = NULL;
5760             SV *sv_dat = NULL;
5761             if ( ! sv_name )      /* should not happen*/
5762                 Perl_croak(aTHX_ "panic: no svname in reg_scan_name");
5763             if (RExC_paren_names)
5764                 he_str = hv_fetch_ent( RExC_paren_names, sv_name, 0, 0 );
5765             if ( he_str )
5766                 sv_dat = HeVAL(he_str);
5767             if ( ! sv_dat )
5768                 vFAIL("Reference to nonexistent named group");
5769             return sv_dat;
5770         }
5771         else {
5772             Perl_croak(aTHX_ "panic: bad flag in reg_scan_name");
5773         }
5774         /* NOT REACHED */
5775     }
5776     return NULL;
5777 }
5778
5779 #define DEBUG_PARSE_MSG(funcname)     DEBUG_PARSE_r({           \
5780     int rem=(int)(RExC_end - RExC_parse);                       \
5781     int cut;                                                    \
5782     int num;                                                    \
5783     int iscut=0;                                                \
5784     if (rem>10) {                                               \
5785         rem=10;                                                 \
5786         iscut=1;                                                \
5787     }                                                           \
5788     cut=10-rem;                                                 \
5789     if (RExC_lastparse!=RExC_parse)                             \
5790         PerlIO_printf(Perl_debug_log," >%.*s%-*s",              \
5791             rem, RExC_parse,                                    \
5792             cut + 4,                                            \
5793             iscut ? "..." : "<"                                 \
5794         );                                                      \
5795     else                                                        \
5796         PerlIO_printf(Perl_debug_log,"%16s","");                \
5797                                                                 \
5798     if (SIZE_ONLY)                                              \
5799        num = RExC_size + 1;                                     \
5800     else                                                        \
5801        num=REG_NODE_NUM(RExC_emit);                             \
5802     if (RExC_lastnum!=num)                                      \
5803        PerlIO_printf(Perl_debug_log,"|%4d",num);                \
5804     else                                                        \
5805        PerlIO_printf(Perl_debug_log,"|%4s","");                 \
5806     PerlIO_printf(Perl_debug_log,"|%*s%-4s",                    \
5807         (int)((depth*2)), "",                                   \
5808         (funcname)                                              \
5809     );                                                          \
5810     RExC_lastnum=num;                                           \
5811     RExC_lastparse=RExC_parse;                                  \
5812 })
5813
5814
5815
5816 #define DEBUG_PARSE(funcname)     DEBUG_PARSE_r({           \
5817     DEBUG_PARSE_MSG((funcname));                            \
5818     PerlIO_printf(Perl_debug_log,"%4s","\n");               \
5819 })
5820 #define DEBUG_PARSE_FMT(funcname,fmt,args)     DEBUG_PARSE_r({           \
5821     DEBUG_PARSE_MSG((funcname));                            \
5822     PerlIO_printf(Perl_debug_log,fmt "\n",args);               \
5823 })
5824
5825 /* This section of code defines the inversion list object and its methods.  The
5826  * interfaces are highly subject to change, so as much as possible is static to
5827  * this file.  An inversion list is here implemented as a malloc'd C array with
5828  * some added info.  More will be coming when functionality is added later.
5829  *
5830  * It is currently implemented as an HV to the outside world, but is actually
5831  * an SV pointing to an array of UVs that the SV thinks are bytes.  This allows
5832  * us to have an array of UV whose memory management is automatically handled
5833  * by the existing facilities for SV's.
5834  *
5835  * Some of the methods should always be private to the implementation, and some
5836  * should eventually be made public */
5837
5838 #define INVLIST_INITIAL_LEN 10
5839
5840 PERL_STATIC_INLINE UV*
5841 S_invlist_array(pTHX_ HV* const invlist)
5842 {
5843     /* Returns the pointer to the inversion list's array.  Every time the
5844      * length changes, this needs to be called in case malloc or realloc moved
5845      * it */
5846
5847     PERL_ARGS_ASSERT_INVLIST_ARRAY;
5848
5849     return (UV *) SvPVX(invlist);
5850 }
5851
5852 PERL_STATIC_INLINE UV
5853 S_invlist_len(pTHX_ HV* const invlist)
5854 {
5855     /* Returns the current number of elements in the inversion list's array */
5856
5857     PERL_ARGS_ASSERT_INVLIST_LEN;
5858
5859     return SvCUR(invlist) / sizeof(UV);
5860 }
5861
5862 PERL_STATIC_INLINE UV
5863 S_invlist_max(pTHX_ HV* const invlist)
5864 {
5865     /* Returns the maximum number of elements storable in the inversion list's
5866      * array, without having to realloc() */
5867
5868     PERL_ARGS_ASSERT_INVLIST_MAX;
5869
5870     return SvLEN(invlist) / sizeof(UV);
5871 }
5872
5873 PERL_STATIC_INLINE void
5874 S_invlist_set_len(pTHX_ HV* const invlist, const UV len)
5875 {
5876     /* Sets the current number of elements stored in the inversion list */
5877
5878     PERL_ARGS_ASSERT_INVLIST_SET_LEN;
5879
5880     SvCUR_set(invlist, len * sizeof(UV));
5881 }
5882
5883 PERL_STATIC_INLINE void
5884 S_invlist_set_max(pTHX_ HV* const invlist, const UV max)
5885 {
5886
5887     /* Sets the maximum number of elements storable in the inversion list
5888      * without having to realloc() */
5889
5890     PERL_ARGS_ASSERT_INVLIST_SET_MAX;
5891
5892     if (max < invlist_len(invlist)) {
5893         Perl_croak(aTHX_ "panic: Can't make max size '%"UVuf"' less than current length %"UVuf" in inversion list", invlist_max(invlist), invlist_len(invlist));
5894     }
5895
5896     SvLEN_set(invlist, max * sizeof(UV));
5897 }
5898
5899 #ifndef PERL_IN_XSUB_RE
5900 HV*
5901 Perl__new_invlist(pTHX_ IV initial_size)
5902 {
5903
5904     /* Return a pointer to a newly constructed inversion list, with enough
5905      * space to store 'initial_size' elements.  If that number is negative, a
5906      * system default is used instead */
5907
5908     if (initial_size < 0) {
5909         initial_size = INVLIST_INITIAL_LEN;
5910     }
5911
5912     /* Allocate the initial space */
5913     return (HV *) newSV(initial_size * sizeof(UV));
5914 }
5915 #endif
5916
5917 PERL_STATIC_INLINE void
5918 S_invlist_destroy(pTHX_ HV* const invlist)
5919 {
5920    /* Inversion list destructor */
5921
5922     PERL_ARGS_ASSERT_INVLIST_DESTROY;
5923
5924     SvREFCNT_dec(invlist);
5925 }
5926
5927 STATIC void
5928 S_invlist_extend(pTHX_ HV* const invlist, const UV new_max)
5929 {
5930     /* Grow the maximum size of an inversion list */
5931
5932     PERL_ARGS_ASSERT_INVLIST_EXTEND;
5933
5934     SvGROW((SV *)invlist, new_max * sizeof(UV));
5935 }
5936
5937 PERL_STATIC_INLINE void
5938 S_invlist_trim(pTHX_ HV* const invlist)
5939 {
5940     PERL_ARGS_ASSERT_INVLIST_TRIM;
5941
5942     /* Change the length of the inversion list to how many entries it currently
5943      * has */
5944
5945     SvPV_shrink_to_cur((SV *) invlist);
5946 }
5947
5948 /* An element is in an inversion list iff its index is even numbered: 0, 2, 4,
5949  * etc */
5950
5951 #define ELEMENT_IN_INVLIST_SET(i) (! ((i) & 1))
5952
5953 #ifndef PERL_IN_XSUB_RE
5954 void
5955 Perl__append_range_to_invlist(pTHX_ HV* const invlist, const UV start, const UV end)
5956 {
5957    /* Subject to change or removal.  Append the range from 'start' to 'end' at
5958     * the end of the inversion list.  The range must be above any existing
5959     * ones. */
5960
5961     UV* array = invlist_array(invlist);
5962     UV max = invlist_max(invlist);
5963     UV len = invlist_len(invlist);
5964
5965     PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST;
5966
5967     if (len > 0) {
5968
5969         /* Here, the existing list is non-empty. The current max entry in the
5970          * list is generally the first value not in the set, except when the
5971          * set extends to the end of permissible values, in which case it is
5972          * the first entry in that final set, and so this call is an attempt to
5973          * append out-of-order */
5974
5975         UV final_element = len - 1;
5976         if (array[final_element] > start
5977             || ELEMENT_IN_INVLIST_SET(final_element))
5978         {
5979             Perl_croak(aTHX_ "panic: attempting to append to an inversion list, but wasn't at the end of the list");
5980         }
5981
5982         /* Here, it is a legal append.  If the new range begins with the first
5983          * value not in the set, it is extending the set, so the new first
5984          * value not in the set is one greater than the newly extended range.
5985          * */
5986         if (array[final_element] == start) {
5987             if (end != UV_MAX) {
5988                 array[final_element] = end + 1;
5989             }
5990             else {
5991                 /* But if the end is the maximum representable on the machine,
5992                  * just let the range that this would extend have no end */
5993                 invlist_set_len(invlist, len - 1);
5994             }
5995             return;
5996         }
5997     }
5998
5999     /* Here the new range doesn't extend any existing set.  Add it */
6000
6001     len += 2;   /* Includes an element each for the start and end of range */
6002
6003     /* If overflows the existing space, extend, which may cause the array to be
6004      * moved */
6005     if (max < len) {
6006         invlist_extend(invlist, len);
6007         array = invlist_array(invlist);
6008     }
6009
6010     invlist_set_len(invlist, len);
6011
6012     /* The next item on the list starts the range, the one after that is
6013      * one past the new range.  */
6014     array[len - 2] = start;
6015     if (end != UV_MAX) {
6016         array[len - 1] = end + 1;
6017     }
6018     else {
6019         /* But if the end is the maximum representable on the machine, just let
6020          * the range have no end */
6021         invlist_set_len(invlist, len - 1);
6022     }
6023 }
6024 #endif
6025
6026 STATIC HV*
6027 S_invlist_union(pTHX_ HV* const a, HV* const b)
6028 {
6029     /* Return a new inversion list which is the union of two inversion lists.
6030      * The basis for this comes from "Unicode Demystified" Chapter 13 by
6031      * Richard Gillam, published by Addison-Wesley, and explained at some
6032      * length there.  The preface says to incorporate its examples into your
6033      * code at your own risk.
6034      *
6035      * The algorithm is like a merge sort.
6036      *
6037      * XXX A potential performance improvement is to keep track as we go along
6038      * if only one of the inputs contributes to the result, meaning the other
6039      * is a subset of that one.  In that case, we can skip the final copy and
6040      * return the larger of the input lists */
6041
6042     UV* array_a = invlist_array(a);   /* a's array */
6043     UV* array_b = invlist_array(b);
6044     UV len_a = invlist_len(a);  /* length of a's array */
6045     UV len_b = invlist_len(b);
6046
6047     HV* u;                      /* the resulting union */
6048     UV* array_u;
6049     UV len_u;
6050
6051     UV i_a = 0;             /* current index into a's array */
6052     UV i_b = 0;
6053     UV i_u = 0;
6054
6055     /* running count, as explained in the algorithm source book; items are
6056      * stopped accumulating and are output when the count changes to/from 0.
6057      * The count is incremented when we start a range that's in the set, and
6058      * decremented when we start a range that's not in the set.  So its range
6059      * is 0 to 2.  Only when the count is zero is something not in the set.
6060      */
6061     UV count = 0;
6062
6063     PERL_ARGS_ASSERT_INVLIST_UNION;
6064
6065     /* Size the union for the worst case: that the sets are completely
6066      * disjoint */
6067     u = _new_invlist(len_a + len_b);
6068     array_u = invlist_array(u);
6069
6070     /* Go through each list item by item, stopping when exhausted one of
6071      * them */
6072     while (i_a < len_a && i_b < len_b) {
6073         UV cp;      /* The element to potentially add to the union's array */
6074         bool cp_in_set;   /* is it in the the input list's set or not */
6075
6076         /* We need to take one or the other of the two inputs for the union.
6077          * Since we are merging two sorted lists, we take the smaller of the
6078          * next items.  In case of a tie, we take the one that is in its set
6079          * first.  If we took one not in the set first, it would decrement the
6080          * count, possibly to 0 which would cause it to be output as ending the
6081          * range, and the next time through we would take the same number, and
6082          * output it again as beginning the next range.  By doing it the
6083          * opposite way, there is no possibility that the count will be
6084          * momentarily decremented to 0, and thus the two adjoining ranges will
6085          * be seamlessly merged.  (In a tie and both are in the set or both not
6086          * in the set, it doesn't matter which we take first.) */
6087         if (array_a[i_a] < array_b[i_b]
6088             || (array_a[i_a] == array_b[i_b] && ELEMENT_IN_INVLIST_SET(i_a)))
6089         {
6090             cp_in_set = ELEMENT_IN_INVLIST_SET(i_a);
6091             cp= array_a[i_a++];
6092         }
6093         else {
6094             cp_in_set = ELEMENT_IN_INVLIST_SET(i_b);
6095             cp= array_b[i_b++];
6096         }
6097
6098         /* Here, have chosen which of the two inputs to look at.  Only output
6099          * if the running count changes to/from 0, which marks the
6100          * beginning/end of a range in that's in the set */
6101         if (cp_in_set) {
6102             if (count == 0) {
6103                 array_u[i_u++] = cp;
6104             }
6105             count++;
6106         }
6107         else {
6108             count--;
6109             if (count == 0) {
6110                 array_u[i_u++] = cp;
6111             }
6112         }
6113     }
6114
6115     /* Here, we are finished going through at least one of the lists, which
6116      * means there is something remaining in at most one.  We check if the list
6117      * that hasn't been exhausted is positioned such that we are in the middle
6118      * of a range in its set or not.  (We are in the set if the next item in
6119      * the array marks the beginning of something not in the set)   If in the
6120      * set, we decrement 'count'; if 0, there is potentially more to output.
6121      * There are four cases:
6122      *  1) Both weren't in their sets, count is 0, and remains 0.  What's left
6123      *     in the union is entirely from the non-exhausted set.
6124      *  2) Both were in their sets, count is 2.  Nothing further should
6125      *     be output, as everything that remains will be in the exhausted
6126      *     list's set, hence in the union; decrementing to 1 but not 0 insures
6127      *     that
6128      *  3) the exhausted was in its set, non-exhausted isn't, count is 1.
6129      *     Nothing further should be output because the union includes
6130      *     everything from the exhausted set.  Not decrementing insures that.
6131      *  4) the exhausted wasn't in its set, non-exhausted is, count is 1;
6132      *     decrementing to 0 insures that we look at the remainder of the
6133      *     non-exhausted set */
6134     if ((i_a != len_a && ! ELEMENT_IN_INVLIST_SET(i_a))
6135         || (i_b != len_b && ! ELEMENT_IN_INVLIST_SET(i_b)))
6136     {
6137         count--;
6138     }
6139
6140     /* The final length is what we've output so far, plus what else is about to
6141      * be output.  (If 'count' is non-zero, then the input list we exhausted
6142      * has everything remaining up to the machine's limit in its set, and hence
6143      * in the union, so there will be no further output. */
6144     len_u = i_u;
6145     if (count == 0) {
6146         /* At most one of the subexpressions will be non-zero */
6147         len_u += (len_a - i_a) + (len_b - i_b);
6148     }
6149
6150     /* Set result to final length, which can change the pointer to array_u, so
6151      * re-find it */
6152     if (len_u != invlist_len(u)) {
6153         invlist_set_len(u, len_u);
6154         invlist_trim(u);
6155         array_u = invlist_array(u);
6156     }
6157
6158     /* When 'count' is 0, the list that was exhausted (if one was shorter than
6159      * the other) ended with everything above it not in its set.  That means
6160      * that the remaining part of the union is precisely the same as the
6161      * non-exhausted list, so can just copy it unchanged.  (If both list were
6162      * exhausted at the same time, then the operations below will be both 0.)
6163      */
6164     if (count == 0) {
6165         IV copy_count; /* At most one will have a non-zero copy count */
6166         if ((copy_count = len_a - i_a) > 0) {
6167             Copy(array_a + i_a, array_u + i_u, copy_count, UV);
6168         }
6169         else if ((copy_count = len_b - i_b) > 0) {
6170             Copy(array_b + i_b, array_u + i_u, copy_count, UV);
6171         }
6172     }
6173
6174     return u;
6175 }
6176
6177 STATIC HV*
6178 S_invlist_intersection(pTHX_ HV* const a, HV* const b)
6179 {
6180     /* Return the intersection of two inversion lists.  The basis for this
6181      * comes from "Unicode Demystified" Chapter 13 by Richard Gillam, published
6182      * by Addison-Wesley, and explained at some length there.  The preface says
6183      * to incorporate its examples into your code at your own risk.
6184      *
6185      * The algorithm is like a merge sort, and is essentially the same as the
6186      * union above
6187      */
6188
6189     UV* array_a = invlist_array(a);   /* a's array */
6190     UV* array_b = invlist_array(b);
6191     UV len_a = invlist_len(a);  /* length of a's array */
6192     UV len_b = invlist_len(b);
6193
6194     HV* r;                   /* the resulting intersection */
6195     UV* array_r;
6196     UV len_r;
6197
6198     UV i_a = 0;             /* current index into a's array */
6199     UV i_b = 0;
6200     UV i_r = 0;
6201
6202     /* running count, as explained in the algorithm source book; items are
6203      * stopped accumulating and are output when the count changes to/from 2.
6204      * The count is incremented when we start a range that's in the set, and
6205      * decremented when we start a range that's not in the set.  So its range
6206      * is 0 to 2.  Only when the count is 2 is something in the intersection.
6207      */
6208     UV count = 0;
6209
6210     PERL_ARGS_ASSERT_INVLIST_INTERSECTION;
6211
6212     /* Size the intersection for the worst case: that the intersection ends up
6213      * fragmenting everything to be completely disjoint */
6214     r= _new_invlist(len_a + len_b);
6215     array_r = invlist_array(r);
6216
6217     /* Go through each list item by item, stopping when exhausted one of
6218      * them */
6219     while (i_a < len_a && i_b < len_b) {
6220         UV cp;      /* The element to potentially add to the intersection's
6221                        array */
6222         bool cp_in_set; /* Is it in the input list's set or not */
6223
6224         /* We need to take one or the other of the two inputs for the union.
6225          * Since we are merging two sorted lists, we take the smaller of the
6226          * next items.  In case of a tie, we take the one that is not in its
6227          * set first (a difference from the union algorithm).  If we took one
6228          * in the set first, it would increment the count, possibly to 2 which
6229          * would cause it to be output as starting a range in the intersection,
6230          * and the next time through we would take that same number, and output
6231          * it again as ending the set.  By doing it the opposite of this, we
6232          * there is no possibility that the count will be momentarily
6233          * incremented to 2.  (In a tie and both are in the set or both not in
6234          * the set, it doesn't matter which we take first.) */
6235         if (array_a[i_a] < array_b[i_b]
6236             || (array_a[i_a] == array_b[i_b] && ! ELEMENT_IN_INVLIST_SET(i_a)))
6237         {
6238             cp_in_set = ELEMENT_IN_INVLIST_SET(i_a);
6239             cp= array_a[i_a++];
6240         }
6241         else {
6242             cp_in_set = ELEMENT_IN_INVLIST_SET(i_b);
6243             cp= array_b[i_b++];
6244         }
6245
6246         /* Here, have chosen which of the two inputs to look at.  Only output
6247          * if the running count changes to/from 2, which marks the
6248          * beginning/end of a range that's in the intersection */
6249         if (cp_in_set) {
6250             count++;
6251             if (count == 2) {
6252                 array_r[i_r++] = cp;
6253             }
6254         }
6255         else {
6256             if (count == 2) {
6257                 array_r[i_r++] = cp;
6258             }
6259             count--;
6260         }
6261     }
6262
6263     /* Here, we are finished going through at least one of the sets, which
6264      * means there is something remaining in at most one.  See the comments in
6265      * the union code */
6266     if ((i_a != len_a && ! ELEMENT_IN_INVLIST_SET(i_a))
6267         || (i_b != len_b && ! ELEMENT_IN_INVLIST_SET(i_b)))
6268     {
6269         count--;
6270     }
6271
6272     /* The final length is what we've output so far plus what else is in the
6273      * intersection.  Only one of the subexpressions below will be non-zero */
6274     len_r = i_r;
6275     if (count == 2) {
6276         len_r += (len_a - i_a) + (len_b - i_b);
6277     }
6278
6279     /* Set result to final length, which can change the pointer to array_r, so
6280      * re-find it */
6281     if (len_r != invlist_len(r)) {
6282         invlist_set_len(r, len_r);
6283         invlist_trim(r);
6284         array_r = invlist_array(r);
6285     }
6286
6287     /* Finish outputting any remaining */
6288     if (count == 2) { /* Only one of will have a non-zero copy count */
6289         IV copy_count;
6290         if ((copy_count = len_a - i_a) > 0) {
6291             Copy(array_a + i_a, array_r + i_r, copy_count, UV);
6292         }
6293         else if ((copy_count = len_b - i_b) > 0) {
6294             Copy(array_b + i_b, array_r + i_r, copy_count, UV);
6295         }
6296     }
6297
6298     return r;
6299 }
6300
6301 STATIC HV*
6302 S_add_range_to_invlist(pTHX_ HV* invlist, const UV start, const UV end)
6303 {
6304     /* Add the range from 'start' to 'end' inclusive to the inversion list's
6305      * set.  A pointer to the inversion list is returned.  This may actually be
6306      * a new list, in which case the passed in one has been destroyed.  The
6307      * passed in inversion list can be NULL, in which case a new one is created
6308      * with just the one range in it */
6309
6310     HV* range_invlist;
6311     HV* added_invlist;
6312     UV len;
6313
6314     if (invlist == NULL) {
6315         invlist = _new_invlist(2);
6316         len = 0;
6317     }
6318     else {
6319         len = invlist_len(invlist);
6320     }
6321
6322     /* If comes after the final entry, can just append it to the end */
6323     if (len == 0
6324         || start >= invlist_array(invlist)
6325                                     [invlist_len(invlist) - 1])
6326     {
6327         _append_range_to_invlist(invlist, start, end);
6328         return invlist;
6329     }
6330
6331     /* Here, can't just append things, create and return a new inversion list
6332      * which is the union of this range and the existing inversion list */
6333     range_invlist = _new_invlist(2);
6334     _append_range_to_invlist(range_invlist, start, end);
6335
6336     added_invlist = invlist_union(invlist, range_invlist);
6337
6338     /* The passed in list can be freed, as well as our temporary */
6339     invlist_destroy(range_invlist);
6340     if (invlist != added_invlist) {
6341         invlist_destroy(invlist);
6342     }
6343
6344     return added_invlist;
6345 }
6346
6347 PERL_STATIC_INLINE HV*
6348 S_add_cp_to_invlist(pTHX_ HV* invlist, const UV cp) {
6349     return add_range_to_invlist(invlist, cp, cp);
6350 }
6351
6352 /* End of inversion list object */
6353
6354 /*
6355  - reg - regular expression, i.e. main body or parenthesized thing
6356  *
6357  * Caller must absorb opening parenthesis.
6358  *
6359  * Combining parenthesis handling with the base level of regular expression
6360  * is a trifle forced, but the need to tie the tails of the branches to what
6361  * follows makes it hard to avoid.
6362  */
6363 #define REGTAIL(x,y,z) regtail((x),(y),(z),depth+1)
6364 #ifdef DEBUGGING
6365 #define REGTAIL_STUDY(x,y,z) regtail_study((x),(y),(z),depth+1)
6366 #else
6367 #define REGTAIL_STUDY(x,y,z) regtail((x),(y),(z),depth+1)
6368 #endif
6369
6370 STATIC regnode *
6371 S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp,U32 depth)
6372     /* paren: Parenthesized? 0=top, 1=(, inside: changed to letter. */
6373 {
6374     dVAR;
6375     register regnode *ret;              /* Will be the head of the group. */
6376     register regnode *br;
6377     register regnode *lastbr;
6378     register regnode *ender = NULL;
6379     register I32 parno = 0;
6380     I32 flags;
6381     U32 oregflags = RExC_flags;
6382     bool have_branch = 0;
6383     bool is_open = 0;
6384     I32 freeze_paren = 0;
6385     I32 after_freeze = 0;
6386
6387     /* for (?g), (?gc), and (?o) warnings; warning
6388        about (?c) will warn about (?g) -- japhy    */
6389
6390 #define WASTED_O  0x01
6391 #define WASTED_G  0x02
6392 #define WASTED_C  0x04
6393 #define WASTED_GC (0x02|0x04)
6394     I32 wastedflags = 0x00;
6395
6396     char * parse_start = RExC_parse; /* MJD */
6397     char * const oregcomp_parse = RExC_parse;
6398
6399     GET_RE_DEBUG_FLAGS_DECL;
6400
6401     PERL_ARGS_ASSERT_REG;
6402     DEBUG_PARSE("reg ");
6403
6404     *flagp = 0;                         /* Tentatively. */
6405
6406
6407     /* Make an OPEN node, if parenthesized. */
6408     if (paren) {
6409         if ( *RExC_parse == '*') { /* (*VERB:ARG) */
6410             char *start_verb = RExC_parse;
6411             STRLEN verb_len = 0;
6412             char *start_arg = NULL;
6413             unsigned char op = 0;
6414             int argok = 1;
6415             int internal_argval = 0; /* internal_argval is only useful if !argok */
6416             while ( *RExC_parse && *RExC_parse != ')' ) {
6417                 if ( *RExC_parse == ':' ) {
6418                     start_arg = RExC_parse + 1;
6419                     break;
6420                 }
6421                 RExC_parse++;
6422             }
6423             ++start_verb;
6424             verb_len = RExC_parse - start_verb;
6425             if ( start_arg ) {
6426                 RExC_parse++;
6427                 while ( *RExC_parse && *RExC_parse != ')' ) 
6428                     RExC_parse++;
6429                 if ( *RExC_parse != ')' ) 
6430                     vFAIL("Unterminated verb pattern argument");
6431                 if ( RExC_parse == start_arg )
6432                     start_arg = NULL;
6433             } else {
6434                 if ( *RExC_parse != ')' )
6435                     vFAIL("Unterminated verb pattern");
6436             }
6437             
6438             switch ( *start_verb ) {
6439             case 'A':  /* (*ACCEPT) */
6440                 if ( memEQs(start_verb,verb_len,"ACCEPT") ) {
6441                     op = ACCEPT;
6442                     internal_argval = RExC_nestroot;
6443                 }
6444                 break;
6445             case 'C':  /* (*COMMIT) */
6446                 if ( memEQs(start_verb,verb_len,"COMMIT") )
6447                     op = COMMIT;
6448                 break;
6449             case 'F':  /* (*FAIL) */
6450                 if ( verb_len==1 || memEQs(start_verb,verb_len,"FAIL") ) {
6451                     op = OPFAIL;
6452                     argok = 0;
6453                 }
6454                 break;
6455             case ':':  /* (*:NAME) */
6456             case 'M':  /* (*MARK:NAME) */
6457                 if ( verb_len==0 || memEQs(start_verb,verb_len,"MARK") ) {
6458                     op = MARKPOINT;
6459                     argok = -1;
6460                 }
6461                 break;
6462             case 'P':  /* (*PRUNE) */
6463                 if ( memEQs(start_verb,verb_len,"PRUNE") )
6464                     op = PRUNE;
6465                 break;
6466             case 'S':   /* (*SKIP) */  
6467                 if ( memEQs(start_verb,verb_len,"SKIP") ) 
6468                     op = SKIP;
6469                 break;
6470             case 'T':  /* (*THEN) */
6471                 /* [19:06] <TimToady> :: is then */
6472                 if ( memEQs(start_verb,verb_len,"THEN") ) {
6473                     op = CUTGROUP;
6474                     RExC_seen |= REG_SEEN_CUTGROUP;
6475                 }
6476                 break;
6477             }
6478             if ( ! op ) {
6479                 RExC_parse++;
6480                 vFAIL3("Unknown verb pattern '%.*s'",
6481                     verb_len, start_verb);
6482             }
6483             if ( argok ) {
6484                 if ( start_arg && internal_argval ) {
6485                     vFAIL3("Verb pattern '%.*s' may not have an argument",
6486                         verb_len, start_verb); 
6487                 } else if ( argok < 0 && !start_arg ) {
6488                     vFAIL3("Verb pattern '%.*s' has a mandatory argument",
6489                         verb_len, start_verb);    
6490                 } else {
6491                     ret = reganode(pRExC_state, op, internal_argval);
6492                     if ( ! internal_argval && ! SIZE_ONLY ) {
6493                         if (start_arg) {
6494                             SV *sv = newSVpvn( start_arg, RExC_parse - start_arg);
6495                             ARG(ret) = add_data( pRExC_state, 1, "S" );
6496                             RExC_rxi->data->data[ARG(ret)]=(void*)sv;
6497                             ret->flags = 0;
6498                         } else {
6499                             ret->flags = 1; 
6500                         }
6501                     }               
6502                 }
6503                 if (!internal_argval)
6504                     RExC_seen |= REG_SEEN_VERBARG;
6505             } else if ( start_arg ) {
6506                 vFAIL3("Verb pattern '%.*s' may not have an argument",
6507                         verb_len, start_verb);    
6508             } else {
6509                 ret = reg_node(pRExC_state, op);
6510             }
6511             nextchar(pRExC_state);
6512             return ret;
6513         } else 
6514         if (*RExC_parse == '?') { /* (?...) */
6515             bool is_logical = 0;
6516             const char * const seqstart = RExC_parse;
6517             bool has_use_defaults = FALSE;
6518
6519             RExC_parse++;
6520             paren = *RExC_parse++;
6521             ret = NULL;                 /* For look-ahead/behind. */
6522             switch (paren) {
6523
6524             case 'P':   /* (?P...) variants for those used to PCRE/Python */
6525                 paren = *RExC_parse++;
6526                 if ( paren == '<')         /* (?P<...>) named capture */
6527                     goto named_capture;
6528                 else if (paren == '>') {   /* (?P>name) named recursion */
6529                     goto named_recursion;
6530                 }
6531                 else if (paren == '=') {   /* (?P=...)  named backref */
6532                     /* this pretty much dupes the code for \k<NAME> in regatom(), if
6533                        you change this make sure you change that */
6534                     char* name_start = RExC_parse;
6535                     U32 num = 0;
6536                     SV *sv_dat = reg_scan_name(pRExC_state,
6537                         SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);
6538                     if (RExC_parse == name_start || *RExC_parse != ')')
6539                         vFAIL2("Sequence %.3s... not terminated",parse_start);
6540
6541                     if (!SIZE_ONLY) {
6542                         num = add_data( pRExC_state, 1, "S" );
6543                         RExC_rxi->data->data[num]=(void*)sv_dat;
6544                         SvREFCNT_inc_simple_void(sv_dat);
6545                     }
6546                     RExC_sawback = 1;
6547                     ret = reganode(pRExC_state,
6548                                    ((! FOLD)
6549                                      ? NREF
6550                                      : (MORE_ASCII_RESTRICTED)
6551                                        ? NREFFA
6552                                        : (AT_LEAST_UNI_SEMANTICS)
6553                                          ? NREFFU
6554                                          : (LOC)
6555                                            ? NREFFL
6556                                            : NREFF),
6557                                     num);
6558                     *flagp |= HASWIDTH;
6559
6560                     Set_Node_Offset(ret, parse_start+1);
6561                     Set_Node_Cur_Length(ret); /* MJD */
6562
6563                     nextchar(pRExC_state);
6564                     return ret;
6565                 }
6566                 RExC_parse++;
6567                 vFAIL3("Sequence (%.*s...) not recognized", RExC_parse-seqstart, seqstart);
6568                 /*NOTREACHED*/
6569             case '<':           /* (?<...) */
6570                 if (*RExC_parse == '!')
6571                     paren = ',';
6572                 else if (*RExC_parse != '=') 
6573               named_capture:
6574                 {               /* (?<...>) */
6575                     char *name_start;
6576                     SV *svname;
6577                     paren= '>';
6578             case '\'':          /* (?'...') */
6579                     name_start= RExC_parse;
6580                     svname = reg_scan_name(pRExC_state,
6581                         SIZE_ONLY ?  /* reverse test from the others */
6582                         REG_RSN_RETURN_NAME : 
6583                         REG_RSN_RETURN_NULL);
6584                     if (RExC_parse == name_start) {
6585                         RExC_parse++;
6586                         vFAIL3("Sequence (%.*s...) not recognized", RExC_parse-seqstart, seqstart);
6587                         /*NOTREACHED*/
6588                     }
6589                     if (*RExC_parse != paren)
6590                         vFAIL2("Sequence (?%c... not terminated",
6591                             paren=='>' ? '<' : paren);
6592                     if (SIZE_ONLY) {
6593                         HE *he_str;
6594                         SV *sv_dat = NULL;
6595                         if (!svname) /* shouldn't happen */
6596                             Perl_croak(aTHX_
6597                                 "panic: reg_scan_name returned NULL");
6598                         if (!RExC_paren_names) {
6599                             RExC_paren_names= newHV();
6600                             sv_2mortal(MUTABLE_SV(RExC_paren_names));
6601 #ifdef DEBUGGING
6602                             RExC_paren_name_list= newAV();
6603                             sv_2mortal(MUTABLE_SV(RExC_paren_name_list));
6604 #endif
6605                         }
6606                         he_str = hv_fetch_ent( RExC_paren_names, svname, 1, 0 );
6607                         if ( he_str )
6608                             sv_dat = HeVAL(he_str);
6609                         if ( ! sv_dat ) {
6610                             /* croak baby croak */
6611                             Perl_croak(aTHX_
6612                                 "panic: paren_name hash element allocation failed");
6613                         } else if ( SvPOK(sv_dat) ) {
6614                             /* (?|...) can mean we have dupes so scan to check
6615                                its already been stored. Maybe a flag indicating
6616                                we are inside such a construct would be useful,
6617                                but the arrays are likely to be quite small, so
6618                                for now we punt -- dmq */
6619                             IV count = SvIV(sv_dat);
6620                             I32 *pv = (I32*)SvPVX(sv_dat);
6621                             IV i;
6622                             for ( i = 0 ; i < count ; i++ ) {
6623                                 if ( pv[i] == RExC_npar ) {
6624                                     count = 0;
6625                                     break;
6626                                 }
6627                             }
6628                             if ( count ) {
6629                                 pv = (I32*)SvGROW(sv_dat, SvCUR(sv_dat) + sizeof(I32)+1);
6630                                 SvCUR_set(sv_dat, SvCUR(sv_dat) + sizeof(I32));
6631                                 pv[count] = RExC_npar;
6632                                 SvIV_set(sv_dat, SvIVX(sv_dat) + 1);
6633                             }
6634                         } else {
6635                             (void)SvUPGRADE(sv_dat,SVt_PVNV);
6636                             sv_setpvn(sv_dat, (char *)&(RExC_npar), sizeof(I32));
6637                             SvIOK_on(sv_dat);
6638                             SvIV_set(sv_dat, 1);
6639                         }
6640 #ifdef DEBUGGING
6641                         if (!av_store(RExC_paren_name_list, RExC_npar, SvREFCNT_inc(svname)))
6642                             SvREFCNT_dec(svname);
6643 #endif
6644
6645                         /*sv_dump(sv_dat);*/
6646                     }
6647                     nextchar(pRExC_state);
6648                     paren = 1;
6649                     goto capturing_parens;
6650                 }
6651                 RExC_seen |= REG_SEEN_LOOKBEHIND;
6652                 RExC_in_lookbehind++;
6653                 RExC_parse++;
6654             case '=':           /* (?=...) */
6655                 RExC_seen_zerolen++;
6656                 break;
6657             case '!':           /* (?!...) */
6658                 RExC_seen_zerolen++;
6659                 if (*RExC_parse == ')') {
6660                     ret=reg_node(pRExC_state, OPFAIL);
6661                     nextchar(pRExC_state);
6662                     return ret;
6663                 }
6664                 break;
6665             case '|':           /* (?|...) */
6666                 /* branch reset, behave like a (?:...) except that
6667                    buffers in alternations share the same numbers */
6668                 paren = ':'; 
6669                 after_freeze = freeze_paren = RExC_npar;
6670                 break;
6671             case ':':           /* (?:...) */
6672             case '>':           /* (?>...) */
6673                 break;
6674             case '$':           /* (?$...) */
6675             case '@':           /* (?@...) */
6676                 vFAIL2("Sequence (?%c...) not implemented", (int)paren);
6677                 break;
6678             case '#':           /* (?#...) */
6679                 while (*RExC_parse && *RExC_parse != ')')
6680                     RExC_parse++;
6681                 if (*RExC_parse != ')')
6682                     FAIL("Sequence (?#... not terminated");
6683                 nextchar(pRExC_state);
6684                 *flagp = TRYAGAIN;
6685                 return NULL;
6686             case '0' :           /* (?0) */
6687             case 'R' :           /* (?R) */
6688                 if (*RExC_parse != ')')
6689                     FAIL("Sequence (?R) not terminated");
6690                 ret = reg_node(pRExC_state, GOSTART);
6691                 *flagp |= POSTPONED;
6692                 nextchar(pRExC_state);
6693                 return ret;
6694                 /*notreached*/
6695             { /* named and numeric backreferences */
6696                 I32 num;
6697             case '&':            /* (?&NAME) */
6698                 parse_start = RExC_parse - 1;
6699               named_recursion:
6700                 {
6701                     SV *sv_dat = reg_scan_name(pRExC_state,
6702                         SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);
6703                      num = sv_dat ? *((I32 *)SvPVX(sv_dat)) : 0;
6704                 }
6705                 goto gen_recurse_regop;
6706                 /* NOT REACHED */
6707             case '+':
6708                 if (!(RExC_parse[0] >= '1' && RExC_parse[0] <= '9')) {
6709                     RExC_parse++;
6710                     vFAIL("Illegal pattern");
6711                 }
6712                 goto parse_recursion;
6713                 /* NOT REACHED*/
6714             case '-': /* (?-1) */
6715                 if (!(RExC_parse[0] >= '1' && RExC_parse[0] <= '9')) {
6716                     RExC_parse--; /* rewind to let it be handled later */
6717                     goto parse_flags;
6718                 } 
6719                 /*FALLTHROUGH */
6720             case '1': case '2': case '3': case '4': /* (?1) */
6721             case '5': case '6': case '7': case '8': case '9':
6722                 RExC_parse--;
6723               parse_recursion:
6724                 num = atoi(RExC_parse);
6725                 parse_start = RExC_parse - 1; /* MJD */
6726                 if (*RExC_parse == '-')
6727                     RExC_parse++;
6728                 while (isDIGIT(*RExC_parse))
6729                         RExC_parse++;
6730                 if (*RExC_parse!=')') 
6731                     vFAIL("Expecting close bracket");
6732                         
6733               gen_recurse_regop:
6734                 if ( paren == '-' ) {
6735                     /*
6736                     Diagram of capture buffer numbering.
6737                     Top line is the normal capture buffer numbers
6738                     Bottom line is the negative indexing as from
6739                     the X (the (?-2))
6740
6741                     +   1 2    3 4 5 X          6 7
6742                        /(a(x)y)(a(b(c(?-2)d)e)f)(g(h))/
6743                     -   5 4    3 2 1 X          x x
6744
6745                     */
6746                     num = RExC_npar + num;
6747                     if (num < 1)  {
6748                         RExC_parse++;
6749                         vFAIL("Reference to nonexistent group");
6750                     }
6751                 } else if ( paren == '+' ) {
6752                     num = RExC_npar + num - 1;
6753                 }
6754
6755                 ret = reganode(pRExC_state, GOSUB, num);
6756                 if (!SIZE_ONLY) {
6757                     if (num > (I32)RExC_rx->nparens) {
6758                         RExC_parse++;
6759                         vFAIL("Reference to nonexistent group");
6760                     }
6761                     ARG2L_SET( ret, RExC_recurse_count++);
6762                     RExC_emit++;
6763                     DEBUG_OPTIMISE_MORE_r(PerlIO_printf(Perl_debug_log,
6764                         "Recurse #%"UVuf" to %"IVdf"\n", (UV)ARG(ret), (IV)ARG2L(ret)));
6765                 } else {
6766                     RExC_size++;
6767                 }
6768                 RExC_seen |= REG_SEEN_RECURSE;
6769                 Set_Node_Length(ret, 1 + regarglen[OP(ret)]); /* MJD */
6770                 Set_Node_Offset(ret, parse_start); /* MJD */
6771
6772                 *flagp |= POSTPONED;
6773                 nextchar(pRExC_state);
6774                 return ret;
6775             } /* named and numeric backreferences */
6776             /* NOT REACHED */
6777
6778             case '?':           /* (??...) */
6779                 is_logical = 1;
6780                 if (*RExC_parse != '{') {
6781                     RExC_parse++;
6782                     vFAIL3("Sequence (%.*s...) not recognized", RExC_parse-seqstart, seqstart);
6783                     /*NOTREACHED*/
6784                 }
6785                 *flagp |= POSTPONED;
6786                 paren = *RExC_parse++;
6787                 /* FALL THROUGH */
6788             case '{':           /* (?{...}) */
6789             {
6790                 I32 count = 1;
6791                 U32 n = 0;
6792                 char c;
6793                 char *s = RExC_parse;
6794
6795                 RExC_seen_zerolen++;
6796                 RExC_seen |= REG_SEEN_EVAL;
6797                 while (count && (c = *RExC_parse)) {
6798                     if (c == '\\') {
6799                         if (RExC_parse[1])
6800                             RExC_parse++;
6801                     }
6802                     else if (c == '{')
6803                         count++;
6804                     else if (c == '}')
6805                         count--;
6806                     RExC_parse++;
6807                 }
6808                 if (*RExC_parse != ')') {
6809                     RExC_parse = s;             
6810                     vFAIL("Sequence (?{...}) not terminated or not {}-balanced");
6811                 }
6812                 if (!SIZE_ONLY) {
6813                     PAD *pad;
6814                     OP_4tree *sop, *rop;
6815                     SV * const sv = newSVpvn(s, RExC_parse - 1 - s);
6816
6817                     ENTER;
6818                     Perl_save_re_context(aTHX);
6819                     rop = Perl_sv_compile_2op_is_broken(aTHX_ sv, &sop, "re", &pad);
6820                     sop->op_private |= OPpREFCOUNTED;
6821                     /* re_dup will OpREFCNT_inc */
6822                     OpREFCNT_set(sop, 1);
6823                     LEAVE;
6824
6825                     n = add_data(pRExC_state, 3, "nop");
6826                     RExC_rxi->data->data[n] = (void*)rop;
6827                     RExC_rxi->data->data[n+1] = (void*)sop;
6828                     RExC_rxi->data->data[n+2] = (void*)pad;
6829                     SvREFCNT_dec(sv);
6830                 }
6831                 else {                                          /* First pass */
6832                     if (PL_reginterp_cnt < ++RExC_seen_evals
6833                         && IN_PERL_RUNTIME)
6834                         /* No compiled RE interpolated, has runtime
6835                            components ===> unsafe.  */
6836                         FAIL("Eval-group not allowed at runtime, use re 'eval'");
6837                     if (PL_tainting && PL_tainted)
6838                         FAIL("Eval-group in insecure regular expression");
6839 #if PERL_VERSION > 8
6840                     if (IN_PERL_COMPILETIME)
6841                         PL_cv_has_eval = 1;
6842 #endif
6843                 }
6844
6845                 nextchar(pRExC_state);
6846                 if (is_logical) {
6847                     ret = reg_node(pRExC_state, LOGICAL);
6848                     if (!SIZE_ONLY)
6849                         ret->flags = 2;
6850                     REGTAIL(pRExC_state, ret, reganode(pRExC_state, EVAL, n));
6851                     /* deal with the length of this later - MJD */
6852                     return ret;
6853                 }
6854                 ret = reganode(pRExC_state, EVAL, n);
6855                 Set_Node_Length(ret, RExC_parse - parse_start + 1);
6856                 Set_Node_Offset(ret, parse_start);
6857                 return ret;
6858             }
6859             case '(':           /* (?(?{...})...) and (?(?=...)...) */
6860             {
6861                 int is_define= 0;
6862                 if (RExC_parse[0] == '?') {        /* (?(?...)) */
6863                     if (RExC_parse[1] == '=' || RExC_parse[1] == '!'
6864                         || RExC_parse[1] == '<'
6865                         || RExC_parse[1] == '{') { /* Lookahead or eval. */
6866                         I32 flag;
6867                         
6868                         ret = reg_node(pRExC_state, LOGICAL);
6869                         if (!SIZE_ONLY)
6870                             ret->flags = 1;
6871                         REGTAIL(pRExC_state, ret, reg(pRExC_state, 1, &flag,depth+1));
6872                         goto insert_if;
6873                     }
6874                 }
6875                 else if ( RExC_parse[0] == '<'     /* (?(<NAME>)...) */
6876                          || RExC_parse[0] == '\'' ) /* (?('NAME')...) */
6877                 {
6878                     char ch = RExC_parse[0] == '<' ? '>' : '\'';
6879                     char *name_start= RExC_parse++;
6880                     U32 num = 0;
6881                     SV *sv_dat=reg_scan_name(pRExC_state,
6882                         SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);
6883                     if (RExC_parse == name_start || *RExC_parse != ch)
6884                         vFAIL2("Sequence (?(%c... not terminated",
6885                             (ch == '>' ? '<' : ch));
6886                     RExC_parse++;
6887                     if (!SIZE_ONLY) {
6888                         num = add_data( pRExC_state, 1, "S" );
6889                         RExC_rxi->data->data[num]=(void*)sv_dat;
6890                         SvREFCNT_inc_simple_void(sv_dat);
6891                     }
6892                     ret = reganode(pRExC_state,NGROUPP,num);
6893                     goto insert_if_check_paren;
6894                 }
6895                 else if (RExC_parse[0] == 'D' &&
6896                          RExC_parse[1] == 'E' &&
6897                          RExC_parse[2] == 'F' &&
6898                          RExC_parse[3] == 'I' &&
6899                          RExC_parse[4] == 'N' &&
6900                          RExC_parse[5] == 'E')
6901                 {
6902                     ret = reganode(pRExC_state,DEFINEP,0);
6903                     RExC_parse +=6 ;
6904                     is_define = 1;
6905                     goto insert_if_check_paren;
6906                 }
6907                 else if (RExC_parse[0] == 'R') {
6908                     RExC_parse++;
6909                     parno = 0;
6910                     if (RExC_parse[0] >= '1' && RExC_parse[0] <= '9' ) {
6911                         parno = atoi(RExC_parse++);
6912                         while (isDIGIT(*RExC_parse))
6913                             RExC_parse++;
6914                     } else if (RExC_parse[0] == '&') {
6915                         SV *sv_dat;
6916                         RExC_parse++;
6917                         sv_dat = reg_scan_name(pRExC_state,
6918                             SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);
6919                         parno = sv_dat ? *((I32 *)SvPVX(sv_dat)) : 0;
6920                     }
6921                     ret = reganode(pRExC_state,INSUBP,parno); 
6922                     goto insert_if_check_paren;
6923                 }
6924                 else if (RExC_parse[0] >= '1' && RExC_parse[0] <= '9' ) {
6925                     /* (?(1)...) */
6926                     char c;
6927                     parno = atoi(RExC_parse++);
6928
6929                     while (isDIGIT(*RExC_parse))
6930                         RExC_parse++;
6931                     ret = reganode(pRExC_state, GROUPP, parno);
6932
6933                  insert_if_check_paren:
6934                     if ((c = *nextchar(pRExC_state)) != ')')
6935                         vFAIL("Switch condition not recognized");
6936                   insert_if:
6937                     REGTAIL(pRExC_state, ret, reganode(pRExC_state, IFTHEN, 0));
6938                     br = regbranch(pRExC_state, &flags, 1,depth+1);
6939                     if (br == NULL)
6940                         br = reganode(pRExC_state, LONGJMP, 0);
6941                     else
6942                         REGTAIL(pRExC_state, br, reganode(pRExC_state, LONGJMP, 0));
6943                     c = *nextchar(pRExC_state);
6944                     if (flags&HASWIDTH)
6945                         *flagp |= HASWIDTH;
6946                     if (c == '|') {
6947                         if (is_define) 
6948                             vFAIL("(?(DEFINE)....) does not allow branches");
6949                         lastbr = reganode(pRExC_state, IFTHEN, 0); /* Fake one for optimizer. */
6950                         regbranch(pRExC_state, &flags, 1,depth+1);
6951                         REGTAIL(pRExC_state, ret, lastbr);
6952                         if (flags&HASWIDTH)
6953                             *flagp |= HASWIDTH;
6954                         c = *nextchar(pRExC_state);
6955                     }
6956                     else
6957                         lastbr = NULL;
6958                     if (c != ')')
6959                         vFAIL("Switch (?(condition)... contains too many branches");
6960                     ender = reg_node(pRExC_state, TAIL);
6961                     REGTAIL(pRExC_state, br, ender);
6962                     if (lastbr) {
6963                         REGTAIL(pRExC_state, lastbr, ender);
6964                         REGTAIL(pRExC_state, NEXTOPER(NEXTOPER(lastbr)), ender);
6965                     }
6966                     else
6967                         REGTAIL(pRExC_state, ret, ender);
6968                     RExC_size++; /* XXX WHY do we need this?!!
6969                                     For large programs it seems to be required
6970                                     but I can't figure out why. -- dmq*/
6971                     return ret;
6972                 }
6973                 else {
6974                     vFAIL2("Unknown switch condition (?(%.2s", RExC_parse);
6975                 }
6976             }
6977             case 0:
6978                 RExC_parse--; /* for vFAIL to print correctly */
6979                 vFAIL("Sequence (? incomplete");
6980                 break;
6981             case DEFAULT_PAT_MOD:   /* Use default flags with the exceptions
6982                                        that follow */
6983                 has_use_defaults = TRUE;
6984                 STD_PMMOD_FLAGS_CLEAR(&RExC_flags);
6985                 set_regex_charset(&RExC_flags, (RExC_utf8 || RExC_uni_semantics)
6986                                                 ? REGEX_UNICODE_CHARSET
6987                                                 : REGEX_DEPENDS_CHARSET);
6988                 goto parse_flags;
6989             default:
6990                 --RExC_parse;
6991                 parse_flags:      /* (?i) */  
6992             {
6993                 U32 posflags = 0, negflags = 0;
6994                 U32 *flagsp = &posflags;
6995                 char has_charset_modifier = '\0';
6996                 regex_charset cs = (RExC_utf8 || RExC_uni_semantics)
6997                                     ? REGEX_UNICODE_CHARSET
6998                                     : REGEX_DEPENDS_CHARSET;
6999
7000                 while (*RExC_parse) {
7001                     /* && strchr("iogcmsx", *RExC_parse) */
7002                     /* (?g), (?gc) and (?o) are useless here
7003                        and must be globally applied -- japhy */
7004                     switch (*RExC_parse) {
7005                     CASE_STD_PMMOD_FLAGS_PARSE_SET(flagsp);
7006                     case LOCALE_PAT_MOD:
7007                         if (has_charset_modifier) {
7008                             goto excess_modifier;
7009                         }
7010                         else if (flagsp == &negflags) {
7011                             goto neg_modifier;
7012                         }
7013                         cs = REGEX_LOCALE_CHARSET;
7014                         has_charset_modifier = LOCALE_PAT_MOD;
7015                         RExC_contains_locale = 1;
7016                         break;
7017                     case UNICODE_PAT_MOD:
7018                         if (has_charset_modifier) {
7019                             goto excess_modifier;
7020                         }
7021                         else if (flagsp == &negflags) {
7022                             goto neg_modifier;
7023                         }
7024                         cs = REGEX_UNICODE_CHARSET;
7025                         has_charset_modifier = UNICODE_PAT_MOD;
7026                         break;
7027                     case ASCII_RESTRICT_PAT_MOD:
7028                         if (flagsp == &negflags) {
7029                             goto neg_modifier;
7030                         }
7031                         if (has_charset_modifier) {
7032                             if (cs != REGEX_ASCII_RESTRICTED_CHARSET) {
7033                                 goto excess_modifier;
7034                             }
7035                             /* Doubled modifier implies more restricted */
7036                             cs = REGEX_ASCII_MORE_RESTRICTED_CHARSET;
7037                         }
7038                         else {
7039                             cs = REGEX_ASCII_RESTRICTED_CHARSET;
7040                         }
7041                         has_charset_modifier = ASCII_RESTRICT_PAT_MOD;
7042                         break;
7043                     case DEPENDS_PAT_MOD:
7044                         if (has_use_defaults) {
7045                             goto fail_modifiers;
7046                         }
7047                         else if (flagsp == &negflags) {
7048                             goto neg_modifier;
7049                         }
7050                         else if (has_charset_modifier) {
7051                             goto excess_modifier;
7052                         }
7053
7054                         /* The dual charset means unicode semantics if the
7055                          * pattern (or target, not known until runtime) are
7056                          * utf8, or something in the pattern indicates unicode
7057                          * semantics */
7058                         cs = (RExC_utf8 || RExC_uni_semantics)
7059                              ? REGEX_UNICODE_CHARSET
7060                              : REGEX_DEPENDS_CHARSET;
7061                         has_charset_modifier = DEPENDS_PAT_MOD;
7062                         break;
7063                     excess_modifier:
7064                         RExC_parse++;
7065                         if (has_charset_modifier == ASCII_RESTRICT_PAT_MOD) {
7066                             vFAIL2("Regexp modifier \"%c\" may appear a maximum of twice", ASCII_RESTRICT_PAT_MOD);
7067                         }
7068                         else if (has_charset_modifier == *(RExC_parse - 1)) {
7069                             vFAIL2("Regexp modifier \"%c\" may not appear twice", *(RExC_parse - 1));
7070                         }
7071                         else {
7072                             vFAIL3("Regexp modifiers \"%c\" and \"%c\" are mutually exclusive", has_charset_modifier, *(RExC_parse - 1));
7073                         }
7074                         /*NOTREACHED*/
7075                     neg_modifier:
7076                         RExC_parse++;
7077                         vFAIL2("Regexp modifier \"%c\" may not appear after the \"-\"", *(RExC_parse - 1));
7078                         /*NOTREACHED*/
7079                     case ONCE_PAT_MOD: /* 'o' */
7080                     case GLOBAL_PAT_MOD: /* 'g' */
7081                         if (SIZE_ONLY && ckWARN(WARN_REGEXP)) {
7082                             const I32 wflagbit = *RExC_parse == 'o' ? WASTED_O : WASTED_G;
7083                             if (! (wastedflags & wflagbit) ) {
7084                                 wastedflags |= wflagbit;
7085                                 vWARN5(
7086                                     RExC_parse + 1,
7087                                     "Useless (%s%c) - %suse /%c modifier",
7088                                     flagsp == &negflags ? "?-" : "?",
7089                                     *RExC_parse,
7090                                     flagsp == &negflags ? "don't " : "",
7091                                     *RExC_parse
7092                                 );
7093                             }
7094                         }
7095                         break;
7096                         
7097                     case CONTINUE_PAT_MOD: /* 'c' */
7098                         if (SIZE_ONLY && ckWARN(WARN_REGEXP)) {
7099                             if (! (wastedflags & WASTED_C) ) {
7100                                 wastedflags |= WASTED_GC;
7101                                 vWARN3(
7102                                     RExC_parse + 1,
7103                                     "Useless (%sc) - %suse /gc modifier",
7104                                     flagsp == &negflags ? "?-" : "?",
7105                                     flagsp == &negflags ? "don't " : ""
7106                                 );
7107                             }
7108                         }
7109                         break;
7110                     case KEEPCOPY_PAT_MOD: /* 'p' */
7111                         if (flagsp == &negflags) {
7112                             if (SIZE_ONLY)
7113                                 ckWARNreg(RExC_parse + 1,"Useless use of (?-p)");
7114                         } else {
7115                             *flagsp |= RXf_PMf_KEEPCOPY;
7116                         }
7117                         break;
7118                     case '-':
7119                         /* A flag is a default iff it is following a minus, so
7120                          * if there is a minus, it means will be trying to
7121                          * re-specify a default which is an error */
7122                         if (has_use_defaults || flagsp == &negflags) {
7123             fail_modifiers:
7124                             RExC_parse++;
7125                             vFAIL3("Sequence (%.*s...) not recognized", RExC_parse-seqstart, seqstart);
7126                             /*NOTREACHED*/
7127                         }
7128                         flagsp = &negflags;
7129                         wastedflags = 0;  /* reset so (?g-c) warns twice */
7130                         break;
7131                     case ':':
7132                         paren = ':';
7133                         /*FALLTHROUGH*/
7134                     case ')':
7135                         RExC_flags |= posflags;
7136                         RExC_flags &= ~negflags;
7137                         set_regex_charset(&RExC_flags, cs);
7138                         if (paren != ':') {
7139                             oregflags |= posflags;
7140                             oregflags &= ~negflags;
7141                             set_regex_charset(&oregflags, cs);
7142                         }
7143                         nextchar(pRExC_state);
7144                         if (paren != ':') {
7145                             *flagp = TRYAGAIN;
7146                             return NULL;
7147                         } else {
7148                             ret = NULL;
7149                             goto parse_rest;
7150                         }
7151                         /*NOTREACHED*/
7152                     default:
7153                         RExC_parse++;
7154                         vFAIL3("Sequence (%.*s...) not recognized", RExC_parse-seqstart, seqstart);
7155                         /*NOTREACHED*/
7156                     }                           
7157                     ++RExC_parse;
7158                 }
7159             }} /* one for the default block, one for the switch */
7160         }
7161         else {                  /* (...) */
7162           capturing_parens:
7163             parno = RExC_npar;
7164             RExC_npar++;
7165             
7166             ret = reganode(pRExC_state, OPEN, parno);
7167             if (!SIZE_ONLY ){
7168                 if (!RExC_nestroot) 
7169                     RExC_nestroot = parno;
7170                 if (RExC_seen & REG_SEEN_RECURSE
7171                     && !RExC_open_parens[parno-1])
7172                 {
7173                     DEBUG_OPTIMISE_MORE_r(PerlIO_printf(Perl_debug_log,
7174                         "Setting open paren #%"IVdf" to %d\n", 
7175                         (IV)parno, REG_NODE_NUM(ret)));
7176                     RExC_open_parens[parno-1]= ret;
7177                 }
7178             }
7179             Set_Node_Length(ret, 1); /* MJD */
7180             Set_Node_Offset(ret, RExC_parse); /* MJD */
7181             is_open = 1;
7182         }
7183     }
7184     else                        /* ! paren */
7185         ret = NULL;
7186    
7187    parse_rest:
7188     /* Pick up the branches, linking them together. */
7189     parse_start = RExC_parse;   /* MJD */
7190     br = regbranch(pRExC_state, &flags, 1,depth+1);
7191
7192     /*     branch_len = (paren != 0); */
7193
7194     if (br == NULL)
7195         return(NULL);
7196     if (*RExC_parse == '|') {
7197         if (!SIZE_ONLY && RExC_extralen) {
7198             reginsert(pRExC_state, BRANCHJ, br, depth+1);
7199         }
7200         else {                  /* MJD */
7201             reginsert(pRExC_state, BRANCH, br, depth+1);
7202             Set_Node_Length(br, paren != 0);
7203             Set_Node_Offset_To_R(br-RExC_emit_start, parse_start-RExC_start);
7204         }
7205         have_branch = 1;
7206         if (SIZE_ONLY)
7207             RExC_extralen += 1;         /* For BRANCHJ-BRANCH. */
7208     }
7209     else if (paren == ':') {
7210         *flagp |= flags&SIMPLE;
7211     }
7212     if (is_open) {                              /* Starts with OPEN. */
7213         REGTAIL(pRExC_state, ret, br);          /* OPEN -> first. */
7214     }
7215     else if (paren != '?')              /* Not Conditional */
7216         ret = br;
7217     *flagp |= flags & (SPSTART | HASWIDTH | POSTPONED);
7218     lastbr = br;
7219     while (*RExC_parse == '|') {
7220         if (!SIZE_ONLY && RExC_extralen) {
7221             ender = reganode(pRExC_state, LONGJMP,0);
7222             REGTAIL(pRExC_state, NEXTOPER(NEXTOPER(lastbr)), ender); /* Append to the previous. */
7223         }
7224         if (SIZE_ONLY)
7225             RExC_extralen += 2;         /* Account for LONGJMP. */
7226         nextchar(pRExC_state);
7227         if (freeze_paren) {
7228             if (RExC_npar > after_freeze)
7229                 after_freeze = RExC_npar;
7230             RExC_npar = freeze_paren;       
7231         }
7232         br = regbranch(pRExC_state, &flags, 0, depth+1);
7233
7234         if (br == NULL)
7235             return(NULL);
7236         REGTAIL(pRExC_state, lastbr, br);               /* BRANCH -> BRANCH. */
7237         lastbr = br;
7238         *flagp |= flags & (SPSTART | HASWIDTH | POSTPONED);
7239     }
7240
7241     if (have_branch || paren != ':') {
7242         /* Make a closing node, and hook it on the end. */
7243         switch (paren) {
7244         case ':':
7245             ender = reg_node(pRExC_state, TAIL);
7246             break;
7247         case 1:
7248             ender = reganode(pRExC_state, CLOSE, parno);
7249             if (!SIZE_ONLY && RExC_seen & REG_SEEN_RECURSE) {
7250                 DEBUG_OPTIMISE_MORE_r(PerlIO_printf(Perl_debug_log,
7251                         "Setting close paren #%"IVdf" to %d\n", 
7252                         (IV)parno, REG_NODE_NUM(ender)));
7253                 RExC_close_parens[parno-1]= ender;
7254                 if (RExC_nestroot == parno) 
7255                     RExC_nestroot = 0;
7256             }       
7257             Set_Node_Offset(ender,RExC_parse+1); /* MJD */
7258             Set_Node_Length(ender,1); /* MJD */
7259             break;
7260         case '<':
7261         case ',':
7262         case '=':
7263         case '!':
7264             *flagp &= ~HASWIDTH;
7265             /* FALL THROUGH */
7266         case '>':
7267             ender = reg_node(pRExC_state, SUCCEED);
7268             break;
7269         case 0:
7270             ender = reg_node(pRExC_state, END);
7271             if (!SIZE_ONLY) {
7272                 assert(!RExC_opend); /* there can only be one! */
7273                 RExC_opend = ender;
7274             }
7275             break;
7276         }
7277         REGTAIL(pRExC_state, lastbr, ender);
7278
7279         if (have_branch && !SIZE_ONLY) {
7280             if (depth==1)
7281                 RExC_seen |= REG_TOP_LEVEL_BRANCHES;
7282
7283             /* Hook the tails of the branches to the closing node. */
7284             for (br = ret; br; br = regnext(br)) {
7285                 const U8 op = PL_regkind[OP(br)];
7286                 if (op == BRANCH) {
7287                     REGTAIL_STUDY(pRExC_state, NEXTOPER(br), ender);
7288                 }
7289                 else if (op == BRANCHJ) {
7290                     REGTAIL_STUDY(pRExC_state, NEXTOPER(NEXTOPER(br)), ender);
7291                 }
7292             }
7293         }
7294     }
7295
7296     {
7297         const char *p;
7298         static const char parens[] = "=!<,>";
7299
7300         if (paren && (p = strchr(parens, paren))) {
7301             U8 node = ((p - parens) % 2) ? UNLESSM : IFMATCH;
7302             int flag = (p - parens) > 1;
7303
7304             if (paren == '>')
7305                 node = SUSPEND, flag = 0;
7306             reginsert(pRExC_state, node,ret, depth+1);
7307             Set_Node_Cur_Length(ret);
7308             Set_Node_Offset(ret, parse_start + 1);
7309             ret->flags = flag;
7310             REGTAIL_STUDY(pRExC_state, ret, reg_node(pRExC_state, TAIL));
7311         }
7312     }
7313
7314     /* Check for proper termination. */
7315     if (paren) {
7316         RExC_flags = oregflags;
7317         if (RExC_parse >= RExC_end || *nextchar(pRExC_state) != ')') {
7318             RExC_parse = oregcomp_parse;
7319             vFAIL("Unmatched (");
7320         }
7321     }
7322     else if (!paren && RExC_parse < RExC_end) {
7323         if (*RExC_parse == ')') {
7324             RExC_parse++;
7325             vFAIL("Unmatched )");
7326         }
7327         else
7328             FAIL("Junk on end of regexp");      /* "Can't happen". */
7329         /* NOTREACHED */
7330     }
7331
7332     if (RExC_in_lookbehind) {
7333         RExC_in_lookbehind--;
7334     }
7335     if (after_freeze > RExC_npar)
7336         RExC_npar = after_freeze;
7337     return(ret);
7338 }
7339
7340 /*
7341  - regbranch - one alternative of an | operator
7342  *
7343  * Implements the concatenation operator.
7344  */
7345 STATIC regnode *
7346 S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth)
7347 {
7348     dVAR;
7349     register regnode *ret;
7350     register regnode *chain = NULL;
7351     register regnode *latest;
7352     I32 flags = 0, c = 0;
7353     GET_RE_DEBUG_FLAGS_DECL;
7354
7355     PERL_ARGS_ASSERT_REGBRANCH;
7356
7357     DEBUG_PARSE("brnc");
7358
7359     if (first)
7360         ret = NULL;
7361     else {
7362         if (!SIZE_ONLY && RExC_extralen)
7363             ret = reganode(pRExC_state, BRANCHJ,0);
7364         else {
7365             ret = reg_node(pRExC_state, BRANCH);
7366             Set_Node_Length(ret, 1);
7367         }
7368     }
7369         
7370     if (!first && SIZE_ONLY)
7371         RExC_extralen += 1;                     /* BRANCHJ */
7372
7373     *flagp = WORST;                     /* Tentatively. */
7374
7375     RExC_parse--;
7376     nextchar(pRExC_state);
7377     while (RExC_parse < RExC_end && *RExC_parse != '|' && *RExC_parse != ')') {
7378         flags &= ~TRYAGAIN;
7379         latest = regpiece(pRExC_state, &flags,depth+1);
7380         if (latest == NULL) {
7381             if (flags & TRYAGAIN)
7382                 continue;
7383             return(NULL);
7384         }
7385         else if (ret == NULL)
7386             ret = latest;
7387         *flagp |= flags&(HASWIDTH|POSTPONED);
7388         if (chain == NULL)      /* First piece. */
7389             *flagp |= flags&SPSTART;
7390         else {
7391             RExC_naughty++;
7392             REGTAIL(pRExC_state, chain, latest);
7393         }
7394         chain = latest;
7395         c++;
7396     }
7397     if (chain == NULL) {        /* Loop ran zero times. */
7398         chain = reg_node(pRExC_state, NOTHING);
7399         if (ret == NULL)
7400             ret = chain;
7401     }
7402     if (c == 1) {
7403         *flagp |= flags&SIMPLE;
7404     }
7405
7406     return ret;
7407 }
7408
7409 /*
7410  - regpiece - something followed by possible [*+?]
7411  *
7412  * Note that the branching code sequences used for ? and the general cases
7413  * of * and + are somewhat optimized:  they use the same NOTHING node as
7414  * both the endmarker for their branch list and the body of the last branch.
7415  * It might seem that this node could be dispensed with entirely, but the
7416  * endmarker role is not redundant.
7417  */
7418 STATIC regnode *
7419 S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
7420 {
7421     dVAR;
7422     register regnode *ret;
7423     register char op;
7424     register char *next;
7425     I32 flags;
7426     const char * const origparse = RExC_parse;
7427     I32 min;
7428     I32 max = REG_INFTY;
7429     char *parse_start;
7430     const char *maxpos = NULL;
7431     GET_RE_DEBUG_FLAGS_DECL;
7432
7433     PERL_ARGS_ASSERT_REGPIECE;
7434
7435     DEBUG_PARSE("piec");
7436
7437     ret = regatom(pRExC_state, &flags,depth+1);
7438     if (ret == NULL) {
7439         if (flags & TRYAGAIN)
7440             *flagp |= TRYAGAIN;
7441         return(NULL);
7442     }
7443
7444     op = *RExC_parse;
7445
7446     if (op == '{' && regcurly(RExC_parse)) {
7447         maxpos = NULL;
7448         parse_start = RExC_parse; /* MJD */
7449         next = RExC_parse + 1;
7450         while (isDIGIT(*next) || *next == ',') {
7451             if (*next == ',') {
7452                 if (maxpos)
7453                     break;
7454                 else
7455                     maxpos = next;
7456             }
7457             next++;
7458         }
7459         if (*next == '}') {             /* got one */
7460             if (!maxpos)
7461                 maxpos = next;
7462             RExC_parse++;
7463             min = atoi(RExC_parse);
7464             if (*maxpos == ',')
7465                 maxpos++;
7466             else
7467                 maxpos = RExC_parse;
7468             max = atoi(maxpos);
7469             if (!max && *maxpos != '0')
7470                 max = REG_INFTY;                /* meaning "infinity" */
7471             else if (max >= REG_INFTY)
7472                 vFAIL2("Quantifier in {,} bigger than %d", REG_INFTY - 1);
7473             RExC_parse = next;
7474             nextchar(pRExC_state);
7475
7476         do_curly:
7477             if ((flags&SIMPLE)) {
7478                 RExC_naughty += 2 + RExC_naughty / 2;
7479                 reginsert(pRExC_state, CURLY, ret, depth+1);
7480                 Set_Node_Offset(ret, parse_start+1); /* MJD */
7481                 Set_Node_Cur_Length(ret);
7482             }
7483             else {
7484                 regnode * const w = reg_node(pRExC_state, WHILEM);
7485
7486                 w->flags = 0;
7487                 REGTAIL(pRExC_state, ret, w);
7488                 if (!SIZE_ONLY && RExC_extralen) {
7489                     reginsert(pRExC_state, LONGJMP,ret, depth+1);
7490                     reginsert(pRExC_state, NOTHING,ret, depth+1);
7491                     NEXT_OFF(ret) = 3;  /* Go over LONGJMP. */
7492                 }
7493                 reginsert(pRExC_state, CURLYX,ret, depth+1);
7494                                 /* MJD hk */
7495                 Set_Node_Offset(ret, parse_start+1);
7496                 Set_Node_Length(ret,
7497                                 op == '{' ? (RExC_parse - parse_start) : 1);
7498
7499                 if (!SIZE_ONLY && RExC_extralen)
7500                     NEXT_OFF(ret) = 3;  /* Go over NOTHING to LONGJMP. */
7501                 REGTAIL(pRExC_state, ret, reg_node(pRExC_state, NOTHING));
7502                 if (SIZE_ONLY)
7503                     RExC_whilem_seen++, RExC_extralen += 3;
7504                 RExC_naughty += 4 + RExC_naughty;       /* compound interest */
7505             }
7506             ret->flags = 0;
7507
7508             if (min > 0)
7509                 *flagp = WORST;
7510             if (max > 0)
7511                 *flagp |= HASWIDTH;
7512             if (max < min)
7513                 vFAIL("Can't do {n,m} with n > m");
7514             if (!SIZE_ONLY) {
7515                 ARG1_SET(ret, (U16)min);
7516                 ARG2_SET(ret, (U16)max);
7517             }
7518
7519             goto nest_check;
7520         }
7521     }
7522
7523     if (!ISMULT1(op)) {
7524         *flagp = flags;
7525         return(ret);
7526     }
7527
7528 #if 0                           /* Now runtime fix should be reliable. */
7529
7530     /* if this is reinstated, don't forget to put this back into perldiag:
7531
7532             =item Regexp *+ operand could be empty at {#} in regex m/%s/
7533
7534            (F) The part of the regexp subject to either the * or + quantifier
7535            could match an empty string. The {#} shows in the regular
7536            expression about where the problem was discovered.
7537
7538     */
7539
7540     if (!(flags&HASWIDTH) && op != '?')
7541       vFAIL("Regexp *+ operand could be empty");
7542 #endif
7543
7544     parse_start = RExC_parse;
7545     nextchar(pRExC_state);
7546
7547     *flagp = (op != '+') ? (WORST|SPSTART|HASWIDTH) : (WORST|HASWIDTH);
7548
7549     if (op == '*' && (flags&SIMPLE)) {
7550         reginsert(pRExC_state, STAR, ret, depth+1);
7551         ret->flags = 0;
7552         RExC_naughty += 4;
7553     }
7554     else if (op == '*') {
7555         min = 0;
7556         goto do_curly;
7557     }
7558     else if (op == '+' && (flags&SIMPLE)) {
7559         reginsert(pRExC_state, PLUS, ret, depth+1);
7560         ret->flags = 0;
7561         RExC_naughty += 3;
7562     }
7563     else if (op == '+') {
7564         min = 1;
7565         goto do_curly;
7566     }
7567     else if (op == '?') {
7568         min = 0; max = 1;
7569         goto do_curly;
7570     }
7571   nest_check:
7572     if (!SIZE_ONLY && !(flags&(HASWIDTH|POSTPONED)) && max > REG_INFTY/3) {
7573         ckWARN3reg(RExC_parse,
7574                    "%.*s matches null string many times",
7575                    (int)(RExC_parse >= origparse ? RExC_parse - origparse : 0),
7576                    origparse);
7577     }
7578
7579     if (RExC_parse < RExC_end && *RExC_parse == '?') {
7580         nextchar(pRExC_state);
7581         reginsert(pRExC_state, MINMOD, ret, depth+1);
7582         REGTAIL(pRExC_state, ret, ret + NODE_STEP_REGNODE);
7583     }
7584 #ifndef REG_ALLOW_MINMOD_SUSPEND
7585     else
7586 #endif
7587     if (RExC_parse < RExC_end && *RExC_parse == '+') {
7588         regnode *ender;
7589         nextchar(pRExC_state);
7590         ender = reg_node(pRExC_state, SUCCEED);
7591         REGTAIL(pRExC_state, ret, ender);
7592         reginsert(pRExC_state, SUSPEND, ret, depth+1);
7593         ret->flags = 0;
7594         ender = reg_node(pRExC_state, TAIL);
7595         REGTAIL(pRExC_state, ret, ender);
7596         /*ret= ender;*/
7597     }
7598
7599     if (RExC_parse < RExC_end && ISMULT2(RExC_parse)) {
7600         RExC_parse++;
7601         vFAIL("Nested quantifiers");
7602     }
7603
7604     return(ret);
7605 }
7606
7607
7608 /* reg_namedseq(pRExC_state,UVp, UV depth)
7609    
7610    This is expected to be called by a parser routine that has 
7611    recognized '\N' and needs to handle the rest. RExC_parse is
7612    expected to point at the first char following the N at the time
7613    of the call.
7614
7615    The \N may be inside (indicated by valuep not being NULL) or outside a
7616    character class.
7617
7618    \N may begin either a named sequence, or if outside a character class, mean
7619    to match a non-newline.  For non single-quoted regexes, the tokenizer has
7620    attempted to decide which, and in the case of a named sequence converted it
7621    into one of the forms: \N{} (if the sequence is null), or \N{U+c1.c2...},
7622    where c1... are the characters in the sequence.  For single-quoted regexes,
7623    the tokenizer passes the \N sequence through unchanged; this code will not
7624    attempt to determine this nor expand those.  The net effect is that if the
7625    beginning of the passed-in pattern isn't '{U+' or there is no '}', it
7626    signals that this \N occurrence means to match a non-newline.
7627    
7628    Only the \N{U+...} form should occur in a character class, for the same
7629    reason that '.' inside a character class means to just match a period: it
7630    just doesn't make sense.
7631    
7632    If valuep is non-null then it is assumed that we are parsing inside 
7633    of a charclass definition and the first codepoint in the resolved
7634    string is returned via *valuep and the routine will return NULL. 
7635    In this mode if a multichar string is returned from the charnames 
7636    handler, a warning will be issued, and only the first char in the 
7637    sequence will be examined. If the string returned is zero length
7638    then the value of *valuep is undefined and NON-NULL will 
7639    be returned to indicate failure. (This will NOT be a valid pointer 
7640    to a regnode.)
7641    
7642    If valuep is null then it is assumed that we are parsing normal text and a
7643    new EXACT node is inserted into the program containing the resolved string,
7644    and a pointer to the new node is returned.  But if the string is zero length
7645    a NOTHING node is emitted instead.
7646
7647    On success RExC_parse is set to the char following the endbrace.
7648    Parsing failures will generate a fatal error via vFAIL(...)
7649  */
7650 STATIC regnode *
7651 S_reg_namedseq(pTHX_ RExC_state_t *pRExC_state, UV *valuep, I32 *flagp, U32 depth)
7652 {
7653     char * endbrace;    /* '}' following the name */
7654     regnode *ret = NULL;
7655     char* p;
7656
7657     GET_RE_DEBUG_FLAGS_DECL;
7658  
7659     PERL_ARGS_ASSERT_REG_NAMEDSEQ;
7660
7661     GET_RE_DEBUG_FLAGS;
7662
7663     /* The [^\n] meaning of \N ignores spaces and comments under the /x
7664      * modifier.  The other meaning does not */
7665     p = (RExC_flags & RXf_PMf_EXTENDED)
7666         ? regwhite( pRExC_state, RExC_parse )
7667         : RExC_parse;
7668    
7669     /* Disambiguate between \N meaning a named character versus \N meaning
7670      * [^\n].  The former is assumed when it can't be the latter. */
7671     if (*p != '{' || regcurly(p)) {
7672         RExC_parse = p;
7673         if (valuep) {
7674             /* no bare \N in a charclass */
7675             vFAIL("\\N in a character class must be a named character: \\N{...}");
7676         }
7677         nextchar(pRExC_state);
7678         ret = reg_node(pRExC_state, REG_ANY);
7679         *flagp |= HASWIDTH|SIMPLE;
7680         RExC_naughty++;
7681         RExC_parse--;
7682         Set_Node_Length(ret, 1); /* MJD */
7683         return ret;
7684     }
7685
7686     /* Here, we have decided it should be a named sequence */
7687
7688     /* The test above made sure that the next real character is a '{', but
7689      * under the /x modifier, it could be separated by space (or a comment and
7690      * \n) and this is not allowed (for consistency with \x{...} and the
7691      * tokenizer handling of \N{NAME}). */
7692     if (*RExC_parse != '{') {
7693         vFAIL("Missing braces on \\N{}");
7694     }
7695
7696     RExC_parse++;       /* Skip past the '{' */
7697
7698     if (! (endbrace = strchr(RExC_parse, '}')) /* no trailing brace */
7699         || ! (endbrace == RExC_parse            /* nothing between the {} */
7700               || (endbrace - RExC_parse >= 2    /* U+ (bad hex is checked below */
7701                   && strnEQ(RExC_parse, "U+", 2)))) /* for a better error msg) */
7702     {
7703         if (endbrace) RExC_parse = endbrace;    /* position msg's '<--HERE' */
7704         vFAIL("\\N{NAME} must be resolved by the lexer");
7705     }
7706
7707     if (endbrace == RExC_parse) {   /* empty: \N{} */
7708         if (! valuep) {
7709             RExC_parse = endbrace + 1;  
7710             return reg_node(pRExC_state,NOTHING);
7711         }
7712
7713         if (SIZE_ONLY) {
7714             ckWARNreg(RExC_parse,
7715                     "Ignoring zero length \\N{} in character class"
7716             );
7717             RExC_parse = endbrace + 1;  
7718         }
7719         *valuep = 0;
7720         return (regnode *) &RExC_parse; /* Invalid regnode pointer */
7721     }
7722
7723     REQUIRE_UTF8;       /* named sequences imply Unicode semantics */
7724     RExC_parse += 2;    /* Skip past the 'U+' */
7725
7726     if (valuep) {   /* In a bracketed char class */
7727         /* We only pay attention to the first char of 
7728         multichar strings being returned. I kinda wonder
7729         if this makes sense as it does change the behaviour
7730         from earlier versions, OTOH that behaviour was broken
7731         as well. XXX Solution is to recharacterize as
7732         [rest-of-class]|multi1|multi2... */
7733
7734         STRLEN length_of_hex;
7735         I32 flags = PERL_SCAN_ALLOW_UNDERSCORES
7736             | PERL_SCAN_DISALLOW_PREFIX
7737             | (SIZE_ONLY ? PERL_SCAN_SILENT_ILLDIGIT : 0);
7738     
7739         char * endchar = RExC_parse + strcspn(RExC_parse, ".}");
7740         if (endchar < endbrace) {
7741             ckWARNreg(endchar, "Using just the first character returned by \\N{} in character class");
7742         }
7743
7744         length_of_hex = (STRLEN)(endchar - RExC_parse);
7745         *valuep = grok_hex(RExC_parse, &length_of_hex, &flags, NULL);
7746
7747         /* The tokenizer should have guaranteed validity, but it's possible to
7748          * bypass it by using single quoting, so check */
7749         if (length_of_hex == 0
7750             || length_of_hex != (STRLEN)(endchar - RExC_parse) )
7751         {
7752             RExC_parse += length_of_hex;        /* Includes all the valid */
7753             RExC_parse += (RExC_orig_utf8)      /* point to after 1st invalid */
7754                             ? UTF8SKIP(RExC_parse)
7755                             : 1;
7756             /* Guard against malformed utf8 */
7757             if (RExC_parse >= endchar) RExC_parse = endchar;
7758             vFAIL("Invalid hexadecimal number in \\N{U+...}");
7759         }    
7760
7761         RExC_parse = endbrace + 1;
7762         if (endchar == endbrace) return NULL;
7763
7764         ret = (regnode *) &RExC_parse;  /* Invalid regnode pointer */
7765     }
7766     else {      /* Not a char class */
7767
7768         /* What is done here is to convert this to a sub-pattern of the form
7769          * (?:\x{char1}\x{char2}...)
7770          * and then call reg recursively.  That way, it retains its atomicness,
7771          * while not having to worry about special handling that some code
7772          * points may have.  toke.c has converted the original Unicode values
7773          * to native, so that we can just pass on the hex values unchanged.  We
7774          * do have to set a flag to keep recoding from happening in the
7775          * recursion */
7776
7777         SV * substitute_parse = newSVpvn_flags("?:", 2, SVf_UTF8|SVs_TEMP);
7778         STRLEN len;
7779         char *endchar;      /* Points to '.' or '}' ending cur char in the input
7780                                stream */
7781         char *orig_end = RExC_end;
7782
7783         while (RExC_parse < endbrace) {
7784
7785             /* Code points are separated by dots.  If none, there is only one
7786              * code point, and is terminated by the brace */
7787             endchar = RExC_parse + strcspn(RExC_parse, ".}");
7788
7789             /* Convert to notation the rest of the code understands */
7790             sv_catpv(substitute_parse, "\\x{");
7791             sv_catpvn(substitute_parse, RExC_parse, endchar - RExC_parse);
7792             sv_catpv(substitute_parse, "}");
7793
7794             /* Point to the beginning of the next character in the sequence. */
7795             RExC_parse = endchar + 1;
7796         }
7797         sv_catpv(substitute_parse, ")");
7798
7799         RExC_parse = SvPV(substitute_parse, len);
7800
7801         /* Don't allow empty number */
7802         if (len < 8) {
7803             vFAIL("Invalid hexadecimal number in \\N{U+...}");
7804         }
7805         RExC_end = RExC_parse + len;
7806
7807         /* The values are Unicode, and therefore not subject to recoding */
7808         RExC_override_recoding = 1;
7809
7810         ret = reg(pRExC_state, 1, flagp, depth+1);
7811
7812         RExC_parse = endbrace;
7813         RExC_end = orig_end;
7814         RExC_override_recoding = 0;
7815
7816         nextchar(pRExC_state);
7817     }
7818
7819     return ret;
7820 }
7821
7822
7823 /*
7824  * reg_recode
7825  *
7826  * It returns the code point in utf8 for the value in *encp.
7827  *    value: a code value in the source encoding
7828  *    encp:  a pointer to an Encode object
7829  *
7830  * If the result from Encode is not a single character,
7831  * it returns U+FFFD (Replacement character) and sets *encp to NULL.
7832  */
7833 STATIC UV
7834 S_reg_recode(pTHX_ const char value, SV **encp)
7835 {
7836     STRLEN numlen = 1;
7837     SV * const sv = newSVpvn_flags(&value, numlen, SVs_TEMP);
7838     const char * const s = *encp ? sv_recode_to_utf8(sv, *encp) : SvPVX(sv);
7839     const STRLEN newlen = SvCUR(sv);
7840     UV uv = UNICODE_REPLACEMENT;
7841
7842     PERL_ARGS_ASSERT_REG_RECODE;
7843
7844     if (newlen)
7845         uv = SvUTF8(sv)
7846              ? utf8n_to_uvchr((U8*)s, newlen, &numlen, UTF8_ALLOW_DEFAULT)
7847              : *(U8*)s;
7848
7849     if (!newlen || numlen != newlen) {
7850         uv = UNICODE_REPLACEMENT;
7851         *encp = NULL;
7852     }
7853     return uv;
7854 }
7855
7856
7857 /*
7858  - regatom - the lowest level
7859
7860    Try to identify anything special at the start of the pattern. If there
7861    is, then handle it as required. This may involve generating a single regop,
7862    such as for an assertion; or it may involve recursing, such as to
7863    handle a () structure.
7864
7865    If the string doesn't start with something special then we gobble up
7866    as much literal text as we can.
7867
7868    Once we have been able to handle whatever type of thing started the
7869    sequence, we return.
7870
7871    Note: we have to be careful with escapes, as they can be both literal
7872    and special, and in the case of \10 and friends can either, depending
7873    on context. Specifically there are two separate switches for handling
7874    escape sequences, with the one for handling literal escapes requiring
7875    a dummy entry for all of the special escapes that are actually handled
7876    by the other.
7877 */
7878
7879 STATIC regnode *
7880 S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
7881 {
7882     dVAR;
7883     register regnode *ret = NULL;
7884     I32 flags;
7885     char *parse_start = RExC_parse;
7886     U8 op;
7887     GET_RE_DEBUG_FLAGS_DECL;
7888     DEBUG_PARSE("atom");
7889     *flagp = WORST;             /* Tentatively. */
7890
7891     PERL_ARGS_ASSERT_REGATOM;
7892
7893 tryagain:
7894     switch ((U8)*RExC_parse) {
7895     case '^':
7896         RExC_seen_zerolen++;
7897         nextchar(pRExC_state);
7898         if (RExC_flags & RXf_PMf_MULTILINE)
7899             ret = reg_node(pRExC_state, MBOL);
7900         else if (RExC_flags & RXf_PMf_SINGLELINE)
7901             ret = reg_node(pRExC_state, SBOL);
7902         else
7903             ret = reg_node(pRExC_state, BOL);
7904         Set_Node_Length(ret, 1); /* MJD */
7905         break;
7906     case '$':
7907         nextchar(pRExC_state);
7908         if (*RExC_parse)
7909             RExC_seen_zerolen++;
7910         if (RExC_flags & RXf_PMf_MULTILINE)
7911             ret = reg_node(pRExC_state, MEOL);
7912         else if (RExC_flags & RXf_PMf_SINGLELINE)
7913             ret = reg_node(pRExC_state, SEOL);
7914         else
7915             ret = reg_node(pRExC_state, EOL);
7916         Set_Node_Length(ret, 1); /* MJD */
7917         break;
7918     case '.':
7919         nextchar(pRExC_state);
7920         if (RExC_flags & RXf_PMf_SINGLELINE)
7921             ret = reg_node(pRExC_state, SANY);
7922         else
7923             ret = reg_node(pRExC_state, REG_ANY);
7924         *flagp |= HASWIDTH|SIMPLE;
7925         RExC_naughty++;
7926         Set_Node_Length(ret, 1); /* MJD */
7927         break;
7928     case '[':
7929     {
7930         char * const oregcomp_parse = ++RExC_parse;
7931         ret = regclass(pRExC_state,depth+1);
7932         if (*RExC_parse != ']') {
7933             RExC_parse = oregcomp_parse;
7934             vFAIL("Unmatched [");
7935         }
7936         nextchar(pRExC_state);
7937         *flagp |= HASWIDTH|SIMPLE;
7938         Set_Node_Length(ret, RExC_parse - oregcomp_parse + 1); /* MJD */
7939         break;
7940     }
7941     case '(':
7942         nextchar(pRExC_state);
7943         ret = reg(pRExC_state, 1, &flags,depth+1);
7944         if (ret == NULL) {
7945                 if (flags & TRYAGAIN) {
7946                     if (RExC_parse == RExC_end) {
7947                          /* Make parent create an empty node if needed. */
7948                         *flagp |= TRYAGAIN;
7949                         return(NULL);
7950                     }
7951                     goto tryagain;
7952                 }
7953                 return(NULL);
7954         }
7955         *flagp |= flags&(HASWIDTH|SPSTART|SIMPLE|POSTPONED);
7956         break;
7957     case '|':
7958     case ')':
7959         if (flags & TRYAGAIN) {
7960             *flagp |= TRYAGAIN;
7961             return NULL;
7962         }
7963         vFAIL("Internal urp");
7964                                 /* Supposed to be caught earlier. */
7965         break;
7966     case '{':
7967         if (!regcurly(RExC_parse)) {
7968             RExC_parse++;
7969             goto defchar;
7970         }
7971         /* FALL THROUGH */
7972     case '?':
7973     case '+':
7974     case '*':
7975         RExC_parse++;
7976         vFAIL("Quantifier follows nothing");
7977         break;
7978     case '\\':
7979         /* Special Escapes
7980
7981            This switch handles escape sequences that resolve to some kind
7982            of special regop and not to literal text. Escape sequnces that
7983            resolve to literal text are handled below in the switch marked
7984            "Literal Escapes".
7985
7986            Every entry in this switch *must* have a corresponding entry
7987            in the literal escape switch. However, the opposite is not
7988            required, as the default for this switch is to jump to the
7989            literal text handling code.
7990         */
7991         switch ((U8)*++RExC_parse) {
7992         /* Special Escapes */
7993         case 'A':
7994             RExC_seen_zerolen++;
7995             ret = reg_node(pRExC_state, SBOL);
7996             *flagp |= SIMPLE;
7997             goto finish_meta_pat;
7998         case 'G':
7999             ret = reg_node(pRExC_state, GPOS);
8000             RExC_seen |= REG_SEEN_GPOS;
8001             *flagp |= SIMPLE;
8002             goto finish_meta_pat;
8003         case 'K':
8004             RExC_seen_zerolen++;
8005             ret = reg_node(pRExC_state, KEEPS);
8006             *flagp |= SIMPLE;
8007             /* XXX:dmq : disabling in-place substitution seems to
8008              * be necessary here to avoid cases of memory corruption, as
8009              * with: C<$_="x" x 80; s/x\K/y/> -- rgs
8010              */
8011             RExC_seen |= REG_SEEN_LOOKBEHIND;
8012             goto finish_meta_pat;
8013         case 'Z':
8014             ret = reg_node(pRExC_state, SEOL);
8015             *flagp |= SIMPLE;
8016             RExC_seen_zerolen++;                /* Do not optimize RE away */
8017             goto finish_meta_pat;
8018         case 'z':
8019             ret = reg_node(pRExC_state, EOS);
8020             *flagp |= SIMPLE;
8021             RExC_seen_zerolen++;                /* Do not optimize RE away */
8022             goto finish_meta_pat;
8023         case 'C':
8024             ret = reg_node(pRExC_state, CANY);
8025             RExC_seen |= REG_SEEN_CANY;
8026             *flagp |= HASWIDTH|SIMPLE;
8027             goto finish_meta_pat;
8028         case 'X':
8029             ret = reg_node(pRExC_state, CLUMP);
8030             *flagp |= HASWIDTH;
8031             goto finish_meta_pat;
8032         case 'w':
8033             switch (get_regex_charset(RExC_flags)) {
8034                 case REGEX_LOCALE_CHARSET:
8035                     op = ALNUML;
8036                     break;
8037                 case REGEX_UNICODE_CHARSET:
8038                     op = ALNUMU;
8039                     break;
8040                 case REGEX_ASCII_RESTRICTED_CHARSET:
8041                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
8042                     op = ALNUMA;
8043                     break;
8044                 case REGEX_DEPENDS_CHARSET:
8045                     op = ALNUM;
8046                     break;
8047                 default:
8048                     goto bad_charset;
8049             }
8050             ret = reg_node(pRExC_state, op);
8051             *flagp |= HASWIDTH|SIMPLE;
8052             goto finish_meta_pat;
8053         case 'W':
8054             switch (get_regex_charset(RExC_flags)) {
8055                 case REGEX_LOCALE_CHARSET:
8056                     op = NALNUML;
8057                     break;
8058                 case REGEX_UNICODE_CHARSET:
8059                     op = NALNUMU;
8060                     break;
8061                 case REGEX_ASCII_RESTRICTED_CHARSET:
8062                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
8063                     op = NALNUMA;
8064                     break;
8065                 case REGEX_DEPENDS_CHARSET:
8066                     op = NALNUM;
8067                     break;
8068                 default:
8069                     goto bad_charset;
8070             }
8071             ret = reg_node(pRExC_state, op);
8072             *flagp |= HASWIDTH|SIMPLE;
8073             goto finish_meta_pat;
8074         case 'b':
8075             RExC_seen_zerolen++;
8076             RExC_seen |= REG_SEEN_LOOKBEHIND;
8077             switch (get_regex_charset(RExC_flags)) {
8078                 case REGEX_LOCALE_CHARSET:
8079                     op = BOUNDL;
8080                     break;
8081                 case REGEX_UNICODE_CHARSET:
8082                     op = BOUNDU;
8083                     break;
8084                 case REGEX_ASCII_RESTRICTED_CHARSET:
8085                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
8086                     op = BOUNDA;
8087                     break;
8088                 case REGEX_DEPENDS_CHARSET:
8089                     op = BOUND;
8090                     break;
8091                 default:
8092                     goto bad_charset;
8093             }
8094             ret = reg_node(pRExC_state, op);
8095             FLAGS(ret) = get_regex_charset(RExC_flags);
8096             *flagp |= SIMPLE;
8097             if (! SIZE_ONLY && (U8) *(RExC_parse + 1) == '{') {
8098                 ckWARNregdep(RExC_parse, "\"\\b{\" is deprecated; use \"\\b\\{\" instead");
8099             }
8100             goto finish_meta_pat;
8101         case 'B':
8102             RExC_seen_zerolen++;
8103             RExC_seen |= REG_SEEN_LOOKBEHIND;
8104             switch (get_regex_charset(RExC_flags)) {
8105                 case REGEX_LOCALE_CHARSET:
8106                     op = NBOUNDL;
8107                     break;
8108                 case REGEX_UNICODE_CHARSET:
8109                     op = NBOUNDU;
8110                     break;
8111                 case REGEX_ASCII_RESTRICTED_CHARSET:
8112                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
8113                     op = NBOUNDA;
8114                     break;
8115                 case REGEX_DEPENDS_CHARSET:
8116                     op = NBOUND;
8117                     break;
8118                 default:
8119                     goto bad_charset;
8120             }
8121             ret = reg_node(pRExC_state, op);
8122             FLAGS(ret) = get_regex_charset(RExC_flags);
8123             *flagp |= SIMPLE;
8124             if (! SIZE_ONLY && (U8) *(RExC_parse + 1) == '{') {
8125                 ckWARNregdep(RExC_parse, "\"\\B{\" is deprecated; use \"\\B\\{\" instead");
8126             }
8127             goto finish_meta_pat;
8128         case 's':
8129             switch (get_regex_charset(RExC_flags)) {
8130                 case REGEX_LOCALE_CHARSET:
8131                     op = SPACEL;
8132                     break;
8133                 case REGEX_UNICODE_CHARSET:
8134                     op = SPACEU;
8135                     break;
8136                 case REGEX_ASCII_RESTRICTED_CHARSET:
8137                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
8138                     op = SPACEA;
8139                     break;
8140                 case REGEX_DEPENDS_CHARSET:
8141                     op = SPACE;
8142                     break;
8143                 default:
8144                     goto bad_charset;
8145             }
8146             ret = reg_node(pRExC_state, op);
8147             *flagp |= HASWIDTH|SIMPLE;
8148             goto finish_meta_pat;
8149         case 'S':
8150             switch (get_regex_charset(RExC_flags)) {
8151                 case REGEX_LOCALE_CHARSET:
8152                     op = NSPACEL;
8153                     break;
8154                 case REGEX_UNICODE_CHARSET:
8155                     op = NSPACEU;
8156                     break;
8157                 case REGEX_ASCII_RESTRICTED_CHARSET:
8158                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
8159                     op = NSPACEA;
8160                     break;
8161                 case REGEX_DEPENDS_CHARSET:
8162                     op = NSPACE;
8163                     break;
8164                 default:
8165                     goto bad_charset;
8166             }
8167             ret = reg_node(pRExC_state, op);
8168             *flagp |= HASWIDTH|SIMPLE;
8169             goto finish_meta_pat;
8170         case 'd':
8171             switch (get_regex_charset(RExC_flags)) {
8172                 case REGEX_LOCALE_CHARSET:
8173                     op = DIGITL;
8174                     break;
8175                 case REGEX_ASCII_RESTRICTED_CHARSET:
8176                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
8177                     op = DIGITA;
8178                     break;
8179                 case REGEX_DEPENDS_CHARSET: /* No difference between these */
8180                 case REGEX_UNICODE_CHARSET:
8181                     op = DIGIT;
8182                     break;
8183                 default:
8184                     goto bad_charset;
8185             }
8186             ret = reg_node(pRExC_state, op);
8187             *flagp |= HASWIDTH|SIMPLE;
8188             goto finish_meta_pat;
8189         case 'D':
8190             switch (get_regex_charset(RExC_flags)) {
8191                 case REGEX_LOCALE_CHARSET:
8192                     op = NDIGITL;
8193                     break;
8194                 case REGEX_ASCII_RESTRICTED_CHARSET:
8195                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
8196                     op = NDIGITA;
8197                     break;
8198                 case REGEX_DEPENDS_CHARSET: /* No difference between these */
8199                 case REGEX_UNICODE_CHARSET:
8200                     op = NDIGIT;
8201                     break;
8202                 default:
8203                     goto bad_charset;
8204             }
8205             ret = reg_node(pRExC_state, op);
8206             *flagp |= HASWIDTH|SIMPLE;
8207             goto finish_meta_pat;
8208         case 'R':
8209             ret = reg_node(pRExC_state, LNBREAK);
8210             *flagp |= HASWIDTH|SIMPLE;
8211             goto finish_meta_pat;
8212         case 'h':
8213             ret = reg_node(pRExC_state, HORIZWS);
8214             *flagp |= HASWIDTH|SIMPLE;
8215             goto finish_meta_pat;
8216         case 'H':
8217             ret = reg_node(pRExC_state, NHORIZWS);
8218             *flagp |= HASWIDTH|SIMPLE;
8219             goto finish_meta_pat;
8220         case 'v':
8221             ret = reg_node(pRExC_state, VERTWS);
8222             *flagp |= HASWIDTH|SIMPLE;
8223             goto finish_meta_pat;
8224         case 'V':
8225             ret = reg_node(pRExC_state, NVERTWS);
8226             *flagp |= HASWIDTH|SIMPLE;
8227          finish_meta_pat:           
8228             nextchar(pRExC_state);
8229             Set_Node_Length(ret, 2); /* MJD */
8230             break;          
8231         case 'p':
8232         case 'P':
8233             {   
8234                 char* const oldregxend = RExC_end;
8235 #ifdef DEBUGGING
8236                 char* parse_start = RExC_parse - 2;
8237 #endif
8238
8239                 if (RExC_parse[1] == '{') {
8240                   /* a lovely hack--pretend we saw [\pX] instead */
8241                     RExC_end = strchr(RExC_parse, '}');
8242                     if (!RExC_end) {
8243                         const U8 c = (U8)*RExC_parse;
8244                         RExC_parse += 2;
8245                         RExC_end = oldregxend;
8246                         vFAIL2("Missing right brace on \\%c{}", c);
8247                     }
8248                     RExC_end++;
8249                 }
8250                 else {
8251                     RExC_end = RExC_parse + 2;
8252                     if (RExC_end > oldregxend)
8253                         RExC_end = oldregxend;
8254                 }
8255                 RExC_parse--;
8256
8257                 ret = regclass(pRExC_state,depth+1);
8258
8259                 RExC_end = oldregxend;
8260                 RExC_parse--;
8261
8262                 Set_Node_Offset(ret, parse_start + 2);
8263                 Set_Node_Cur_Length(ret);
8264                 nextchar(pRExC_state);
8265                 *flagp |= HASWIDTH|SIMPLE;
8266             }
8267             break;
8268         case 'N': 
8269             /* Handle \N and \N{NAME} here and not below because it can be
8270             multicharacter. join_exact() will join them up later on. 
8271             Also this makes sure that things like /\N{BLAH}+/ and 
8272             \N{BLAH} being multi char Just Happen. dmq*/
8273             ++RExC_parse;
8274             ret= reg_namedseq(pRExC_state, NULL, flagp, depth);
8275             break;
8276         case 'k':    /* Handle \k<NAME> and \k'NAME' */
8277         parse_named_seq:
8278         {   
8279             char ch= RExC_parse[1];         
8280             if (ch != '<' && ch != '\'' && ch != '{') {
8281                 RExC_parse++;
8282                 vFAIL2("Sequence %.2s... not terminated",parse_start);
8283             } else {
8284                 /* this pretty much dupes the code for (?P=...) in reg(), if
8285                    you change this make sure you change that */
8286                 char* name_start = (RExC_parse += 2);
8287                 U32 num = 0;
8288                 SV *sv_dat = reg_scan_name(pRExC_state,
8289                     SIZE_ONLY ? REG_RSN_RETURN_NULL : REG_RSN_RETURN_DATA);
8290                 ch= (ch == '<') ? '>' : (ch == '{') ? '}' : '\'';
8291                 if (RExC_parse == name_start || *RExC_parse != ch)
8292                     vFAIL2("Sequence %.3s... not terminated",parse_start);
8293
8294                 if (!SIZE_ONLY) {
8295                     num = add_data( pRExC_state, 1, "S" );
8296                     RExC_rxi->data->data[num]=(void*)sv_dat;
8297                     SvREFCNT_inc_simple_void(sv_dat);
8298                 }
8299
8300                 RExC_sawback = 1;
8301                 ret = reganode(pRExC_state,
8302                                ((! FOLD)
8303                                  ? NREF
8304                                  : (MORE_ASCII_RESTRICTED)
8305                                    ? NREFFA
8306                                    : (AT_LEAST_UNI_SEMANTICS)
8307                                      ? NREFFU
8308                                      : (LOC)
8309                                        ? NREFFL
8310                                        : NREFF),
8311                                 num);
8312                 *flagp |= HASWIDTH;
8313
8314                 /* override incorrect value set in reganode MJD */
8315                 Set_Node_Offset(ret, parse_start+1);
8316                 Set_Node_Cur_Length(ret); /* MJD */
8317                 nextchar(pRExC_state);
8318
8319             }
8320             break;
8321         }
8322         case 'g': 
8323         case '1': case '2': case '3': case '4':
8324         case '5': case '6': case '7': case '8': case '9':
8325             {
8326                 I32 num;
8327                 bool isg = *RExC_parse == 'g';
8328                 bool isrel = 0; 
8329                 bool hasbrace = 0;
8330                 if (isg) {
8331                     RExC_parse++;
8332                     if (*RExC_parse == '{') {
8333                         RExC_parse++;
8334                         hasbrace = 1;
8335                     }
8336                     if (*RExC_parse == '-') {
8337                         RExC_parse++;
8338                         isrel = 1;
8339                     }
8340                     if (hasbrace && !isDIGIT(*RExC_parse)) {
8341                         if (isrel) RExC_parse--;
8342                         RExC_parse -= 2;                            
8343                         goto parse_named_seq;
8344                 }   }
8345                 num = atoi(RExC_parse);
8346                 if (isg && num == 0)
8347                     vFAIL("Reference to invalid group 0");
8348                 if (isrel) {
8349                     num = RExC_npar - num;
8350                     if (num < 1)
8351                         vFAIL("Reference to nonexistent or unclosed group");
8352                 }
8353                 if (!isg && num > 9 && num >= RExC_npar)
8354                     goto defchar;
8355                 else {
8356                     char * const parse_start = RExC_parse - 1; /* MJD */
8357                     while (isDIGIT(*RExC_parse))
8358                         RExC_parse++;
8359                     if (parse_start == RExC_parse - 1) 
8360                         vFAIL("Unterminated \\g... pattern");
8361                     if (hasbrace) {
8362                         if (*RExC_parse != '}') 
8363                             vFAIL("Unterminated \\g{...} pattern");
8364                         RExC_parse++;
8365                     }    
8366                     if (!SIZE_ONLY) {
8367                         if (num > (I32)RExC_rx->nparens)
8368                             vFAIL("Reference to nonexistent group");
8369                     }
8370                     RExC_sawback = 1;
8371                     ret = reganode(pRExC_state,
8372                                    ((! FOLD)
8373                                      ? REF
8374                                      : (MORE_ASCII_RESTRICTED)
8375                                        ? REFFA
8376                                        : (AT_LEAST_UNI_SEMANTICS)
8377                                          ? REFFU
8378                                          : (LOC)
8379                                            ? REFFL
8380                                            : REFF),
8381                                     num);
8382                     *flagp |= HASWIDTH;
8383
8384                     /* override incorrect value set in reganode MJD */
8385                     Set_Node_Offset(ret, parse_start+1);
8386                     Set_Node_Cur_Length(ret); /* MJD */
8387                     RExC_parse--;
8388                     nextchar(pRExC_state);
8389                 }
8390             }
8391             break;
8392         case '\0':
8393             if (RExC_parse >= RExC_end)
8394                 FAIL("Trailing \\");
8395             /* FALL THROUGH */
8396         default:
8397             /* Do not generate "unrecognized" warnings here, we fall
8398                back into the quick-grab loop below */
8399             parse_start--;
8400             goto defchar;
8401         }
8402         break;
8403
8404     case '#':
8405         if (RExC_flags & RXf_PMf_EXTENDED) {
8406             if ( reg_skipcomment( pRExC_state ) )
8407                 goto tryagain;
8408         }
8409         /* FALL THROUGH */
8410
8411     default:
8412
8413             parse_start = RExC_parse - 1;
8414
8415             RExC_parse++;
8416
8417         defchar: {
8418             typedef enum {
8419                 generic_char = 0,
8420                 char_s,
8421                 upsilon_1,
8422                 upsilon_2,
8423                 iota_1,
8424                 iota_2,
8425             } char_state;
8426             char_state latest_char_state = generic_char;
8427             register STRLEN len;
8428             register UV ender;
8429             register char *p;
8430             char *s;
8431             STRLEN foldlen;
8432             U8 tmpbuf[UTF8_MAXBYTES_CASE+1], *foldbuf;
8433             regnode * orig_emit;
8434
8435             ender = 0;
8436             orig_emit = RExC_emit; /* Save the original output node position in
8437                                       case we need to output a different node
8438                                       type */
8439             ret = reg_node(pRExC_state,
8440                            (U8) ((! FOLD) ? EXACT
8441                                           : (LOC)
8442                                              ? EXACTFL
8443                                              : (MORE_ASCII_RESTRICTED)
8444                                                ? EXACTFA
8445                                                : (AT_LEAST_UNI_SEMANTICS)
8446                                                  ? EXACTFU
8447                                                  : EXACTF)
8448                     );
8449             s = STRING(ret);
8450             for (len = 0, p = RExC_parse - 1;
8451               len < 127 && p < RExC_end;
8452               len++)
8453             {
8454                 char * const oldp = p;
8455
8456                 if (RExC_flags & RXf_PMf_EXTENDED)
8457                     p = regwhite( pRExC_state, p );
8458                 switch ((U8)*p) {
8459                 case '^':
8460                 case '$':
8461                 case '.':
8462                 case '[':
8463                 case '(':
8464                 case ')':
8465                 case '|':
8466                     goto loopdone;
8467                 case '\\':
8468                     /* Literal Escapes Switch
8469
8470                        This switch is meant to handle escape sequences that
8471                        resolve to a literal character.
8472
8473                        Every escape sequence that represents something
8474                        else, like an assertion or a char class, is handled
8475                        in the switch marked 'Special Escapes' above in this
8476                        routine, but also has an entry here as anything that
8477                        isn't explicitly mentioned here will be treated as
8478                        an unescaped equivalent literal.
8479                     */
8480
8481                     switch ((U8)*++p) {
8482                     /* These are all the special escapes. */
8483                     case 'A':             /* Start assertion */
8484                     case 'b': case 'B':   /* Word-boundary assertion*/
8485                     case 'C':             /* Single char !DANGEROUS! */
8486                     case 'd': case 'D':   /* digit class */
8487                     case 'g': case 'G':   /* generic-backref, pos assertion */
8488                     case 'h': case 'H':   /* HORIZWS */
8489                     case 'k': case 'K':   /* named backref, keep marker */
8490                     case 'N':             /* named char sequence */
8491                     case 'p': case 'P':   /* Unicode property */
8492                               case 'R':   /* LNBREAK */
8493                     case 's': case 'S':   /* space class */
8494                     case 'v': case 'V':   /* VERTWS */
8495                     case 'w': case 'W':   /* word class */
8496                     case 'X':             /* eXtended Unicode "combining character sequence" */
8497                     case 'z': case 'Z':   /* End of line/string assertion */
8498                         --p;
8499                         goto loopdone;
8500
8501                     /* Anything after here is an escape that resolves to a
8502                        literal. (Except digits, which may or may not)
8503                      */
8504                     case 'n':
8505                         ender = '\n';
8506                         p++;
8507                         break;
8508                     case 'r':
8509                         ender = '\r';
8510                         p++;
8511                         break;
8512                     case 't':
8513                         ender = '\t';
8514                         p++;
8515                         break;
8516                     case 'f':
8517                         ender = '\f';
8518                         p++;
8519                         break;
8520                     case 'e':
8521                           ender = ASCII_TO_NATIVE('\033');
8522                         p++;
8523                         break;
8524                     case 'a':
8525                           ender = ASCII_TO_NATIVE('\007');
8526                         p++;
8527                         break;
8528                     case 'o':
8529                         {
8530                             STRLEN brace_len = len;
8531                             UV result;
8532                             const char* error_msg;
8533
8534                             bool valid = grok_bslash_o(p,
8535                                                        &result,
8536                                                        &brace_len,
8537                                                        &error_msg,
8538                                                        1);
8539                             p += brace_len;
8540                             if (! valid) {
8541                                 RExC_parse = p; /* going to die anyway; point
8542                                                    to exact spot of failure */
8543                                 vFAIL(error_msg);
8544                             }
8545                             else
8546                             {
8547                                 ender = result;
8548                             }
8549                             if (PL_encoding && ender < 0x100) {
8550                                 goto recode_encoding;
8551                             }
8552                             if (ender > 0xff) {
8553                                 REQUIRE_UTF8;
8554                             }
8555                             break;
8556                         }
8557                     case 'x':
8558                         if (*++p == '{') {
8559                             char* const e = strchr(p, '}');
8560         
8561                             if (!e) {
8562                                 RExC_parse = p + 1;
8563                                 vFAIL("Missing right brace on \\x{}");
8564                             }
8565                             else {
8566                                 I32 flags = PERL_SCAN_ALLOW_UNDERSCORES
8567                                     | PERL_SCAN_DISALLOW_PREFIX;
8568                                 STRLEN numlen = e - p - 1;
8569                                 ender = grok_hex(p + 1, &numlen, &flags, NULL);
8570                                 if (ender > 0xff)
8571                                     REQUIRE_UTF8;
8572                                 p = e + 1;
8573                             }
8574                         }
8575                         else {
8576                             I32 flags = PERL_SCAN_DISALLOW_PREFIX;
8577                             STRLEN numlen = 2;
8578                             ender = grok_hex(p, &numlen, &flags, NULL);
8579                             p += numlen;
8580                         }
8581                         if (PL_encoding && ender < 0x100)
8582                             goto recode_encoding;
8583                         break;
8584                     case 'c':
8585                         p++;
8586                         ender = grok_bslash_c(*p++, UTF, SIZE_ONLY);
8587                         break;
8588                     case '0': case '1': case '2': case '3':case '4':
8589                     case '5': case '6': case '7': case '8':case '9':
8590                         if (*p == '0' ||
8591                             (isDIGIT(p[1]) && atoi(p) >= RExC_npar))
8592                         {
8593                             I32 flags = PERL_SCAN_SILENT_ILLDIGIT;
8594                             STRLEN numlen = 3;
8595                             ender = grok_oct(p, &numlen, &flags, NULL);
8596                             if (ender > 0xff) {
8597                                 REQUIRE_UTF8;
8598                             }
8599                             p += numlen;
8600                         }
8601                         else {
8602                             --p;
8603                             goto loopdone;
8604                         }
8605                         if (PL_encoding && ender < 0x100)
8606                             goto recode_encoding;
8607                         break;
8608                     recode_encoding:
8609                         if (! RExC_override_recoding) {
8610                             SV* enc = PL_encoding;
8611                             ender = reg_recode((const char)(U8)ender, &enc);
8612                             if (!enc && SIZE_ONLY)
8613                                 ckWARNreg(p, "Invalid escape in the specified encoding");
8614                             REQUIRE_UTF8;
8615                         }
8616                         break;
8617                     case '\0':
8618                         if (p >= RExC_end)
8619                             FAIL("Trailing \\");
8620                         /* FALL THROUGH */
8621                     default:
8622                         if (!SIZE_ONLY&& isALPHA(*p)) {
8623                             /* Include any { following the alpha to emphasize
8624                              * that it could be part of an escape at some point
8625                              * in the future */
8626                             int len = (*(p + 1) == '{') ? 2 : 1;
8627                             ckWARN3reg(p + len, "Unrecognized escape \\%.*s passed through", len, p);
8628                         }
8629                         goto normal_default;
8630                     }
8631                     break;
8632                 default:
8633                   normal_default:
8634                     if (UTF8_IS_START(*p) && UTF) {
8635                         STRLEN numlen;
8636                         ender = utf8n_to_uvchr((U8*)p, RExC_end - p,
8637                                                &numlen, UTF8_ALLOW_DEFAULT);
8638                         p += numlen;
8639                     }
8640                     else
8641                         ender = (U8) *p++;
8642                     break;
8643                 } /* End of switch on the literal */
8644
8645                 /* Certain characters are problematic because their folded
8646                  * length is so different from their original length that it
8647                  * isn't handleable by the optimizer.  They are therefore not
8648                  * placed in an EXACTish node; and are here handled specially.
8649                  * (Even if the optimizer handled LATIN_SMALL_LETTER_SHARP_S,
8650                  * putting it in a special node keeps regexec from having to
8651                  * deal with a non-utf8 multi-char fold */
8652                 if (FOLD
8653                     && (ender > 255 || (! MORE_ASCII_RESTRICTED && ! LOC)))
8654                 {
8655                     /* We look for either side of the fold.  For example \xDF
8656                      * folds to 'ss'.  We look for both the single character
8657                      * \xDF and the sequence 'ss'.  When we find something that
8658                      * could be one of those, we stop and flush whatever we
8659                      * have output so far into the EXACTish node that was being
8660                      * built.  Then restore the input pointer to what it was.
8661                      * regatom will return that EXACT node, and will be called
8662                      * again, positioned so the first character is the one in
8663                      * question, which we return in a different node type.
8664                      * The multi-char folds are a sequence, so the occurrence
8665                      * of the first character in that sequence doesn't
8666                      * necessarily mean that what follows is the rest of the
8667                      * sequence.  We keep track of that with a state machine,
8668                      * with the state being set to the latest character
8669                      * processed before the current one.  Most characters will
8670                      * set the state to 0, but if one occurs that is part of a
8671                      * potential tricky fold sequence, the state is set to that
8672                      * character, and the next loop iteration sees if the state
8673                      * should progress towards the final folded-from character,
8674                      * or if it was a false alarm.  If it turns out to be a
8675                      * false alarm, the character(s) will be output in a new
8676                      * EXACTish node, and join_exact() will later combine them.
8677                      * In the case of the 'ss' sequence, which is more common
8678                      * and more easily checked, some look-ahead is done to
8679                      * save time by ruling-out some false alarms */
8680                     switch (ender) {
8681                         default:
8682                             latest_char_state = generic_char;
8683                             break;
8684                         case 's':
8685                         case 'S':
8686                         case 0x17F: /* LATIN SMALL LETTER LONG S */
8687                              if (AT_LEAST_UNI_SEMANTICS) {
8688                                 if (latest_char_state == char_s) {  /* 'ss' */
8689                                     ender = LATIN_SMALL_LETTER_SHARP_S;
8690                                     goto do_tricky;
8691                                 }
8692                                 else if (p < RExC_end) {
8693
8694                                     /* Look-ahead at the next character.  If it
8695                                      * is also an s, we handle as a sharp s
8696                                      * tricky regnode.  */
8697                                     if (*p == 's' || *p == 'S') {
8698
8699                                         /* But first flush anything in the
8700                                          * EXACTish buffer */
8701                                         if (len != 0) {
8702                                             p = oldp;
8703                                             goto loopdone;
8704                                         }
8705                                         p++;    /* Account for swallowing this
8706                                                    's' up */
8707                                         ender = LATIN_SMALL_LETTER_SHARP_S;
8708                                         goto do_tricky;
8709                                     }
8710                                         /* Here, the next character is not a
8711                                          * literal 's', but still could
8712                                          * evaluate to one if part of a \o{},
8713                                          * \x or \OCTAL-DIGIT.  The minimum
8714                                          * length required for that is 4, eg
8715                                          * \x53 or \123 */
8716                                     else if (*p == '\\'
8717                                              && p < RExC_end - 4
8718                                              && (isDIGIT(*(p + 1))
8719                                                  || *(p + 1) == 'x'
8720                                                  || *(p + 1) == 'o' ))
8721                                     {
8722
8723                                         /* Here, it could be an 's', too much
8724                                          * bother to figure it out here.  Flush
8725                                          * the buffer if any; when come back
8726                                          * here, set the state so know that the
8727                                          * previous char was an 's' */
8728                                         if (len != 0) {
8729                                             latest_char_state = generic_char;
8730                                             p = oldp;
8731                                             goto loopdone;
8732                                         }
8733                                         latest_char_state = char_s;
8734                                         break;
8735                                     }
8736                                 }
8737                             }
8738
8739                             /* Here, can't be an 'ss' sequence, or at least not
8740                              * one that could fold to/from the sharp ss */
8741                             latest_char_state = generic_char;
8742                             break;
8743                         case 0x03C5:    /* First char in upsilon series */
8744                             if (p < RExC_end - 4) { /* Need >= 4 bytes left */
8745                                 latest_char_state = upsilon_1;
8746                                 if (len != 0) {
8747                                     p = oldp;
8748                                     goto loopdone;
8749                                 }
8750                             }
8751                             else {
8752                                 latest_char_state = generic_char;
8753                             }
8754                             break;
8755                         case 0x03B9:    /* First char in iota series */
8756                             if (p < RExC_end - 4) {
8757                                 latest_char_state = iota_1;
8758                                 if (len != 0) {
8759                                     p = oldp;
8760                                     goto loopdone;
8761                                 }
8762                             }
8763                             else {
8764                                 latest_char_state = generic_char;
8765                             }
8766                             break;
8767                         case 0x0308:
8768                             if (latest_char_state == upsilon_1) {
8769                                 latest_char_state = upsilon_2;
8770                             }
8771                             else if (latest_char_state == iota_1) {
8772                                 latest_char_state = iota_2;
8773                             }
8774                             else {
8775                                 latest_char_state = generic_char;
8776                             }
8777                             break;
8778                         case 0x301:
8779                             if (latest_char_state == upsilon_2) {
8780                                 ender = GREEK_SMALL_LETTER_UPSILON_WITH_DIALYTIKA_AND_TONOS;
8781                                 goto do_tricky;
8782                             }
8783                             else if (latest_char_state == iota_2) {
8784                                 ender = GREEK_SMALL_LETTER_IOTA_WITH_DIALYTIKA_AND_TONOS;
8785                                 goto do_tricky;
8786                             }
8787                             latest_char_state = generic_char;
8788                             break;
8789
8790                         /* These are the tricky fold characters.  Flush any
8791                          * buffer first. */
8792                         case GREEK_SMALL_LETTER_UPSILON_WITH_DIALYTIKA_AND_TONOS:
8793                         case GREEK_SMALL_LETTER_IOTA_WITH_DIALYTIKA_AND_TONOS:
8794                         case LATIN_SMALL_LETTER_SHARP_S:
8795                         case LATIN_CAPITAL_LETTER_SHARP_S:
8796                         case 0x1FD3:
8797                         case 0x1FE3:
8798                             if (len != 0) {
8799                                 p = oldp;
8800                                 goto loopdone;
8801                             }
8802                             /* FALL THROUGH */
8803                         do_tricky: {
8804                             char* const oldregxend = RExC_end;
8805                             U8 tmpbuf[UTF8_MAXBYTES+1];
8806
8807                             /* Here, we know we need to generate a special
8808                              * regnode, and 'ender' contains the tricky
8809                              * character.  What's done is to pretend it's in a
8810                              * [bracketed] class, and let the code that deals
8811                              * with those handle it, as that code has all the
8812                              * intelligence necessary.  First save the current
8813                              * parse state, get rid of the already allocated
8814                              * but empty EXACT node that the ANYOFV node will
8815                              * replace, and point the parse to a buffer which
8816                              * we fill with the character we want the regclass
8817                              * code to think is being parsed */
8818                             RExC_emit = orig_emit;
8819                             RExC_parse = (char *) tmpbuf;
8820                             if (UTF) {
8821                                 U8 *d = uvchr_to_utf8(tmpbuf, ender);
8822                                 *d = '\0';
8823                                 RExC_end = (char *) d;
8824                             }
8825                             else {  /* ender above 255 already excluded */
8826                                 tmpbuf[0] = (U8) ender;
8827                                 tmpbuf[1] = '\0';
8828                                 RExC_end = RExC_parse + 1;
8829                             }
8830
8831                             ret = regclass(pRExC_state,depth+1);
8832
8833                             /* Here, have parsed the buffer.  Reset the parse to
8834                              * the actual input, and return */
8835                             RExC_end = oldregxend;
8836                             RExC_parse = p - 1;
8837
8838                             Set_Node_Offset(ret, RExC_parse);
8839                             Set_Node_Cur_Length(ret);
8840                             nextchar(pRExC_state);
8841                             *flagp |= HASWIDTH|SIMPLE;
8842                             return ret;
8843                         }
8844                     }
8845                 }
8846
8847                 if ( RExC_flags & RXf_PMf_EXTENDED)
8848                     p = regwhite( pRExC_state, p );
8849                 if (UTF && FOLD) {
8850                     /* Prime the casefolded buffer.  Locale rules, which apply
8851                      * only to code points < 256, aren't known until execution,
8852                      * so for them, just output the original character using
8853                      * utf8 */
8854                     if (LOC && ender < 256) {
8855                         if (UNI_IS_INVARIANT(ender)) {
8856                             *tmpbuf = (U8) ender;
8857                             foldlen = 1;
8858                         } else {
8859                             *tmpbuf = UTF8_TWO_BYTE_HI(ender);
8860                             *(tmpbuf + 1) = UTF8_TWO_BYTE_LO(ender);
8861                             foldlen = 2;
8862                         }
8863                     }
8864                     else if (isASCII(ender)) {  /* Note: Here can't also be LOC
8865                                                  */
8866                         ender = toLOWER(ender);
8867                         *tmpbuf = (U8) ender;
8868                         foldlen = 1;
8869                     }
8870                     else if (! MORE_ASCII_RESTRICTED && ! LOC) {
8871
8872                         /* Locale and /aa require more selectivity about the
8873                          * fold, so are handled below.  Otherwise, here, just
8874                          * use the fold */
8875                         ender = toFOLD_uni(ender, tmpbuf, &foldlen);
8876                     }
8877                     else {
8878                         /* Under locale rules or /aa we are not to mix,
8879                          * respectively, ords < 256 or ASCII with non-.  So
8880                          * reject folds that mix them, using only the
8881                          * non-folded code point.  So do the fold to a
8882                          * temporary, and inspect each character in it. */
8883                         U8 trialbuf[UTF8_MAXBYTES_CASE+1];
8884                         U8* s = trialbuf;
8885                         UV tmpender = toFOLD_uni(ender, trialbuf, &foldlen);
8886                         U8* e = s + foldlen;
8887                         bool fold_ok = TRUE;
8888
8889                         while (s < e) {
8890                             if (isASCII(*s)
8891                                 || (LOC && (UTF8_IS_INVARIANT(*s)
8892                                            || UTF8_IS_DOWNGRADEABLE_START(*s))))
8893                             {
8894                                 fold_ok = FALSE;
8895                                 break;
8896                             }
8897                             s += UTF8SKIP(s);
8898                         }
8899                         if (fold_ok) {
8900                             Copy(trialbuf, tmpbuf, foldlen, U8);
8901                             ender = tmpender;
8902                         }
8903                         else {
8904                             uvuni_to_utf8(tmpbuf, ender);
8905                             foldlen = UNISKIP(ender);
8906                         }
8907                     }
8908                 }
8909                 if (p < RExC_end && ISMULT2(p)) { /* Back off on ?+*. */
8910                     if (len)
8911                         p = oldp;
8912                     else if (UTF) {
8913                          if (FOLD) {
8914                               /* Emit all the Unicode characters. */
8915                               STRLEN numlen;
8916                               for (foldbuf = tmpbuf;
8917                                    foldlen;
8918                                    foldlen -= numlen) {
8919                                    ender = utf8_to_uvchr(foldbuf, &numlen);
8920                                    if (numlen > 0) {
8921                                         const STRLEN unilen = reguni(pRExC_state, ender, s);
8922                                         s       += unilen;
8923                                         len     += unilen;
8924                                         /* In EBCDIC the numlen
8925                                          * and unilen can differ. */
8926                                         foldbuf += numlen;
8927                                         if (numlen >= foldlen)
8928                                              break;
8929                                    }
8930                                    else
8931                                         break; /* "Can't happen." */
8932                               }
8933                          }
8934                          else {
8935                               const STRLEN unilen = reguni(pRExC_state, ender, s);
8936                               if (unilen > 0) {
8937                                    s   += unilen;
8938                                    len += unilen;
8939                               }
8940                          }
8941                     }
8942                     else {
8943                         len++;
8944                         REGC((char)ender, s++);
8945                     }
8946                     break;
8947                 }
8948                 if (UTF) {
8949                      if (FOLD) {
8950                           /* Emit all the Unicode characters. */
8951                           STRLEN numlen;
8952                           for (foldbuf = tmpbuf;
8953                                foldlen;
8954                                foldlen -= numlen) {
8955                                ender = utf8_to_uvchr(foldbuf, &numlen);
8956                                if (numlen > 0) {
8957                                     const STRLEN unilen = reguni(pRExC_state, ender, s);
8958                                     len     += unilen;
8959                                     s       += unilen;
8960                                     /* In EBCDIC the numlen
8961                                      * and unilen can differ. */
8962                                     foldbuf += numlen;
8963                                     if (numlen >= foldlen)
8964                                          break;
8965                                }
8966                                else
8967                                     break;
8968                           }
8969                      }
8970                      else {
8971                           const STRLEN unilen = reguni(pRExC_state, ender, s);
8972                           if (unilen > 0) {
8973                                s   += unilen;
8974                                len += unilen;
8975                           }
8976                      }
8977                      len--;
8978                 }
8979                 else {
8980                     REGC((char)ender, s++);
8981                 }
8982             }
8983         loopdone:   /* Jumped to when encounters something that shouldn't be in
8984                        the node */
8985             RExC_parse = p - 1;
8986             Set_Node_Cur_Length(ret); /* MJD */
8987             nextchar(pRExC_state);
8988             {
8989                 /* len is STRLEN which is unsigned, need to copy to signed */
8990                 IV iv = len;
8991                 if (iv < 0)
8992                     vFAIL("Internal disaster");
8993             }
8994             if (len > 0)
8995                 *flagp |= HASWIDTH;
8996             if (len == 1 && UNI_IS_INVARIANT(ender))
8997                 *flagp |= SIMPLE;
8998                 
8999             if (SIZE_ONLY)
9000                 RExC_size += STR_SZ(len);
9001             else {
9002                 STR_LEN(ret) = len;
9003                 RExC_emit += STR_SZ(len);
9004             }
9005         }
9006         break;
9007     }
9008
9009     return(ret);
9010
9011 /* Jumped to when an unrecognized character set is encountered */
9012 bad_charset:
9013     Perl_croak(aTHX_ "panic: Unknown regex character set encoding: %u", get_regex_charset(RExC_flags));
9014     return(NULL);
9015 }
9016
9017 STATIC char *
9018 S_regwhite( RExC_state_t *pRExC_state, char *p )
9019 {
9020     const char *e = RExC_end;
9021
9022     PERL_ARGS_ASSERT_REGWHITE;
9023
9024     while (p < e) {
9025         if (isSPACE(*p))
9026             ++p;
9027         else if (*p == '#') {
9028             bool ended = 0;
9029             do {
9030                 if (*p++ == '\n') {
9031                     ended = 1;
9032                     break;
9033                 }
9034             } while (p < e);
9035             if (!ended)
9036                 RExC_seen |= REG_SEEN_RUN_ON_COMMENT;
9037         }
9038         else
9039             break;
9040     }
9041     return p;
9042 }
9043
9044 /* Parse POSIX character classes: [[:foo:]], [[=foo=]], [[.foo.]].
9045    Character classes ([:foo:]) can also be negated ([:^foo:]).
9046    Returns a named class id (ANYOF_XXX) if successful, -1 otherwise.
9047    Equivalence classes ([=foo=]) and composites ([.foo.]) are parsed,
9048    but trigger failures because they are currently unimplemented. */
9049
9050 #define POSIXCC_DONE(c)   ((c) == ':')
9051 #define POSIXCC_NOTYET(c) ((c) == '=' || (c) == '.')
9052 #define POSIXCC(c) (POSIXCC_DONE(c) || POSIXCC_NOTYET(c))
9053
9054 STATIC I32
9055 S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value)
9056 {
9057     dVAR;
9058     I32 namedclass = OOB_NAMEDCLASS;
9059
9060     PERL_ARGS_ASSERT_REGPPOSIXCC;
9061
9062     if (value == '[' && RExC_parse + 1 < RExC_end &&
9063         /* I smell either [: or [= or [. -- POSIX has been here, right? */
9064         POSIXCC(UCHARAT(RExC_parse))) {
9065         const char c = UCHARAT(RExC_parse);
9066         char* const s = RExC_parse++;
9067         
9068         while (RExC_parse < RExC_end && UCHARAT(RExC_parse) != c)
9069             RExC_parse++;
9070         if (RExC_parse == RExC_end)
9071             /* Grandfather lone [:, [=, [. */
9072             RExC_parse = s;
9073         else {
9074             const char* const t = RExC_parse++; /* skip over the c */
9075             assert(*t == c);
9076
9077             if (UCHARAT(RExC_parse) == ']') {
9078                 const char *posixcc = s + 1;
9079                 RExC_parse++; /* skip over the ending ] */
9080
9081                 if (*s == ':') {
9082                     const I32 complement = *posixcc == '^' ? *posixcc++ : 0;
9083                     const I32 skip = t - posixcc;
9084
9085                     /* Initially switch on the length of the name.  */
9086                     switch (skip) {
9087                     case 4:
9088                         if (memEQ(posixcc, "word", 4)) /* this is not POSIX, this is the Perl \w */
9089                             namedclass = complement ? ANYOF_NALNUM : ANYOF_ALNUM;
9090                         break;
9091                     case 5:
9092                         /* Names all of length 5.  */
9093                         /* alnum alpha ascii blank cntrl digit graph lower
9094                            print punct space upper  */
9095                         /* Offset 4 gives the best switch position.  */
9096                         switch (posixcc[4]) {
9097                         case 'a':
9098                             if (memEQ(posixcc, "alph", 4)) /* alpha */
9099                                 namedclass = complement ? ANYOF_NALPHA : ANYOF_ALPHA;
9100                             break;
9101                         case 'e':
9102                             if (memEQ(posixcc, "spac", 4)) /* space */
9103                                 namedclass = complement ? ANYOF_NPSXSPC : ANYOF_PSXSPC;
9104                             break;
9105                         case 'h':
9106                             if (memEQ(posixcc, "grap", 4)) /* graph */
9107                                 namedclass = complement ? ANYOF_NGRAPH : ANYOF_GRAPH;
9108                             break;
9109                         case 'i':
9110                             if (memEQ(posixcc, "asci", 4)) /* ascii */
9111                                 namedclass = complement ? ANYOF_NASCII : ANYOF_ASCII;
9112                             break;
9113                         case 'k':
9114                             if (memEQ(posixcc, "blan", 4)) /* blank */
9115                                 namedclass = complement ? ANYOF_NBLANK : ANYOF_BLANK;
9116                             break;
9117                         case 'l':
9118                             if (memEQ(posixcc, "cntr", 4)) /* cntrl */
9119                                 namedclass = complement ? ANYOF_NCNTRL : ANYOF_CNTRL;
9120                             break;
9121                         case 'm':
9122                             if (memEQ(posixcc, "alnu", 4)) /* alnum */
9123                                 namedclass = complement ? ANYOF_NALNUMC : ANYOF_ALNUMC;
9124                             break;
9125                         case 'r':
9126                             if (memEQ(posixcc, "lowe", 4)) /* lower */
9127                                 namedclass = complement ? ANYOF_NLOWER : ANYOF_LOWER;
9128                             else if (memEQ(posixcc, "uppe", 4)) /* upper */
9129                                 namedclass = complement ? ANYOF_NUPPER : ANYOF_UPPER;
9130                             break;
9131                         case 't':
9132                             if (memEQ(posixcc, "digi", 4)) /* digit */
9133                                 namedclass = complement ? ANYOF_NDIGIT : ANYOF_DIGIT;
9134                             else if (memEQ(posixcc, "prin", 4)) /* print */
9135                                 namedclass = complement ? ANYOF_NPRINT : ANYOF_PRINT;
9136                             else if (memEQ(posixcc, "punc", 4)) /* punct */
9137                                 namedclass = complement ? ANYOF_NPUNCT : ANYOF_PUNCT;
9138                             break;
9139                         }
9140                         break;
9141                     case 6:
9142                         if (memEQ(posixcc, "xdigit", 6))
9143                             namedclass = complement ? ANYOF_NXDIGIT : ANYOF_XDIGIT;
9144                         break;
9145                     }
9146
9147                     if (namedclass == OOB_NAMEDCLASS)
9148                         Simple_vFAIL3("POSIX class [:%.*s:] unknown",
9149                                       t - s - 1, s + 1);
9150                     assert (posixcc[skip] == ':');
9151                     assert (posixcc[skip+1] == ']');
9152                 } else if (!SIZE_ONLY) {
9153                     /* [[=foo=]] and [[.foo.]] are still future. */
9154
9155                     /* adjust RExC_parse so the warning shows after
9156                        the class closes */
9157                     while (UCHARAT(RExC_parse) && UCHARAT(RExC_parse) != ']')
9158                         RExC_parse++;
9159                     Simple_vFAIL3("POSIX syntax [%c %c] is reserved for future extensions", c, c);
9160                 }
9161             } else {
9162                 /* Maternal grandfather:
9163                  * "[:" ending in ":" but not in ":]" */
9164                 RExC_parse = s;
9165             }
9166         }
9167     }
9168
9169     return namedclass;
9170 }
9171
9172 STATIC void
9173 S_checkposixcc(pTHX_ RExC_state_t *pRExC_state)
9174 {
9175     dVAR;
9176
9177     PERL_ARGS_ASSERT_CHECKPOSIXCC;
9178
9179     if (POSIXCC(UCHARAT(RExC_parse))) {
9180         const char *s = RExC_parse;
9181         const char  c = *s++;
9182
9183         while (isALNUM(*s))
9184             s++;
9185         if (*s && c == *s && s[1] == ']') {
9186             ckWARN3reg(s+2,
9187                        "POSIX syntax [%c %c] belongs inside character classes",
9188                        c, c);
9189
9190             /* [[=foo=]] and [[.foo.]] are still future. */
9191             if (POSIXCC_NOTYET(c)) {
9192                 /* adjust RExC_parse so the error shows after
9193                    the class closes */
9194                 while (UCHARAT(RExC_parse) && UCHARAT(RExC_parse++) != ']')
9195                     NOOP;
9196                 Simple_vFAIL3("POSIX syntax [%c %c] is reserved for future extensions", c, c);
9197             }
9198         }
9199     }
9200 }
9201
9202 /* No locale test, and always Unicode semantics */
9203 #define _C_C_T_NOLOC_(NAME,TEST,WORD)                                          \
9204 ANYOF_##NAME:                                                                  \
9205         for (value = 0; value < 256; value++)                                  \
9206             if (TEST)                                                          \
9207             stored += set_regclass_bit(pRExC_state, ret, (U8) value, &l1_fold_invlist, &unicode_alternate);  \
9208     yesno = '+';                                                               \
9209     what = WORD;                                                               \
9210     break;                                                                     \
9211 case ANYOF_N##NAME:                                                            \
9212         for (value = 0; value < 256; value++)                                  \
9213             if (!TEST)                                                         \
9214             stored += set_regclass_bit(pRExC_state, ret, (U8) value, &l1_fold_invlist, &unicode_alternate);  \
9215     yesno = '!';                                                               \
9216     what = WORD;                                                               \
9217     break
9218
9219 /* Like the above, but there are differences if we are in uni-8-bit or not, so
9220  * there are two tests passed in, to use depending on that. There aren't any
9221  * cases where the label is different from the name, so no need for that
9222  * parameter */
9223 #define _C_C_T_(NAME, TEST_8, TEST_7, WORD)                                    \
9224 ANYOF_##NAME:                                                                  \
9225     if (LOC) ANYOF_CLASS_SET(ret, ANYOF_##NAME);                               \
9226     else if (UNI_SEMANTICS) {                                                  \
9227         for (value = 0; value < 256; value++) {                                \
9228             if (TEST_8(value)) stored +=                                       \
9229                       set_regclass_bit(pRExC_state, ret, (U8) value, &l1_fold_invlist, &unicode_alternate);  \
9230         }                                                                      \
9231     }                                                                          \
9232     else {                                                                     \
9233         for (value = 0; value < 128; value++) {                                \
9234             if (TEST_7(UNI_TO_NATIVE(value))) stored +=                        \
9235                 set_regclass_bit(pRExC_state, ret,                     \
9236                                    (U8) UNI_TO_NATIVE(value), &l1_fold_invlist, &unicode_alternate);                 \
9237         }                                                                      \
9238     }                                                                          \
9239     yesno = '+';                                                               \
9240     what = WORD;                                                               \
9241     break;                                                                     \
9242 case ANYOF_N##NAME:                                                            \
9243     if (LOC) ANYOF_CLASS_SET(ret, ANYOF_N##NAME);                              \
9244     else if (UNI_SEMANTICS) {                                                  \
9245         for (value = 0; value < 256; value++) {                                \
9246             if (! TEST_8(value)) stored +=                                     \
9247                     set_regclass_bit(pRExC_state, ret, (U8) value, &l1_fold_invlist, &unicode_alternate);    \
9248         }                                                                      \
9249     }                                                                          \
9250     else {                                                                     \
9251         for (value = 0; value < 128; value++) {                                \
9252             if (! TEST_7(UNI_TO_NATIVE(value))) stored += set_regclass_bit(  \
9253                         pRExC_state, ret, (U8) UNI_TO_NATIVE(value), &l1_fold_invlist, &unicode_alternate);    \
9254         }                                                                      \
9255         if (AT_LEAST_ASCII_RESTRICTED) {                                       \
9256             for (value = 128; value < 256; value++) {                          \
9257              stored += set_regclass_bit(                                     \
9258                            pRExC_state, ret, (U8) UNI_TO_NATIVE(value), &l1_fold_invlist, &unicode_alternate); \
9259             }                                                                  \
9260             ANYOF_FLAGS(ret) |= ANYOF_UNICODE_ALL;                             \
9261         }                                                                      \
9262         else {                                                                 \
9263             /* For a non-ut8 target string with DEPENDS semantics, all above   \
9264              * ASCII Latin1 code points match the complement of any of the     \
9265              * classes.  But in utf8, they have their Unicode semantics, so    \
9266              * can't just set them in the bitmap, or else regexec.c will think \
9267              * they matched when they shouldn't. */                            \
9268             ANYOF_FLAGS(ret) |= ANYOF_NON_UTF8_LATIN1_ALL;                     \
9269         }                                                                      \
9270     }                                                                          \
9271     yesno = '!';                                                               \
9272     what = WORD;                                                               \
9273     break
9274
9275 STATIC U8
9276 S_set_regclass_bit_fold(pTHX_ RExC_state_t *pRExC_state, regnode* node, const U8 value, HV** invlist_ptr, AV** alternate_ptr)
9277 {
9278
9279     /* Handle the setting of folds in the bitmap for non-locale ANYOF nodes.
9280      * Locale folding is done at run-time, so this function should not be
9281      * called for nodes that are for locales.
9282      *
9283      * This function sets the bit corresponding to the fold of the input
9284      * 'value', if not already set.  The fold of 'f' is 'F', and the fold of
9285      * 'F' is 'f'.
9286      *
9287      * It also knows about the characters that are in the bitmap that have
9288      * folds that are matchable only outside it, and sets the appropriate lists
9289      * and flags.
9290      *
9291      * It returns the number of bits that actually changed from 0 to 1 */
9292
9293     U8 stored = 0;
9294     U8 fold;
9295
9296     PERL_ARGS_ASSERT_SET_REGCLASS_BIT_FOLD;
9297
9298     fold = (AT_LEAST_UNI_SEMANTICS) ? PL_fold_latin1[value]
9299                                     : PL_fold[value];
9300
9301     /* It assumes the bit for 'value' has already been set */
9302     if (fold != value && ! ANYOF_BITMAP_TEST(node, fold)) {
9303         ANYOF_BITMAP_SET(node, fold);
9304         stored++;
9305     }
9306     if (_HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(value) && (! isASCII(value) || ! MORE_ASCII_RESTRICTED)) {
9307         /* Certain Latin1 characters have matches outside the bitmap.  To get
9308          * here, 'value' is one of those characters.   None of these matches is
9309          * valid for ASCII characters under /aa, which have been excluded by
9310          * the 'if' above.  The matches fall into three categories:
9311          * 1) They are singly folded-to or -from an above 255 character, as
9312          *    LATIN SMALL LETTER Y WITH DIAERESIS and LATIN CAPITAL LETTER Y
9313          *    WITH DIAERESIS;
9314          * 2) They are part of a multi-char fold with another character in the
9315          *    bitmap, only LATIN SMALL LETTER SHARP S => "ss" fits that bill;
9316          * 3) They are part of a multi-char fold with a character not in the
9317          *    bitmap, such as various ligatures.
9318          * We aren't dealing fully with multi-char folds, except we do deal
9319          * with the pattern containing a character that has a multi-char fold
9320          * (not so much the inverse).
9321          * For types 1) and 3), the matches only happen when the target string
9322          * is utf8; that's not true for 2), and we set a flag for it.
9323          *
9324          * The code below adds to the passed in inversion list the single fold
9325          * closures for 'value'.  The values are hard-coded here so that an
9326          * innocent-looking character class, like /[ks]/i won't have to go out
9327          * to disk to find the possible matches.  XXX It would be better to
9328          * generate these via regen, in case a new version of the Unicode
9329          * standard adds new mappings, though that is not really likely. */
9330         switch (value) {
9331             case 'k':
9332             case 'K':
9333                 /* KELVIN SIGN */
9334                 *invlist_ptr = add_cp_to_invlist(*invlist_ptr, 0x212A);
9335                 break;
9336             case 's':
9337             case 'S':
9338                 /* LATIN SMALL LETTER LONG S */
9339                 *invlist_ptr = add_cp_to_invlist(*invlist_ptr, 0x017F);
9340                 break;
9341             case MICRO_SIGN:
9342                 *invlist_ptr = add_cp_to_invlist(*invlist_ptr,
9343                                                  GREEK_SMALL_LETTER_MU);
9344                 *invlist_ptr = add_cp_to_invlist(*invlist_ptr,
9345                                                  GREEK_CAPITAL_LETTER_MU);
9346                 break;
9347             case LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE:
9348             case LATIN_SMALL_LETTER_A_WITH_RING_ABOVE:
9349                 /* ANGSTROM SIGN */
9350                 *invlist_ptr = add_cp_to_invlist(*invlist_ptr, 0x212B);
9351                 if (DEPENDS_SEMANTICS) {    /* See DEPENDS comment below */
9352                     *invlist_ptr = add_cp_to_invlist(*invlist_ptr,
9353                                                      PL_fold_latin1[value]);
9354                 }
9355                 break;
9356             case LATIN_SMALL_LETTER_Y_WITH_DIAERESIS:
9357                 *invlist_ptr = add_cp_to_invlist(*invlist_ptr,
9358                                         LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS);
9359                 break;
9360             case LATIN_SMALL_LETTER_SHARP_S:
9361                 *invlist_ptr = add_cp_to_invlist(*invlist_ptr,
9362                                         LATIN_CAPITAL_LETTER_SHARP_S);
9363
9364                 /* Under /a, /d, and /u, this can match the two chars "ss" */
9365                 if (! MORE_ASCII_RESTRICTED) {
9366                     add_alternate(alternate_ptr, (U8 *) "ss", 2);
9367
9368                     /* And under /u or /a, it can match even if the target is
9369                      * not utf8 */
9370                     if (AT_LEAST_UNI_SEMANTICS) {
9371                         ANYOF_FLAGS(node) |= ANYOF_NONBITMAP_NON_UTF8;
9372                     }
9373                 }
9374                 break;
9375             case 'F': case 'f':
9376             case 'I': case 'i':
9377             case 'L': case 'l':
9378             case 'T': case 't':
9379             case 'A': case 'a':
9380             case 'H': case 'h':
9381             case 'J': case 'j':
9382             case 'N': case 'n':
9383             case 'W': case 'w':
9384             case 'Y': case 'y':
9385                 /* These all are targets of multi-character folds from code
9386                  * points that require UTF8 to express, so they can't match
9387                  * unless the target string is in UTF-8, so no action here is
9388                  * necessary, as regexec.c properly handles the general case
9389                  * for UTF-8 matching */
9390                 break;
9391             default:
9392                 /* Use deprecated warning to increase the chances of this
9393                  * being output */
9394                 ckWARN2regdep(RExC_parse, "Perl folding rules are not up-to-date for 0x%x; please use the perlbug utility to report;", value);
9395                 break;
9396         }
9397     }
9398     else if (DEPENDS_SEMANTICS
9399             && ! isASCII(value)
9400             && PL_fold_latin1[value] != value)
9401     {
9402            /* Under DEPENDS rules, non-ASCII Latin1 characters match their
9403             * folds only when the target string is in UTF-8.  We add the fold
9404             * here to the list of things to match outside the bitmap, which
9405             * won't be looked at unless it is UTF8 (or else if something else
9406             * says to look even if not utf8, but those things better not happen
9407             * under DEPENDS semantics. */
9408         *invlist_ptr = add_cp_to_invlist(*invlist_ptr, PL_fold_latin1[value]);
9409     }
9410
9411     return stored;
9412 }
9413
9414
9415 PERL_STATIC_INLINE U8
9416 S_set_regclass_bit(pTHX_ RExC_state_t *pRExC_state, regnode* node, const U8 value, HV** invlist_ptr, AV** alternate_ptr)
9417 {
9418     /* This inline function sets a bit in the bitmap if not already set, and if
9419      * appropriate, its fold, returning the number of bits that actually
9420      * changed from 0 to 1 */
9421
9422     U8 stored;
9423
9424     PERL_ARGS_ASSERT_SET_REGCLASS_BIT;
9425
9426     if (ANYOF_BITMAP_TEST(node, value)) {   /* Already set */
9427         return 0;
9428     }
9429
9430     ANYOF_BITMAP_SET(node, value);
9431     stored = 1;
9432
9433     if (FOLD && ! LOC) {        /* Locale folds aren't known until runtime */
9434         stored += set_regclass_bit_fold(pRExC_state, node, value, invlist_ptr, alternate_ptr);
9435     }
9436
9437     return stored;
9438 }
9439
9440 STATIC void
9441 S_add_alternate(pTHX_ AV** alternate_ptr, U8* string, STRLEN len)
9442 {
9443     /* Adds input 'string' with length 'len' to the ANYOF node's unicode
9444      * alternate list, pointed to by 'alternate_ptr'.  This is an array of
9445      * the multi-character folds of characters in the node */
9446     SV *sv;
9447
9448     PERL_ARGS_ASSERT_ADD_ALTERNATE;
9449
9450     if (! *alternate_ptr) {
9451         *alternate_ptr = newAV();
9452     }
9453     sv = newSVpvn_utf8((char*)string, len, TRUE);
9454     av_push(*alternate_ptr, sv);
9455     return;
9456 }
9457
9458 /*
9459    parse a class specification and produce either an ANYOF node that
9460    matches the pattern or perhaps will be optimized into an EXACTish node
9461    instead. The node contains a bit map for the first 256 characters, with the
9462    corresponding bit set if that character is in the list.  For characters
9463    above 255, a range list is used */
9464
9465 STATIC regnode *
9466 S_regclass(pTHX_ RExC_state_t *pRExC_state, U32 depth)
9467 {
9468     dVAR;
9469     register UV nextvalue;
9470     register IV prevvalue = OOB_UNICODE;
9471     register IV range = 0;
9472     UV value = 0; /* XXX:dmq: needs to be referenceable (unfortunately) */
9473     register regnode *ret;
9474     STRLEN numlen;
9475     IV namedclass;
9476     char *rangebegin = NULL;
9477     bool need_class = 0;
9478     bool allow_full_fold = TRUE;   /* Assume wants multi-char folding */
9479     SV *listsv = NULL;
9480     STRLEN initial_listsv_len = 0; /* Kind of a kludge to see if it is more
9481                                       than just initialized.  */
9482     UV n;
9483
9484     /* code points this node matches that can't be stored in the bitmap */
9485     HV* nonbitmap = NULL;
9486
9487     /* The items that are to match that aren't stored in the bitmap, but are a
9488      * result of things that are stored there.  This is the fold closure of
9489      * such a character, either because it has DEPENDS semantics and shouldn't
9490      * be matched unless the target string is utf8, or is a code point that is
9491      * too large for the bit map, as for example, the fold of the MICRO SIGN is
9492      * above 255.  This all is solely for performance reasons.  By having this
9493      * code know the outside-the-bitmap folds that the bitmapped characters are
9494      * involved with, we don't have to go out to disk to find the list of
9495      * matches, unless the character class includes code points that aren't
9496      * storable in the bit map.  That means that a character class with an 's'
9497      * in it, for example, doesn't need to go out to disk to find everything
9498      * that matches.  A 2nd list is used so that the 'nonbitmap' list is kept
9499      * empty unless there is something whose fold we don't know about, and will
9500      * have to go out to the disk to find. */
9501     HV* l1_fold_invlist = NULL;
9502
9503     /* List of multi-character folds that are matched by this node */
9504     AV* unicode_alternate  = NULL;
9505 #ifdef EBCDIC
9506     UV literal_endpoint = 0;
9507 #endif
9508     UV stored = 0;  /* how many chars stored in the bitmap */
9509
9510     regnode * const orig_emit = RExC_emit; /* Save the original RExC_emit in
9511         case we need to change the emitted regop to an EXACT. */
9512     const char * orig_parse = RExC_parse;
9513     GET_RE_DEBUG_FLAGS_DECL;
9514
9515     PERL_ARGS_ASSERT_REGCLASS;
9516 #ifndef DEBUGGING
9517     PERL_UNUSED_ARG(depth);
9518 #endif
9519
9520     DEBUG_PARSE("clas");
9521
9522     /* Assume we are going to generate an ANYOF node. */
9523     ret = reganode(pRExC_state, ANYOF, 0);
9524
9525
9526     if (!SIZE_ONLY) {
9527         ANYOF_FLAGS(ret) = 0;
9528     }
9529
9530     if (UCHARAT(RExC_parse) == '^') {   /* Complement of range. */
9531         RExC_naughty++;
9532         RExC_parse++;
9533         if (!SIZE_ONLY)
9534             ANYOF_FLAGS(ret) |= ANYOF_INVERT;
9535
9536         /* We have decided to not allow multi-char folds in inverted character
9537          * classes, due to the confusion that can happen, even with classes
9538          * that are designed for a non-Unicode world:  You have the peculiar
9539          * case that:
9540             "s s" =~ /^[^\xDF]+$/i => Y
9541             "ss"  =~ /^[^\xDF]+$/i => N
9542          *
9543          * See [perl #89750] */
9544         allow_full_fold = FALSE;
9545     }
9546
9547     if (SIZE_ONLY) {
9548         RExC_size += ANYOF_SKIP;
9549         listsv = &PL_sv_undef; /* For code scanners: listsv always non-NULL. */
9550     }
9551     else {
9552         RExC_emit += ANYOF_SKIP;
9553         if (LOC) {
9554             ANYOF_FLAGS(ret) |= ANYOF_LOCALE;
9555         }
9556         ANYOF_BITMAP_ZERO(ret);
9557         listsv = newSVpvs("# comment\n");
9558         initial_listsv_len = SvCUR(listsv);
9559     }
9560
9561     nextvalue = RExC_parse < RExC_end ? UCHARAT(RExC_parse) : 0;
9562
9563     if (!SIZE_ONLY && POSIXCC(nextvalue))
9564         checkposixcc(pRExC_state);
9565
9566     /* allow 1st char to be ] (allowing it to be - is dealt with later) */
9567     if (UCHARAT(RExC_parse) == ']')
9568         goto charclassloop;
9569
9570 parseit:
9571     while (RExC_parse < RExC_end && UCHARAT(RExC_parse) != ']') {
9572
9573     charclassloop:
9574
9575         namedclass = OOB_NAMEDCLASS; /* initialize as illegal */
9576
9577         if (!range)
9578             rangebegin = RExC_parse;
9579         if (UTF) {
9580             value = utf8n_to_uvchr((U8*)RExC_parse,
9581                                    RExC_end - RExC_parse,
9582                                    &numlen, UTF8_ALLOW_DEFAULT);
9583             RExC_parse += numlen;
9584         }
9585         else
9586             value = UCHARAT(RExC_parse++);
9587
9588         nextvalue = RExC_parse < RExC_end ? UCHARAT(RExC_parse) : 0;
9589         if (value == '[' && POSIXCC(nextvalue))
9590             namedclass = regpposixcc(pRExC_state, value);
9591         else if (value == '\\') {
9592             if (UTF) {
9593                 value = utf8n_to_uvchr((U8*)RExC_parse,
9594                                    RExC_end - RExC_parse,
9595                                    &numlen, UTF8_ALLOW_DEFAULT);
9596                 RExC_parse += numlen;
9597             }
9598             else
9599                 value = UCHARAT(RExC_parse++);
9600             /* Some compilers cannot handle switching on 64-bit integer
9601              * values, therefore value cannot be an UV.  Yes, this will
9602              * be a problem later if we want switch on Unicode.
9603              * A similar issue a little bit later when switching on
9604              * namedclass. --jhi */
9605             switch ((I32)value) {
9606             case 'w':   namedclass = ANYOF_ALNUM;       break;
9607             case 'W':   namedclass = ANYOF_NALNUM;      break;
9608             case 's':   namedclass = ANYOF_SPACE;       break;
9609             case 'S':   namedclass = ANYOF_NSPACE;      break;
9610             case 'd':   namedclass = ANYOF_DIGIT;       break;
9611             case 'D':   namedclass = ANYOF_NDIGIT;      break;
9612             case 'v':   namedclass = ANYOF_VERTWS;      break;
9613             case 'V':   namedclass = ANYOF_NVERTWS;     break;
9614             case 'h':   namedclass = ANYOF_HORIZWS;     break;
9615             case 'H':   namedclass = ANYOF_NHORIZWS;    break;
9616             case 'N':  /* Handle \N{NAME} in class */
9617                 {
9618                     /* We only pay attention to the first char of 
9619                     multichar strings being returned. I kinda wonder
9620                     if this makes sense as it does change the behaviour
9621                     from earlier versions, OTOH that behaviour was broken
9622                     as well. */
9623                     UV v; /* value is register so we cant & it /grrr */
9624                     if (reg_namedseq(pRExC_state, &v, NULL, depth)) {
9625                         goto parseit;
9626                     }
9627                     value= v; 
9628                 }
9629                 break;
9630             case 'p':
9631             case 'P':
9632                 {
9633                 char *e;
9634                 if (RExC_parse >= RExC_end)
9635                     vFAIL2("Empty \\%c{}", (U8)value);
9636                 if (*RExC_parse == '{') {
9637                     const U8 c = (U8)value;
9638                     e = strchr(RExC_parse++, '}');
9639                     if (!e)
9640                         vFAIL2("Missing right brace on \\%c{}", c);
9641                     while (isSPACE(UCHARAT(RExC_parse)))
9642                         RExC_parse++;
9643                     if (e == RExC_parse)
9644                         vFAIL2("Empty \\%c{}", c);
9645                     n = e - RExC_parse;
9646                     while (isSPACE(UCHARAT(RExC_parse + n - 1)))
9647                         n--;
9648                 }
9649                 else {
9650                     e = RExC_parse;
9651                     n = 1;
9652                 }
9653                 if (!SIZE_ONLY) {
9654                     if (UCHARAT(RExC_parse) == '^') {
9655                          RExC_parse++;
9656                          n--;
9657                          value = value == 'p' ? 'P' : 'p'; /* toggle */
9658                          while (isSPACE(UCHARAT(RExC_parse))) {
9659                               RExC_parse++;
9660                               n--;
9661                          }
9662                     }
9663
9664                     /* Add the property name to the list.  If /i matching, give
9665                      * a different name which consists of the normal name
9666                      * sandwiched between two underscores and '_i'.  The design
9667                      * is discussed in the commit message for this. */
9668                     Perl_sv_catpvf(aTHX_ listsv, "%cutf8::%s%.*s%s\n",
9669                                         (value=='p' ? '+' : '!'),
9670                                         (FOLD) ? "__" : "",
9671                                         (int)n,
9672                                         RExC_parse,
9673                                         (FOLD) ? "_i" : ""
9674                                     );
9675                 }
9676                 RExC_parse = e + 1;
9677
9678                 /* The \p could match something in the Latin1 range, hence
9679                  * something that isn't utf8 */
9680                 ANYOF_FLAGS(ret) |= ANYOF_NONBITMAP_NON_UTF8;
9681                 namedclass = ANYOF_MAX;  /* no official name, but it's named */
9682
9683                 /* \p means they want Unicode semantics */
9684                 RExC_uni_semantics = 1;
9685                 }
9686                 break;
9687             case 'n':   value = '\n';                   break;
9688             case 'r':   value = '\r';                   break;
9689             case 't':   value = '\t';                   break;
9690             case 'f':   value = '\f';                   break;
9691             case 'b':   value = '\b';                   break;
9692             case 'e':   value = ASCII_TO_NATIVE('\033');break;
9693             case 'a':   value = ASCII_TO_NATIVE('\007');break;
9694             case 'o':
9695                 RExC_parse--;   /* function expects to be pointed at the 'o' */
9696                 {
9697                     const char* error_msg;
9698                     bool valid = grok_bslash_o(RExC_parse,
9699                                                &value,
9700                                                &numlen,
9701                                                &error_msg,
9702                                                SIZE_ONLY);
9703                     RExC_parse += numlen;
9704                     if (! valid) {
9705                         vFAIL(error_msg);
9706                     }
9707                 }
9708                 if (PL_encoding && value < 0x100) {
9709                     goto recode_encoding;
9710                 }
9711                 break;
9712             case 'x':
9713                 if (*RExC_parse == '{') {
9714                     I32 flags = PERL_SCAN_ALLOW_UNDERSCORES
9715                         | PERL_SCAN_DISALLOW_PREFIX;
9716                     char * const e = strchr(RExC_parse++, '}');
9717                     if (!e)
9718                         vFAIL("Missing right brace on \\x{}");
9719
9720                     numlen = e - RExC_parse;
9721                     value = grok_hex(RExC_parse, &numlen, &flags, NULL);
9722                     RExC_parse = e + 1;
9723                 }
9724                 else {
9725                     I32 flags = PERL_SCAN_DISALLOW_PREFIX;
9726                     numlen = 2;
9727                     value = grok_hex(RExC_parse, &numlen, &flags, NULL);
9728                     RExC_parse += numlen;
9729                 }
9730                 if (PL_encoding && value < 0x100)
9731                     goto recode_encoding;
9732                 break;
9733             case 'c':
9734                 value = grok_bslash_c(*RExC_parse++, UTF, SIZE_ONLY);
9735                 break;
9736             case '0': case '1': case '2': case '3': case '4':
9737             case '5': case '6': case '7':
9738                 {
9739                     /* Take 1-3 octal digits */
9740                     I32 flags = PERL_SCAN_SILENT_ILLDIGIT;
9741                     numlen = 3;
9742                     value = grok_oct(--RExC_parse, &numlen, &flags, NULL);
9743                     RExC_parse += numlen;
9744                     if (PL_encoding && value < 0x100)
9745                         goto recode_encoding;
9746                     break;
9747                 }
9748             recode_encoding:
9749                 if (! RExC_override_recoding) {
9750                     SV* enc = PL_encoding;
9751                     value = reg_recode((const char)(U8)value, &enc);
9752                     if (!enc && SIZE_ONLY)
9753                         ckWARNreg(RExC_parse,
9754                                   "Invalid escape in the specified encoding");
9755                     break;
9756                 }
9757             default:
9758                 /* Allow \_ to not give an error */
9759                 if (!SIZE_ONLY && isALNUM(value) && value != '_') {
9760                     ckWARN2reg(RExC_parse,
9761                                "Unrecognized escape \\%c in character class passed through",
9762                                (int)value);
9763                 }
9764                 break;
9765             }
9766         } /* end of \blah */
9767 #ifdef EBCDIC
9768         else
9769             literal_endpoint++;
9770 #endif
9771
9772         if (namedclass > OOB_NAMEDCLASS) { /* this is a named class \blah */
9773
9774             /* What matches in a locale is not known until runtime, so need to
9775              * (one time per class) allocate extra space to pass to regexec.
9776              * The space will contain a bit for each named class that is to be
9777              * matched against.  This isn't needed for \p{} and pseudo-classes,
9778              * as they are not affected by locale, and hence are dealt with
9779              * separately */
9780             if (LOC && namedclass < ANYOF_MAX && ! need_class) {
9781                 need_class = 1;
9782                 if (SIZE_ONLY) {
9783                     RExC_size += ANYOF_CLASS_SKIP - ANYOF_SKIP;
9784                 }
9785                 else {
9786                     RExC_emit += ANYOF_CLASS_SKIP - ANYOF_SKIP;
9787                     ANYOF_CLASS_ZERO(ret);
9788                 }
9789                 ANYOF_FLAGS(ret) |= ANYOF_CLASS;
9790             }
9791
9792             /* a bad range like a-\d, a-[:digit:].  The '-' is taken as a
9793              * literal, as is the character that began the false range, i.e.
9794              * the 'a' in the examples */
9795             if (range) {
9796                 if (!SIZE_ONLY) {
9797                     const int w =
9798                         RExC_parse >= rangebegin ?
9799                         RExC_parse - rangebegin : 0;
9800                     ckWARN4reg(RExC_parse,
9801                                "False [] range \"%*.*s\"",
9802                                w, w, rangebegin);
9803
9804                     stored +=
9805                          set_regclass_bit(pRExC_state, ret, '-', &l1_fold_invlist, &unicode_alternate);
9806                     if (prevvalue < 256) {
9807                         stored +=
9808                          set_regclass_bit(pRExC_state, ret, (U8) prevvalue, &l1_fold_invlist, &unicode_alternate);
9809                     }
9810                     else {
9811                         nonbitmap = add_cp_to_invlist(nonbitmap, prevvalue);
9812                     }
9813                 }
9814
9815                 range = 0; /* this was not a true range */
9816             }
9817
9818
9819     
9820             if (!SIZE_ONLY) {
9821                 const char *what = NULL;
9822                 char yesno = 0;
9823
9824                 /* Possible truncation here but in some 64-bit environments
9825                  * the compiler gets heartburn about switch on 64-bit values.
9826                  * A similar issue a little earlier when switching on value.
9827                  * --jhi */
9828                 switch ((I32)namedclass) {
9829                 
9830                 case _C_C_T_(ALNUMC, isALNUMC_L1, isALNUMC, "XPosixAlnum");
9831                 case _C_C_T_(ALPHA, isALPHA_L1, isALPHA, "XPosixAlpha");
9832                 case _C_C_T_(BLANK, isBLANK_L1, isBLANK, "XPosixBlank");
9833                 case _C_C_T_(CNTRL, isCNTRL_L1, isCNTRL, "XPosixCntrl");
9834                 case _C_C_T_(GRAPH, isGRAPH_L1, isGRAPH, "XPosixGraph");
9835                 case _C_C_T_(LOWER, isLOWER_L1, isLOWER, "XPosixLower");
9836                 case _C_C_T_(PRINT, isPRINT_L1, isPRINT, "XPosixPrint");
9837                 case _C_C_T_(PSXSPC, isPSXSPC_L1, isPSXSPC, "XPosixSpace");
9838                 case _C_C_T_(PUNCT, isPUNCT_L1, isPUNCT, "XPosixPunct");
9839                 case _C_C_T_(UPPER, isUPPER_L1, isUPPER, "XPosixUpper");
9840                 /* \s, \w match all unicode if utf8. */
9841                 case _C_C_T_(SPACE, isSPACE_L1, isSPACE, "SpacePerl");
9842                 case _C_C_T_(ALNUM, isWORDCHAR_L1, isALNUM, "Word");
9843                 case _C_C_T_(XDIGIT, isXDIGIT_L1, isXDIGIT, "XPosixXDigit");
9844                 case _C_C_T_NOLOC_(VERTWS, is_VERTWS_latin1(&value), "VertSpace");
9845                 case _C_C_T_NOLOC_(HORIZWS, is_HORIZWS_latin1(&value), "HorizSpace");
9846                 case ANYOF_ASCII:
9847                     if (LOC)
9848                         ANYOF_CLASS_SET(ret, ANYOF_ASCII);
9849                     else {
9850                         for (value = 0; value < 128; value++)
9851                             stored +=
9852                               set_regclass_bit(pRExC_state, ret, (U8) ASCII_TO_NATIVE(value), &l1_fold_invlist, &unicode_alternate);
9853                     }
9854                     yesno = '+';
9855                     what = NULL;        /* Doesn't match outside ascii, so
9856                                            don't want to add +utf8:: */
9857                     break;
9858                 case ANYOF_NASCII:
9859                     if (LOC)
9860                         ANYOF_CLASS_SET(ret, ANYOF_NASCII);
9861                     else {
9862                         for (value = 128; value < 256; value++)
9863                             stored +=
9864                               set_regclass_bit(pRExC_state, ret, (U8) ASCII_TO_NATIVE(value), &l1_fold_invlist, &unicode_alternate);
9865                     }
9866                     ANYOF_FLAGS(ret) |= ANYOF_UNICODE_ALL;
9867                     yesno = '!';
9868                     what = "ASCII";
9869                     break;              
9870                 case ANYOF_DIGIT:
9871                     if (LOC)
9872                         ANYOF_CLASS_SET(ret, ANYOF_DIGIT);
9873                     else {
9874                         /* consecutive digits assumed */
9875                         for (value = '0'; value <= '9'; value++)
9876                             stored +=
9877                               set_regclass_bit(pRExC_state, ret, (U8) value, &l1_fold_invlist, &unicode_alternate);
9878                     }
9879                     yesno = '+';
9880                     what = "Digit";
9881                     break;
9882                 case ANYOF_NDIGIT:
9883                     if (LOC)
9884                         ANYOF_CLASS_SET(ret, ANYOF_NDIGIT);
9885                     else {
9886                         /* consecutive digits assumed */
9887                         for (value = 0; value < '0'; value++)
9888                             stored +=
9889                               set_regclass_bit(pRExC_state, ret, (U8) value, &l1_fold_invlist, &unicode_alternate);
9890                         for (value = '9' + 1; value < 256; value++)
9891                             stored +=
9892                               set_regclass_bit(pRExC_state, ret, (U8) value, &l1_fold_invlist, &unicode_alternate);
9893                     }
9894                     yesno = '!';
9895                     what = "Digit";
9896                     if (AT_LEAST_ASCII_RESTRICTED ) {
9897                         ANYOF_FLAGS(ret) |= ANYOF_UNICODE_ALL;
9898                     }
9899                     break;              
9900                 case ANYOF_MAX:
9901                     /* this is to handle \p and \P */
9902                     break;
9903                 default:
9904                     vFAIL("Invalid [::] class");
9905                     break;
9906                 }
9907                 if (what && ! (AT_LEAST_ASCII_RESTRICTED)) {
9908                     /* Strings such as "+utf8::isWord\n" */
9909                     Perl_sv_catpvf(aTHX_ listsv, "%cutf8::Is%s\n", yesno, what);
9910                 }
9911
9912                 continue;
9913             }
9914         } /* end of namedclass \blah */
9915
9916         if (range) {
9917             if (prevvalue > (IV)value) /* b-a */ {
9918                 const int w = RExC_parse - rangebegin;
9919                 Simple_vFAIL4("Invalid [] range \"%*.*s\"", w, w, rangebegin);
9920                 range = 0; /* not a valid range */
9921             }
9922         }
9923         else {
9924             prevvalue = value; /* save the beginning of the range */
9925             if (RExC_parse+1 < RExC_end
9926                 && *RExC_parse == '-'
9927                 && RExC_parse[1] != ']')
9928             {
9929                 RExC_parse++;
9930
9931                 /* a bad range like \w-, [:word:]- ? */
9932                 if (namedclass > OOB_NAMEDCLASS) {
9933                     if (ckWARN(WARN_REGEXP)) {
9934                         const int w =
9935                             RExC_parse >= rangebegin ?
9936                             RExC_parse - rangebegin : 0;
9937                         vWARN4(RExC_parse,
9938                                "False [] range \"%*.*s\"",
9939                                w, w, rangebegin);
9940                     }
9941                     if (!SIZE_ONLY)
9942                         stored +=
9943                             set_regclass_bit(pRExC_state, ret, '-', &l1_fold_invlist, &unicode_alternate);
9944                 } else
9945                     range = 1;  /* yeah, it's a range! */
9946                 continue;       /* but do it the next time */
9947             }
9948         }
9949
9950         /* non-Latin1 code point implies unicode semantics.  Must be set in
9951          * pass1 so is there for the whole of pass 2 */
9952         if (value > 255) {
9953             RExC_uni_semantics = 1;
9954         }
9955
9956         /* now is the next time */
9957         if (!SIZE_ONLY) {
9958             if (prevvalue < 256) {
9959                 const IV ceilvalue = value < 256 ? value : 255;
9960                 IV i;
9961 #ifdef EBCDIC
9962                 /* In EBCDIC [\x89-\x91] should include
9963                  * the \x8e but [i-j] should not. */
9964                 if (literal_endpoint == 2 &&
9965                     ((isLOWER(prevvalue) && isLOWER(ceilvalue)) ||
9966                      (isUPPER(prevvalue) && isUPPER(ceilvalue))))
9967                 {
9968                     if (isLOWER(prevvalue)) {
9969                         for (i = prevvalue; i <= ceilvalue; i++)
9970                             if (isLOWER(i) && !ANYOF_BITMAP_TEST(ret,i)) {
9971                                 stored +=
9972                                   set_regclass_bit(pRExC_state, ret, (U8) i, &l1_fold_invlist, &unicode_alternate);
9973                             }
9974                     } else {
9975                         for (i = prevvalue; i <= ceilvalue; i++)
9976                             if (isUPPER(i) && !ANYOF_BITMAP_TEST(ret,i)) {
9977                                 stored +=
9978                                   set_regclass_bit(pRExC_state, ret, (U8) i, &l1_fold_invlist, &unicode_alternate);
9979                             }
9980                     }
9981                 }
9982                 else
9983 #endif
9984                       for (i = prevvalue; i <= ceilvalue; i++) {
9985                         stored += set_regclass_bit(pRExC_state, ret, (U8) i, &l1_fold_invlist, &unicode_alternate);
9986                       }
9987           }
9988           if (value > 255) {
9989             const UV prevnatvalue  = NATIVE_TO_UNI(prevvalue);
9990             const UV natvalue      = NATIVE_TO_UNI(value);
9991             nonbitmap = add_range_to_invlist(nonbitmap, prevnatvalue, natvalue);
9992         }
9993 #ifdef EBCDIC
9994             literal_endpoint = 0;
9995 #endif
9996         }
9997
9998         range = 0; /* this range (if it was one) is done now */
9999     }
10000
10001
10002
10003     if (SIZE_ONLY)
10004         return ret;
10005     /****** !SIZE_ONLY AFTER HERE *********/
10006
10007     /* If folding and there are code points above 255, we calculate all
10008      * characters that could fold to or from the ones already on the list */
10009     if (FOLD && nonbitmap) {
10010         UV i;
10011
10012         HV* fold_intersection;
10013         UV* fold_list;
10014
10015         /* This is a list of all the characters that participate in folds
10016             * (except marks, etc in multi-char folds */
10017         if (! PL_utf8_foldable) {
10018             SV* swash = swash_init("utf8", "Cased", &PL_sv_undef, 1, 0);
10019             PL_utf8_foldable = _swash_to_invlist(swash);
10020         }
10021
10022         /* This is a hash that for a particular fold gives all characters
10023             * that are involved in it */
10024         if (! PL_utf8_foldclosures) {
10025
10026             /* If we were unable to find any folds, then we likely won't be
10027              * able to find the closures.  So just create an empty list.
10028              * Folding will effectively be restricted to the non-Unicode rules
10029              * hard-coded into Perl.  (This case happens legitimately during
10030              * compilation of Perl itself before the Unicode tables are
10031              * generated) */
10032             if (invlist_len(PL_utf8_foldable) == 0) {
10033                 PL_utf8_foldclosures = _new_invlist(0);
10034             } else {
10035                 /* If the folds haven't been read in, call a fold function
10036                     * to force that */
10037                 if (! PL_utf8_tofold) {
10038                     U8 dummy[UTF8_MAXBYTES+1];
10039                     STRLEN dummy_len;
10040                     to_utf8_fold((U8*) "A", dummy, &dummy_len);
10041                 }
10042                 PL_utf8_foldclosures = _swash_inversion_hash(PL_utf8_tofold);
10043             }
10044         }
10045
10046         /* Only the characters in this class that participate in folds need
10047             * be checked.  Get the intersection of this class and all the
10048             * possible characters that are foldable.  This can quickly narrow
10049             * down a large class */
10050         fold_intersection = invlist_intersection(PL_utf8_foldable, nonbitmap);
10051
10052         /* Now look at the foldable characters in this class individually */
10053         fold_list = invlist_array(fold_intersection);
10054         for (i = 0; i < invlist_len(fold_intersection); i++) {
10055             UV j;
10056
10057             /* The next entry is the beginning of the range that is in the
10058              * class */
10059             UV start = fold_list[i++];
10060
10061
10062             /* The next entry is the beginning of the next range, which
10063                 * isn't in the class, so the end of the current range is one
10064                 * less than that */
10065             UV end = fold_list[i] - 1;
10066
10067             /* Look at every character in the range */
10068             for (j = start; j <= end; j++) {
10069
10070                 /* Get its fold */
10071                 U8 foldbuf[UTF8_MAXBYTES_CASE+1];
10072                 STRLEN foldlen;
10073                 const UV f =
10074                     _to_uni_fold_flags(j, foldbuf, &foldlen, allow_full_fold);
10075
10076                 if (foldlen > (STRLEN)UNISKIP(f)) {
10077
10078                     /* Any multicharacter foldings (disallowed in
10079                         * lookbehind patterns) require the following
10080                         * transform: [ABCDEF] -> (?:[ABCabcDEFd]|pq|rst) where
10081                         * E folds into "pq" and F folds into "rst", all other
10082                         * characters fold to single characters.  We save away
10083                         * these multicharacter foldings, to be later saved as
10084                         * part of the additional "s" data. */
10085                     if (! RExC_in_lookbehind) {
10086                         U8* loc = foldbuf;
10087                         U8* e = foldbuf + foldlen;
10088
10089                         /* If any of the folded characters of this are in
10090                             * the Latin1 range, tell the regex engine that
10091                             * this can match a non-utf8 target string.  The
10092                             * only multi-byte fold whose source is in the
10093                             * Latin1 range (U+00DF) applies only when the
10094                             * target string is utf8, or under unicode rules */
10095                         if (j > 255 || AT_LEAST_UNI_SEMANTICS) {
10096                             while (loc < e) {
10097
10098                                 /* Can't mix ascii with non- under /aa */
10099                                 if (MORE_ASCII_RESTRICTED
10100                                     && (isASCII(*loc) != isASCII(j)))
10101                                 {
10102                                     goto end_multi_fold;
10103                                 }
10104                                 if (UTF8_IS_INVARIANT(*loc)
10105                                     || UTF8_IS_DOWNGRADEABLE_START(*loc))
10106                                 {
10107                                     /* Can't mix above and below 256 under
10108                                         * LOC */
10109                                     if (LOC) {
10110                                         goto end_multi_fold;
10111                                     }
10112                                     ANYOF_FLAGS(ret)
10113                                             |= ANYOF_NONBITMAP_NON_UTF8;
10114                                     break;
10115                                 }
10116                                 loc += UTF8SKIP(loc);
10117                             }
10118                         }
10119
10120                         add_alternate(&unicode_alternate, foldbuf, foldlen);
10121                     end_multi_fold: ;
10122                     }
10123
10124                     /* This is special-cased, as it is the only letter which
10125                      * has both a multi-fold and single-fold in Latin1.  All
10126                      * the other chars that have single and multi-folds are
10127                      * always in utf8, and the utf8 folding algorithm catches
10128                      * them */
10129                     if (! LOC && j == LATIN_CAPITAL_LETTER_SHARP_S) {
10130                         stored += set_regclass_bit(pRExC_state,
10131                                         ret,
10132                                         LATIN_SMALL_LETTER_SHARP_S,
10133                                         &l1_fold_invlist, &unicode_alternate);
10134                     }
10135                 }
10136                 else {
10137                     /* Single character fold.  Add everything in its fold
10138                         * closure to the list that this node should match */
10139                     SV** listp;
10140
10141                     /* The fold closures data structure is a hash with the
10142                         * keys being every character that is folded to, like
10143                         * 'k', and the values each an array of everything that
10144                         * folds to its key.  e.g. [ 'k', 'K', KELVIN_SIGN ] */
10145                     if ((listp = hv_fetch(PL_utf8_foldclosures,
10146                                     (char *) foldbuf, foldlen, FALSE)))
10147                     {
10148                         AV* list = (AV*) *listp;
10149                         IV k;
10150                         for (k = 0; k <= av_len(list); k++) {
10151                             SV** c_p = av_fetch(list, k, FALSE);
10152                             UV c;
10153                             if (c_p == NULL) {
10154                                 Perl_croak(aTHX_ "panic: invalid PL_utf8_foldclosures structure");
10155                             }
10156                             c = SvUV(*c_p);
10157
10158                             /* /aa doesn't allow folds between ASCII and
10159                                 * non-; /l doesn't allow them between above
10160                                 * and below 256 */
10161                             if ((MORE_ASCII_RESTRICTED
10162                                  && (isASCII(c) != isASCII(j)))
10163                                     || (LOC && ((c < 256) != (j < 256))))
10164                             {
10165                                 continue;
10166                             }
10167
10168                             if (c < 256 && AT_LEAST_UNI_SEMANTICS) {
10169                                 stored += set_regclass_bit(pRExC_state,
10170                                         ret,
10171                                         (U8) c,
10172                                         &l1_fold_invlist, &unicode_alternate);
10173                             }
10174                                 /* It may be that the code point is already
10175                                     * in this range or already in the bitmap,
10176                                     * in which case we need do nothing */
10177                             else if ((c < start || c > end)
10178                                         && (c > 255
10179                                             || ! ANYOF_BITMAP_TEST(ret, c)))
10180                             {
10181                                 nonbitmap = add_cp_to_invlist(nonbitmap, c);
10182                             }
10183                         }
10184                     }
10185                 }
10186             }
10187         }
10188         invlist_destroy(fold_intersection);
10189     }
10190
10191     /* Combine the two lists into one. */
10192     if (l1_fold_invlist) {
10193         if (nonbitmap) {
10194             HV* temp = invlist_union(nonbitmap, l1_fold_invlist);
10195             invlist_destroy(nonbitmap);
10196             nonbitmap = temp;
10197             invlist_destroy(l1_fold_invlist);
10198         }
10199         else {
10200             nonbitmap = l1_fold_invlist;
10201         }
10202     }
10203
10204     /* Here, we have calculated what code points should be in the character
10205      * class.   Now we can see about various optimizations.  Fold calculation
10206      * needs to take place before inversion.  Otherwise /[^k]/i would invert to
10207      * include K, which under /i would match k. */
10208
10209     /* Optimize inverted simple patterns (e.g. [^a-z]).  Note that we haven't
10210      * set the FOLD flag yet, so this this does optimize those.  It doesn't
10211      * optimize locale.  Doing so perhaps could be done as long as there is
10212      * nothing like \w in it; some thought also would have to be given to the
10213      * interaction with above 0x100 chars */
10214     if (! LOC
10215         && (ANYOF_FLAGS(ret) & ANYOF_FLAGS_ALL) == ANYOF_INVERT
10216         && ! unicode_alternate
10217         && ! nonbitmap
10218         && SvCUR(listsv) == initial_listsv_len)
10219     {
10220         for (value = 0; value < ANYOF_BITMAP_SIZE; ++value)
10221             ANYOF_BITMAP(ret)[value] ^= 0xFF;
10222         stored = 256 - stored;
10223
10224         /* The inversion means that everything above 255 is matched; and at the
10225          * same time we clear the invert flag */
10226         ANYOF_FLAGS(ret) = ANYOF_UNICODE_ALL;
10227     }
10228
10229     /* Folding in the bitmap is taken care of above, but not for locale (for
10230      * which we have to wait to see what folding is in effect at runtime), and
10231      * for things not in the bitmap.  Set run-time fold flag for these */
10232     if (FOLD && (LOC || nonbitmap || unicode_alternate)) {
10233         ANYOF_FLAGS(ret) |= ANYOF_LOC_NONBITMAP_FOLD;
10234     }
10235
10236     /* A single character class can be "optimized" into an EXACTish node.
10237      * Note that since we don't currently count how many characters there are
10238      * outside the bitmap, we are XXX missing optimization possibilities for
10239      * them.  This optimization can't happen unless this is a truly single
10240      * character class, which means that it can't be an inversion into a
10241      * many-character class, and there must be no possibility of there being
10242      * things outside the bitmap.  'stored' (only) for locales doesn't include
10243      * \w, etc, so have to make a special test that they aren't present
10244      *
10245      * Similarly A 2-character class of the very special form like [bB] can be
10246      * optimized into an EXACTFish node, but only for non-locales, and for
10247      * characters which only have the two folds; so things like 'fF' and 'Ii'
10248      * wouldn't work because they are part of the fold of 'LATIN SMALL LIGATURE
10249      * FI'. */
10250     if (! nonbitmap
10251         && ! unicode_alternate
10252         && SvCUR(listsv) == initial_listsv_len
10253         && ! (ANYOF_FLAGS(ret) & (ANYOF_INVERT|ANYOF_UNICODE_ALL))
10254         && (((stored == 1 && ((! (ANYOF_FLAGS(ret) & ANYOF_LOCALE))
10255                               || (! ANYOF_CLASS_TEST_ANY_SET(ret)))))
10256             || (stored == 2 && ((! (ANYOF_FLAGS(ret) & ANYOF_LOCALE))
10257                                  && (! _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(value))
10258                                  /* If the latest code point has a fold whose
10259                                   * bit is set, it must be the only other one */
10260                                 && ((prevvalue = PL_fold_latin1[value]) != (IV)value)
10261                                  && ANYOF_BITMAP_TEST(ret, prevvalue)))))
10262     {
10263         /* Note that the information needed to decide to do this optimization
10264          * is not currently available until the 2nd pass, and that the actually
10265          * used EXACTish node takes less space than the calculated ANYOF node,
10266          * and hence the amount of space calculated in the first pass is larger
10267          * than actually used, so this optimization doesn't gain us any space.
10268          * But an EXACT node is faster than an ANYOF node, and can be combined
10269          * with any adjacent EXACT nodes later by the optimizer for further
10270          * gains.  The speed of executing an EXACTF is similar to an ANYOF
10271          * node, so the optimization advantage comes from the ability to join
10272          * it to adjacent EXACT nodes */
10273
10274         const char * cur_parse= RExC_parse;
10275         U8 op;
10276         RExC_emit = (regnode *)orig_emit;
10277         RExC_parse = (char *)orig_parse;
10278
10279         if (stored == 1) {
10280
10281             /* A locale node with one point can be folded; all the other cases
10282              * with folding will have two points, since we calculate them above
10283              */
10284             if (ANYOF_FLAGS(ret) & ANYOF_LOC_NONBITMAP_FOLD) {
10285                  op = EXACTFL;
10286             }
10287             else {
10288                 op = EXACT;
10289             }
10290         }   /* else 2 chars in the bit map: the folds of each other */
10291         else if (AT_LEAST_UNI_SEMANTICS || !isASCII(value)) {
10292
10293             /* To join adjacent nodes, they must be the exact EXACTish type.
10294              * Try to use the most likely type, by using EXACTFU if the regex
10295              * calls for them, or is required because the character is
10296              * non-ASCII */
10297             op = EXACTFU;
10298         }
10299         else {    /* Otherwise, more likely to be EXACTF type */
10300             op = EXACTF;
10301         }
10302
10303         ret = reg_node(pRExC_state, op);
10304         RExC_parse = (char *)cur_parse;
10305         if (UTF && ! NATIVE_IS_INVARIANT(value)) {
10306             *STRING(ret)= UTF8_EIGHT_BIT_HI((U8) value);
10307             *(STRING(ret) + 1)= UTF8_EIGHT_BIT_LO((U8) value);
10308             STR_LEN(ret)= 2;
10309             RExC_emit += STR_SZ(2);
10310         }
10311         else {
10312             *STRING(ret)= (char)value;
10313             STR_LEN(ret)= 1;
10314             RExC_emit += STR_SZ(1);
10315         }
10316         SvREFCNT_dec(listsv);
10317         return ret;
10318     }
10319
10320     if (nonbitmap) {
10321         UV* nonbitmap_array = invlist_array(nonbitmap);
10322         UV nonbitmap_len = invlist_len(nonbitmap);
10323         UV i;
10324
10325         /*  Here have the full list of items to match that aren't in the
10326          *  bitmap.  Convert to the structure that the rest of the code is
10327          *  expecting.   XXX That rest of the code should convert to this
10328          *  structure */
10329         for (i = 0; i < nonbitmap_len; i++) {
10330
10331             /* The next entry is the beginning of the range that is in the
10332              * class */
10333             UV start = nonbitmap_array[i++];
10334             UV end;
10335
10336             /* The next entry is the beginning of the next range, which isn't
10337              * in the class, so the end of the current range is one less than
10338              * that.  But if there is no next range, it means that the range
10339              * begun by 'start' extends to infinity, which for this platform
10340              * ends at UV_MAX */
10341             if (i == nonbitmap_len) {
10342                 end = UV_MAX;
10343             }
10344             else {
10345                 end = nonbitmap_array[i] - 1;
10346             }
10347
10348             if (start == end) {
10349                 Perl_sv_catpvf(aTHX_ listsv, "%04"UVxf"\n", start);
10350             }
10351             else {
10352                 /* The \t sets the whole range */
10353                 Perl_sv_catpvf(aTHX_ listsv, "%04"UVxf"\t%04"UVxf"\n",
10354                         /* XXX EBCDIC */
10355                                    start, end);
10356             }
10357         }
10358         invlist_destroy(nonbitmap);
10359     }
10360
10361     if (SvCUR(listsv) == initial_listsv_len && ! unicode_alternate) {
10362         ARG_SET(ret, ANYOF_NONBITMAP_EMPTY);
10363         SvREFCNT_dec(listsv);
10364         SvREFCNT_dec(unicode_alternate);
10365     }
10366     else {
10367
10368         AV * const av = newAV();
10369         SV *rv;
10370         /* The 0th element stores the character class description
10371          * in its textual form: used later (regexec.c:Perl_regclass_swash())
10372          * to initialize the appropriate swash (which gets stored in
10373          * the 1st element), and also useful for dumping the regnode.
10374          * The 2nd element stores the multicharacter foldings,
10375          * used later (regexec.c:S_reginclass()). */
10376         av_store(av, 0, listsv);
10377         av_store(av, 1, NULL);
10378
10379         /* Store any computed multi-char folds only if we are allowing
10380          * them */
10381         if (allow_full_fold) {
10382             av_store(av, 2, MUTABLE_SV(unicode_alternate));
10383             if (unicode_alternate) { /* This node is variable length */
10384                 OP(ret) = ANYOFV;
10385             }
10386         }
10387         else {
10388             av_store(av, 2, NULL);
10389         }
10390         rv = newRV_noinc(MUTABLE_SV(av));
10391         n = add_data(pRExC_state, 1, "s");
10392         RExC_rxi->data->data[n] = (void*)rv;
10393         ARG_SET(ret, n);
10394     }
10395     return ret;
10396 }
10397 #undef _C_C_T_
10398
10399
10400 /* reg_skipcomment()
10401
10402    Absorbs an /x style # comments from the input stream.
10403    Returns true if there is more text remaining in the stream.
10404    Will set the REG_SEEN_RUN_ON_COMMENT flag if the comment
10405    terminates the pattern without including a newline.
10406
10407    Note its the callers responsibility to ensure that we are
10408    actually in /x mode
10409
10410 */
10411
10412 STATIC bool
10413 S_reg_skipcomment(pTHX_ RExC_state_t *pRExC_state)
10414 {
10415     bool ended = 0;
10416
10417     PERL_ARGS_ASSERT_REG_SKIPCOMMENT;
10418
10419     while (RExC_parse < RExC_end)
10420         if (*RExC_parse++ == '\n') {
10421             ended = 1;
10422             break;
10423         }
10424     if (!ended) {
10425         /* we ran off the end of the pattern without ending
10426            the comment, so we have to add an \n when wrapping */
10427         RExC_seen |= REG_SEEN_RUN_ON_COMMENT;
10428         return 0;
10429     } else
10430         return 1;
10431 }
10432
10433 /* nextchar()
10434
10435    Advances the parse position, and optionally absorbs
10436    "whitespace" from the inputstream.
10437
10438    Without /x "whitespace" means (?#...) style comments only,
10439    with /x this means (?#...) and # comments and whitespace proper.
10440
10441    Returns the RExC_parse point from BEFORE the scan occurs.
10442
10443    This is the /x friendly way of saying RExC_parse++.
10444 */
10445
10446 STATIC char*
10447 S_nextchar(pTHX_ RExC_state_t *pRExC_state)
10448 {
10449     char* const retval = RExC_parse++;
10450
10451     PERL_ARGS_ASSERT_NEXTCHAR;
10452
10453     for (;;) {
10454         if (*RExC_parse == '(' && RExC_parse[1] == '?' &&
10455                 RExC_parse[2] == '#') {
10456             while (*RExC_parse != ')') {
10457                 if (RExC_parse == RExC_end)
10458                     FAIL("Sequence (?#... not terminated");
10459                 RExC_parse++;
10460             }
10461             RExC_parse++;
10462             continue;
10463         }
10464         if (RExC_flags & RXf_PMf_EXTENDED) {
10465             if (isSPACE(*RExC_parse)) {
10466                 RExC_parse++;
10467                 continue;
10468             }
10469             else if (*RExC_parse == '#') {
10470                 if ( reg_skipcomment( pRExC_state ) )
10471                     continue;
10472             }
10473         }
10474         return retval;
10475     }
10476 }
10477
10478 /*
10479 - reg_node - emit a node
10480 */
10481 STATIC regnode *                        /* Location. */
10482 S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op)
10483 {
10484     dVAR;
10485     register regnode *ptr;
10486     regnode * const ret = RExC_emit;
10487     GET_RE_DEBUG_FLAGS_DECL;
10488
10489     PERL_ARGS_ASSERT_REG_NODE;
10490
10491     if (SIZE_ONLY) {
10492         SIZE_ALIGN(RExC_size);
10493         RExC_size += 1;
10494         return(ret);
10495     }
10496     if (RExC_emit >= RExC_emit_bound)
10497         Perl_croak(aTHX_ "panic: reg_node overrun trying to emit %d", op);
10498
10499     NODE_ALIGN_FILL(ret);
10500     ptr = ret;
10501     FILL_ADVANCE_NODE(ptr, op);
10502 #ifdef RE_TRACK_PATTERN_OFFSETS
10503     if (RExC_offsets) {         /* MJD */
10504         MJD_OFFSET_DEBUG(("%s:%d: (op %s) %s %"UVuf" (len %"UVuf") (max %"UVuf").\n", 
10505               "reg_node", __LINE__, 
10506               PL_reg_name[op],
10507               (UV)(RExC_emit - RExC_emit_start) > RExC_offsets[0] 
10508                 ? "Overwriting end of array!\n" : "OK",
10509               (UV)(RExC_emit - RExC_emit_start),
10510               (UV)(RExC_parse - RExC_start),
10511               (UV)RExC_offsets[0])); 
10512         Set_Node_Offset(RExC_emit, RExC_parse + (op == END));
10513     }
10514 #endif
10515     RExC_emit = ptr;
10516     return(ret);
10517 }
10518
10519 /*
10520 - reganode - emit a node with an argument
10521 */
10522 STATIC regnode *                        /* Location. */
10523 S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)
10524 {
10525     dVAR;
10526     register regnode *ptr;
10527     regnode * const ret = RExC_emit;
10528     GET_RE_DEBUG_FLAGS_DECL;
10529
10530     PERL_ARGS_ASSERT_REGANODE;
10531
10532     if (SIZE_ONLY) {
10533         SIZE_ALIGN(RExC_size);
10534         RExC_size += 2;
10535         /* 
10536            We can't do this:
10537            
10538            assert(2==regarglen[op]+1); 
10539         
10540            Anything larger than this has to allocate the extra amount.
10541            If we changed this to be:
10542            
10543            RExC_size += (1 + regarglen[op]);
10544            
10545            then it wouldn't matter. Its not clear what side effect
10546            might come from that so its not done so far.
10547            -- dmq
10548         */
10549         return(ret);
10550     }
10551     if (RExC_emit >= RExC_emit_bound)
10552         Perl_croak(aTHX_ "panic: reg_node overrun trying to emit %d", op);
10553
10554     NODE_ALIGN_FILL(ret);
10555     ptr = ret;
10556     FILL_ADVANCE_NODE_ARG(ptr, op, arg);
10557 #ifdef RE_TRACK_PATTERN_OFFSETS
10558     if (RExC_offsets) {         /* MJD */
10559         MJD_OFFSET_DEBUG(("%s(%d): (op %s) %s %"UVuf" <- %"UVuf" (max %"UVuf").\n", 
10560               "reganode",
10561               __LINE__,
10562               PL_reg_name[op],
10563               (UV)(RExC_emit - RExC_emit_start) > RExC_offsets[0] ? 
10564               "Overwriting end of array!\n" : "OK",
10565               (UV)(RExC_emit - RExC_emit_start),
10566               (UV)(RExC_parse - RExC_start),
10567               (UV)RExC_offsets[0])); 
10568         Set_Cur_Node_Offset;
10569     }
10570 #endif            
10571     RExC_emit = ptr;
10572     return(ret);
10573 }
10574
10575 /*
10576 - reguni - emit (if appropriate) a Unicode character
10577 */
10578 STATIC STRLEN
10579 S_reguni(pTHX_ const RExC_state_t *pRExC_state, UV uv, char* s)
10580 {
10581     dVAR;
10582
10583     PERL_ARGS_ASSERT_REGUNI;
10584
10585     return SIZE_ONLY ? UNISKIP(uv) : (uvchr_to_utf8((U8*)s, uv) - (U8*)s);
10586 }
10587
10588 /*
10589 - reginsert - insert an operator in front of already-emitted operand
10590 *
10591 * Means relocating the operand.
10592 */
10593 STATIC void
10594 S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth)
10595 {
10596     dVAR;
10597     register regnode *src;
10598     register regnode *dst;
10599     register regnode *place;
10600     const int offset = regarglen[(U8)op];
10601     const int size = NODE_STEP_REGNODE + offset;
10602     GET_RE_DEBUG_FLAGS_DECL;
10603
10604     PERL_ARGS_ASSERT_REGINSERT;
10605     PERL_UNUSED_ARG(depth);
10606 /* (PL_regkind[(U8)op] == CURLY ? EXTRA_STEP_2ARGS : 0); */
10607     DEBUG_PARSE_FMT("inst"," - %s",PL_reg_name[op]);
10608     if (SIZE_ONLY) {
10609         RExC_size += size;
10610         return;
10611     }
10612
10613     src = RExC_emit;
10614     RExC_emit += size;
10615     dst = RExC_emit;
10616     if (RExC_open_parens) {
10617         int paren;
10618         /*DEBUG_PARSE_FMT("inst"," - %"IVdf, (IV)RExC_npar);*/
10619         for ( paren=0 ; paren < RExC_npar ; paren++ ) {
10620             if ( RExC_open_parens[paren] >= opnd ) {
10621                 /*DEBUG_PARSE_FMT("open"," - %d",size);*/
10622                 RExC_open_parens[paren] += size;
10623             } else {
10624                 /*DEBUG_PARSE_FMT("open"," - %s","ok");*/
10625             }
10626             if ( RExC_close_parens[paren] >= opnd ) {
10627                 /*DEBUG_PARSE_FMT("close"," - %d",size);*/
10628                 RExC_close_parens[paren] += size;
10629             } else {
10630                 /*DEBUG_PARSE_FMT("close"," - %s","ok");*/
10631             }
10632         }
10633     }
10634
10635     while (src > opnd) {
10636         StructCopy(--src, --dst, regnode);
10637 #ifdef RE_TRACK_PATTERN_OFFSETS
10638         if (RExC_offsets) {     /* MJD 20010112 */
10639             MJD_OFFSET_DEBUG(("%s(%d): (op %s) %s copy %"UVuf" -> %"UVuf" (max %"UVuf").\n",
10640                   "reg_insert",
10641                   __LINE__,
10642                   PL_reg_name[op],
10643                   (UV)(dst - RExC_emit_start) > RExC_offsets[0] 
10644                     ? "Overwriting end of array!\n" : "OK",
10645                   (UV)(src - RExC_emit_start),
10646                   (UV)(dst - RExC_emit_start),
10647                   (UV)RExC_offsets[0])); 
10648             Set_Node_Offset_To_R(dst-RExC_emit_start, Node_Offset(src));
10649             Set_Node_Length_To_R(dst-RExC_emit_start, Node_Length(src));
10650         }
10651 #endif
10652     }
10653     
10654
10655     place = opnd;               /* Op node, where operand used to be. */
10656 #ifdef RE_TRACK_PATTERN_OFFSETS
10657     if (RExC_offsets) {         /* MJD */
10658         MJD_OFFSET_DEBUG(("%s(%d): (op %s) %s %"UVuf" <- %"UVuf" (max %"UVuf").\n", 
10659               "reginsert",
10660               __LINE__,
10661               PL_reg_name[op],
10662               (UV)(place - RExC_emit_start) > RExC_offsets[0] 
10663               ? "Overwriting end of array!\n" : "OK",
10664               (UV)(place - RExC_emit_start),
10665               (UV)(RExC_parse - RExC_start),
10666               (UV)RExC_offsets[0]));
10667         Set_Node_Offset(place, RExC_parse);
10668         Set_Node_Length(place, 1);
10669     }
10670 #endif    
10671     src = NEXTOPER(place);
10672     FILL_ADVANCE_NODE(place, op);
10673     Zero(src, offset, regnode);
10674 }
10675
10676 /*
10677 - regtail - set the next-pointer at the end of a node chain of p to val.
10678 - SEE ALSO: regtail_study
10679 */
10680 /* TODO: All three parms should be const */
10681 STATIC void
10682 S_regtail(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val,U32 depth)
10683 {
10684     dVAR;
10685     register regnode *scan;
10686     GET_RE_DEBUG_FLAGS_DECL;
10687
10688     PERL_ARGS_ASSERT_REGTAIL;
10689 #ifndef DEBUGGING
10690     PERL_UNUSED_ARG(depth);
10691 #endif
10692
10693     if (SIZE_ONLY)
10694         return;
10695
10696     /* Find last node. */
10697     scan = p;
10698     for (;;) {
10699         regnode * const temp = regnext(scan);
10700         DEBUG_PARSE_r({
10701             SV * const mysv=sv_newmortal();
10702             DEBUG_PARSE_MSG((scan==p ? "tail" : ""));
10703             regprop(RExC_rx, mysv, scan);
10704             PerlIO_printf(Perl_debug_log, "~ %s (%d) %s %s\n",
10705                 SvPV_nolen_const(mysv), REG_NODE_NUM(scan),
10706                     (temp == NULL ? "->" : ""),
10707                     (temp == NULL ? PL_reg_name[OP(val)] : "")
10708             );
10709         });
10710         if (temp == NULL)
10711             break;
10712         scan = temp;
10713     }
10714
10715     if (reg_off_by_arg[OP(scan)]) {
10716         ARG_SET(scan, val - scan);
10717     }
10718     else {
10719         NEXT_OFF(scan) = val - scan;
10720     }
10721 }
10722
10723 #ifdef DEBUGGING
10724 /*
10725 - regtail_study - set the next-pointer at the end of a node chain of p to val.
10726 - Look for optimizable sequences at the same time.
10727 - currently only looks for EXACT chains.
10728
10729 This is experimental code. The idea is to use this routine to perform 
10730 in place optimizations on branches and groups as they are constructed,
10731 with the long term intention of removing optimization from study_chunk so
10732 that it is purely analytical.
10733
10734 Currently only used when in DEBUG mode. The macro REGTAIL_STUDY() is used
10735 to control which is which.
10736
10737 */
10738 /* TODO: All four parms should be const */
10739
10740 STATIC U8
10741 S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val,U32 depth)
10742 {
10743     dVAR;
10744     register regnode *scan;
10745     U8 exact = PSEUDO;
10746 #ifdef EXPERIMENTAL_INPLACESCAN
10747     I32 min = 0;
10748 #endif
10749     GET_RE_DEBUG_FLAGS_DECL;
10750
10751     PERL_ARGS_ASSERT_REGTAIL_STUDY;
10752
10753
10754     if (SIZE_ONLY)
10755         return exact;
10756
10757     /* Find last node. */
10758
10759     scan = p;
10760     for (;;) {
10761         regnode * const temp = regnext(scan);
10762 #ifdef EXPERIMENTAL_INPLACESCAN
10763         if (PL_regkind[OP(scan)] == EXACT)
10764             if (join_exact(pRExC_state,scan,&min,1,val,depth+1))
10765                 return EXACT;
10766 #endif
10767         if ( exact ) {
10768             switch (OP(scan)) {
10769                 case EXACT:
10770                 case EXACTF:
10771                 case EXACTFA:
10772                 case EXACTFU:
10773                 case EXACTFL:
10774                         if( exact == PSEUDO )
10775                             exact= OP(scan);
10776                         else if ( exact != OP(scan) )
10777                             exact= 0;
10778                 case NOTHING:
10779                     break;
10780                 default:
10781                     exact= 0;
10782             }
10783         }
10784         DEBUG_PARSE_r({
10785             SV * const mysv=sv_newmortal();
10786             DEBUG_PARSE_MSG((scan==p ? "tsdy" : ""));
10787             regprop(RExC_rx, mysv, scan);
10788             PerlIO_printf(Perl_debug_log, "~ %s (%d) -> %s\n",
10789                 SvPV_nolen_const(mysv),
10790                 REG_NODE_NUM(scan),
10791                 PL_reg_name[exact]);
10792         });
10793         if (temp == NULL)
10794             break;
10795         scan = temp;
10796     }
10797     DEBUG_PARSE_r({
10798         SV * const mysv_val=sv_newmortal();
10799         DEBUG_PARSE_MSG("");
10800         regprop(RExC_rx, mysv_val, val);
10801         PerlIO_printf(Perl_debug_log, "~ attach to %s (%"IVdf") offset to %"IVdf"\n",
10802                       SvPV_nolen_const(mysv_val),
10803                       (IV)REG_NODE_NUM(val),
10804                       (IV)(val - scan)
10805         );
10806     });
10807     if (reg_off_by_arg[OP(scan)]) {
10808         ARG_SET(scan, val - scan);
10809     }
10810     else {
10811         NEXT_OFF(scan) = val - scan;
10812     }
10813
10814     return exact;
10815 }
10816 #endif
10817
10818 /*
10819  - regdump - dump a regexp onto Perl_debug_log in vaguely comprehensible form
10820  */
10821 #ifdef DEBUGGING
10822 static void 
10823 S_regdump_extflags(pTHX_ const char *lead, const U32 flags)
10824 {
10825     int bit;
10826     int set=0;
10827     regex_charset cs;
10828
10829     for (bit=0; bit<32; bit++) {
10830         if (flags & (1<<bit)) {
10831             if ((1<<bit) & RXf_PMf_CHARSET) {   /* Output separately, below */
10832                 continue;
10833             }
10834             if (!set++ && lead) 
10835                 PerlIO_printf(Perl_debug_log, "%s",lead);
10836             PerlIO_printf(Perl_debug_log, "%s ",PL_reg_extflags_name[bit]);
10837         }               
10838     }      
10839     if ((cs = get_regex_charset(flags)) != REGEX_DEPENDS_CHARSET) {
10840             if (!set++ && lead) {
10841                 PerlIO_printf(Perl_debug_log, "%s",lead);
10842             }
10843             switch (cs) {
10844                 case REGEX_UNICODE_CHARSET:
10845                     PerlIO_printf(Perl_debug_log, "UNICODE");
10846                     break;
10847                 case REGEX_LOCALE_CHARSET:
10848                     PerlIO_printf(Perl_debug_log, "LOCALE");
10849                     break;
10850                 case REGEX_ASCII_RESTRICTED_CHARSET:
10851                     PerlIO_printf(Perl_debug_log, "ASCII-RESTRICTED");
10852                     break;
10853                 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
10854                     PerlIO_printf(Perl_debug_log, "ASCII-MORE_RESTRICTED");
10855                     break;
10856                 default:
10857                     PerlIO_printf(Perl_debug_log, "UNKNOWN CHARACTER SET");
10858                     break;
10859             }
10860     }
10861     if (lead)  {
10862         if (set) 
10863             PerlIO_printf(Perl_debug_log, "\n");
10864         else 
10865             PerlIO_printf(Perl_debug_log, "%s[none-set]\n",lead);
10866     }            
10867 }   
10868 #endif
10869
10870 void
10871 Perl_regdump(pTHX_ const regexp *r)
10872 {
10873 #ifdef DEBUGGING
10874     dVAR;
10875     SV * const sv = sv_newmortal();
10876     SV *dsv= sv_newmortal();
10877     RXi_GET_DECL(r,ri);
10878     GET_RE_DEBUG_FLAGS_DECL;
10879
10880     PERL_ARGS_ASSERT_REGDUMP;
10881
10882     (void)dumpuntil(r, ri->program, ri->program + 1, NULL, NULL, sv, 0, 0);
10883
10884     /* Header fields of interest. */
10885     if (r->anchored_substr) {
10886         RE_PV_QUOTED_DECL(s, 0, dsv, SvPVX_const(r->anchored_substr), 
10887             RE_SV_DUMPLEN(r->anchored_substr), 30);
10888         PerlIO_printf(Perl_debug_log,
10889                       "anchored %s%s at %"IVdf" ",
10890                       s, RE_SV_TAIL(r->anchored_substr),
10891                       (IV)r->anchored_offset);
10892     } else if (r->anchored_utf8) {
10893         RE_PV_QUOTED_DECL(s, 1, dsv, SvPVX_const(r->anchored_utf8), 
10894             RE_SV_DUMPLEN(r->anchored_utf8), 30);
10895         PerlIO_printf(Perl_debug_log,
10896                       "anchored utf8 %s%s at %"IVdf" ",
10897                       s, RE_SV_TAIL(r->anchored_utf8),
10898                       (IV)r->anchored_offset);
10899     }                 
10900     if (r->float_substr) {
10901         RE_PV_QUOTED_DECL(s, 0, dsv, SvPVX_const(r->float_substr), 
10902             RE_SV_DUMPLEN(r->float_substr), 30);
10903         PerlIO_printf(Perl_debug_log,
10904                       "floating %s%s at %"IVdf"..%"UVuf" ",
10905                       s, RE_SV_TAIL(r->float_substr),
10906                       (IV)r->float_min_offset, (UV)r->float_max_offset);
10907     } else if (r->float_utf8) {
10908         RE_PV_QUOTED_DECL(s, 1, dsv, SvPVX_const(r->float_utf8), 
10909             RE_SV_DUMPLEN(r->float_utf8), 30);
10910         PerlIO_printf(Perl_debug_log,
10911                       "floating utf8 %s%s at %"IVdf"..%"UVuf" ",
10912                       s, RE_SV_TAIL(r->float_utf8),
10913                       (IV)r->float_min_offset, (UV)r->float_max_offset);
10914     }
10915     if (r->check_substr || r->check_utf8)
10916         PerlIO_printf(Perl_debug_log,
10917                       (const char *)
10918                       (r->check_substr == r->float_substr
10919                        && r->check_utf8 == r->float_utf8
10920                        ? "(checking floating" : "(checking anchored"));
10921     if (r->extflags & RXf_NOSCAN)
10922         PerlIO_printf(Perl_debug_log, " noscan");
10923     if (r->extflags & RXf_CHECK_ALL)
10924         PerlIO_printf(Perl_debug_log, " isall");
10925     if (r->check_substr || r->check_utf8)
10926         PerlIO_printf(Perl_debug_log, ") ");
10927
10928     if (ri->regstclass) {
10929         regprop(r, sv, ri->regstclass);
10930         PerlIO_printf(Perl_debug_log, "stclass %s ", SvPVX_const(sv));
10931     }
10932     if (r->extflags & RXf_ANCH) {
10933         PerlIO_printf(Perl_debug_log, "anchored");
10934         if (r->extflags & RXf_ANCH_BOL)
10935             PerlIO_printf(Perl_debug_log, "(BOL)");
10936         if (r->extflags & RXf_ANCH_MBOL)
10937             PerlIO_printf(Perl_debug_log, "(MBOL)");
10938         if (r->extflags & RXf_ANCH_SBOL)
10939             PerlIO_printf(Perl_debug_log, "(SBOL)");
10940         if (r->extflags & RXf_ANCH_GPOS)
10941             PerlIO_printf(Perl_debug_log, "(GPOS)");
10942         PerlIO_putc(Perl_debug_log, ' ');
10943     }
10944     if (r->extflags & RXf_GPOS_SEEN)
10945         PerlIO_printf(Perl_debug_log, "GPOS:%"UVuf" ", (UV)r->gofs);
10946     if (r->intflags & PREGf_SKIP)
10947         PerlIO_printf(Perl_debug_log, "plus ");
10948     if (r->intflags & PREGf_IMPLICIT)
10949         PerlIO_printf(Perl_debug_log, "implicit ");
10950     PerlIO_printf(Perl_debug_log, "minlen %"IVdf" ", (IV)r->minlen);
10951     if (r->extflags & RXf_EVAL_SEEN)
10952         PerlIO_printf(Perl_debug_log, "with eval ");
10953     PerlIO_printf(Perl_debug_log, "\n");
10954     DEBUG_FLAGS_r(regdump_extflags("r->extflags: ",r->extflags));            
10955 #else
10956     PERL_ARGS_ASSERT_REGDUMP;
10957     PERL_UNUSED_CONTEXT;
10958     PERL_UNUSED_ARG(r);
10959 #endif  /* DEBUGGING */
10960 }
10961
10962 /*
10963 - regprop - printable representation of opcode
10964 */
10965 #define EMIT_ANYOF_TEST_SEPARATOR(do_sep,sv,flags) \
10966 STMT_START { \
10967         if (do_sep) {                           \
10968             Perl_sv_catpvf(aTHX_ sv,"%s][%s",PL_colors[1],PL_colors[0]); \
10969             if (flags & ANYOF_INVERT)           \
10970                 /*make sure the invert info is in each */ \
10971                 sv_catpvs(sv, "^");             \
10972             do_sep = 0;                         \
10973         }                                       \
10974 } STMT_END
10975
10976 void
10977 Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o)
10978 {
10979 #ifdef DEBUGGING
10980     dVAR;
10981     register int k;
10982     RXi_GET_DECL(prog,progi);
10983     GET_RE_DEBUG_FLAGS_DECL;
10984     
10985     PERL_ARGS_ASSERT_REGPROP;
10986
10987     sv_setpvs(sv, "");
10988
10989     if (OP(o) > REGNODE_MAX)            /* regnode.type is unsigned */
10990         /* It would be nice to FAIL() here, but this may be called from
10991            regexec.c, and it would be hard to supply pRExC_state. */
10992         Perl_croak(aTHX_ "Corrupted regexp opcode %d > %d", (int)OP(o), (int)REGNODE_MAX);
10993     sv_catpv(sv, PL_reg_name[OP(o)]); /* Take off const! */
10994
10995     k = PL_regkind[OP(o)];
10996
10997     if (k == EXACT) {
10998         sv_catpvs(sv, " ");
10999         /* Using is_utf8_string() (via PERL_PV_UNI_DETECT) 
11000          * is a crude hack but it may be the best for now since 
11001          * we have no flag "this EXACTish node was UTF-8" 
11002          * --jhi */
11003         pv_pretty(sv, STRING(o), STR_LEN(o), 60, PL_colors[0], PL_colors[1],
11004                   PERL_PV_ESCAPE_UNI_DETECT |
11005                   PERL_PV_ESCAPE_NONASCII   |
11006                   PERL_PV_PRETTY_ELLIPSES   |
11007                   PERL_PV_PRETTY_LTGT       |
11008                   PERL_PV_PRETTY_NOCLEAR
11009                   );
11010     } else if (k == TRIE) {
11011         /* print the details of the trie in dumpuntil instead, as
11012          * progi->data isn't available here */
11013         const char op = OP(o);
11014         const U32 n = ARG(o);
11015         const reg_ac_data * const ac = IS_TRIE_AC(op) ?
11016                (reg_ac_data *)progi->data->data[n] :
11017                NULL;
11018         const reg_trie_data * const trie
11019             = (reg_trie_data*)progi->data->data[!IS_TRIE_AC(op) ? n : ac->trie];
11020         
11021         Perl_sv_catpvf(aTHX_ sv, "-%s",PL_reg_name[o->flags]);
11022         DEBUG_TRIE_COMPILE_r(
11023             Perl_sv_catpvf(aTHX_ sv,
11024                 "<S:%"UVuf"/%"IVdf" W:%"UVuf" L:%"UVuf"/%"UVuf" C:%"UVuf"/%"UVuf">",
11025                 (UV)trie->startstate,
11026                 (IV)trie->statecount-1, /* -1 because of the unused 0 element */
11027                 (UV)trie->wordcount,
11028                 (UV)trie->minlen,
11029                 (UV)trie->maxlen,
11030                 (UV)TRIE_CHARCOUNT(trie),
11031                 (UV)trie->uniquecharcount
11032             )
11033         );
11034         if ( IS_ANYOF_TRIE(op) || trie->bitmap ) {
11035             int i;
11036             int rangestart = -1;
11037             U8* bitmap = IS_ANYOF_TRIE(op) ? (U8*)ANYOF_BITMAP(o) : (U8*)TRIE_BITMAP(trie);
11038             sv_catpvs(sv, "[");
11039             for (i = 0; i <= 256; i++) {
11040                 if (i < 256 && BITMAP_TEST(bitmap,i)) {
11041                     if (rangestart == -1)
11042                         rangestart = i;
11043                 } else if (rangestart != -1) {
11044                     if (i <= rangestart + 3)
11045                         for (; rangestart < i; rangestart++)
11046                             put_byte(sv, rangestart);
11047                     else {
11048                         put_byte(sv, rangestart);
11049                         sv_catpvs(sv, "-");
11050                         put_byte(sv, i - 1);
11051                     }
11052                     rangestart = -1;
11053                 }
11054             }
11055             sv_catpvs(sv, "]");
11056         } 
11057          
11058     } else if (k == CURLY) {
11059         if (OP(o) == CURLYM || OP(o) == CURLYN || OP(o) == CURLYX)
11060             Perl_sv_catpvf(aTHX_ sv, "[%d]", o->flags); /* Parenth number */
11061         Perl_sv_catpvf(aTHX_ sv, " {%d,%d}", ARG1(o), ARG2(o));
11062     }
11063     else if (k == WHILEM && o->flags)                   /* Ordinal/of */
11064         Perl_sv_catpvf(aTHX_ sv, "[%d/%d]", o->flags & 0xf, o->flags>>4);
11065     else if (k == REF || k == OPEN || k == CLOSE || k == GROUPP || OP(o)==ACCEPT) {
11066         Perl_sv_catpvf(aTHX_ sv, "%d", (int)ARG(o));    /* Parenth number */
11067         if ( RXp_PAREN_NAMES(prog) ) {
11068             if ( k != REF || (OP(o) < NREF)) {
11069                 AV *list= MUTABLE_AV(progi->data->data[progi->name_list_idx]);
11070                 SV **name= av_fetch(list, ARG(o), 0 );
11071                 if (name)
11072                     Perl_sv_catpvf(aTHX_ sv, " '%"SVf"'", SVfARG(*name));
11073             }       
11074             else {
11075                 AV *list= MUTABLE_AV(progi->data->data[ progi->name_list_idx ]);
11076                 SV *sv_dat= MUTABLE_SV(progi->data->data[ ARG( o ) ]);
11077                 I32 *nums=(I32*)SvPVX(sv_dat);
11078                 SV **name= av_fetch(list, nums[0], 0 );
11079                 I32 n;
11080                 if (name) {
11081                     for ( n=0; n<SvIVX(sv_dat); n++ ) {
11082                         Perl_sv_catpvf(aTHX_ sv, "%s%"IVdf,
11083                                     (n ? "," : ""), (IV)nums[n]);
11084                     }
11085                     Perl_sv_catpvf(aTHX_ sv, " '%"SVf"'", SVfARG(*name));
11086                 }
11087             }
11088         }            
11089     } else if (k == GOSUB) 
11090         Perl_sv_catpvf(aTHX_ sv, "%d[%+d]", (int)ARG(o),(int)ARG2L(o)); /* Paren and offset */
11091     else if (k == VERB) {
11092         if (!o->flags) 
11093             Perl_sv_catpvf(aTHX_ sv, ":%"SVf, 
11094                            SVfARG((MUTABLE_SV(progi->data->data[ ARG( o ) ]))));
11095     } else if (k == LOGICAL)
11096         Perl_sv_catpvf(aTHX_ sv, "[%d]", o->flags);     /* 2: embedded, otherwise 1 */
11097     else if (k == FOLDCHAR)
11098         Perl_sv_catpvf(aTHX_ sv, "[0x%"UVXf"]", PTR2UV(ARG(o)) );
11099     else if (k == ANYOF) {
11100         int i, rangestart = -1;
11101         const U8 flags = ANYOF_FLAGS(o);
11102         int do_sep = 0;
11103
11104         /* Should be synchronized with * ANYOF_ #xdefines in regcomp.h */
11105         static const char * const anyofs[] = {
11106             "\\w",
11107             "\\W",
11108             "\\s",
11109             "\\S",
11110             "\\d",
11111             "\\D",
11112             "[:alnum:]",
11113             "[:^alnum:]",
11114             "[:alpha:]",
11115             "[:^alpha:]",
11116             "[:ascii:]",
11117             "[:^ascii:]",
11118             "[:cntrl:]",
11119             "[:^cntrl:]",
11120             "[:graph:]",
11121             "[:^graph:]",
11122             "[:lower:]",
11123             "[:^lower:]",
11124             "[:print:]",
11125             "[:^print:]",
11126             "[:punct:]",
11127             "[:^punct:]",
11128             "[:upper:]",
11129             "[:^upper:]",
11130             "[:xdigit:]",
11131             "[:^xdigit:]",
11132             "[:space:]",
11133             "[:^space:]",
11134             "[:blank:]",
11135             "[:^blank:]"
11136         };
11137
11138         if (flags & ANYOF_LOCALE)
11139             sv_catpvs(sv, "{loc}");
11140         if (flags & ANYOF_LOC_NONBITMAP_FOLD)
11141             sv_catpvs(sv, "{i}");
11142         Perl_sv_catpvf(aTHX_ sv, "[%s", PL_colors[0]);
11143         if (flags & ANYOF_INVERT)
11144             sv_catpvs(sv, "^");
11145         
11146         /* output what the standard cp 0-255 bitmap matches */
11147         for (i = 0; i <= 256; i++) {
11148             if (i < 256 && ANYOF_BITMAP_TEST(o,i)) {
11149                 if (rangestart == -1)
11150                     rangestart = i;
11151             } else if (rangestart != -1) {
11152                 if (i <= rangestart + 3)
11153                     for (; rangestart < i; rangestart++)
11154                         put_byte(sv, rangestart);
11155                 else {
11156                     put_byte(sv, rangestart);
11157                     sv_catpvs(sv, "-");
11158                     put_byte(sv, i - 1);
11159                 }
11160                 do_sep = 1;
11161                 rangestart = -1;
11162             }
11163         }
11164         
11165         EMIT_ANYOF_TEST_SEPARATOR(do_sep,sv,flags);
11166         /* output any special charclass tests (used entirely under use locale) */
11167         if (ANYOF_CLASS_TEST_ANY_SET(o))
11168             for (i = 0; i < (int)(sizeof(anyofs)/sizeof(char*)); i++)
11169                 if (ANYOF_CLASS_TEST(o,i)) {
11170                     sv_catpv(sv, anyofs[i]);
11171                     do_sep = 1;
11172                 }
11173         
11174         EMIT_ANYOF_TEST_SEPARATOR(do_sep,sv,flags);
11175         
11176         if (flags & ANYOF_NON_UTF8_LATIN1_ALL) {
11177             sv_catpvs(sv, "{non-utf8-latin1-all}");
11178         }
11179
11180         /* output information about the unicode matching */
11181         if (flags & ANYOF_UNICODE_ALL)
11182             sv_catpvs(sv, "{unicode_all}");
11183         else if (ANYOF_NONBITMAP(o))
11184             sv_catpvs(sv, "{unicode}");
11185         if (flags & ANYOF_NONBITMAP_NON_UTF8)
11186             sv_catpvs(sv, "{outside bitmap}");
11187
11188         if (ANYOF_NONBITMAP(o)) {
11189             SV *lv;
11190             SV * const sw = regclass_swash(prog, o, FALSE, &lv, 0);
11191         
11192             if (lv) {
11193                 if (sw) {
11194                     U8 s[UTF8_MAXBYTES_CASE+1];
11195
11196                     for (i = 0; i <= 256; i++) { /* just the first 256 */
11197                         uvchr_to_utf8(s, i);
11198                         
11199                         if (i < 256 && swash_fetch(sw, s, TRUE)) {
11200                             if (rangestart == -1)
11201                                 rangestart = i;
11202                         } else if (rangestart != -1) {
11203                             if (i <= rangestart + 3)
11204                                 for (; rangestart < i; rangestart++) {
11205                                     const U8 * const e = uvchr_to_utf8(s,rangestart);
11206                                     U8 *p;
11207                                     for(p = s; p < e; p++)
11208                                         put_byte(sv, *p);
11209                                 }
11210                             else {
11211                                 const U8 *e = uvchr_to_utf8(s,rangestart);
11212                                 U8 *p;
11213                                 for (p = s; p < e; p++)
11214                                     put_byte(sv, *p);
11215                                 sv_catpvs(sv, "-");
11216                                 e = uvchr_to_utf8(s, i-1);
11217                                 for (p = s; p < e; p++)
11218                                     put_byte(sv, *p);
11219                                 }
11220                                 rangestart = -1;
11221                             }
11222                         }
11223                         
11224                     sv_catpvs(sv, "..."); /* et cetera */
11225                 }
11226
11227                 {
11228                     char *s = savesvpv(lv);
11229                     char * const origs = s;
11230                 
11231                     while (*s && *s != '\n')
11232                         s++;
11233                 
11234                     if (*s == '\n') {
11235                         const char * const t = ++s;
11236                         
11237                         while (*s) {
11238                             if (*s == '\n')
11239                                 *s = ' ';
11240                             s++;
11241                         }
11242                         if (s[-1] == ' ')
11243                             s[-1] = 0;
11244                         
11245                         sv_catpv(sv, t);
11246                     }
11247                 
11248                     Safefree(origs);
11249                 }
11250             }
11251         }
11252
11253         Perl_sv_catpvf(aTHX_ sv, "%s]", PL_colors[1]);
11254     }
11255     else if (k == BRANCHJ && (OP(o) == UNLESSM || OP(o) == IFMATCH))
11256         Perl_sv_catpvf(aTHX_ sv, "[%d]", -(o->flags));
11257 #else
11258     PERL_UNUSED_CONTEXT;
11259     PERL_UNUSED_ARG(sv);
11260     PERL_UNUSED_ARG(o);
11261     PERL_UNUSED_ARG(prog);
11262 #endif  /* DEBUGGING */
11263 }
11264
11265 SV *
11266 Perl_re_intuit_string(pTHX_ REGEXP * const r)
11267 {                               /* Assume that RE_INTUIT is set */
11268     dVAR;
11269     struct regexp *const prog = (struct regexp *)SvANY(r);
11270     GET_RE_DEBUG_FLAGS_DECL;
11271
11272     PERL_ARGS_ASSERT_RE_INTUIT_STRING;
11273     PERL_UNUSED_CONTEXT;
11274
11275     DEBUG_COMPILE_r(
11276         {
11277             const char * const s = SvPV_nolen_const(prog->check_substr
11278                       ? prog->check_substr : prog->check_utf8);
11279
11280             if (!PL_colorset) reginitcolors();
11281             PerlIO_printf(Perl_debug_log,
11282                       "%sUsing REx %ssubstr:%s \"%s%.60s%s%s\"\n",
11283                       PL_colors[4],
11284                       prog->check_substr ? "" : "utf8 ",
11285                       PL_colors[5],PL_colors[0],
11286                       s,
11287                       PL_colors[1],
11288                       (strlen(s) > 60 ? "..." : ""));
11289         } );
11290
11291     return prog->check_substr ? prog->check_substr : prog->check_utf8;
11292 }
11293
11294 /* 
11295    pregfree() 
11296    
11297    handles refcounting and freeing the perl core regexp structure. When 
11298    it is necessary to actually free the structure the first thing it 
11299    does is call the 'free' method of the regexp_engine associated to
11300    the regexp, allowing the handling of the void *pprivate; member 
11301    first. (This routine is not overridable by extensions, which is why 
11302    the extensions free is called first.)
11303    
11304    See regdupe and regdupe_internal if you change anything here. 
11305 */
11306 #ifndef PERL_IN_XSUB_RE
11307 void
11308 Perl_pregfree(pTHX_ REGEXP *r)
11309 {
11310     SvREFCNT_dec(r);
11311 }
11312
11313 void
11314 Perl_pregfree2(pTHX_ REGEXP *rx)
11315 {
11316     dVAR;
11317     struct regexp *const r = (struct regexp *)SvANY(rx);
11318     GET_RE_DEBUG_FLAGS_DECL;
11319
11320     PERL_ARGS_ASSERT_PREGFREE2;
11321
11322     if (r->mother_re) {
11323         ReREFCNT_dec(r->mother_re);
11324     } else {
11325         CALLREGFREE_PVT(rx); /* free the private data */
11326         SvREFCNT_dec(RXp_PAREN_NAMES(r));
11327     }        
11328     if (r->substrs) {
11329         SvREFCNT_dec(r->anchored_substr);
11330         SvREFCNT_dec(r->anchored_utf8);
11331         SvREFCNT_dec(r->float_substr);
11332         SvREFCNT_dec(r->float_utf8);
11333         Safefree(r->substrs);
11334     }
11335     RX_MATCH_COPY_FREE(rx);
11336 #ifdef PERL_OLD_COPY_ON_WRITE
11337     SvREFCNT_dec(r->saved_copy);
11338 #endif
11339     Safefree(r->offs);
11340 }
11341
11342 /*  reg_temp_copy()
11343     
11344     This is a hacky workaround to the structural issue of match results
11345     being stored in the regexp structure which is in turn stored in
11346     PL_curpm/PL_reg_curpm. The problem is that due to qr// the pattern
11347     could be PL_curpm in multiple contexts, and could require multiple
11348     result sets being associated with the pattern simultaneously, such
11349     as when doing a recursive match with (??{$qr})
11350     
11351     The solution is to make a lightweight copy of the regexp structure 
11352     when a qr// is returned from the code executed by (??{$qr}) this
11353     lightweight copy doesn't actually own any of its data except for
11354     the starp/end and the actual regexp structure itself. 
11355     
11356 */    
11357     
11358     
11359 REGEXP *
11360 Perl_reg_temp_copy (pTHX_ REGEXP *ret_x, REGEXP *rx)
11361 {
11362     struct regexp *ret;
11363     struct regexp *const r = (struct regexp *)SvANY(rx);
11364     register const I32 npar = r->nparens+1;
11365
11366     PERL_ARGS_ASSERT_REG_TEMP_COPY;
11367
11368     if (!ret_x)
11369         ret_x = (REGEXP*) newSV_type(SVt_REGEXP);
11370     ret = (struct regexp *)SvANY(ret_x);
11371     
11372     (void)ReREFCNT_inc(rx);
11373     /* We can take advantage of the existing "copied buffer" mechanism in SVs
11374        by pointing directly at the buffer, but flagging that the allocated
11375        space in the copy is zero. As we've just done a struct copy, it's now
11376        a case of zero-ing that, rather than copying the current length.  */
11377     SvPV_set(ret_x, RX_WRAPPED(rx));
11378     SvFLAGS(ret_x) |= SvFLAGS(rx) & (SVf_POK|SVp_POK|SVf_UTF8);
11379     memcpy(&(ret->xpv_cur), &(r->xpv_cur),
11380            sizeof(regexp) - STRUCT_OFFSET(regexp, xpv_cur));
11381     SvLEN_set(ret_x, 0);
11382     SvSTASH_set(ret_x, NULL);
11383     SvMAGIC_set(ret_x, NULL);
11384     Newx(ret->offs, npar, regexp_paren_pair);
11385     Copy(r->offs, ret->offs, npar, regexp_paren_pair);
11386     if (r->substrs) {
11387         Newx(ret->substrs, 1, struct reg_substr_data);
11388         StructCopy(r->substrs, ret->substrs, struct reg_substr_data);
11389
11390         SvREFCNT_inc_void(ret->anchored_substr);
11391         SvREFCNT_inc_void(ret->anchored_utf8);
11392         SvREFCNT_inc_void(ret->float_substr);
11393         SvREFCNT_inc_void(ret->float_utf8);
11394
11395         /* check_substr and check_utf8, if non-NULL, point to either their
11396            anchored or float namesakes, and don't hold a second reference.  */
11397     }
11398     RX_MATCH_COPIED_off(ret_x);
11399 #ifdef PERL_OLD_COPY_ON_WRITE
11400     ret->saved_copy = NULL;
11401 #endif
11402     ret->mother_re = rx;
11403     
11404     return ret_x;
11405 }
11406 #endif
11407
11408 /* regfree_internal() 
11409
11410    Free the private data in a regexp. This is overloadable by 
11411    extensions. Perl takes care of the regexp structure in pregfree(), 
11412    this covers the *pprivate pointer which technically perl doesn't 
11413    know about, however of course we have to handle the 
11414    regexp_internal structure when no extension is in use. 
11415    
11416    Note this is called before freeing anything in the regexp 
11417    structure. 
11418  */
11419  
11420 void
11421 Perl_regfree_internal(pTHX_ REGEXP * const rx)
11422 {
11423     dVAR;
11424     struct regexp *const r = (struct regexp *)SvANY(rx);
11425     RXi_GET_DECL(r,ri);
11426     GET_RE_DEBUG_FLAGS_DECL;
11427
11428     PERL_ARGS_ASSERT_REGFREE_INTERNAL;
11429
11430     DEBUG_COMPILE_r({
11431         if (!PL_colorset)
11432             reginitcolors();
11433         {
11434             SV *dsv= sv_newmortal();
11435             RE_PV_QUOTED_DECL(s, RX_UTF8(rx),
11436                 dsv, RX_PRECOMP(rx), RX_PRELEN(rx), 60);
11437             PerlIO_printf(Perl_debug_log,"%sFreeing REx:%s %s\n", 
11438                 PL_colors[4],PL_colors[5],s);
11439         }
11440     });
11441 #ifdef RE_TRACK_PATTERN_OFFSETS
11442     if (ri->u.offsets)
11443         Safefree(ri->u.offsets);             /* 20010421 MJD */
11444 #endif
11445     if (ri->data) {
11446         int n = ri->data->count;
11447         PAD* new_comppad = NULL;
11448         PAD* old_comppad;
11449         PADOFFSET refcnt;
11450
11451         while (--n >= 0) {
11452           /* If you add a ->what type here, update the comment in regcomp.h */
11453             switch (ri->data->what[n]) {
11454             case 'a':
11455             case 's':
11456             case 'S':
11457             case 'u':
11458                 SvREFCNT_dec(MUTABLE_SV(ri->data->data[n]));
11459                 break;
11460             case 'f':
11461                 Safefree(ri->data->data[n]);
11462                 break;
11463             case 'p':
11464                 new_comppad = MUTABLE_AV(ri->data->data[n]);
11465                 break;
11466             case 'o':
11467                 if (new_comppad == NULL)
11468                     Perl_croak(aTHX_ "panic: pregfree comppad");
11469                 PAD_SAVE_LOCAL(old_comppad,
11470                     /* Watch out for global destruction's random ordering. */
11471                     (SvTYPE(new_comppad) == SVt_PVAV) ? new_comppad : NULL
11472                 );
11473                 OP_REFCNT_LOCK;
11474                 refcnt = OpREFCNT_dec((OP_4tree*)ri->data->data[n]);
11475                 OP_REFCNT_UNLOCK;
11476                 if (!refcnt)
11477                     op_free((OP_4tree*)ri->data->data[n]);
11478
11479                 PAD_RESTORE_LOCAL(old_comppad);
11480                 SvREFCNT_dec(MUTABLE_SV(new_comppad));
11481                 new_comppad = NULL;
11482                 break;
11483             case 'n':
11484                 break;
11485             case 'T':           
11486                 { /* Aho Corasick add-on structure for a trie node.
11487                      Used in stclass optimization only */
11488                     U32 refcount;
11489                     reg_ac_data *aho=(reg_ac_data*)ri->data->data[n];
11490                     OP_REFCNT_LOCK;
11491                     refcount = --aho->refcount;
11492                     OP_REFCNT_UNLOCK;
11493                     if ( !refcount ) {
11494                         PerlMemShared_free(aho->states);
11495                         PerlMemShared_free(aho->fail);
11496                          /* do this last!!!! */
11497                         PerlMemShared_free(ri->data->data[n]);
11498                         PerlMemShared_free(ri->regstclass);
11499                     }
11500                 }
11501                 break;
11502             case 't':
11503                 {
11504                     /* trie structure. */
11505                     U32 refcount;
11506                     reg_trie_data *trie=(reg_trie_data*)ri->data->data[n];
11507                     OP_REFCNT_LOCK;
11508                     refcount = --trie->refcount;
11509                     OP_REFCNT_UNLOCK;
11510                     if ( !refcount ) {
11511                         PerlMemShared_free(trie->charmap);
11512                         PerlMemShared_free(trie->states);
11513                         PerlMemShared_free(trie->trans);
11514                         if (trie->bitmap)
11515                             PerlMemShared_free(trie->bitmap);
11516                         if (trie->jump)
11517                             PerlMemShared_free(trie->jump);
11518                         PerlMemShared_free(trie->wordinfo);
11519                         /* do this last!!!! */
11520                         PerlMemShared_free(ri->data->data[n]);
11521                     }
11522                 }
11523                 break;
11524             default:
11525                 Perl_croak(aTHX_ "panic: regfree data code '%c'", ri->data->what[n]);
11526             }
11527         }
11528         Safefree(ri->data->what);
11529         Safefree(ri->data);
11530     }
11531
11532     Safefree(ri);
11533 }
11534
11535 #define av_dup_inc(s,t) MUTABLE_AV(sv_dup_inc((const SV *)s,t))
11536 #define hv_dup_inc(s,t) MUTABLE_HV(sv_dup_inc((const SV *)s,t))
11537 #define SAVEPVN(p,n)    ((p) ? savepvn(p,n) : NULL)
11538
11539 /* 
11540    re_dup - duplicate a regexp. 
11541    
11542    This routine is expected to clone a given regexp structure. It is only
11543    compiled under USE_ITHREADS.
11544
11545    After all of the core data stored in struct regexp is duplicated
11546    the regexp_engine.dupe method is used to copy any private data
11547    stored in the *pprivate pointer. This allows extensions to handle
11548    any duplication it needs to do.
11549
11550    See pregfree() and regfree_internal() if you change anything here. 
11551 */
11552 #if defined(USE_ITHREADS)
11553 #ifndef PERL_IN_XSUB_RE
11554 void
11555 Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param)
11556 {
11557     dVAR;
11558     I32 npar;
11559     const struct regexp *r = (const struct regexp *)SvANY(sstr);
11560     struct regexp *ret = (struct regexp *)SvANY(dstr);
11561     
11562     PERL_ARGS_ASSERT_RE_DUP_GUTS;
11563
11564     npar = r->nparens+1;
11565     Newx(ret->offs, npar, regexp_paren_pair);
11566     Copy(r->offs, ret->offs, npar, regexp_paren_pair);
11567     if(ret->swap) {
11568         /* no need to copy these */
11569         Newx(ret->swap, npar, regexp_paren_pair);
11570     }
11571
11572     if (ret->substrs) {
11573         /* Do it this way to avoid reading from *r after the StructCopy().
11574            That way, if any of the sv_dup_inc()s dislodge *r from the L1
11575            cache, it doesn't matter.  */
11576         const bool anchored = r->check_substr
11577             ? r->check_substr == r->anchored_substr
11578             : r->check_utf8 == r->anchored_utf8;
11579         Newx(ret->substrs, 1, struct reg_substr_data);
11580         StructCopy(r->substrs, ret->substrs, struct reg_substr_data);
11581
11582         ret->anchored_substr = sv_dup_inc(ret->anchored_substr, param);
11583         ret->anchored_utf8 = sv_dup_inc(ret->anchored_utf8, param);
11584         ret->float_substr = sv_dup_inc(ret->float_substr, param);
11585         ret->float_utf8 = sv_dup_inc(ret->float_utf8, param);
11586
11587         /* check_substr and check_utf8, if non-NULL, point to either their
11588            anchored or float namesakes, and don't hold a second reference.  */
11589
11590         if (ret->check_substr) {
11591             if (anchored) {
11592                 assert(r->check_utf8 == r->anchored_utf8);
11593                 ret->check_substr = ret->anchored_substr;
11594                 ret->check_utf8 = ret->anchored_utf8;
11595             } else {
11596                 assert(r->check_substr == r->float_substr);
11597                 assert(r->check_utf8 == r->float_utf8);
11598                 ret->check_substr = ret->float_substr;
11599                 ret->check_utf8 = ret->float_utf8;
11600             }
11601         } else if (ret->check_utf8) {
11602             if (anchored) {
11603                 ret->check_utf8 = ret->anchored_utf8;
11604             } else {
11605                 ret->check_utf8 = ret->float_utf8;
11606             }
11607         }
11608     }
11609
11610     RXp_PAREN_NAMES(ret) = hv_dup_inc(RXp_PAREN_NAMES(ret), param);
11611
11612     if (ret->pprivate)
11613         RXi_SET(ret,CALLREGDUPE_PVT(dstr,param));
11614
11615     if (RX_MATCH_COPIED(dstr))
11616         ret->subbeg  = SAVEPVN(ret->subbeg, ret->sublen);
11617     else
11618         ret->subbeg = NULL;
11619 #ifdef PERL_OLD_COPY_ON_WRITE
11620     ret->saved_copy = NULL;
11621 #endif
11622
11623     if (ret->mother_re) {
11624         if (SvPVX_const(dstr) == SvPVX_const(ret->mother_re)) {
11625             /* Our storage points directly to our mother regexp, but that's
11626                1: a buffer in a different thread
11627                2: something we no longer hold a reference on
11628                so we need to copy it locally.  */
11629             /* Note we need to sue SvCUR() on our mother_re, because it, in
11630                turn, may well be pointing to its own mother_re.  */
11631             SvPV_set(dstr, SAVEPVN(SvPVX_const(ret->mother_re),
11632                                    SvCUR(ret->mother_re)+1));
11633             SvLEN_set(dstr, SvCUR(ret->mother_re)+1);
11634         }
11635         ret->mother_re      = NULL;
11636     }
11637     ret->gofs = 0;
11638 }
11639 #endif /* PERL_IN_XSUB_RE */
11640
11641 /*
11642    regdupe_internal()
11643    
11644    This is the internal complement to regdupe() which is used to copy
11645    the structure pointed to by the *pprivate pointer in the regexp.
11646    This is the core version of the extension overridable cloning hook.
11647    The regexp structure being duplicated will be copied by perl prior
11648    to this and will be provided as the regexp *r argument, however 
11649    with the /old/ structures pprivate pointer value. Thus this routine
11650    may override any copying normally done by perl.
11651    
11652    It returns a pointer to the new regexp_internal structure.
11653 */
11654
11655 void *
11656 Perl_regdupe_internal(pTHX_ REGEXP * const rx, CLONE_PARAMS *param)
11657 {
11658     dVAR;
11659     struct regexp *const r = (struct regexp *)SvANY(rx);
11660     regexp_internal *reti;
11661     int len, npar;
11662     RXi_GET_DECL(r,ri);
11663
11664     PERL_ARGS_ASSERT_REGDUPE_INTERNAL;
11665     
11666     npar = r->nparens+1;
11667     len = ProgLen(ri);
11668     
11669     Newxc(reti, sizeof(regexp_internal) + len*sizeof(regnode), char, regexp_internal);
11670     Copy(ri->program, reti->program, len+1, regnode);
11671     
11672
11673     reti->regstclass = NULL;
11674
11675     if (ri->data) {
11676         struct reg_data *d;
11677         const int count = ri->data->count;
11678         int i;
11679
11680         Newxc(d, sizeof(struct reg_data) + count*sizeof(void *),
11681                 char, struct reg_data);
11682         Newx(d->what, count, U8);
11683
11684         d->count = count;
11685         for (i = 0; i < count; i++) {
11686             d->what[i] = ri->data->what[i];
11687             switch (d->what[i]) {
11688                 /* legal options are one of: sSfpontTua
11689                    see also regcomp.h and pregfree() */
11690             case 'a': /* actually an AV, but the dup function is identical.  */
11691             case 's':
11692             case 'S':
11693             case 'p': /* actually an AV, but the dup function is identical.  */
11694             case 'u': /* actually an HV, but the dup function is identical.  */
11695                 d->data[i] = sv_dup_inc((const SV *)ri->data->data[i], param);
11696                 break;
11697             case 'f':
11698                 /* This is cheating. */
11699                 Newx(d->data[i], 1, struct regnode_charclass_class);
11700                 StructCopy(ri->data->data[i], d->data[i],
11701                             struct regnode_charclass_class);
11702                 reti->regstclass = (regnode*)d->data[i];
11703                 break;
11704             case 'o':
11705                 /* Compiled op trees are readonly and in shared memory,
11706                    and can thus be shared without duplication. */
11707                 OP_REFCNT_LOCK;
11708                 d->data[i] = (void*)OpREFCNT_inc((OP*)ri->data->data[i]);
11709                 OP_REFCNT_UNLOCK;
11710                 break;
11711             case 'T':
11712                 /* Trie stclasses are readonly and can thus be shared
11713                  * without duplication. We free the stclass in pregfree
11714                  * when the corresponding reg_ac_data struct is freed.
11715                  */
11716                 reti->regstclass= ri->regstclass;
11717                 /* Fall through */
11718             case 't':
11719                 OP_REFCNT_LOCK;
11720                 ((reg_trie_data*)ri->data->data[i])->refcount++;
11721                 OP_REFCNT_UNLOCK;
11722                 /* Fall through */
11723             case 'n':
11724                 d->data[i] = ri->data->data[i];
11725                 break;
11726             default:
11727                 Perl_croak(aTHX_ "panic: re_dup unknown data code '%c'", ri->data->what[i]);
11728             }
11729         }
11730
11731         reti->data = d;
11732     }
11733     else
11734         reti->data = NULL;
11735
11736     reti->name_list_idx = ri->name_list_idx;
11737
11738 #ifdef RE_TRACK_PATTERN_OFFSETS
11739     if (ri->u.offsets) {
11740         Newx(reti->u.offsets, 2*len+1, U32);
11741         Copy(ri->u.offsets, reti->u.offsets, 2*len+1, U32);
11742     }
11743 #else
11744     SetProgLen(reti,len);
11745 #endif
11746
11747     return (void*)reti;
11748 }
11749
11750 #endif    /* USE_ITHREADS */
11751
11752 #ifndef PERL_IN_XSUB_RE
11753
11754 /*
11755  - regnext - dig the "next" pointer out of a node
11756  */
11757 regnode *
11758 Perl_regnext(pTHX_ register regnode *p)
11759 {
11760     dVAR;
11761     register I32 offset;
11762
11763     if (!p)
11764         return(NULL);
11765
11766     if (OP(p) > REGNODE_MAX) {          /* regnode.type is unsigned */
11767         Perl_croak(aTHX_ "Corrupted regexp opcode %d > %d", (int)OP(p), (int)REGNODE_MAX);
11768     }
11769
11770     offset = (reg_off_by_arg[OP(p)] ? ARG(p) : NEXT_OFF(p));
11771     if (offset == 0)
11772         return(NULL);
11773
11774     return(p+offset);
11775 }
11776 #endif
11777
11778 STATIC void     
11779 S_re_croak2(pTHX_ const char* pat1,const char* pat2,...)
11780 {
11781     va_list args;
11782     STRLEN l1 = strlen(pat1);
11783     STRLEN l2 = strlen(pat2);
11784     char buf[512];
11785     SV *msv;
11786     const char *message;
11787
11788     PERL_ARGS_ASSERT_RE_CROAK2;
11789
11790     if (l1 > 510)
11791         l1 = 510;
11792     if (l1 + l2 > 510)
11793         l2 = 510 - l1;
11794     Copy(pat1, buf, l1 , char);
11795     Copy(pat2, buf + l1, l2 , char);
11796     buf[l1 + l2] = '\n';
11797     buf[l1 + l2 + 1] = '\0';
11798 #ifdef I_STDARG
11799     /* ANSI variant takes additional second argument */
11800     va_start(args, pat2);
11801 #else
11802     va_start(args);
11803 #endif
11804     msv = vmess(buf, &args);
11805     va_end(args);
11806     message = SvPV_const(msv,l1);
11807     if (l1 > 512)
11808         l1 = 512;
11809     Copy(message, buf, l1 , char);
11810     buf[l1-1] = '\0';                   /* Overwrite \n */
11811     Perl_croak(aTHX_ "%s", buf);
11812 }
11813
11814 /* XXX Here's a total kludge.  But we need to re-enter for swash routines. */
11815
11816 #ifndef PERL_IN_XSUB_RE
11817 void
11818 Perl_save_re_context(pTHX)
11819 {
11820     dVAR;
11821
11822     struct re_save_state *state;
11823
11824     SAVEVPTR(PL_curcop);
11825     SSGROW(SAVESTACK_ALLOC_FOR_RE_SAVE_STATE + 1);
11826
11827     state = (struct re_save_state *)(PL_savestack + PL_savestack_ix);
11828     PL_savestack_ix += SAVESTACK_ALLOC_FOR_RE_SAVE_STATE;
11829     SSPUSHUV(SAVEt_RE_STATE);
11830
11831     Copy(&PL_reg_state, state, 1, struct re_save_state);
11832
11833     PL_reg_start_tmp = 0;
11834     PL_reg_start_tmpl = 0;
11835     PL_reg_oldsaved = NULL;
11836     PL_reg_oldsavedlen = 0;
11837     PL_reg_maxiter = 0;
11838     PL_reg_leftiter = 0;
11839     PL_reg_poscache = NULL;
11840     PL_reg_poscache_size = 0;
11841 #ifdef PERL_OLD_COPY_ON_WRITE
11842     PL_nrs = NULL;
11843 #endif
11844
11845     /* Save $1..$n (#18107: UTF-8 s/(\w+)/uc($1)/e); AMS 20021106. */
11846     if (PL_curpm) {
11847         const REGEXP * const rx = PM_GETRE(PL_curpm);
11848         if (rx) {
11849             U32 i;
11850             for (i = 1; i <= RX_NPARENS(rx); i++) {
11851                 char digits[TYPE_CHARS(long)];
11852                 const STRLEN len = my_snprintf(digits, sizeof(digits), "%lu", (long)i);
11853                 GV *const *const gvp
11854                     = (GV**)hv_fetch(PL_defstash, digits, len, 0);
11855
11856                 if (gvp) {
11857                     GV * const gv = *gvp;
11858                     if (SvTYPE(gv) == SVt_PVGV && GvSV(gv))
11859                         save_scalar(gv);
11860                 }
11861             }
11862         }
11863     }
11864 }
11865 #endif
11866
11867 static void
11868 clear_re(pTHX_ void *r)
11869 {
11870     dVAR;
11871     ReREFCNT_dec((REGEXP *)r);
11872 }
11873
11874 #ifdef DEBUGGING
11875
11876 STATIC void
11877 S_put_byte(pTHX_ SV *sv, int c)
11878 {
11879     PERL_ARGS_ASSERT_PUT_BYTE;
11880
11881     /* Our definition of isPRINT() ignores locales, so only bytes that are
11882        not part of UTF-8 are considered printable. I assume that the same
11883        holds for UTF-EBCDIC.
11884        Also, code point 255 is not printable in either (it's E0 in EBCDIC,
11885        which Wikipedia says:
11886
11887        EO, or Eight Ones, is an 8-bit EBCDIC character code represented as all
11888        ones (binary 1111 1111, hexadecimal FF). It is similar, but not
11889        identical, to the ASCII delete (DEL) or rubout control character.
11890        ) So the old condition can be simplified to !isPRINT(c)  */
11891     if (!isPRINT(c)) {
11892         if (c < 256) {
11893             Perl_sv_catpvf(aTHX_ sv, "\\x%02x", c);
11894         }
11895         else {
11896             Perl_sv_catpvf(aTHX_ sv, "\\x{%x}", c);
11897         }
11898     }
11899     else {
11900         const char string = c;
11901         if (c == '-' || c == ']' || c == '\\' || c == '^')
11902             sv_catpvs(sv, "\\");
11903         sv_catpvn(sv, &string, 1);
11904     }
11905 }
11906
11907
11908 #define CLEAR_OPTSTART \
11909     if (optstart) STMT_START { \
11910             DEBUG_OPTIMISE_r(PerlIO_printf(Perl_debug_log, " (%"IVdf" nodes)\n", (IV)(node - optstart))); \
11911             optstart=NULL; \
11912     } STMT_END
11913
11914 #define DUMPUNTIL(b,e) CLEAR_OPTSTART; node=dumpuntil(r,start,(b),(e),last,sv,indent+1,depth+1);
11915
11916 STATIC const regnode *
11917 S_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node,
11918             const regnode *last, const regnode *plast, 
11919             SV* sv, I32 indent, U32 depth)
11920 {
11921     dVAR;
11922     register U8 op = PSEUDO;    /* Arbitrary non-END op. */
11923     register const regnode *next;
11924     const regnode *optstart= NULL;
11925     
11926     RXi_GET_DECL(r,ri);
11927     GET_RE_DEBUG_FLAGS_DECL;
11928
11929     PERL_ARGS_ASSERT_DUMPUNTIL;
11930
11931 #ifdef DEBUG_DUMPUNTIL
11932     PerlIO_printf(Perl_debug_log, "--- %d : %d - %d - %d\n",indent,node-start,
11933         last ? last-start : 0,plast ? plast-start : 0);
11934 #endif
11935             
11936     if (plast && plast < last) 
11937         last= plast;
11938
11939     while (PL_regkind[op] != END && (!last || node < last)) {
11940         /* While that wasn't END last time... */
11941         NODE_ALIGN(node);
11942         op = OP(node);
11943         if (op == CLOSE || op == WHILEM)
11944             indent--;
11945         next = regnext((regnode *)node);
11946
11947         /* Where, what. */
11948         if (OP(node) == OPTIMIZED) {
11949             if (!optstart && RE_DEBUG_FLAG(RE_DEBUG_COMPILE_OPTIMISE))
11950                 optstart = node;
11951             else
11952                 goto after_print;
11953         } else
11954             CLEAR_OPTSTART;
11955         
11956         regprop(r, sv, node);
11957         PerlIO_printf(Perl_debug_log, "%4"IVdf":%*s%s", (IV)(node - start),
11958                       (int)(2*indent + 1), "", SvPVX_const(sv));
11959         
11960         if (OP(node) != OPTIMIZED) {                  
11961             if (next == NULL)           /* Next ptr. */
11962                 PerlIO_printf(Perl_debug_log, " (0)");
11963             else if (PL_regkind[(U8)op] == BRANCH && PL_regkind[OP(next)] != BRANCH )
11964                 PerlIO_printf(Perl_debug_log, " (FAIL)");
11965             else 
11966                 PerlIO_printf(Perl_debug_log, " (%"IVdf")", (IV)(next - start));
11967             (void)PerlIO_putc(Perl_debug_log, '\n'); 
11968         }
11969         
11970       after_print:
11971         if (PL_regkind[(U8)op] == BRANCHJ) {
11972             assert(next);
11973             {
11974                 register const regnode *nnode = (OP(next) == LONGJMP
11975                                              ? regnext((regnode *)next)
11976                                              : next);
11977                 if (last && nnode > last)
11978                     nnode = last;
11979                 DUMPUNTIL(NEXTOPER(NEXTOPER(node)), nnode);
11980             }
11981         }
11982         else if (PL_regkind[(U8)op] == BRANCH) {
11983             assert(next);
11984             DUMPUNTIL(NEXTOPER(node), next);
11985         }
11986         else if ( PL_regkind[(U8)op]  == TRIE ) {
11987             const regnode *this_trie = node;
11988             const char op = OP(node);
11989             const U32 n = ARG(node);
11990             const reg_ac_data * const ac = op>=AHOCORASICK ?
11991                (reg_ac_data *)ri->data->data[n] :
11992                NULL;
11993             const reg_trie_data * const trie =
11994                 (reg_trie_data*)ri->data->data[op<AHOCORASICK ? n : ac->trie];
11995 #ifdef DEBUGGING
11996             AV *const trie_words = MUTABLE_AV(ri->data->data[n + TRIE_WORDS_OFFSET]);
11997 #endif
11998             const regnode *nextbranch= NULL;
11999             I32 word_idx;
12000             sv_setpvs(sv, "");
12001             for (word_idx= 0; word_idx < (I32)trie->wordcount; word_idx++) {
12002                 SV ** const elem_ptr = av_fetch(trie_words,word_idx,0);
12003                 
12004                 PerlIO_printf(Perl_debug_log, "%*s%s ",
12005                    (int)(2*(indent+3)), "",
12006                     elem_ptr ? pv_pretty(sv, SvPV_nolen_const(*elem_ptr), SvCUR(*elem_ptr), 60,
12007                             PL_colors[0], PL_colors[1],
12008                             (SvUTF8(*elem_ptr) ? PERL_PV_ESCAPE_UNI : 0) |
12009                             PERL_PV_PRETTY_ELLIPSES    |
12010                             PERL_PV_PRETTY_LTGT
12011                             )
12012                             : "???"
12013                 );
12014                 if (trie->jump) {
12015                     U16 dist= trie->jump[word_idx+1];
12016                     PerlIO_printf(Perl_debug_log, "(%"UVuf")\n",
12017                                   (UV)((dist ? this_trie + dist : next) - start));
12018                     if (dist) {
12019                         if (!nextbranch)
12020                             nextbranch= this_trie + trie->jump[0];    
12021                         DUMPUNTIL(this_trie + dist, nextbranch);
12022                     }
12023                     if (nextbranch && PL_regkind[OP(nextbranch)]==BRANCH)
12024                         nextbranch= regnext((regnode *)nextbranch);
12025                 } else {
12026                     PerlIO_printf(Perl_debug_log, "\n");
12027                 }
12028             }
12029             if (last && next > last)
12030                 node= last;
12031             else
12032                 node= next;
12033         }
12034         else if ( op == CURLY ) {   /* "next" might be very big: optimizer */
12035             DUMPUNTIL(NEXTOPER(node) + EXTRA_STEP_2ARGS,
12036                     NEXTOPER(node) + EXTRA_STEP_2ARGS + 1);
12037         }
12038         else if (PL_regkind[(U8)op] == CURLY && op != CURLYX) {
12039             assert(next);
12040             DUMPUNTIL(NEXTOPER(node) + EXTRA_STEP_2ARGS, next);
12041         }
12042         else if ( op == PLUS || op == STAR) {
12043             DUMPUNTIL(NEXTOPER(node), NEXTOPER(node) + 1);
12044         }
12045         else if (PL_regkind[(U8)op] == ANYOF) {
12046             /* arglen 1 + class block */
12047             node += 1 + ((ANYOF_FLAGS(node) & ANYOF_CLASS)
12048                     ? ANYOF_CLASS_SKIP : ANYOF_SKIP);
12049             node = NEXTOPER(node);
12050         }
12051         else if (PL_regkind[(U8)op] == EXACT) {
12052             /* Literal string, where present. */
12053             node += NODE_SZ_STR(node) - 1;
12054             node = NEXTOPER(node);
12055         }
12056         else {
12057             node = NEXTOPER(node);
12058             node += regarglen[(U8)op];
12059         }
12060         if (op == CURLYX || op == OPEN)
12061             indent++;
12062     }
12063     CLEAR_OPTSTART;
12064 #ifdef DEBUG_DUMPUNTIL    
12065     PerlIO_printf(Perl_debug_log, "--- %d\n", (int)indent);
12066 #endif
12067     return node;
12068 }
12069
12070 #endif  /* DEBUGGING */
12071
12072 /*
12073  * Local variables:
12074  * c-indentation-style: bsd
12075  * c-basic-offset: 4
12076  * indent-tabs-mode: t
12077  * End:
12078  *
12079  * ex: set ts=8 sts=4 sw=4 noet:
12080  */