This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Avoid defining the same global between perl and re.pm
[perl5.git] / regcomp.c
1 /*    regcomp.c
2  */
3
4 /*
5  * 'A fair jaw-cracker dwarf-language must be.'            --Samwise Gamgee
6  *
7  *     [p.285 of _The Lord of the Rings_, II/iii: "The Ring Goes South"]
8  */
9
10 /* This file contains functions for compiling a regular expression.  See
11  * also regexec.c which funnily enough, contains functions for executing
12  * a regular expression.
13  *
14  * This file is also copied at build time to ext/re/re_comp.c, where
15  * it's built with -DPERL_EXT_RE_BUILD -DPERL_EXT_RE_DEBUG -DPERL_EXT.
16  * This causes the main functions to be compiled under new names and with
17  * debugging support added, which makes "use re 'debug'" work.
18  */
19
20 /* NOTE: this is derived from Henry Spencer's regexp code, and should not
21  * confused with the original package (see point 3 below).  Thanks, Henry!
22  */
23
24 /* Additional note: this code is very heavily munged from Henry's version
25  * in places.  In some spots I've traded clarity for efficiency, so don't
26  * blame Henry for some of the lack of readability.
27  */
28
29 /* The names of the functions have been changed from regcomp and
30  * regexec to pregcomp and pregexec in order to avoid conflicts
31  * with the POSIX routines of the same names.
32 */
33
34 #ifdef PERL_EXT_RE_BUILD
35 #include "re_top.h"
36 #endif
37
38 /*
39  * pregcomp and pregexec -- regsub and regerror are not used in perl
40  *
41  *      Copyright (c) 1986 by University of Toronto.
42  *      Written by Henry Spencer.  Not derived from licensed software.
43  *
44  *      Permission is granted to anyone to use this software for any
45  *      purpose on any computer system, and to redistribute it freely,
46  *      subject to the following restrictions:
47  *
48  *      1. The author is not responsible for the consequences of use of
49  *              this software, no matter how awful, even if they arise
50  *              from defects in it.
51  *
52  *      2. The origin of this software must not be misrepresented, either
53  *              by explicit claim or by omission.
54  *
55  *      3. Altered versions must be plainly marked as such, and must not
56  *              be misrepresented as being the original software.
57  *
58  *
59  ****    Alterations to Henry's code are...
60  ****
61  ****    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
62  ****    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
63  ****    by Larry Wall and others
64  ****
65  ****    You may distribute under the terms of either the GNU General Public
66  ****    License or the Artistic License, as specified in the README file.
67
68  *
69  * Beware that some of this code is subtly aware of the way operator
70  * precedence is structured in regular expressions.  Serious changes in
71  * regular-expression syntax might require a total rethink.
72  */
73 #include "EXTERN.h"
74 #define PERL_IN_REGCOMP_C
75 #include "perl.h"
76
77 #ifndef PERL_IN_XSUB_RE
78 #  include "INTERN.h"
79 #endif
80
81 #define REG_COMP_C
82 #ifdef PERL_IN_XSUB_RE
83 #  include "re_comp.h"
84 #else
85 #  include "regcomp.h"
86 #endif
87
88 #include "dquote_static.c"
89 #ifndef PERL_IN_XSUB_RE
90 #  include "charclass_invlists.h"
91 #endif
92
93 #ifdef op
94 #undef op
95 #endif /* op */
96
97 #ifdef MSDOS
98 #  if defined(BUGGY_MSC6)
99  /* MSC 6.00A breaks on op/regexp.t test 85 unless we turn this off */
100 #    pragma optimize("a",off)
101  /* But MSC 6.00A is happy with 'w', for aliases only across function calls*/
102 #    pragma optimize("w",on )
103 #  endif /* BUGGY_MSC6 */
104 #endif /* MSDOS */
105
106 #ifndef STATIC
107 #define STATIC  static
108 #endif
109
110 typedef struct RExC_state_t {
111     U32         flags;                  /* are we folding, multilining? */
112     char        *precomp;               /* uncompiled string. */
113     REGEXP      *rx_sv;                 /* The SV that is the regexp. */
114     regexp      *rx;                    /* perl core regexp structure */
115     regexp_internal     *rxi;           /* internal data for regexp object pprivate field */        
116     char        *start;                 /* Start of input for compile */
117     char        *end;                   /* End of input for compile */
118     char        *parse;                 /* Input-scan pointer. */
119     I32         whilem_seen;            /* number of WHILEM in this expr */
120     regnode     *emit_start;            /* Start of emitted-code area */
121     regnode     *emit_bound;            /* First regnode outside of the allocated space */
122     regnode     *emit;                  /* Code-emit pointer; &regdummy = don't = compiling */
123     I32         naughty;                /* How bad is this pattern? */
124     I32         sawback;                /* Did we see \1, ...? */
125     U32         seen;
126     I32         size;                   /* Code size. */
127     I32         npar;                   /* Capture buffer count, (OPEN). */
128     I32         cpar;                   /* Capture buffer count, (CLOSE). */
129     I32         nestroot;               /* root parens we are in - used by accept */
130     I32         extralen;
131     I32         seen_zerolen;
132     I32         seen_evals;
133     regnode     **open_parens;          /* pointers to open parens */
134     regnode     **close_parens;         /* pointers to close parens */
135     regnode     *opend;                 /* END node in program */
136     I32         utf8;           /* whether the pattern is utf8 or not */
137     I32         orig_utf8;      /* whether the pattern was originally in utf8 */
138                                 /* XXX use this for future optimisation of case
139                                  * where pattern must be upgraded to utf8. */
140     I32         uni_semantics;  /* If a d charset modifier should use unicode
141                                    rules, even if the pattern is not in
142                                    utf8 */
143     HV          *paren_names;           /* Paren names */
144     
145     regnode     **recurse;              /* Recurse regops */
146     I32         recurse_count;          /* Number of recurse regops */
147     I32         in_lookbehind;
148     I32         contains_locale;
149     I32         override_recoding;
150 #if ADD_TO_REGEXEC
151     char        *starttry;              /* -Dr: where regtry was called. */
152 #define RExC_starttry   (pRExC_state->starttry)
153 #endif
154 #ifdef DEBUGGING
155     const char  *lastparse;
156     I32         lastnum;
157     AV          *paren_name_list;       /* idx -> name */
158 #define RExC_lastparse  (pRExC_state->lastparse)
159 #define RExC_lastnum    (pRExC_state->lastnum)
160 #define RExC_paren_name_list    (pRExC_state->paren_name_list)
161 #endif
162 } RExC_state_t;
163
164 #define RExC_flags      (pRExC_state->flags)
165 #define RExC_precomp    (pRExC_state->precomp)
166 #define RExC_rx_sv      (pRExC_state->rx_sv)
167 #define RExC_rx         (pRExC_state->rx)
168 #define RExC_rxi        (pRExC_state->rxi)
169 #define RExC_start      (pRExC_state->start)
170 #define RExC_end        (pRExC_state->end)
171 #define RExC_parse      (pRExC_state->parse)
172 #define RExC_whilem_seen        (pRExC_state->whilem_seen)
173 #ifdef RE_TRACK_PATTERN_OFFSETS
174 #define RExC_offsets    (pRExC_state->rxi->u.offsets) /* I am not like the others */
175 #endif
176 #define RExC_emit       (pRExC_state->emit)
177 #define RExC_emit_start (pRExC_state->emit_start)
178 #define RExC_emit_bound (pRExC_state->emit_bound)
179 #define RExC_naughty    (pRExC_state->naughty)
180 #define RExC_sawback    (pRExC_state->sawback)
181 #define RExC_seen       (pRExC_state->seen)
182 #define RExC_size       (pRExC_state->size)
183 #define RExC_npar       (pRExC_state->npar)
184 #define RExC_nestroot   (pRExC_state->nestroot)
185 #define RExC_extralen   (pRExC_state->extralen)
186 #define RExC_seen_zerolen       (pRExC_state->seen_zerolen)
187 #define RExC_seen_evals (pRExC_state->seen_evals)
188 #define RExC_utf8       (pRExC_state->utf8)
189 #define RExC_uni_semantics      (pRExC_state->uni_semantics)
190 #define RExC_orig_utf8  (pRExC_state->orig_utf8)
191 #define RExC_open_parens        (pRExC_state->open_parens)
192 #define RExC_close_parens       (pRExC_state->close_parens)
193 #define RExC_opend      (pRExC_state->opend)
194 #define RExC_paren_names        (pRExC_state->paren_names)
195 #define RExC_recurse    (pRExC_state->recurse)
196 #define RExC_recurse_count      (pRExC_state->recurse_count)
197 #define RExC_in_lookbehind      (pRExC_state->in_lookbehind)
198 #define RExC_contains_locale    (pRExC_state->contains_locale)
199 #define RExC_override_recoding  (pRExC_state->override_recoding)
200
201
202 #define ISMULT1(c)      ((c) == '*' || (c) == '+' || (c) == '?')
203 #define ISMULT2(s)      ((*s) == '*' || (*s) == '+' || (*s) == '?' || \
204         ((*s) == '{' && regcurly(s)))
205
206 #ifdef SPSTART
207 #undef SPSTART          /* dratted cpp namespace... */
208 #endif
209 /*
210  * Flags to be passed up and down.
211  */
212 #define WORST           0       /* Worst case. */
213 #define HASWIDTH        0x01    /* Known to match non-null strings. */
214
215 /* Simple enough to be STAR/PLUS operand, in an EXACT node must be a single
216  * character, and if utf8, must be invariant.  Note that this is not the same thing as REGNODE_SIMPLE */
217 #define SIMPLE          0x02
218 #define SPSTART         0x04    /* Starts with * or +. */
219 #define TRYAGAIN        0x08    /* Weeded out a declaration. */
220 #define POSTPONED       0x10    /* (?1),(?&name), (??{...}) or similar */
221
222 #define REG_NODE_NUM(x) ((x) ? (int)((x)-RExC_emit_start) : -1)
223
224 /* whether trie related optimizations are enabled */
225 #if PERL_ENABLE_EXTENDED_TRIE_OPTIMISATION
226 #define TRIE_STUDY_OPT
227 #define FULL_TRIE_STUDY
228 #define TRIE_STCLASS
229 #endif
230
231
232
233 #define PBYTE(u8str,paren) ((U8*)(u8str))[(paren) >> 3]
234 #define PBITVAL(paren) (1 << ((paren) & 7))
235 #define PAREN_TEST(u8str,paren) ( PBYTE(u8str,paren) & PBITVAL(paren))
236 #define PAREN_SET(u8str,paren) PBYTE(u8str,paren) |= PBITVAL(paren)
237 #define PAREN_UNSET(u8str,paren) PBYTE(u8str,paren) &= (~PBITVAL(paren))
238
239 /* If not already in utf8, do a longjmp back to the beginning */
240 #define UTF8_LONGJMP 42 /* Choose a value not likely to ever conflict */
241 #define REQUIRE_UTF8    STMT_START {                                       \
242                                      if (! UTF) JMPENV_JUMP(UTF8_LONGJMP); \
243                         } STMT_END
244
245 /* About scan_data_t.
246
247   During optimisation we recurse through the regexp program performing
248   various inplace (keyhole style) optimisations. In addition study_chunk
249   and scan_commit populate this data structure with information about
250   what strings MUST appear in the pattern. We look for the longest 
251   string that must appear at a fixed location, and we look for the
252   longest string that may appear at a floating location. So for instance
253   in the pattern:
254   
255     /FOO[xX]A.*B[xX]BAR/
256     
257   Both 'FOO' and 'A' are fixed strings. Both 'B' and 'BAR' are floating
258   strings (because they follow a .* construct). study_chunk will identify
259   both FOO and BAR as being the longest fixed and floating strings respectively.
260   
261   The strings can be composites, for instance
262   
263      /(f)(o)(o)/
264      
265   will result in a composite fixed substring 'foo'.
266   
267   For each string some basic information is maintained:
268   
269   - offset or min_offset
270     This is the position the string must appear at, or not before.
271     It also implicitly (when combined with minlenp) tells us how many
272     characters must match before the string we are searching for.
273     Likewise when combined with minlenp and the length of the string it
274     tells us how many characters must appear after the string we have 
275     found.
276   
277   - max_offset
278     Only used for floating strings. This is the rightmost point that
279     the string can appear at. If set to I32 max it indicates that the
280     string can occur infinitely far to the right.
281   
282   - minlenp
283     A pointer to the minimum length of the pattern that the string 
284     was found inside. This is important as in the case of positive 
285     lookahead or positive lookbehind we can have multiple patterns 
286     involved. Consider
287     
288     /(?=FOO).*F/
289     
290     The minimum length of the pattern overall is 3, the minimum length
291     of the lookahead part is 3, but the minimum length of the part that
292     will actually match is 1. So 'FOO's minimum length is 3, but the 
293     minimum length for the F is 1. This is important as the minimum length
294     is used to determine offsets in front of and behind the string being 
295     looked for.  Since strings can be composites this is the length of the
296     pattern at the time it was committed with a scan_commit. Note that
297     the length is calculated by study_chunk, so that the minimum lengths
298     are not known until the full pattern has been compiled, thus the 
299     pointer to the value.
300   
301   - lookbehind
302   
303     In the case of lookbehind the string being searched for can be
304     offset past the start point of the final matching string. 
305     If this value was just blithely removed from the min_offset it would
306     invalidate some of the calculations for how many chars must match
307     before or after (as they are derived from min_offset and minlen and
308     the length of the string being searched for). 
309     When the final pattern is compiled and the data is moved from the
310     scan_data_t structure into the regexp structure the information
311     about lookbehind is factored in, with the information that would 
312     have been lost precalculated in the end_shift field for the 
313     associated string.
314
315   The fields pos_min and pos_delta are used to store the minimum offset
316   and the delta to the maximum offset at the current point in the pattern.    
317
318 */
319
320 typedef struct scan_data_t {
321     /*I32 len_min;      unused */
322     /*I32 len_delta;    unused */
323     I32 pos_min;
324     I32 pos_delta;
325     SV *last_found;
326     I32 last_end;           /* min value, <0 unless valid. */
327     I32 last_start_min;
328     I32 last_start_max;
329     SV **longest;           /* Either &l_fixed, or &l_float. */
330     SV *longest_fixed;      /* longest fixed string found in pattern */
331     I32 offset_fixed;       /* offset where it starts */
332     I32 *minlen_fixed;      /* pointer to the minlen relevant to the string */
333     I32 lookbehind_fixed;   /* is the position of the string modfied by LB */
334     SV *longest_float;      /* longest floating string found in pattern */
335     I32 offset_float_min;   /* earliest point in string it can appear */
336     I32 offset_float_max;   /* latest point in string it can appear */
337     I32 *minlen_float;      /* pointer to the minlen relevant to the string */
338     I32 lookbehind_float;   /* is the position of the string modified by LB */
339     I32 flags;
340     I32 whilem_c;
341     I32 *last_closep;
342     struct regnode_charclass_class *start_class;
343 } scan_data_t;
344
345 /*
346  * Forward declarations for pregcomp()'s friends.
347  */
348
349 static const scan_data_t zero_scan_data =
350   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0};
351
352 #define SF_BEFORE_EOL           (SF_BEFORE_SEOL|SF_BEFORE_MEOL)
353 #define SF_BEFORE_SEOL          0x0001
354 #define SF_BEFORE_MEOL          0x0002
355 #define SF_FIX_BEFORE_EOL       (SF_FIX_BEFORE_SEOL|SF_FIX_BEFORE_MEOL)
356 #define SF_FL_BEFORE_EOL        (SF_FL_BEFORE_SEOL|SF_FL_BEFORE_MEOL)
357
358 #ifdef NO_UNARY_PLUS
359 #  define SF_FIX_SHIFT_EOL      (0+2)
360 #  define SF_FL_SHIFT_EOL               (0+4)
361 #else
362 #  define SF_FIX_SHIFT_EOL      (+2)
363 #  define SF_FL_SHIFT_EOL               (+4)
364 #endif
365
366 #define SF_FIX_BEFORE_SEOL      (SF_BEFORE_SEOL << SF_FIX_SHIFT_EOL)
367 #define SF_FIX_BEFORE_MEOL      (SF_BEFORE_MEOL << SF_FIX_SHIFT_EOL)
368
369 #define SF_FL_BEFORE_SEOL       (SF_BEFORE_SEOL << SF_FL_SHIFT_EOL)
370 #define SF_FL_BEFORE_MEOL       (SF_BEFORE_MEOL << SF_FL_SHIFT_EOL) /* 0x20 */
371 #define SF_IS_INF               0x0040
372 #define SF_HAS_PAR              0x0080
373 #define SF_IN_PAR               0x0100
374 #define SF_HAS_EVAL             0x0200
375 #define SCF_DO_SUBSTR           0x0400
376 #define SCF_DO_STCLASS_AND      0x0800
377 #define SCF_DO_STCLASS_OR       0x1000
378 #define SCF_DO_STCLASS          (SCF_DO_STCLASS_AND|SCF_DO_STCLASS_OR)
379 #define SCF_WHILEM_VISITED_POS  0x2000
380
381 #define SCF_TRIE_RESTUDY        0x4000 /* Do restudy? */
382 #define SCF_SEEN_ACCEPT         0x8000 
383
384 #define UTF cBOOL(RExC_utf8)
385 #define LOC (get_regex_charset(RExC_flags) == REGEX_LOCALE_CHARSET)
386 #define UNI_SEMANTICS (get_regex_charset(RExC_flags) == REGEX_UNICODE_CHARSET)
387 #define DEPENDS_SEMANTICS (get_regex_charset(RExC_flags) == REGEX_DEPENDS_CHARSET)
388 #define AT_LEAST_UNI_SEMANTICS (get_regex_charset(RExC_flags) >= REGEX_UNICODE_CHARSET)
389 #define ASCII_RESTRICTED (get_regex_charset(RExC_flags) == REGEX_ASCII_RESTRICTED_CHARSET)
390 #define MORE_ASCII_RESTRICTED (get_regex_charset(RExC_flags) == REGEX_ASCII_MORE_RESTRICTED_CHARSET)
391 #define AT_LEAST_ASCII_RESTRICTED (get_regex_charset(RExC_flags) >= REGEX_ASCII_RESTRICTED_CHARSET)
392
393 #define FOLD cBOOL(RExC_flags & RXf_PMf_FOLD)
394
395 #define OOB_UNICODE             12345678
396 #define OOB_NAMEDCLASS          -1
397
398 #define CHR_SVLEN(sv) (UTF ? sv_len_utf8(sv) : SvCUR(sv))
399 #define CHR_DIST(a,b) (UTF ? utf8_distance(a,b) : a - b)
400
401
402 /* length of regex to show in messages that don't mark a position within */
403 #define RegexLengthToShowInErrorMessages 127
404
405 /*
406  * If MARKER[12] are adjusted, be sure to adjust the constants at the top
407  * of t/op/regmesg.t, the tests in t/op/re_tests, and those in
408  * op/pragma/warn/regcomp.
409  */
410 #define MARKER1 "<-- HERE"    /* marker as it appears in the description */
411 #define MARKER2 " <-- HERE "  /* marker as it appears within the regex */
412
413 #define REPORT_LOCATION " in regex; marked by " MARKER1 " in m/%.*s" MARKER2 "%s/"
414
415 /*
416  * Calls SAVEDESTRUCTOR_X if needed, then calls Perl_croak with the given
417  * arg. Show regex, up to a maximum length. If it's too long, chop and add
418  * "...".
419  */
420 #define _FAIL(code) STMT_START {                                        \
421     const char *ellipses = "";                                          \
422     IV len = RExC_end - RExC_precomp;                                   \
423                                                                         \
424     if (!SIZE_ONLY)                                                     \
425         SAVEDESTRUCTOR_X(clear_re,(void*)RExC_rx_sv);                   \
426     if (len > RegexLengthToShowInErrorMessages) {                       \
427         /* chop 10 shorter than the max, to ensure meaning of "..." */  \
428         len = RegexLengthToShowInErrorMessages - 10;                    \
429         ellipses = "...";                                               \
430     }                                                                   \
431     code;                                                               \
432 } STMT_END
433
434 #define FAIL(msg) _FAIL(                            \
435     Perl_croak(aTHX_ "%s in regex m/%.*s%s/",       \
436             msg, (int)len, RExC_precomp, ellipses))
437
438 #define FAIL2(msg,arg) _FAIL(                       \
439     Perl_croak(aTHX_ msg " in regex m/%.*s%s/",     \
440             arg, (int)len, RExC_precomp, ellipses))
441
442 /*
443  * Simple_vFAIL -- like FAIL, but marks the current location in the scan
444  */
445 #define Simple_vFAIL(m) STMT_START {                                    \
446     const IV offset = RExC_parse - RExC_precomp;                        \
447     Perl_croak(aTHX_ "%s" REPORT_LOCATION,                              \
448             m, (int)offset, RExC_precomp, RExC_precomp + offset);       \
449 } STMT_END
450
451 /*
452  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL()
453  */
454 #define vFAIL(m) STMT_START {                           \
455     if (!SIZE_ONLY)                                     \
456         SAVEDESTRUCTOR_X(clear_re,(void*)RExC_rx_sv);   \
457     Simple_vFAIL(m);                                    \
458 } STMT_END
459
460 /*
461  * Like Simple_vFAIL(), but accepts two arguments.
462  */
463 #define Simple_vFAIL2(m,a1) STMT_START {                        \
464     const IV offset = RExC_parse - RExC_precomp;                        \
465     S_re_croak2(aTHX_ m, REPORT_LOCATION, a1,                   \
466             (int)offset, RExC_precomp, RExC_precomp + offset);  \
467 } STMT_END
468
469 /*
470  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL2().
471  */
472 #define vFAIL2(m,a1) STMT_START {                       \
473     if (!SIZE_ONLY)                                     \
474         SAVEDESTRUCTOR_X(clear_re,(void*)RExC_rx_sv);   \
475     Simple_vFAIL2(m, a1);                               \
476 } STMT_END
477
478
479 /*
480  * Like Simple_vFAIL(), but accepts three arguments.
481  */
482 #define Simple_vFAIL3(m, a1, a2) STMT_START {                   \
483     const IV offset = RExC_parse - RExC_precomp;                \
484     S_re_croak2(aTHX_ m, REPORT_LOCATION, a1, a2,               \
485             (int)offset, RExC_precomp, RExC_precomp + offset);  \
486 } STMT_END
487
488 /*
489  * Calls SAVEDESTRUCTOR_X if needed, then Simple_vFAIL3().
490  */
491 #define vFAIL3(m,a1,a2) STMT_START {                    \
492     if (!SIZE_ONLY)                                     \
493         SAVEDESTRUCTOR_X(clear_re,(void*)RExC_rx_sv);   \
494     Simple_vFAIL3(m, a1, a2);                           \
495 } STMT_END
496
497 /*
498  * Like Simple_vFAIL(), but accepts four arguments.
499  */
500 #define Simple_vFAIL4(m, a1, a2, a3) STMT_START {               \
501     const IV offset = RExC_parse - RExC_precomp;                \
502     S_re_croak2(aTHX_ m, REPORT_LOCATION, a1, a2, a3,           \
503             (int)offset, RExC_precomp, RExC_precomp + offset);  \
504 } STMT_END
505
506 #define ckWARNreg(loc,m) STMT_START {                                   \
507     const IV offset = loc - RExC_precomp;                               \
508     Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,      \
509             (int)offset, RExC_precomp, RExC_precomp + offset);          \
510 } STMT_END
511
512 #define ckWARNregdep(loc,m) STMT_START {                                \
513     const IV offset = loc - RExC_precomp;                               \
514     Perl_ck_warner_d(aTHX_ packWARN2(WARN_DEPRECATED, WARN_REGEXP),     \
515             m REPORT_LOCATION,                                          \
516             (int)offset, RExC_precomp, RExC_precomp + offset);          \
517 } STMT_END
518
519 #define ckWARN2regdep(loc,m, a1) STMT_START {                           \
520     const IV offset = loc - RExC_precomp;                               \
521     Perl_ck_warner_d(aTHX_ packWARN2(WARN_DEPRECATED, WARN_REGEXP),     \
522             m REPORT_LOCATION,                                          \
523             a1, (int)offset, RExC_precomp, RExC_precomp + offset);      \
524 } STMT_END
525
526 #define ckWARN2reg(loc, m, a1) STMT_START {                             \
527     const IV offset = loc - RExC_precomp;                               \
528     Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,      \
529             a1, (int)offset, RExC_precomp, RExC_precomp + offset);      \
530 } STMT_END
531
532 #define vWARN3(loc, m, a1, a2) STMT_START {                             \
533     const IV offset = loc - RExC_precomp;                               \
534     Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,         \
535             a1, a2, (int)offset, RExC_precomp, RExC_precomp + offset);  \
536 } STMT_END
537
538 #define ckWARN3reg(loc, m, a1, a2) STMT_START {                         \
539     const IV offset = loc - RExC_precomp;                               \
540     Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,      \
541             a1, a2, (int)offset, RExC_precomp, RExC_precomp + offset);  \
542 } STMT_END
543
544 #define vWARN4(loc, m, a1, a2, a3) STMT_START {                         \
545     const IV offset = loc - RExC_precomp;                               \
546     Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,         \
547             a1, a2, a3, (int)offset, RExC_precomp, RExC_precomp + offset); \
548 } STMT_END
549
550 #define ckWARN4reg(loc, m, a1, a2, a3) STMT_START {                     \
551     const IV offset = loc - RExC_precomp;                               \
552     Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,      \
553             a1, a2, a3, (int)offset, RExC_precomp, RExC_precomp + offset); \
554 } STMT_END
555
556 #define vWARN5(loc, m, a1, a2, a3, a4) STMT_START {                     \
557     const IV offset = loc - RExC_precomp;                               \
558     Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,         \
559             a1, a2, a3, a4, (int)offset, RExC_precomp, RExC_precomp + offset); \
560 } STMT_END
561
562
563 /* Allow for side effects in s */
564 #define REGC(c,s) STMT_START {                  \
565     if (!SIZE_ONLY) *(s) = (c); else (void)(s); \
566 } STMT_END
567
568 /* Macros for recording node offsets.   20001227 mjd@plover.com 
569  * Nodes are numbered 1, 2, 3, 4.  Node #n's position is recorded in
570  * element 2*n-1 of the array.  Element #2n holds the byte length node #n.
571  * Element 0 holds the number n.
572  * Position is 1 indexed.
573  */
574 #ifndef RE_TRACK_PATTERN_OFFSETS
575 #define Set_Node_Offset_To_R(node,byte)
576 #define Set_Node_Offset(node,byte)
577 #define Set_Cur_Node_Offset
578 #define Set_Node_Length_To_R(node,len)
579 #define Set_Node_Length(node,len)
580 #define Set_Node_Cur_Length(node)
581 #define Node_Offset(n) 
582 #define Node_Length(n) 
583 #define Set_Node_Offset_Length(node,offset,len)
584 #define ProgLen(ri) ri->u.proglen
585 #define SetProgLen(ri,x) ri->u.proglen = x
586 #else
587 #define ProgLen(ri) ri->u.offsets[0]
588 #define SetProgLen(ri,x) ri->u.offsets[0] = x
589 #define Set_Node_Offset_To_R(node,byte) STMT_START {                    \
590     if (! SIZE_ONLY) {                                                  \
591         MJD_OFFSET_DEBUG(("** (%d) offset of node %d is %d.\n",         \
592                     __LINE__, (int)(node), (int)(byte)));               \
593         if((node) < 0) {                                                \
594             Perl_croak(aTHX_ "value of node is %d in Offset macro", (int)(node)); \
595         } else {                                                        \
596             RExC_offsets[2*(node)-1] = (byte);                          \
597         }                                                               \
598     }                                                                   \
599 } STMT_END
600
601 #define Set_Node_Offset(node,byte) \
602     Set_Node_Offset_To_R((node)-RExC_emit_start, (byte)-RExC_start)
603 #define Set_Cur_Node_Offset Set_Node_Offset(RExC_emit, RExC_parse)
604
605 #define Set_Node_Length_To_R(node,len) STMT_START {                     \
606     if (! SIZE_ONLY) {                                                  \
607         MJD_OFFSET_DEBUG(("** (%d) size of node %d is %d.\n",           \
608                 __LINE__, (int)(node), (int)(len)));                    \
609         if((node) < 0) {                                                \
610             Perl_croak(aTHX_ "value of node is %d in Length macro", (int)(node)); \
611         } else {                                                        \
612             RExC_offsets[2*(node)] = (len);                             \
613         }                                                               \
614     }                                                                   \
615 } STMT_END
616
617 #define Set_Node_Length(node,len) \
618     Set_Node_Length_To_R((node)-RExC_emit_start, len)
619 #define Set_Cur_Node_Length(len) Set_Node_Length(RExC_emit, len)
620 #define Set_Node_Cur_Length(node) \
621     Set_Node_Length(node, RExC_parse - parse_start)
622
623 /* Get offsets and lengths */
624 #define Node_Offset(n) (RExC_offsets[2*((n)-RExC_emit_start)-1])
625 #define Node_Length(n) (RExC_offsets[2*((n)-RExC_emit_start)])
626
627 #define Set_Node_Offset_Length(node,offset,len) STMT_START {    \
628     Set_Node_Offset_To_R((node)-RExC_emit_start, (offset));     \
629     Set_Node_Length_To_R((node)-RExC_emit_start, (len));        \
630 } STMT_END
631 #endif
632
633 #if PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS
634 #define EXPERIMENTAL_INPLACESCAN
635 #endif /*PERL_ENABLE_EXPERIMENTAL_REGEX_OPTIMISATIONS*/
636
637 #define DEBUG_STUDYDATA(str,data,depth)                              \
638 DEBUG_OPTIMISE_MORE_r(if(data){                                      \
639     PerlIO_printf(Perl_debug_log,                                    \
640         "%*s" str "Pos:%"IVdf"/%"IVdf                                \
641         " Flags: 0x%"UVXf" Whilem_c: %"IVdf" Lcp: %"IVdf" %s",       \
642         (int)(depth)*2, "",                                          \
643         (IV)((data)->pos_min),                                       \
644         (IV)((data)->pos_delta),                                     \
645         (UV)((data)->flags),                                         \
646         (IV)((data)->whilem_c),                                      \
647         (IV)((data)->last_closep ? *((data)->last_closep) : -1),     \
648         is_inf ? "INF " : ""                                         \
649     );                                                               \
650     if ((data)->last_found)                                          \
651         PerlIO_printf(Perl_debug_log,                                \
652             "Last:'%s' %"IVdf":%"IVdf"/%"IVdf" %sFixed:'%s' @ %"IVdf \
653             " %sFloat: '%s' @ %"IVdf"/%"IVdf"",                      \
654             SvPVX_const((data)->last_found),                         \
655             (IV)((data)->last_end),                                  \
656             (IV)((data)->last_start_min),                            \
657             (IV)((data)->last_start_max),                            \
658             ((data)->longest &&                                      \
659              (data)->longest==&((data)->longest_fixed)) ? "*" : "",  \
660             SvPVX_const((data)->longest_fixed),                      \
661             (IV)((data)->offset_fixed),                              \
662             ((data)->longest &&                                      \
663              (data)->longest==&((data)->longest_float)) ? "*" : "",  \
664             SvPVX_const((data)->longest_float),                      \
665             (IV)((data)->offset_float_min),                          \
666             (IV)((data)->offset_float_max)                           \
667         );                                                           \
668     PerlIO_printf(Perl_debug_log,"\n");                              \
669 });
670
671 static void clear_re(pTHX_ void *r);
672
673 /* Mark that we cannot extend a found fixed substring at this point.
674    Update the longest found anchored substring and the longest found
675    floating substrings if needed. */
676
677 STATIC void
678 S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, scan_data_t *data, I32 *minlenp, int is_inf)
679 {
680     const STRLEN l = CHR_SVLEN(data->last_found);
681     const STRLEN old_l = CHR_SVLEN(*data->longest);
682     GET_RE_DEBUG_FLAGS_DECL;
683
684     PERL_ARGS_ASSERT_SCAN_COMMIT;
685
686     if ((l >= old_l) && ((l > old_l) || (data->flags & SF_BEFORE_EOL))) {
687         SvSetMagicSV(*data->longest, data->last_found);
688         if (*data->longest == data->longest_fixed) {
689             data->offset_fixed = l ? data->last_start_min : data->pos_min;
690             if (data->flags & SF_BEFORE_EOL)
691                 data->flags
692                     |= ((data->flags & SF_BEFORE_EOL) << SF_FIX_SHIFT_EOL);
693             else
694                 data->flags &= ~SF_FIX_BEFORE_EOL;
695             data->minlen_fixed=minlenp;
696             data->lookbehind_fixed=0;
697         }
698         else { /* *data->longest == data->longest_float */
699             data->offset_float_min = l ? data->last_start_min : data->pos_min;
700             data->offset_float_max = (l
701                                       ? data->last_start_max
702                                       : data->pos_min + data->pos_delta);
703             if (is_inf || (U32)data->offset_float_max > (U32)I32_MAX)
704                 data->offset_float_max = I32_MAX;
705             if (data->flags & SF_BEFORE_EOL)
706                 data->flags
707                     |= ((data->flags & SF_BEFORE_EOL) << SF_FL_SHIFT_EOL);
708             else
709                 data->flags &= ~SF_FL_BEFORE_EOL;
710             data->minlen_float=minlenp;
711             data->lookbehind_float=0;
712         }
713     }
714     SvCUR_set(data->last_found, 0);
715     {
716         SV * const sv = data->last_found;
717         if (SvUTF8(sv) && SvMAGICAL(sv)) {
718             MAGIC * const mg = mg_find(sv, PERL_MAGIC_utf8);
719             if (mg)
720                 mg->mg_len = 0;
721         }
722     }
723     data->last_end = -1;
724     data->flags &= ~SF_BEFORE_EOL;
725     DEBUG_STUDYDATA("commit: ",data,0);
726 }
727
728 /* Can match anything (initialization) */
729 STATIC void
730 S_cl_anything(const RExC_state_t *pRExC_state, struct regnode_charclass_class *cl)
731 {
732     PERL_ARGS_ASSERT_CL_ANYTHING;
733
734     ANYOF_BITMAP_SETALL(cl);
735     cl->flags = ANYOF_CLASS|ANYOF_EOS|ANYOF_UNICODE_ALL
736                 |ANYOF_LOC_NONBITMAP_FOLD|ANYOF_NON_UTF8_LATIN1_ALL;
737
738     /* If any portion of the regex is to operate under locale rules,
739      * initialization includes it.  The reason this isn't done for all regexes
740      * is that the optimizer was written under the assumption that locale was
741      * all-or-nothing.  Given the complexity and lack of documentation in the
742      * optimizer, and that there are inadequate test cases for locale, so many
743      * parts of it may not work properly, it is safest to avoid locale unless
744      * necessary. */
745     if (RExC_contains_locale) {
746         ANYOF_CLASS_SETALL(cl);     /* /l uses class */
747         cl->flags |= ANYOF_LOCALE;
748     }
749     else {
750         ANYOF_CLASS_ZERO(cl);       /* Only /l uses class now */
751     }
752 }
753
754 /* Can match anything (initialization) */
755 STATIC int
756 S_cl_is_anything(const struct regnode_charclass_class *cl)
757 {
758     int value;
759
760     PERL_ARGS_ASSERT_CL_IS_ANYTHING;
761
762     for (value = 0; value <= ANYOF_MAX; value += 2)
763         if (ANYOF_CLASS_TEST(cl, value) && ANYOF_CLASS_TEST(cl, value + 1))
764             return 1;
765     if (!(cl->flags & ANYOF_UNICODE_ALL))
766         return 0;
767     if (!ANYOF_BITMAP_TESTALLSET((const void*)cl))
768         return 0;
769     return 1;
770 }
771
772 /* Can match anything (initialization) */
773 STATIC void
774 S_cl_init(const RExC_state_t *pRExC_state, struct regnode_charclass_class *cl)
775 {
776     PERL_ARGS_ASSERT_CL_INIT;
777
778     Zero(cl, 1, struct regnode_charclass_class);
779     cl->type = ANYOF;
780     cl_anything(pRExC_state, cl);
781     ARG_SET(cl, ANYOF_NONBITMAP_EMPTY);
782 }
783
784 /* These two functions currently do the exact same thing */
785 #define cl_init_zero            S_cl_init
786
787 /* 'AND' a given class with another one.  Can create false positives.  'cl'
788  * should not be inverted.  'and_with->flags & ANYOF_CLASS' should be 0 if
789  * 'and_with' is a regnode_charclass instead of a regnode_charclass_class. */
790 STATIC void
791 S_cl_and(struct regnode_charclass_class *cl,
792         const struct regnode_charclass_class *and_with)
793 {
794     PERL_ARGS_ASSERT_CL_AND;
795
796     assert(and_with->type == ANYOF);
797
798     /* I (khw) am not sure all these restrictions are necessary XXX */
799     if (!(ANYOF_CLASS_TEST_ANY_SET(and_with))
800         && !(ANYOF_CLASS_TEST_ANY_SET(cl))
801         && (and_with->flags & ANYOF_LOCALE) == (cl->flags & ANYOF_LOCALE)
802         && !(and_with->flags & ANYOF_LOC_NONBITMAP_FOLD)
803         && !(cl->flags & ANYOF_LOC_NONBITMAP_FOLD)) {
804         int i;
805
806         if (and_with->flags & ANYOF_INVERT)
807             for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
808                 cl->bitmap[i] &= ~and_with->bitmap[i];
809         else
810             for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
811                 cl->bitmap[i] &= and_with->bitmap[i];
812     } /* XXXX: logic is complicated otherwise, leave it along for a moment. */
813
814     if (and_with->flags & ANYOF_INVERT) {
815
816         /* Here, the and'ed node is inverted.  Get the AND of the flags that
817          * aren't affected by the inversion.  Those that are affected are
818          * handled individually below */
819         U8 affected_flags = cl->flags & ~INVERSION_UNAFFECTED_FLAGS;
820         cl->flags &= (and_with->flags & INVERSION_UNAFFECTED_FLAGS);
821         cl->flags |= affected_flags;
822
823         /* We currently don't know how to deal with things that aren't in the
824          * bitmap, but we know that the intersection is no greater than what
825          * is already in cl, so let there be false positives that get sorted
826          * out after the synthetic start class succeeds, and the node is
827          * matched for real. */
828
829         /* The inversion of these two flags indicate that the resulting
830          * intersection doesn't have them */
831         if (and_with->flags & ANYOF_UNICODE_ALL) {
832             cl->flags &= ~ANYOF_UNICODE_ALL;
833         }
834         if (and_with->flags & ANYOF_NON_UTF8_LATIN1_ALL) {
835             cl->flags &= ~ANYOF_NON_UTF8_LATIN1_ALL;
836         }
837     }
838     else {   /* and'd node is not inverted */
839         U8 outside_bitmap_but_not_utf8; /* Temp variable */
840
841         if (! ANYOF_NONBITMAP(and_with)) {
842
843             /* Here 'and_with' doesn't match anything outside the bitmap
844              * (except possibly ANYOF_UNICODE_ALL), which means the
845              * intersection can't either, except for ANYOF_UNICODE_ALL, in
846              * which case we don't know what the intersection is, but it's no
847              * greater than what cl already has, so can just leave it alone,
848              * with possible false positives */
849             if (! (and_with->flags & ANYOF_UNICODE_ALL)) {
850                 ARG_SET(cl, ANYOF_NONBITMAP_EMPTY);
851                 cl->flags &= ~ANYOF_NONBITMAP_NON_UTF8;
852             }
853         }
854         else if (! ANYOF_NONBITMAP(cl)) {
855
856             /* Here, 'and_with' does match something outside the bitmap, and cl
857              * doesn't have a list of things to match outside the bitmap.  If
858              * cl can match all code points above 255, the intersection will
859              * be those above-255 code points that 'and_with' matches.  If cl
860              * can't match all Unicode code points, it means that it can't
861              * match anything outside the bitmap (since the 'if' that got us
862              * into this block tested for that), so we leave the bitmap empty.
863              */
864             if (cl->flags & ANYOF_UNICODE_ALL) {
865                 ARG_SET(cl, ARG(and_with));
866
867                 /* and_with's ARG may match things that don't require UTF8.
868                  * And now cl's will too, in spite of this being an 'and'.  See
869                  * the comments below about the kludge */
870                 cl->flags |= and_with->flags & ANYOF_NONBITMAP_NON_UTF8;
871             }
872         }
873         else {
874             /* Here, both 'and_with' and cl match something outside the
875              * bitmap.  Currently we do not do the intersection, so just match
876              * whatever cl had at the beginning.  */
877         }
878
879
880         /* Take the intersection of the two sets of flags.  However, the
881          * ANYOF_NONBITMAP_NON_UTF8 flag is treated as an 'or'.  This is a
882          * kludge around the fact that this flag is not treated like the others
883          * which are initialized in cl_anything().  The way the optimizer works
884          * is that the synthetic start class (SSC) is initialized to match
885          * anything, and then the first time a real node is encountered, its
886          * values are AND'd with the SSC's with the result being the values of
887          * the real node.  However, there are paths through the optimizer where
888          * the AND never gets called, so those initialized bits are set
889          * inappropriately, which is not usually a big deal, as they just cause
890          * false positives in the SSC, which will just mean a probably
891          * imperceptible slow down in execution.  However this bit has a
892          * higher false positive consequence in that it can cause utf8.pm,
893          * utf8_heavy.pl ... to be loaded when not necessary, which is a much
894          * bigger slowdown and also causes significant extra memory to be used.
895          * In order to prevent this, the code now takes a different tack.  The
896          * bit isn't set unless some part of the regular expression needs it,
897          * but once set it won't get cleared.  This means that these extra
898          * modules won't get loaded unless there was some path through the
899          * pattern that would have required them anyway, and  so any false
900          * positives that occur by not ANDing them out when they could be
901          * aren't as severe as they would be if we treated this bit like all
902          * the others */
903         outside_bitmap_but_not_utf8 = (cl->flags | and_with->flags)
904                                       & ANYOF_NONBITMAP_NON_UTF8;
905         cl->flags &= and_with->flags;
906         cl->flags |= outside_bitmap_but_not_utf8;
907     }
908 }
909
910 /* 'OR' a given class with another one.  Can create false positives.  'cl'
911  * should not be inverted.  'or_with->flags & ANYOF_CLASS' should be 0 if
912  * 'or_with' is a regnode_charclass instead of a regnode_charclass_class. */
913 STATIC void
914 S_cl_or(const RExC_state_t *pRExC_state, struct regnode_charclass_class *cl, const struct regnode_charclass_class *or_with)
915 {
916     PERL_ARGS_ASSERT_CL_OR;
917
918     if (or_with->flags & ANYOF_INVERT) {
919
920         /* Here, the or'd node is to be inverted.  This means we take the
921          * complement of everything not in the bitmap, but currently we don't
922          * know what that is, so give up and match anything */
923         if (ANYOF_NONBITMAP(or_with)) {
924             cl_anything(pRExC_state, cl);
925         }
926         /* We do not use
927          * (B1 | CL1) | (!B2 & !CL2) = (B1 | !B2 & !CL2) | (CL1 | (!B2 & !CL2))
928          *   <= (B1 | !B2) | (CL1 | !CL2)
929          * which is wasteful if CL2 is small, but we ignore CL2:
930          *   (B1 | CL1) | (!B2 & !CL2) <= (B1 | CL1) | !B2 = (B1 | !B2) | CL1
931          * XXXX Can we handle case-fold?  Unclear:
932          *   (OK1(i) | OK1(i')) | !(OK1(i) | OK1(i')) =
933          *   (OK1(i) | OK1(i')) | (!OK1(i) & !OK1(i'))
934          */
935         else if ( (or_with->flags & ANYOF_LOCALE) == (cl->flags & ANYOF_LOCALE)
936              && !(or_with->flags & ANYOF_LOC_NONBITMAP_FOLD)
937              && !(cl->flags & ANYOF_LOC_NONBITMAP_FOLD) ) {
938             int i;
939
940             for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
941                 cl->bitmap[i] |= ~or_with->bitmap[i];
942         } /* XXXX: logic is complicated otherwise */
943         else {
944             cl_anything(pRExC_state, cl);
945         }
946
947         /* And, we can just take the union of the flags that aren't affected
948          * by the inversion */
949         cl->flags |= or_with->flags & INVERSION_UNAFFECTED_FLAGS;
950
951         /* For the remaining flags:
952             ANYOF_UNICODE_ALL and inverted means to not match anything above
953                     255, which means that the union with cl should just be
954                     what cl has in it, so can ignore this flag
955             ANYOF_NON_UTF8_LATIN1_ALL and inverted means if not utf8 and ord
956                     is 127-255 to match them, but then invert that, so the
957                     union with cl should just be what cl has in it, so can
958                     ignore this flag
959          */
960     } else {    /* 'or_with' is not inverted */
961         /* (B1 | CL1) | (B2 | CL2) = (B1 | B2) | (CL1 | CL2)) */
962         if ( (or_with->flags & ANYOF_LOCALE) == (cl->flags & ANYOF_LOCALE)
963              && (!(or_with->flags & ANYOF_LOC_NONBITMAP_FOLD)
964                  || (cl->flags & ANYOF_LOC_NONBITMAP_FOLD)) ) {
965             int i;
966
967             /* OR char bitmap and class bitmap separately */
968             for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
969                 cl->bitmap[i] |= or_with->bitmap[i];
970             if (ANYOF_CLASS_TEST_ANY_SET(or_with)) {
971                 for (i = 0; i < ANYOF_CLASSBITMAP_SIZE; i++)
972                     cl->classflags[i] |= or_with->classflags[i];
973                 cl->flags |= ANYOF_CLASS;
974             }
975         }
976         else { /* XXXX: logic is complicated, leave it along for a moment. */
977             cl_anything(pRExC_state, cl);
978         }
979
980         if (ANYOF_NONBITMAP(or_with)) {
981
982             /* Use the added node's outside-the-bit-map match if there isn't a
983              * conflict.  If there is a conflict (both nodes match something
984              * outside the bitmap, but what they match outside is not the same
985              * pointer, and hence not easily compared until XXX we extend
986              * inversion lists this far), give up and allow the start class to
987              * match everything outside the bitmap.  If that stuff is all above
988              * 255, can just set UNICODE_ALL, otherwise caould be anything. */
989             if (! ANYOF_NONBITMAP(cl)) {
990                 ARG_SET(cl, ARG(or_with));
991             }
992             else if (ARG(cl) != ARG(or_with)) {
993
994                 if ((or_with->flags & ANYOF_NONBITMAP_NON_UTF8)) {
995                     cl_anything(pRExC_state, cl);
996                 }
997                 else {
998                     cl->flags |= ANYOF_UNICODE_ALL;
999                 }
1000             }
1001         }
1002
1003         /* Take the union */
1004         cl->flags |= or_with->flags;
1005     }
1006 }
1007
1008 #define TRIE_LIST_ITEM(state,idx) (trie->states[state].trans.list)[ idx ]
1009 #define TRIE_LIST_CUR(state)  ( TRIE_LIST_ITEM( state, 0 ).forid )
1010 #define TRIE_LIST_LEN(state) ( TRIE_LIST_ITEM( state, 0 ).newstate )
1011 #define TRIE_LIST_USED(idx)  ( trie->states[state].trans.list ? (TRIE_LIST_CUR( idx ) - 1) : 0 )
1012
1013
1014 #ifdef DEBUGGING
1015 /*
1016    dump_trie(trie,widecharmap,revcharmap)
1017    dump_trie_interim_list(trie,widecharmap,revcharmap,next_alloc)
1018    dump_trie_interim_table(trie,widecharmap,revcharmap,next_alloc)
1019
1020    These routines dump out a trie in a somewhat readable format.
1021    The _interim_ variants are used for debugging the interim
1022    tables that are used to generate the final compressed
1023    representation which is what dump_trie expects.
1024
1025    Part of the reason for their existence is to provide a form
1026    of documentation as to how the different representations function.
1027
1028 */
1029
1030 /*
1031   Dumps the final compressed table form of the trie to Perl_debug_log.
1032   Used for debugging make_trie().
1033 */
1034
1035 STATIC void
1036 S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap,
1037             AV *revcharmap, U32 depth)
1038 {
1039     U32 state;
1040     SV *sv=sv_newmortal();
1041     int colwidth= widecharmap ? 6 : 4;
1042     U16 word;
1043     GET_RE_DEBUG_FLAGS_DECL;
1044
1045     PERL_ARGS_ASSERT_DUMP_TRIE;
1046
1047     PerlIO_printf( Perl_debug_log, "%*sChar : %-6s%-6s%-4s ",
1048         (int)depth * 2 + 2,"",
1049         "Match","Base","Ofs" );
1050
1051     for( state = 0 ; state < trie->uniquecharcount ; state++ ) {
1052         SV ** const tmp = av_fetch( revcharmap, state, 0);
1053         if ( tmp ) {
1054             PerlIO_printf( Perl_debug_log, "%*s", 
1055                 colwidth,
1056                 pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), colwidth, 
1057                             PL_colors[0], PL_colors[1],
1058                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
1059                             PERL_PV_ESCAPE_FIRSTCHAR 
1060                 ) 
1061             );
1062         }
1063     }
1064     PerlIO_printf( Perl_debug_log, "\n%*sState|-----------------------",
1065         (int)depth * 2 + 2,"");
1066
1067     for( state = 0 ; state < trie->uniquecharcount ; state++ )
1068         PerlIO_printf( Perl_debug_log, "%.*s", colwidth, "--------");
1069     PerlIO_printf( Perl_debug_log, "\n");
1070
1071     for( state = 1 ; state < trie->statecount ; state++ ) {
1072         const U32 base = trie->states[ state ].trans.base;
1073
1074         PerlIO_printf( Perl_debug_log, "%*s#%4"UVXf"|", (int)depth * 2 + 2,"", (UV)state);
1075
1076         if ( trie->states[ state ].wordnum ) {
1077             PerlIO_printf( Perl_debug_log, " W%4X", trie->states[ state ].wordnum );
1078         } else {
1079             PerlIO_printf( Perl_debug_log, "%6s", "" );
1080         }
1081
1082         PerlIO_printf( Perl_debug_log, " @%4"UVXf" ", (UV)base );
1083
1084         if ( base ) {
1085             U32 ofs = 0;
1086
1087             while( ( base + ofs  < trie->uniquecharcount ) ||
1088                    ( base + ofs - trie->uniquecharcount < trie->lasttrans
1089                      && trie->trans[ base + ofs - trie->uniquecharcount ].check != state))
1090                     ofs++;
1091
1092             PerlIO_printf( Perl_debug_log, "+%2"UVXf"[ ", (UV)ofs);
1093
1094             for ( ofs = 0 ; ofs < trie->uniquecharcount ; ofs++ ) {
1095                 if ( ( base + ofs >= trie->uniquecharcount ) &&
1096                      ( base + ofs - trie->uniquecharcount < trie->lasttrans ) &&
1097                      trie->trans[ base + ofs - trie->uniquecharcount ].check == state )
1098                 {
1099                    PerlIO_printf( Perl_debug_log, "%*"UVXf,
1100                     colwidth,
1101                     (UV)trie->trans[ base + ofs - trie->uniquecharcount ].next );
1102                 } else {
1103                     PerlIO_printf( Perl_debug_log, "%*s",colwidth,"   ." );
1104                 }
1105             }
1106
1107             PerlIO_printf( Perl_debug_log, "]");
1108
1109         }
1110         PerlIO_printf( Perl_debug_log, "\n" );
1111     }
1112     PerlIO_printf(Perl_debug_log, "%*sword_info N:(prev,len)=", (int)depth*2, "");
1113     for (word=1; word <= trie->wordcount; word++) {
1114         PerlIO_printf(Perl_debug_log, " %d:(%d,%d)",
1115             (int)word, (int)(trie->wordinfo[word].prev),
1116             (int)(trie->wordinfo[word].len));
1117     }
1118     PerlIO_printf(Perl_debug_log, "\n" );
1119 }    
1120 /*
1121   Dumps a fully constructed but uncompressed trie in list form.
1122   List tries normally only are used for construction when the number of 
1123   possible chars (trie->uniquecharcount) is very high.
1124   Used for debugging make_trie().
1125 */
1126 STATIC void
1127 S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie,
1128                          HV *widecharmap, AV *revcharmap, U32 next_alloc,
1129                          U32 depth)
1130 {
1131     U32 state;
1132     SV *sv=sv_newmortal();
1133     int colwidth= widecharmap ? 6 : 4;
1134     GET_RE_DEBUG_FLAGS_DECL;
1135
1136     PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST;
1137
1138     /* print out the table precompression.  */
1139     PerlIO_printf( Perl_debug_log, "%*sState :Word | Transition Data\n%*s%s",
1140         (int)depth * 2 + 2,"", (int)depth * 2 + 2,"",
1141         "------:-----+-----------------\n" );
1142     
1143     for( state=1 ; state < next_alloc ; state ++ ) {
1144         U16 charid;
1145     
1146         PerlIO_printf( Perl_debug_log, "%*s %4"UVXf" :",
1147             (int)depth * 2 + 2,"", (UV)state  );
1148         if ( ! trie->states[ state ].wordnum ) {
1149             PerlIO_printf( Perl_debug_log, "%5s| ","");
1150         } else {
1151             PerlIO_printf( Perl_debug_log, "W%4x| ",
1152                 trie->states[ state ].wordnum
1153             );
1154         }
1155         for( charid = 1 ; charid <= TRIE_LIST_USED( state ) ; charid++ ) {
1156             SV ** const tmp = av_fetch( revcharmap, TRIE_LIST_ITEM(state,charid).forid, 0);
1157             if ( tmp ) {
1158                 PerlIO_printf( Perl_debug_log, "%*s:%3X=%4"UVXf" | ",
1159                     colwidth,
1160                     pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), colwidth, 
1161                             PL_colors[0], PL_colors[1],
1162                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
1163                             PERL_PV_ESCAPE_FIRSTCHAR 
1164                     ) ,
1165                     TRIE_LIST_ITEM(state,charid).forid,
1166                     (UV)TRIE_LIST_ITEM(state,charid).newstate
1167                 );
1168                 if (!(charid % 10)) 
1169                     PerlIO_printf(Perl_debug_log, "\n%*s| ",
1170                         (int)((depth * 2) + 14), "");
1171             }
1172         }
1173         PerlIO_printf( Perl_debug_log, "\n");
1174     }
1175 }    
1176
1177 /*
1178   Dumps a fully constructed but uncompressed trie in table form.
1179   This is the normal DFA style state transition table, with a few 
1180   twists to facilitate compression later. 
1181   Used for debugging make_trie().
1182 */
1183 STATIC void
1184 S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie,
1185                           HV *widecharmap, AV *revcharmap, U32 next_alloc,
1186                           U32 depth)
1187 {
1188     U32 state;
1189     U16 charid;
1190     SV *sv=sv_newmortal();
1191     int colwidth= widecharmap ? 6 : 4;
1192     GET_RE_DEBUG_FLAGS_DECL;
1193
1194     PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE;
1195     
1196     /*
1197        print out the table precompression so that we can do a visual check
1198        that they are identical.
1199      */
1200     
1201     PerlIO_printf( Perl_debug_log, "%*sChar : ",(int)depth * 2 + 2,"" );
1202
1203     for( charid = 0 ; charid < trie->uniquecharcount ; charid++ ) {
1204         SV ** const tmp = av_fetch( revcharmap, charid, 0);
1205         if ( tmp ) {
1206             PerlIO_printf( Perl_debug_log, "%*s", 
1207                 colwidth,
1208                 pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), colwidth, 
1209                             PL_colors[0], PL_colors[1],
1210                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
1211                             PERL_PV_ESCAPE_FIRSTCHAR 
1212                 ) 
1213             );
1214         }
1215     }
1216
1217     PerlIO_printf( Perl_debug_log, "\n%*sState+-",(int)depth * 2 + 2,"" );
1218
1219     for( charid=0 ; charid < trie->uniquecharcount ; charid++ ) {
1220         PerlIO_printf( Perl_debug_log, "%.*s", colwidth,"--------");
1221     }
1222
1223     PerlIO_printf( Perl_debug_log, "\n" );
1224
1225     for( state=1 ; state < next_alloc ; state += trie->uniquecharcount ) {
1226
1227         PerlIO_printf( Perl_debug_log, "%*s%4"UVXf" : ", 
1228             (int)depth * 2 + 2,"",
1229             (UV)TRIE_NODENUM( state ) );
1230
1231         for( charid = 0 ; charid < trie->uniquecharcount ; charid++ ) {
1232             UV v=(UV)SAFE_TRIE_NODENUM( trie->trans[ state + charid ].next );
1233             if (v)
1234                 PerlIO_printf( Perl_debug_log, "%*"UVXf, colwidth, v );
1235             else
1236                 PerlIO_printf( Perl_debug_log, "%*s", colwidth, "." );
1237         }
1238         if ( ! trie->states[ TRIE_NODENUM( state ) ].wordnum ) {
1239             PerlIO_printf( Perl_debug_log, " (%4"UVXf")\n", (UV)trie->trans[ state ].check );
1240         } else {
1241             PerlIO_printf( Perl_debug_log, " (%4"UVXf") W%4X\n", (UV)trie->trans[ state ].check,
1242             trie->states[ TRIE_NODENUM( state ) ].wordnum );
1243         }
1244     }
1245 }
1246
1247 #endif
1248
1249
1250 /* make_trie(startbranch,first,last,tail,word_count,flags,depth)
1251   startbranch: the first branch in the whole branch sequence
1252   first      : start branch of sequence of branch-exact nodes.
1253                May be the same as startbranch
1254   last       : Thing following the last branch.
1255                May be the same as tail.
1256   tail       : item following the branch sequence
1257   count      : words in the sequence
1258   flags      : currently the OP() type we will be building one of /EXACT(|F|Fl)/
1259   depth      : indent depth
1260
1261 Inplace optimizes a sequence of 2 or more Branch-Exact nodes into a TRIE node.
1262
1263 A trie is an N'ary tree where the branches are determined by digital
1264 decomposition of the key. IE, at the root node you look up the 1st character and
1265 follow that branch repeat until you find the end of the branches. Nodes can be
1266 marked as "accepting" meaning they represent a complete word. Eg:
1267
1268   /he|she|his|hers/
1269
1270 would convert into the following structure. Numbers represent states, letters
1271 following numbers represent valid transitions on the letter from that state, if
1272 the number is in square brackets it represents an accepting state, otherwise it
1273 will be in parenthesis.
1274
1275       +-h->+-e->[3]-+-r->(8)-+-s->[9]
1276       |    |
1277       |   (2)
1278       |    |
1279      (1)   +-i->(6)-+-s->[7]
1280       |
1281       +-s->(3)-+-h->(4)-+-e->[5]
1282
1283       Accept Word Mapping: 3=>1 (he),5=>2 (she), 7=>3 (his), 9=>4 (hers)
1284
1285 This shows that when matching against the string 'hers' we will begin at state 1
1286 read 'h' and move to state 2, read 'e' and move to state 3 which is accepting,
1287 then read 'r' and go to state 8 followed by 's' which takes us to state 9 which
1288 is also accepting. Thus we know that we can match both 'he' and 'hers' with a
1289 single traverse. We store a mapping from accepting to state to which word was
1290 matched, and then when we have multiple possibilities we try to complete the
1291 rest of the regex in the order in which they occured in the alternation.
1292
1293 The only prior NFA like behaviour that would be changed by the TRIE support is
1294 the silent ignoring of duplicate alternations which are of the form:
1295
1296  / (DUPE|DUPE) X? (?{ ... }) Y /x
1297
1298 Thus EVAL blocks following a trie may be called a different number of times with
1299 and without the optimisation. With the optimisations dupes will be silently
1300 ignored. This inconsistent behaviour of EVAL type nodes is well established as
1301 the following demonstrates:
1302
1303  'words'=~/(word|word|word)(?{ print $1 })[xyz]/
1304
1305 which prints out 'word' three times, but
1306
1307  'words'=~/(word|word|word)(?{ print $1 })S/
1308
1309 which doesnt print it out at all. This is due to other optimisations kicking in.
1310
1311 Example of what happens on a structural level:
1312
1313 The regexp /(ac|ad|ab)+/ will produce the following debug output:
1314
1315    1: CURLYM[1] {1,32767}(18)
1316    5:   BRANCH(8)
1317    6:     EXACT <ac>(16)
1318    8:   BRANCH(11)
1319    9:     EXACT <ad>(16)
1320   11:   BRANCH(14)
1321   12:     EXACT <ab>(16)
1322   16:   SUCCEED(0)
1323   17:   NOTHING(18)
1324   18: END(0)
1325
1326 This would be optimizable with startbranch=5, first=5, last=16, tail=16
1327 and should turn into:
1328
1329    1: CURLYM[1] {1,32767}(18)
1330    5:   TRIE(16)
1331         [Words:3 Chars Stored:6 Unique Chars:4 States:5 NCP:1]
1332           <ac>
1333           <ad>
1334           <ab>
1335   16:   SUCCEED(0)
1336   17:   NOTHING(18)
1337   18: END(0)
1338
1339 Cases where tail != last would be like /(?foo|bar)baz/:
1340
1341    1: BRANCH(4)
1342    2:   EXACT <foo>(8)
1343    4: BRANCH(7)
1344    5:   EXACT <bar>(8)
1345    7: TAIL(8)
1346    8: EXACT <baz>(10)
1347   10: END(0)
1348
1349 which would be optimizable with startbranch=1, first=1, last=7, tail=8
1350 and would end up looking like:
1351
1352     1: TRIE(8)
1353       [Words:2 Chars Stored:6 Unique Chars:5 States:7 NCP:1]
1354         <foo>
1355         <bar>
1356    7: TAIL(8)
1357    8: EXACT <baz>(10)
1358   10: END(0)
1359
1360     d = uvuni_to_utf8_flags(d, uv, 0);
1361
1362 is the recommended Unicode-aware way of saying
1363
1364     *(d++) = uv;
1365 */
1366
1367 #define TRIE_STORE_REVCHAR                                                 \
1368     STMT_START {                                                           \
1369         if (UTF) {                                                         \
1370             SV *zlopp = newSV(2);                                          \
1371             unsigned char *flrbbbbb = (unsigned char *) SvPVX(zlopp);      \
1372             unsigned const char *const kapow = uvuni_to_utf8(flrbbbbb, uvc & 0xFF); \
1373             SvCUR_set(zlopp, kapow - flrbbbbb);                            \
1374             SvPOK_on(zlopp);                                               \
1375             SvUTF8_on(zlopp);                                              \
1376             av_push(revcharmap, zlopp);                                    \
1377         } else {                                                           \
1378             char ooooff = (char)uvc;                                               \
1379             av_push(revcharmap, newSVpvn(&ooooff, 1));                     \
1380         }                                                                  \
1381         } STMT_END
1382
1383 #define TRIE_READ_CHAR STMT_START {                                           \
1384     wordlen++;                                                                \
1385     if ( UTF ) {                                                              \
1386         if ( folder ) {                                                       \
1387             if ( foldlen > 0 ) {                                              \
1388                uvc = utf8n_to_uvuni( scan, UTF8_MAXLEN, &len, uniflags );     \
1389                foldlen -= len;                                                \
1390                scan += len;                                                   \
1391                len = 0;                                                       \
1392             } else {                                                          \
1393                 len = UTF8SKIP(uc);\
1394                 uvc = to_utf8_fold( uc, foldbuf, &foldlen);                   \
1395                 foldlen -= UNISKIP( uvc );                                    \
1396                 scan = foldbuf + UNISKIP( uvc );                              \
1397             }                                                                 \
1398         } else {                                                              \
1399             uvc = utf8n_to_uvuni( (const U8*)uc, UTF8_MAXLEN, &len, uniflags);\
1400         }                                                                     \
1401     } else {                                                                  \
1402         uvc = (U32)*uc;                                                       \
1403         len = 1;                                                              \
1404     }                                                                         \
1405 } STMT_END
1406
1407
1408
1409 #define TRIE_LIST_PUSH(state,fid,ns) STMT_START {               \
1410     if ( TRIE_LIST_CUR( state ) >=TRIE_LIST_LEN( state ) ) {    \
1411         U32 ging = TRIE_LIST_LEN( state ) *= 2;                 \
1412         Renew( trie->states[ state ].trans.list, ging, reg_trie_trans_le ); \
1413     }                                                           \
1414     TRIE_LIST_ITEM( state, TRIE_LIST_CUR( state ) ).forid = fid;     \
1415     TRIE_LIST_ITEM( state, TRIE_LIST_CUR( state ) ).newstate = ns;   \
1416     TRIE_LIST_CUR( state )++;                                   \
1417 } STMT_END
1418
1419 #define TRIE_LIST_NEW(state) STMT_START {                       \
1420     Newxz( trie->states[ state ].trans.list,               \
1421         4, reg_trie_trans_le );                                 \
1422      TRIE_LIST_CUR( state ) = 1;                                \
1423      TRIE_LIST_LEN( state ) = 4;                                \
1424 } STMT_END
1425
1426 #define TRIE_HANDLE_WORD(state) STMT_START {                    \
1427     U16 dupe= trie->states[ state ].wordnum;                    \
1428     regnode * const noper_next = regnext( noper );              \
1429                                                                 \
1430     DEBUG_r({                                                   \
1431         /* store the word for dumping */                        \
1432         SV* tmp;                                                \
1433         if (OP(noper) != NOTHING)                               \
1434             tmp = newSVpvn_utf8(STRING(noper), STR_LEN(noper), UTF);    \
1435         else                                                    \
1436             tmp = newSVpvn_utf8( "", 0, UTF );                  \
1437         av_push( trie_words, tmp );                             \
1438     });                                                         \
1439                                                                 \
1440     curword++;                                                  \
1441     trie->wordinfo[curword].prev   = 0;                         \
1442     trie->wordinfo[curword].len    = wordlen;                   \
1443     trie->wordinfo[curword].accept = state;                     \
1444                                                                 \
1445     if ( noper_next < tail ) {                                  \
1446         if (!trie->jump)                                        \
1447             trie->jump = (U16 *) PerlMemShared_calloc( word_count + 1, sizeof(U16) ); \
1448         trie->jump[curword] = (U16)(noper_next - convert);      \
1449         if (!jumper)                                            \
1450             jumper = noper_next;                                \
1451         if (!nextbranch)                                        \
1452             nextbranch= regnext(cur);                           \
1453     }                                                           \
1454                                                                 \
1455     if ( dupe ) {                                               \
1456         /* It's a dupe. Pre-insert into the wordinfo[].prev   */\
1457         /* chain, so that when the bits of chain are later    */\
1458         /* linked together, the dups appear in the chain      */\
1459         trie->wordinfo[curword].prev = trie->wordinfo[dupe].prev; \
1460         trie->wordinfo[dupe].prev = curword;                    \
1461     } else {                                                    \
1462         /* we haven't inserted this word yet.                */ \
1463         trie->states[ state ].wordnum = curword;                \
1464     }                                                           \
1465 } STMT_END
1466
1467
1468 #define TRIE_TRANS_STATE(state,base,ucharcount,charid,special)          \
1469      ( ( base + charid >=  ucharcount                                   \
1470          && base + charid < ubound                                      \
1471          && state == trie->trans[ base - ucharcount + charid ].check    \
1472          && trie->trans[ base - ucharcount + charid ].next )            \
1473            ? trie->trans[ base - ucharcount + charid ].next             \
1474            : ( state==1 ? special : 0 )                                 \
1475       )
1476
1477 #define MADE_TRIE       1
1478 #define MADE_JUMP_TRIE  2
1479 #define MADE_EXACT_TRIE 4
1480
1481 STATIC I32
1482 S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth)
1483 {
1484     dVAR;
1485     /* first pass, loop through and scan words */
1486     reg_trie_data *trie;
1487     HV *widecharmap = NULL;
1488     AV *revcharmap = newAV();
1489     regnode *cur;
1490     const U32 uniflags = UTF8_ALLOW_DEFAULT;
1491     STRLEN len = 0;
1492     UV uvc = 0;
1493     U16 curword = 0;
1494     U32 next_alloc = 0;
1495     regnode *jumper = NULL;
1496     regnode *nextbranch = NULL;
1497     regnode *convert = NULL;
1498     U32 *prev_states; /* temp array mapping each state to previous one */
1499     /* we just use folder as a flag in utf8 */
1500     const U8 * folder = NULL;
1501
1502 #ifdef DEBUGGING
1503     const U32 data_slot = add_data( pRExC_state, 4, "tuuu" );
1504     AV *trie_words = NULL;
1505     /* along with revcharmap, this only used during construction but both are
1506      * useful during debugging so we store them in the struct when debugging.
1507      */
1508 #else
1509     const U32 data_slot = add_data( pRExC_state, 2, "tu" );
1510     STRLEN trie_charcount=0;
1511 #endif
1512     SV *re_trie_maxbuff;
1513     GET_RE_DEBUG_FLAGS_DECL;
1514
1515     PERL_ARGS_ASSERT_MAKE_TRIE;
1516 #ifndef DEBUGGING
1517     PERL_UNUSED_ARG(depth);
1518 #endif
1519
1520     switch (flags) {
1521         case EXACT: break;
1522         case EXACTFA:
1523         case EXACTFU: folder = PL_fold_latin1; break;
1524         case EXACTF:  folder = PL_fold; break;
1525         case EXACTFL: folder = PL_fold_locale; break;
1526         default: Perl_croak( aTHX_ "panic! In trie construction, unknown node type %u", (unsigned) flags );
1527     }
1528
1529     trie = (reg_trie_data *) PerlMemShared_calloc( 1, sizeof(reg_trie_data) );
1530     trie->refcount = 1;
1531     trie->startstate = 1;
1532     trie->wordcount = word_count;
1533     RExC_rxi->data->data[ data_slot ] = (void*)trie;
1534     trie->charmap = (U16 *) PerlMemShared_calloc( 256, sizeof(U16) );
1535     if (!(UTF && folder))
1536         trie->bitmap = (char *) PerlMemShared_calloc( ANYOF_BITMAP_SIZE, 1 );
1537     trie->wordinfo = (reg_trie_wordinfo *) PerlMemShared_calloc(
1538                        trie->wordcount+1, sizeof(reg_trie_wordinfo));
1539
1540     DEBUG_r({
1541         trie_words = newAV();
1542     });
1543
1544     re_trie_maxbuff = get_sv(RE_TRIE_MAXBUF_NAME, 1);
1545     if (!SvIOK(re_trie_maxbuff)) {
1546         sv_setiv(re_trie_maxbuff, RE_TRIE_MAXBUF_INIT);
1547     }
1548     DEBUG_OPTIMISE_r({
1549                 PerlIO_printf( Perl_debug_log,
1550                   "%*smake_trie start==%d, first==%d, last==%d, tail==%d depth=%d\n",
1551                   (int)depth * 2 + 2, "", 
1552                   REG_NODE_NUM(startbranch),REG_NODE_NUM(first), 
1553                   REG_NODE_NUM(last), REG_NODE_NUM(tail),
1554                   (int)depth);
1555     });
1556    
1557    /* Find the node we are going to overwrite */
1558     if ( first == startbranch && OP( last ) != BRANCH ) {
1559         /* whole branch chain */
1560         convert = first;
1561     } else {
1562         /* branch sub-chain */
1563         convert = NEXTOPER( first );
1564     }
1565         
1566     /*  -- First loop and Setup --
1567
1568        We first traverse the branches and scan each word to determine if it
1569        contains widechars, and how many unique chars there are, this is
1570        important as we have to build a table with at least as many columns as we
1571        have unique chars.
1572
1573        We use an array of integers to represent the character codes 0..255
1574        (trie->charmap) and we use a an HV* to store Unicode characters. We use the
1575        native representation of the character value as the key and IV's for the
1576        coded index.
1577
1578        *TODO* If we keep track of how many times each character is used we can
1579        remap the columns so that the table compression later on is more
1580        efficient in terms of memory by ensuring the most common value is in the
1581        middle and the least common are on the outside.  IMO this would be better
1582        than a most to least common mapping as theres a decent chance the most
1583        common letter will share a node with the least common, meaning the node
1584        will not be compressible. With a middle is most common approach the worst
1585        case is when we have the least common nodes twice.
1586
1587      */
1588
1589     for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
1590         regnode * const noper = NEXTOPER( cur );
1591         const U8 *uc = (U8*)STRING( noper );
1592         const U8 * const e  = uc + STR_LEN( noper );
1593         STRLEN foldlen = 0;
1594         U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
1595         const U8 *scan = (U8*)NULL;
1596         U32 wordlen      = 0;         /* required init */
1597         STRLEN chars = 0;
1598         bool set_bit = trie->bitmap ? 1 : 0; /*store the first char in the bitmap?*/
1599
1600         if (OP(noper) == NOTHING) {
1601             trie->minlen= 0;
1602             continue;
1603         }
1604         if ( set_bit ) /* bitmap only alloced when !(UTF&&Folding) */
1605             TRIE_BITMAP_SET(trie,*uc); /* store the raw first byte
1606                                           regardless of encoding */
1607
1608         for ( ; uc < e ; uc += len ) {
1609             TRIE_CHARCOUNT(trie)++;
1610             TRIE_READ_CHAR;
1611             chars++;
1612             if ( uvc < 256 ) {
1613                 if ( !trie->charmap[ uvc ] ) {
1614                     trie->charmap[ uvc ]=( ++trie->uniquecharcount );
1615                     if ( folder )
1616                         trie->charmap[ folder[ uvc ] ] = trie->charmap[ uvc ];
1617                     TRIE_STORE_REVCHAR;
1618                 }
1619                 if ( set_bit ) {
1620                     /* store the codepoint in the bitmap, and its folded
1621                      * equivalent. */
1622                     TRIE_BITMAP_SET(trie,uvc);
1623
1624                     /* store the folded codepoint */
1625                     if ( folder ) TRIE_BITMAP_SET(trie,folder[ uvc ]);
1626
1627                     if ( !UTF ) {
1628                         /* store first byte of utf8 representation of
1629                            variant codepoints */
1630                         if (! UNI_IS_INVARIANT(uvc)) {
1631                             TRIE_BITMAP_SET(trie, UTF8_TWO_BYTE_HI(uvc));
1632                         }
1633                     }
1634                     set_bit = 0; /* We've done our bit :-) */
1635                 }
1636             } else {
1637                 SV** svpp;
1638                 if ( !widecharmap )
1639                     widecharmap = newHV();
1640
1641                 svpp = hv_fetch( widecharmap, (char*)&uvc, sizeof( UV ), 1 );
1642
1643                 if ( !svpp )
1644                     Perl_croak( aTHX_ "error creating/fetching widecharmap entry for 0x%"UVXf, uvc );
1645
1646                 if ( !SvTRUE( *svpp ) ) {
1647                     sv_setiv( *svpp, ++trie->uniquecharcount );
1648                     TRIE_STORE_REVCHAR;
1649                 }
1650             }
1651         }
1652         if( cur == first ) {
1653             trie->minlen=chars;
1654             trie->maxlen=chars;
1655         } else if (chars < trie->minlen) {
1656             trie->minlen=chars;
1657         } else if (chars > trie->maxlen) {
1658             trie->maxlen=chars;
1659         }
1660
1661     } /* end first pass */
1662     DEBUG_TRIE_COMPILE_r(
1663         PerlIO_printf( Perl_debug_log, "%*sTRIE(%s): W:%d C:%d Uq:%d Min:%d Max:%d\n",
1664                 (int)depth * 2 + 2,"",
1665                 ( widecharmap ? "UTF8" : "NATIVE" ), (int)word_count,
1666                 (int)TRIE_CHARCOUNT(trie), trie->uniquecharcount,
1667                 (int)trie->minlen, (int)trie->maxlen )
1668     );
1669
1670     /*
1671         We now know what we are dealing with in terms of unique chars and
1672         string sizes so we can calculate how much memory a naive
1673         representation using a flat table  will take. If it's over a reasonable
1674         limit (as specified by ${^RE_TRIE_MAXBUF}) we use a more memory
1675         conservative but potentially much slower representation using an array
1676         of lists.
1677
1678         At the end we convert both representations into the same compressed
1679         form that will be used in regexec.c for matching with. The latter
1680         is a form that cannot be used to construct with but has memory
1681         properties similar to the list form and access properties similar
1682         to the table form making it both suitable for fast searches and
1683         small enough that its feasable to store for the duration of a program.
1684
1685         See the comment in the code where the compressed table is produced
1686         inplace from the flat tabe representation for an explanation of how
1687         the compression works.
1688
1689     */
1690
1691
1692     Newx(prev_states, TRIE_CHARCOUNT(trie) + 2, U32);
1693     prev_states[1] = 0;
1694
1695     if ( (IV)( ( TRIE_CHARCOUNT(trie) + 1 ) * trie->uniquecharcount + 1) > SvIV(re_trie_maxbuff) ) {
1696         /*
1697             Second Pass -- Array Of Lists Representation
1698
1699             Each state will be represented by a list of charid:state records
1700             (reg_trie_trans_le) the first such element holds the CUR and LEN
1701             points of the allocated array. (See defines above).
1702
1703             We build the initial structure using the lists, and then convert
1704             it into the compressed table form which allows faster lookups
1705             (but cant be modified once converted).
1706         */
1707
1708         STRLEN transcount = 1;
1709
1710         DEBUG_TRIE_COMPILE_MORE_r( PerlIO_printf( Perl_debug_log, 
1711             "%*sCompiling trie using list compiler\n",
1712             (int)depth * 2 + 2, ""));
1713
1714         trie->states = (reg_trie_state *)
1715             PerlMemShared_calloc( TRIE_CHARCOUNT(trie) + 2,
1716                                   sizeof(reg_trie_state) );
1717         TRIE_LIST_NEW(1);
1718         next_alloc = 2;
1719
1720         for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
1721
1722             regnode * const noper = NEXTOPER( cur );
1723             U8 *uc           = (U8*)STRING( noper );
1724             const U8 * const e = uc + STR_LEN( noper );
1725             U32 state        = 1;         /* required init */
1726             U16 charid       = 0;         /* sanity init */
1727             U8 *scan         = (U8*)NULL; /* sanity init */
1728             STRLEN foldlen   = 0;         /* required init */
1729             U32 wordlen      = 0;         /* required init */
1730             U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
1731
1732             if (OP(noper) != NOTHING) {
1733                 for ( ; uc < e ; uc += len ) {
1734
1735                     TRIE_READ_CHAR;
1736
1737                     if ( uvc < 256 ) {
1738                         charid = trie->charmap[ uvc ];
1739                     } else {
1740                         SV** const svpp = hv_fetch( widecharmap, (char*)&uvc, sizeof( UV ), 0);
1741                         if ( !svpp ) {
1742                             charid = 0;
1743                         } else {
1744                             charid=(U16)SvIV( *svpp );
1745                         }
1746                     }
1747                     /* charid is now 0 if we dont know the char read, or nonzero if we do */
1748                     if ( charid ) {
1749
1750                         U16 check;
1751                         U32 newstate = 0;
1752
1753                         charid--;
1754                         if ( !trie->states[ state ].trans.list ) {
1755                             TRIE_LIST_NEW( state );
1756                         }
1757                         for ( check = 1; check <= TRIE_LIST_USED( state ); check++ ) {
1758                             if ( TRIE_LIST_ITEM( state, check ).forid == charid ) {
1759                                 newstate = TRIE_LIST_ITEM( state, check ).newstate;
1760                                 break;
1761                             }
1762                         }
1763                         if ( ! newstate ) {
1764                             newstate = next_alloc++;
1765                             prev_states[newstate] = state;
1766                             TRIE_LIST_PUSH( state, charid, newstate );
1767                             transcount++;
1768                         }
1769                         state = newstate;
1770                     } else {
1771                         Perl_croak( aTHX_ "panic! In trie construction, no char mapping for %"IVdf, uvc );
1772                     }
1773                 }
1774             }
1775             TRIE_HANDLE_WORD(state);
1776
1777         } /* end second pass */
1778
1779         /* next alloc is the NEXT state to be allocated */
1780         trie->statecount = next_alloc; 
1781         trie->states = (reg_trie_state *)
1782             PerlMemShared_realloc( trie->states,
1783                                    next_alloc
1784                                    * sizeof(reg_trie_state) );
1785
1786         /* and now dump it out before we compress it */
1787         DEBUG_TRIE_COMPILE_MORE_r(dump_trie_interim_list(trie, widecharmap,
1788                                                          revcharmap, next_alloc,
1789                                                          depth+1)
1790         );
1791
1792         trie->trans = (reg_trie_trans *)
1793             PerlMemShared_calloc( transcount, sizeof(reg_trie_trans) );
1794         {
1795             U32 state;
1796             U32 tp = 0;
1797             U32 zp = 0;
1798
1799
1800             for( state=1 ; state < next_alloc ; state ++ ) {
1801                 U32 base=0;
1802
1803                 /*
1804                 DEBUG_TRIE_COMPILE_MORE_r(
1805                     PerlIO_printf( Perl_debug_log, "tp: %d zp: %d ",tp,zp)
1806                 );
1807                 */
1808
1809                 if (trie->states[state].trans.list) {
1810                     U16 minid=TRIE_LIST_ITEM( state, 1).forid;
1811                     U16 maxid=minid;
1812                     U16 idx;
1813
1814                     for( idx = 2 ; idx <= TRIE_LIST_USED( state ) ; idx++ ) {
1815                         const U16 forid = TRIE_LIST_ITEM( state, idx).forid;
1816                         if ( forid < minid ) {
1817                             minid=forid;
1818                         } else if ( forid > maxid ) {
1819                             maxid=forid;
1820                         }
1821                     }
1822                     if ( transcount < tp + maxid - minid + 1) {
1823                         transcount *= 2;
1824                         trie->trans = (reg_trie_trans *)
1825                             PerlMemShared_realloc( trie->trans,
1826                                                      transcount
1827                                                      * sizeof(reg_trie_trans) );
1828                         Zero( trie->trans + (transcount / 2), transcount / 2 , reg_trie_trans );
1829                     }
1830                     base = trie->uniquecharcount + tp - minid;
1831                     if ( maxid == minid ) {
1832                         U32 set = 0;
1833                         for ( ; zp < tp ; zp++ ) {
1834                             if ( ! trie->trans[ zp ].next ) {
1835                                 base = trie->uniquecharcount + zp - minid;
1836                                 trie->trans[ zp ].next = TRIE_LIST_ITEM( state, 1).newstate;
1837                                 trie->trans[ zp ].check = state;
1838                                 set = 1;
1839                                 break;
1840                             }
1841                         }
1842                         if ( !set ) {
1843                             trie->trans[ tp ].next = TRIE_LIST_ITEM( state, 1).newstate;
1844                             trie->trans[ tp ].check = state;
1845                             tp++;
1846                             zp = tp;
1847                         }
1848                     } else {
1849                         for ( idx=1; idx <= TRIE_LIST_USED( state ) ; idx++ ) {
1850                             const U32 tid = base -  trie->uniquecharcount + TRIE_LIST_ITEM( state, idx ).forid;
1851                             trie->trans[ tid ].next = TRIE_LIST_ITEM( state, idx ).newstate;
1852                             trie->trans[ tid ].check = state;
1853                         }
1854                         tp += ( maxid - minid + 1 );
1855                     }
1856                     Safefree(trie->states[ state ].trans.list);
1857                 }
1858                 /*
1859                 DEBUG_TRIE_COMPILE_MORE_r(
1860                     PerlIO_printf( Perl_debug_log, " base: %d\n",base);
1861                 );
1862                 */
1863                 trie->states[ state ].trans.base=base;
1864             }
1865             trie->lasttrans = tp + 1;
1866         }
1867     } else {
1868         /*
1869            Second Pass -- Flat Table Representation.
1870
1871            we dont use the 0 slot of either trans[] or states[] so we add 1 to each.
1872            We know that we will need Charcount+1 trans at most to store the data
1873            (one row per char at worst case) So we preallocate both structures
1874            assuming worst case.
1875
1876            We then construct the trie using only the .next slots of the entry
1877            structs.
1878
1879            We use the .check field of the first entry of the node temporarily to
1880            make compression both faster and easier by keeping track of how many non
1881            zero fields are in the node.
1882
1883            Since trans are numbered from 1 any 0 pointer in the table is a FAIL
1884            transition.
1885
1886            There are two terms at use here: state as a TRIE_NODEIDX() which is a
1887            number representing the first entry of the node, and state as a
1888            TRIE_NODENUM() which is the trans number. state 1 is TRIE_NODEIDX(1) and
1889            TRIE_NODENUM(1), state 2 is TRIE_NODEIDX(2) and TRIE_NODENUM(3) if there
1890            are 2 entrys per node. eg:
1891
1892              A B       A B
1893           1. 2 4    1. 3 7
1894           2. 0 3    3. 0 5
1895           3. 0 0    5. 0 0
1896           4. 0 0    7. 0 0
1897
1898            The table is internally in the right hand, idx form. However as we also
1899            have to deal with the states array which is indexed by nodenum we have to
1900            use TRIE_NODENUM() to convert.
1901
1902         */
1903         DEBUG_TRIE_COMPILE_MORE_r( PerlIO_printf( Perl_debug_log, 
1904             "%*sCompiling trie using table compiler\n",
1905             (int)depth * 2 + 2, ""));
1906
1907         trie->trans = (reg_trie_trans *)
1908             PerlMemShared_calloc( ( TRIE_CHARCOUNT(trie) + 1 )
1909                                   * trie->uniquecharcount + 1,
1910                                   sizeof(reg_trie_trans) );
1911         trie->states = (reg_trie_state *)
1912             PerlMemShared_calloc( TRIE_CHARCOUNT(trie) + 2,
1913                                   sizeof(reg_trie_state) );
1914         next_alloc = trie->uniquecharcount + 1;
1915
1916
1917         for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
1918
1919             regnode * const noper   = NEXTOPER( cur );
1920             const U8 *uc     = (U8*)STRING( noper );
1921             const U8 * const e = uc + STR_LEN( noper );
1922
1923             U32 state        = 1;         /* required init */
1924
1925             U16 charid       = 0;         /* sanity init */
1926             U32 accept_state = 0;         /* sanity init */
1927             U8 *scan         = (U8*)NULL; /* sanity init */
1928
1929             STRLEN foldlen   = 0;         /* required init */
1930             U32 wordlen      = 0;         /* required init */
1931             U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
1932
1933             if ( OP(noper) != NOTHING ) {
1934                 for ( ; uc < e ; uc += len ) {
1935
1936                     TRIE_READ_CHAR;
1937
1938                     if ( uvc < 256 ) {
1939                         charid = trie->charmap[ uvc ];
1940                     } else {
1941                         SV* const * const svpp = hv_fetch( widecharmap, (char*)&uvc, sizeof( UV ), 0);
1942                         charid = svpp ? (U16)SvIV(*svpp) : 0;
1943                     }
1944                     if ( charid ) {
1945                         charid--;
1946                         if ( !trie->trans[ state + charid ].next ) {
1947                             trie->trans[ state + charid ].next = next_alloc;
1948                             trie->trans[ state ].check++;
1949                             prev_states[TRIE_NODENUM(next_alloc)]
1950                                     = TRIE_NODENUM(state);
1951                             next_alloc += trie->uniquecharcount;
1952                         }
1953                         state = trie->trans[ state + charid ].next;
1954                     } else {
1955                         Perl_croak( aTHX_ "panic! In trie construction, no char mapping for %"IVdf, uvc );
1956                     }
1957                     /* charid is now 0 if we dont know the char read, or nonzero if we do */
1958                 }
1959             }
1960             accept_state = TRIE_NODENUM( state );
1961             TRIE_HANDLE_WORD(accept_state);
1962
1963         } /* end second pass */
1964
1965         /* and now dump it out before we compress it */
1966         DEBUG_TRIE_COMPILE_MORE_r(dump_trie_interim_table(trie, widecharmap,
1967                                                           revcharmap,
1968                                                           next_alloc, depth+1));
1969
1970         {
1971         /*
1972            * Inplace compress the table.*
1973
1974            For sparse data sets the table constructed by the trie algorithm will
1975            be mostly 0/FAIL transitions or to put it another way mostly empty.
1976            (Note that leaf nodes will not contain any transitions.)
1977
1978            This algorithm compresses the tables by eliminating most such
1979            transitions, at the cost of a modest bit of extra work during lookup:
1980
1981            - Each states[] entry contains a .base field which indicates the
1982            index in the state[] array wheres its transition data is stored.
1983
1984            - If .base is 0 there are no valid transitions from that node.
1985
1986            - If .base is nonzero then charid is added to it to find an entry in
1987            the trans array.
1988
1989            -If trans[states[state].base+charid].check!=state then the
1990            transition is taken to be a 0/Fail transition. Thus if there are fail
1991            transitions at the front of the node then the .base offset will point
1992            somewhere inside the previous nodes data (or maybe even into a node
1993            even earlier), but the .check field determines if the transition is
1994            valid.
1995
1996            XXX - wrong maybe?
1997            The following process inplace converts the table to the compressed
1998            table: We first do not compress the root node 1,and mark all its
1999            .check pointers as 1 and set its .base pointer as 1 as well. This
2000            allows us to do a DFA construction from the compressed table later,
2001            and ensures that any .base pointers we calculate later are greater
2002            than 0.
2003
2004            - We set 'pos' to indicate the first entry of the second node.
2005
2006            - We then iterate over the columns of the node, finding the first and
2007            last used entry at l and m. We then copy l..m into pos..(pos+m-l),
2008            and set the .check pointers accordingly, and advance pos
2009            appropriately and repreat for the next node. Note that when we copy
2010            the next pointers we have to convert them from the original
2011            NODEIDX form to NODENUM form as the former is not valid post
2012            compression.
2013
2014            - If a node has no transitions used we mark its base as 0 and do not
2015            advance the pos pointer.
2016
2017            - If a node only has one transition we use a second pointer into the
2018            structure to fill in allocated fail transitions from other states.
2019            This pointer is independent of the main pointer and scans forward
2020            looking for null transitions that are allocated to a state. When it
2021            finds one it writes the single transition into the "hole".  If the
2022            pointer doesnt find one the single transition is appended as normal.
2023
2024            - Once compressed we can Renew/realloc the structures to release the
2025            excess space.
2026
2027            See "Table-Compression Methods" in sec 3.9 of the Red Dragon,
2028            specifically Fig 3.47 and the associated pseudocode.
2029
2030            demq
2031         */
2032         const U32 laststate = TRIE_NODENUM( next_alloc );
2033         U32 state, charid;
2034         U32 pos = 0, zp=0;
2035         trie->statecount = laststate;
2036
2037         for ( state = 1 ; state < laststate ; state++ ) {
2038             U8 flag = 0;
2039             const U32 stateidx = TRIE_NODEIDX( state );
2040             const U32 o_used = trie->trans[ stateidx ].check;
2041             U32 used = trie->trans[ stateidx ].check;
2042             trie->trans[ stateidx ].check = 0;
2043
2044             for ( charid = 0 ; used && charid < trie->uniquecharcount ; charid++ ) {
2045                 if ( flag || trie->trans[ stateidx + charid ].next ) {
2046                     if ( trie->trans[ stateidx + charid ].next ) {
2047                         if (o_used == 1) {
2048                             for ( ; zp < pos ; zp++ ) {
2049                                 if ( ! trie->trans[ zp ].next ) {
2050                                     break;
2051                                 }
2052                             }
2053                             trie->states[ state ].trans.base = zp + trie->uniquecharcount - charid ;
2054                             trie->trans[ zp ].next = SAFE_TRIE_NODENUM( trie->trans[ stateidx + charid ].next );
2055                             trie->trans[ zp ].check = state;
2056                             if ( ++zp > pos ) pos = zp;
2057                             break;
2058                         }
2059                         used--;
2060                     }
2061                     if ( !flag ) {
2062                         flag = 1;
2063                         trie->states[ state ].trans.base = pos + trie->uniquecharcount - charid ;
2064                     }
2065                     trie->trans[ pos ].next = SAFE_TRIE_NODENUM( trie->trans[ stateidx + charid ].next );
2066                     trie->trans[ pos ].check = state;
2067                     pos++;
2068                 }
2069             }
2070         }
2071         trie->lasttrans = pos + 1;
2072         trie->states = (reg_trie_state *)
2073             PerlMemShared_realloc( trie->states, laststate
2074                                    * sizeof(reg_trie_state) );
2075         DEBUG_TRIE_COMPILE_MORE_r(
2076                 PerlIO_printf( Perl_debug_log,
2077                     "%*sAlloc: %d Orig: %"IVdf" elements, Final:%"IVdf". Savings of %%%5.2f\n",
2078                     (int)depth * 2 + 2,"",
2079                     (int)( ( TRIE_CHARCOUNT(trie) + 1 ) * trie->uniquecharcount + 1 ),
2080                     (IV)next_alloc,
2081                     (IV)pos,
2082                     ( ( next_alloc - pos ) * 100 ) / (double)next_alloc );
2083             );
2084
2085         } /* end table compress */
2086     }
2087     DEBUG_TRIE_COMPILE_MORE_r(
2088             PerlIO_printf(Perl_debug_log, "%*sStatecount:%"UVxf" Lasttrans:%"UVxf"\n",
2089                 (int)depth * 2 + 2, "",
2090                 (UV)trie->statecount,
2091                 (UV)trie->lasttrans)
2092     );
2093     /* resize the trans array to remove unused space */
2094     trie->trans = (reg_trie_trans *)
2095         PerlMemShared_realloc( trie->trans, trie->lasttrans
2096                                * sizeof(reg_trie_trans) );
2097
2098     {   /* Modify the program and insert the new TRIE node */ 
2099         U8 nodetype =(U8)(flags & 0xFF);
2100         char *str=NULL;
2101         
2102 #ifdef DEBUGGING
2103         regnode *optimize = NULL;
2104 #ifdef RE_TRACK_PATTERN_OFFSETS
2105
2106         U32 mjd_offset = 0;
2107         U32 mjd_nodelen = 0;
2108 #endif /* RE_TRACK_PATTERN_OFFSETS */
2109 #endif /* DEBUGGING */
2110         /*
2111            This means we convert either the first branch or the first Exact,
2112            depending on whether the thing following (in 'last') is a branch
2113            or not and whther first is the startbranch (ie is it a sub part of
2114            the alternation or is it the whole thing.)
2115            Assuming its a sub part we convert the EXACT otherwise we convert
2116            the whole branch sequence, including the first.
2117          */
2118         /* Find the node we are going to overwrite */
2119         if ( first != startbranch || OP( last ) == BRANCH ) {
2120             /* branch sub-chain */
2121             NEXT_OFF( first ) = (U16)(last - first);
2122 #ifdef RE_TRACK_PATTERN_OFFSETS
2123             DEBUG_r({
2124                 mjd_offset= Node_Offset((convert));
2125                 mjd_nodelen= Node_Length((convert));
2126             });
2127 #endif
2128             /* whole branch chain */
2129         }
2130 #ifdef RE_TRACK_PATTERN_OFFSETS
2131         else {
2132             DEBUG_r({
2133                 const  regnode *nop = NEXTOPER( convert );
2134                 mjd_offset= Node_Offset((nop));
2135                 mjd_nodelen= Node_Length((nop));
2136             });
2137         }
2138         DEBUG_OPTIMISE_r(
2139             PerlIO_printf(Perl_debug_log, "%*sMJD offset:%"UVuf" MJD length:%"UVuf"\n",
2140                 (int)depth * 2 + 2, "",
2141                 (UV)mjd_offset, (UV)mjd_nodelen)
2142         );
2143 #endif
2144         /* But first we check to see if there is a common prefix we can 
2145            split out as an EXACT and put in front of the TRIE node.  */
2146         trie->startstate= 1;
2147         if ( trie->bitmap && !widecharmap && !trie->jump  ) {
2148             U32 state;
2149             for ( state = 1 ; state < trie->statecount-1 ; state++ ) {
2150                 U32 ofs = 0;
2151                 I32 idx = -1;
2152                 U32 count = 0;
2153                 const U32 base = trie->states[ state ].trans.base;
2154
2155                 if ( trie->states[state].wordnum )
2156                         count = 1;
2157
2158                 for ( ofs = 0 ; ofs < trie->uniquecharcount ; ofs++ ) {
2159                     if ( ( base + ofs >= trie->uniquecharcount ) &&
2160                          ( base + ofs - trie->uniquecharcount < trie->lasttrans ) &&
2161                          trie->trans[ base + ofs - trie->uniquecharcount ].check == state )
2162                     {
2163                         if ( ++count > 1 ) {
2164                             SV **tmp = av_fetch( revcharmap, ofs, 0);
2165                             const U8 *ch = (U8*)SvPV_nolen_const( *tmp );
2166                             if ( state == 1 ) break;
2167                             if ( count == 2 ) {
2168                                 Zero(trie->bitmap, ANYOF_BITMAP_SIZE, char);
2169                                 DEBUG_OPTIMISE_r(
2170                                     PerlIO_printf(Perl_debug_log,
2171                                         "%*sNew Start State=%"UVuf" Class: [",
2172                                         (int)depth * 2 + 2, "",
2173                                         (UV)state));
2174                                 if (idx >= 0) {
2175                                     SV ** const tmp = av_fetch( revcharmap, idx, 0);
2176                                     const U8 * const ch = (U8*)SvPV_nolen_const( *tmp );
2177
2178                                     TRIE_BITMAP_SET(trie,*ch);
2179                                     if ( folder )
2180                                         TRIE_BITMAP_SET(trie, folder[ *ch ]);
2181                                     DEBUG_OPTIMISE_r(
2182                                         PerlIO_printf(Perl_debug_log, "%s", (char*)ch)
2183                                     );
2184                                 }
2185                             }
2186                             TRIE_BITMAP_SET(trie,*ch);
2187                             if ( folder )
2188                                 TRIE_BITMAP_SET(trie,folder[ *ch ]);
2189                             DEBUG_OPTIMISE_r(PerlIO_printf( Perl_debug_log,"%s", ch));
2190                         }
2191                         idx = ofs;
2192                     }
2193                 }
2194                 if ( count == 1 ) {
2195                     SV **tmp = av_fetch( revcharmap, idx, 0);
2196                     STRLEN len;
2197                     char *ch = SvPV( *tmp, len );
2198                     DEBUG_OPTIMISE_r({
2199                         SV *sv=sv_newmortal();
2200                         PerlIO_printf( Perl_debug_log,
2201                             "%*sPrefix State: %"UVuf" Idx:%"UVuf" Char='%s'\n",
2202                             (int)depth * 2 + 2, "",
2203                             (UV)state, (UV)idx, 
2204                             pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), 6, 
2205                                 PL_colors[0], PL_colors[1],
2206                                 (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0) |
2207                                 PERL_PV_ESCAPE_FIRSTCHAR 
2208                             )
2209                         );
2210                     });
2211                     if ( state==1 ) {
2212                         OP( convert ) = nodetype;
2213                         str=STRING(convert);
2214                         STR_LEN(convert)=0;
2215                     }
2216                     STR_LEN(convert) += len;
2217                     while (len--)
2218                         *str++ = *ch++;
2219                 } else {
2220 #ifdef DEBUGGING            
2221                     if (state>1)
2222                         DEBUG_OPTIMISE_r(PerlIO_printf( Perl_debug_log,"]\n"));
2223 #endif
2224                     break;
2225                 }
2226             }
2227             trie->prefixlen = (state-1);
2228             if (str) {
2229                 regnode *n = convert+NODE_SZ_STR(convert);
2230                 NEXT_OFF(convert) = NODE_SZ_STR(convert);
2231                 trie->startstate = state;
2232                 trie->minlen -= (state - 1);
2233                 trie->maxlen -= (state - 1);
2234 #ifdef DEBUGGING
2235                /* At least the UNICOS C compiler choked on this
2236                 * being argument to DEBUG_r(), so let's just have
2237                 * it right here. */
2238                if (
2239 #ifdef PERL_EXT_RE_BUILD
2240                    1
2241 #else
2242                    DEBUG_r_TEST
2243 #endif
2244                    ) {
2245                    regnode *fix = convert;
2246                    U32 word = trie->wordcount;
2247                    mjd_nodelen++;
2248                    Set_Node_Offset_Length(convert, mjd_offset, state - 1);
2249                    while( ++fix < n ) {
2250                        Set_Node_Offset_Length(fix, 0, 0);
2251                    }
2252                    while (word--) {
2253                        SV ** const tmp = av_fetch( trie_words, word, 0 );
2254                        if (tmp) {
2255                            if ( STR_LEN(convert) <= SvCUR(*tmp) )
2256                                sv_chop(*tmp, SvPV_nolen(*tmp) + STR_LEN(convert));
2257                            else
2258                                sv_chop(*tmp, SvPV_nolen(*tmp) + SvCUR(*tmp));
2259                        }
2260                    }
2261                }
2262 #endif
2263                 if (trie->maxlen) {
2264                     convert = n;
2265                 } else {
2266                     NEXT_OFF(convert) = (U16)(tail - convert);
2267                     DEBUG_r(optimize= n);
2268                 }
2269             }
2270         }
2271         if (!jumper) 
2272             jumper = last; 
2273         if ( trie->maxlen ) {
2274             NEXT_OFF( convert ) = (U16)(tail - convert);
2275             ARG_SET( convert, data_slot );
2276             /* Store the offset to the first unabsorbed branch in 
2277                jump[0], which is otherwise unused by the jump logic. 
2278                We use this when dumping a trie and during optimisation. */
2279             if (trie->jump) 
2280                 trie->jump[0] = (U16)(nextbranch - convert);
2281             
2282             /* If the start state is not accepting (meaning there is no empty string/NOTHING)
2283              *   and there is a bitmap
2284              *   and the first "jump target" node we found leaves enough room
2285              * then convert the TRIE node into a TRIEC node, with the bitmap
2286              * embedded inline in the opcode - this is hypothetically faster.
2287              */
2288             if ( !trie->states[trie->startstate].wordnum
2289                  && trie->bitmap
2290                  && ( (char *)jumper - (char *)convert) >= (int)sizeof(struct regnode_charclass) )
2291             {
2292                 OP( convert ) = TRIEC;
2293                 Copy(trie->bitmap, ((struct regnode_charclass *)convert)->bitmap, ANYOF_BITMAP_SIZE, char);
2294                 PerlMemShared_free(trie->bitmap);
2295                 trie->bitmap= NULL;
2296             } else 
2297                 OP( convert ) = TRIE;
2298
2299             /* store the type in the flags */
2300             convert->flags = nodetype;
2301             DEBUG_r({
2302             optimize = convert 
2303                       + NODE_STEP_REGNODE 
2304                       + regarglen[ OP( convert ) ];
2305             });
2306             /* XXX We really should free up the resource in trie now, 
2307                    as we won't use them - (which resources?) dmq */
2308         }
2309         /* needed for dumping*/
2310         DEBUG_r(if (optimize) {
2311             regnode *opt = convert;
2312
2313             while ( ++opt < optimize) {
2314                 Set_Node_Offset_Length(opt,0,0);
2315             }
2316             /* 
2317                 Try to clean up some of the debris left after the 
2318                 optimisation.
2319              */
2320             while( optimize < jumper ) {
2321                 mjd_nodelen += Node_Length((optimize));
2322                 OP( optimize ) = OPTIMIZED;
2323                 Set_Node_Offset_Length(optimize,0,0);
2324                 optimize++;
2325             }
2326             Set_Node_Offset_Length(convert,mjd_offset,mjd_nodelen);
2327         });
2328     } /* end node insert */
2329
2330     /*  Finish populating the prev field of the wordinfo array.  Walk back
2331      *  from each accept state until we find another accept state, and if
2332      *  so, point the first word's .prev field at the second word. If the
2333      *  second already has a .prev field set, stop now. This will be the
2334      *  case either if we've already processed that word's accept state,
2335      *  or that state had multiple words, and the overspill words were
2336      *  already linked up earlier.
2337      */
2338     {
2339         U16 word;
2340         U32 state;
2341         U16 prev;
2342
2343         for (word=1; word <= trie->wordcount; word++) {
2344             prev = 0;
2345             if (trie->wordinfo[word].prev)
2346                 continue;
2347             state = trie->wordinfo[word].accept;
2348             while (state) {
2349                 state = prev_states[state];
2350                 if (!state)
2351                     break;
2352                 prev = trie->states[state].wordnum;
2353                 if (prev)
2354                     break;
2355             }
2356             trie->wordinfo[word].prev = prev;
2357         }
2358         Safefree(prev_states);
2359     }
2360
2361
2362     /* and now dump out the compressed format */
2363     DEBUG_TRIE_COMPILE_r(dump_trie(trie, widecharmap, revcharmap, depth+1));
2364
2365     RExC_rxi->data->data[ data_slot + 1 ] = (void*)widecharmap;
2366 #ifdef DEBUGGING
2367     RExC_rxi->data->data[ data_slot + TRIE_WORDS_OFFSET ] = (void*)trie_words;
2368     RExC_rxi->data->data[ data_slot + 3 ] = (void*)revcharmap;
2369 #else
2370     SvREFCNT_dec(revcharmap);
2371 #endif
2372     return trie->jump 
2373            ? MADE_JUMP_TRIE 
2374            : trie->startstate>1 
2375              ? MADE_EXACT_TRIE 
2376              : MADE_TRIE;
2377 }
2378
2379 STATIC void
2380 S_make_trie_failtable(pTHX_ RExC_state_t *pRExC_state, regnode *source,  regnode *stclass, U32 depth)
2381 {
2382 /* The Trie is constructed and compressed now so we can build a fail array if it's needed
2383
2384    This is basically the Aho-Corasick algorithm. Its from exercise 3.31 and 3.32 in the
2385    "Red Dragon" -- Compilers, principles, techniques, and tools. Aho, Sethi, Ullman 1985/88
2386    ISBN 0-201-10088-6
2387
2388    We find the fail state for each state in the trie, this state is the longest proper
2389    suffix of the current state's 'word' that is also a proper prefix of another word in our
2390    trie. State 1 represents the word '' and is thus the default fail state. This allows
2391    the DFA not to have to restart after its tried and failed a word at a given point, it
2392    simply continues as though it had been matching the other word in the first place.
2393    Consider
2394       'abcdgu'=~/abcdefg|cdgu/
2395    When we get to 'd' we are still matching the first word, we would encounter 'g' which would
2396    fail, which would bring us to the state representing 'd' in the second word where we would
2397    try 'g' and succeed, proceeding to match 'cdgu'.
2398  */
2399  /* add a fail transition */
2400     const U32 trie_offset = ARG(source);
2401     reg_trie_data *trie=(reg_trie_data *)RExC_rxi->data->data[trie_offset];
2402     U32 *q;
2403     const U32 ucharcount = trie->uniquecharcount;
2404     const U32 numstates = trie->statecount;
2405     const U32 ubound = trie->lasttrans + ucharcount;
2406     U32 q_read = 0;
2407     U32 q_write = 0;
2408     U32 charid;
2409     U32 base = trie->states[ 1 ].trans.base;
2410     U32 *fail;
2411     reg_ac_data *aho;
2412     const U32 data_slot = add_data( pRExC_state, 1, "T" );
2413     GET_RE_DEBUG_FLAGS_DECL;
2414
2415     PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE;
2416 #ifndef DEBUGGING
2417     PERL_UNUSED_ARG(depth);
2418 #endif
2419
2420
2421     ARG_SET( stclass, data_slot );
2422     aho = (reg_ac_data *) PerlMemShared_calloc( 1, sizeof(reg_ac_data) );
2423     RExC_rxi->data->data[ data_slot ] = (void*)aho;
2424     aho->trie=trie_offset;
2425     aho->states=(reg_trie_state *)PerlMemShared_malloc( numstates * sizeof(reg_trie_state) );
2426     Copy( trie->states, aho->states, numstates, reg_trie_state );
2427     Newxz( q, numstates, U32);
2428     aho->fail = (U32 *) PerlMemShared_calloc( numstates, sizeof(U32) );
2429     aho->refcount = 1;
2430     fail = aho->fail;
2431     /* initialize fail[0..1] to be 1 so that we always have
2432        a valid final fail state */
2433     fail[ 0 ] = fail[ 1 ] = 1;
2434
2435     for ( charid = 0; charid < ucharcount ; charid++ ) {
2436         const U32 newstate = TRIE_TRANS_STATE( 1, base, ucharcount, charid, 0 );
2437         if ( newstate ) {
2438             q[ q_write ] = newstate;
2439             /* set to point at the root */
2440             fail[ q[ q_write++ ] ]=1;
2441         }
2442     }
2443     while ( q_read < q_write) {
2444         const U32 cur = q[ q_read++ % numstates ];
2445         base = trie->states[ cur ].trans.base;
2446
2447         for ( charid = 0 ; charid < ucharcount ; charid++ ) {
2448             const U32 ch_state = TRIE_TRANS_STATE( cur, base, ucharcount, charid, 1 );
2449             if (ch_state) {
2450                 U32 fail_state = cur;
2451                 U32 fail_base;
2452                 do {
2453                     fail_state = fail[ fail_state ];
2454                     fail_base = aho->states[ fail_state ].trans.base;
2455                 } while ( !TRIE_TRANS_STATE( fail_state, fail_base, ucharcount, charid, 1 ) );
2456
2457                 fail_state = TRIE_TRANS_STATE( fail_state, fail_base, ucharcount, charid, 1 );
2458                 fail[ ch_state ] = fail_state;
2459                 if ( !aho->states[ ch_state ].wordnum && aho->states[ fail_state ].wordnum )
2460                 {
2461                         aho->states[ ch_state ].wordnum =  aho->states[ fail_state ].wordnum;
2462                 }
2463                 q[ q_write++ % numstates] = ch_state;
2464             }
2465         }
2466     }
2467     /* restore fail[0..1] to 0 so that we "fall out" of the AC loop
2468        when we fail in state 1, this allows us to use the
2469        charclass scan to find a valid start char. This is based on the principle
2470        that theres a good chance the string being searched contains lots of stuff
2471        that cant be a start char.
2472      */
2473     fail[ 0 ] = fail[ 1 ] = 0;
2474     DEBUG_TRIE_COMPILE_r({
2475         PerlIO_printf(Perl_debug_log,
2476                       "%*sStclass Failtable (%"UVuf" states): 0", 
2477                       (int)(depth * 2), "", (UV)numstates
2478         );
2479         for( q_read=1; q_read<numstates; q_read++ ) {
2480             PerlIO_printf(Perl_debug_log, ", %"UVuf, (UV)fail[q_read]);
2481         }
2482         PerlIO_printf(Perl_debug_log, "\n");
2483     });
2484     Safefree(q);
2485     /*RExC_seen |= REG_SEEN_TRIEDFA;*/
2486 }
2487
2488
2489 /*
2490  * There are strange code-generation bugs caused on sparc64 by gcc-2.95.2.
2491  * These need to be revisited when a newer toolchain becomes available.
2492  */
2493 #if defined(__sparc64__) && defined(__GNUC__)
2494 #   if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)
2495 #       undef  SPARC64_GCC_WORKAROUND
2496 #       define SPARC64_GCC_WORKAROUND 1
2497 #   endif
2498 #endif
2499
2500 #define DEBUG_PEEP(str,scan,depth) \
2501     DEBUG_OPTIMISE_r({if (scan){ \
2502        SV * const mysv=sv_newmortal(); \
2503        regnode *Next = regnext(scan); \
2504        regprop(RExC_rx, mysv, scan); \
2505        PerlIO_printf(Perl_debug_log, "%*s" str ">%3d: %s (%d)\n", \
2506        (int)depth*2, "", REG_NODE_NUM(scan), SvPV_nolen_const(mysv),\
2507        Next ? (REG_NODE_NUM(Next)) : 0 ); \
2508    }});
2509
2510
2511 /* The below joins as many adjacent EXACTish nodes as possible into a single
2512  * one, and looks for problematic sequences of characters whose folds vs.
2513  * non-folds have sufficiently different lengths, that the optimizer would be
2514  * fooled into rejecting legitimate matches of them, and the trie construction
2515  * code can't cope with them.  The joining is only done if:
2516  * 1) there is room in the current conglomerated node to entirely contain the
2517  *    next one.
2518  * 2) they are the exact same node type
2519  *
2520  * The adjacent nodes actually may be separated by NOTHING kind nodes, and
2521  * these get optimized out
2522  *
2523  * If there are problematic code sequences, *min_subtract is set to the delta
2524  * that the minimum size of the node can be less than its actual size.  And,
2525  * the node type of the result is changed to reflect that it contains these
2526  * sequences.
2527  *
2528  * And *has_exactf_sharp_s is set to indicate whether or not the node is EXACTF
2529  * and contains LATIN SMALL LETTER SHARP S
2530  *
2531  * This is as good a place as any to discuss the design of handling these
2532  * problematic sequences.  It's been wrong in Perl for a very long time.  There
2533  * are three code points in Unicode whose folded lengths differ so much from
2534  * the un-folded lengths that it causes problems for the optimizer and trie
2535  * construction.  Why only these are problematic, and not others where lengths
2536  * also differ is something I (khw) do not understand.  New versions of Unicode
2537  * might add more such code points.  Hopefully the logic in fold_grind.t that
2538  * figures out what to test (in part by verifying that each size-combination
2539  * gets tested) will catch any that do come along, so they can be added to the
2540  * special handling below.  The chances of new ones are actually rather small,
2541  * as most, if not all, of the world's scripts that have casefolding have
2542  * already been encoded by Unicode.  Also, a number of Unicode's decisions were
2543  * made to allow compatibility with pre-existing standards, and almost all of
2544  * those have already been dealt with.  These would otherwise be the most
2545  * likely candidates for generating further tricky sequences.  In other words,
2546  * Unicode by itself is unlikely to add new ones unless it is for compatibility
2547  * with pre-existing standards, and there aren't many of those left.
2548  *
2549  * The previous designs for dealing with these involved assigning a special
2550  * node for them.  This approach doesn't work, as evidenced by this example:
2551  *      "\xDFs" =~ /s\xDF/ui    # Used to fail before these patches
2552  * Both these fold to "sss", but if the pattern is parsed to create a node of
2553  * that would match just the \xDF, it won't be able to handle the case where a
2554  * successful match would have to cross the node's boundary.  The new approach
2555  * that hopefully generally solves the problem generates an EXACTFU_SS node
2556  * that is "sss".
2557  *
2558  * There are a number of components to the approach (a lot of work for just
2559  * three code points!):
2560  * 1)   This routine examines each EXACTFish node that could contain the
2561  *      problematic sequences.  It returns in *min_subtract how much to
2562  *      subtract from the the actual length of the string to get a real minimum
2563  *      for one that could match it.  This number is usually 0 except for the
2564  *      problematic sequences.  This delta is used by the caller to adjust the
2565  *      min length of the match, and the delta between min and max, so that the
2566  *      optimizer doesn't reject these possibilities based on size constraints.
2567  * 2)   These sequences are not currently correctly handled by the trie code
2568  *      either, so it changes the joined node type to ops that are not handled
2569  *      by trie's, those new ops being EXACTFU_SS and EXACTFU_NO_TRIE.
2570  * 3)   This is sufficient for the two Greek sequences (described below), but
2571  *      the one involving the Sharp s (\xDF) needs more.  The node type
2572  *      EXACTFU_SS is used for an EXACTFU node that contains at least one "ss"
2573  *      sequence in it.  For non-UTF-8 patterns and strings, this is the only
2574  *      case where there is a possible fold length change.  That means that a
2575  *      regular EXACTFU node without UTF-8 involvement doesn't have to concern
2576  *      itself with length changes, and so can be processed faster.  regexec.c
2577  *      takes advantage of this.  Generally, an EXACTFish node that is in UTF-8
2578  *      is pre-folded by regcomp.c.  This saves effort in regex matching.
2579  *      However, probably mostly for historical reasons, the pre-folding isn't
2580  *      done for non-UTF8 patterns (and it can't be for EXACTF and EXACTFL
2581  *      nodes, as what they fold to isn't known until runtime.)  The fold
2582  *      possibilities for the non-UTF8 patterns are quite simple, except for
2583  *      the sharp s.  All the ones that don't involve a UTF-8 target string
2584  *      are members of a fold-pair, and arrays are set up for all of them
2585  *      that quickly find the other member of the pair.  It might actually
2586  *      be faster to pre-fold these, but it isn't currently done, except for
2587  *      the sharp s.  Code elsewhere in this file makes sure that it gets
2588  *      folded to 'ss', even if the pattern isn't UTF-8.  This avoids the
2589  *      issues described in the next item.
2590  * 4)   A problem remains for the sharp s in EXACTF nodes.  Whether it matches
2591  *      'ss' or not is not knowable at compile time.  It will match iff the
2592  *      target string is in UTF-8, unlike the EXACTFU nodes, where it always
2593  *      matches; and the EXACTFL and EXACTFA nodes where it never does.  Thus
2594  *      it can't be folded to "ss" at compile time, unlike EXACTFU does as
2595  *      described in item 3).  An assumption that the optimizer part of
2596  *      regexec.c (probably unwittingly) makes is that a character in the
2597  *      pattern corresponds to at most a single character in the target string.
2598  *      (And I do mean character, and not byte here, unlike other parts of the
2599  *      documentation that have never been updated to account for multibyte
2600  *      Unicode.)  This assumption is wrong only in this case, as all other
2601  *      cases are either 1-1 folds when no UTF-8 is involved; or is true by
2602  *      virtue of having this file pre-fold UTF-8 patterns.   I'm
2603  *      reluctant to try to change this assumption, so instead the code punts.
2604  *      This routine examines EXACTF nodes for the sharp s, and returns a
2605  *      boolean indicating whether or not the node is an EXACTF node that
2606  *      contains a sharp s.  When it is true, the caller sets a flag that later
2607  *      causes the optimizer in this file to not set values for the floating
2608  *      and fixed string lengths, and thus avoids the optimizer code in
2609  *      regexec.c that makes the invalid assumption.  Thus, there is no
2610  *      optimization based on string lengths for EXACTF nodes that contain the
2611  *      sharp s.  This only happens for /id rules (which means the pattern
2612  *      isn't in UTF-8).
2613  */
2614
2615 #define JOIN_EXACT(scan,min_subtract,has_exactf_sharp_s, flags) \
2616     if (PL_regkind[OP(scan)] == EXACT) \
2617         join_exact(pRExC_state,(scan),(min_subtract),has_exactf_sharp_s, (flags),NULL,depth+1)
2618
2619 STATIC U32
2620 S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *has_exactf_sharp_s, U32 flags,regnode *val, U32 depth) {
2621     /* Merge several consecutive EXACTish nodes into one. */
2622     regnode *n = regnext(scan);
2623     U32 stringok = 1;
2624     regnode *next = scan + NODE_SZ_STR(scan);
2625     U32 merged = 0;
2626     U32 stopnow = 0;
2627 #ifdef DEBUGGING
2628     regnode *stop = scan;
2629     GET_RE_DEBUG_FLAGS_DECL;
2630 #else
2631     PERL_UNUSED_ARG(depth);
2632 #endif
2633
2634     PERL_ARGS_ASSERT_JOIN_EXACT;
2635 #ifndef EXPERIMENTAL_INPLACESCAN
2636     PERL_UNUSED_ARG(flags);
2637     PERL_UNUSED_ARG(val);
2638 #endif
2639     DEBUG_PEEP("join",scan,depth);
2640
2641     /* Look through the subsequent nodes in the chain.  Skip NOTHING, merge
2642      * EXACT ones that are mergeable to the current one. */
2643     while (n
2644            && (PL_regkind[OP(n)] == NOTHING
2645                || (stringok && OP(n) == OP(scan)))
2646            && NEXT_OFF(n)
2647            && NEXT_OFF(scan) + NEXT_OFF(n) < I16_MAX)
2648     {
2649         
2650         if (OP(n) == TAIL || n > next)
2651             stringok = 0;
2652         if (PL_regkind[OP(n)] == NOTHING) {
2653             DEBUG_PEEP("skip:",n,depth);
2654             NEXT_OFF(scan) += NEXT_OFF(n);
2655             next = n + NODE_STEP_REGNODE;
2656 #ifdef DEBUGGING
2657             if (stringok)
2658                 stop = n;
2659 #endif
2660             n = regnext(n);
2661         }
2662         else if (stringok) {
2663             const unsigned int oldl = STR_LEN(scan);
2664             regnode * const nnext = regnext(n);
2665
2666             if (oldl + STR_LEN(n) > U8_MAX)
2667                 break;
2668             
2669             DEBUG_PEEP("merg",n,depth);
2670             merged++;
2671
2672             NEXT_OFF(scan) += NEXT_OFF(n);
2673             STR_LEN(scan) += STR_LEN(n);
2674             next = n + NODE_SZ_STR(n);
2675             /* Now we can overwrite *n : */
2676             Move(STRING(n), STRING(scan) + oldl, STR_LEN(n), char);
2677 #ifdef DEBUGGING
2678             stop = next - 1;
2679 #endif
2680             n = nnext;
2681             if (stopnow) break;
2682         }
2683
2684 #ifdef EXPERIMENTAL_INPLACESCAN
2685         if (flags && !NEXT_OFF(n)) {
2686             DEBUG_PEEP("atch", val, depth);
2687             if (reg_off_by_arg[OP(n)]) {
2688                 ARG_SET(n, val - n);
2689             }
2690             else {
2691                 NEXT_OFF(n) = val - n;
2692             }
2693             stopnow = 1;
2694         }
2695 #endif
2696     }
2697
2698     *min_subtract = 0;
2699     *has_exactf_sharp_s = FALSE;
2700
2701     /* Here, all the adjacent mergeable EXACTish nodes have been merged.  We
2702      * can now analyze for sequences of problematic code points.  (Prior to
2703      * this final joining, sequences could have been split over boundaries, and
2704      * hence missed).  The sequences only happen in folding, hence for any
2705      * non-EXACT EXACTish node */
2706     if (OP(scan) != EXACT) {
2707         U8 *s;
2708         U8 * s0 = (U8*) STRING(scan);
2709         U8 * const s_end = s0 + STR_LEN(scan);
2710
2711         /* The below is perhaps overboard, but this allows us to save a test
2712          * each time through the loop at the expense of a mask.  This is
2713          * because on both EBCDIC and ASCII machines, 'S' and 's' differ by a
2714          * single bit.  On ASCII they are 32 apart; on EBCDIC, they are 64.
2715          * This uses an exclusive 'or' to find that bit and then inverts it to
2716          * form a mask, with just a single 0, in the bit position where 'S' and
2717          * 's' differ. */
2718         const U8 S_or_s_mask = ~ ('S' ^ 's');
2719         const U8 s_masked = 's' & S_or_s_mask;
2720
2721         /* One pass is made over the node's string looking for all the
2722          * possibilities.  to avoid some tests in the loop, there are two main
2723          * cases, for UTF-8 patterns (which can't have EXACTF nodes) and
2724          * non-UTF-8 */
2725         if (UTF) {
2726
2727             /* There are two problematic Greek code points in Unicode
2728              * casefolding
2729              *
2730              * U+0390 - GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
2731              * U+03B0 - GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
2732              *
2733              * which casefold to
2734              *
2735              * Unicode                      UTF-8
2736              *
2737              * U+03B9 U+0308 U+0301         0xCE 0xB9 0xCC 0x88 0xCC 0x81
2738              * U+03C5 U+0308 U+0301         0xCF 0x85 0xCC 0x88 0xCC 0x81
2739              *
2740              * This means that in case-insensitive matching (or "loose
2741              * matching", as Unicode calls it), an EXACTF of length six (the
2742              * UTF-8 encoded byte length of the above casefolded versions) can
2743              * match a target string of length two (the byte length of UTF-8
2744              * encoded U+0390 or U+03B0).  This would rather mess up the
2745              * minimum length computation.  (there are other code points that
2746              * also fold to these two sequences, but the delta is smaller)
2747              *
2748              * If these sequences are found, the minimum length is decreased by
2749              * four (six minus two).
2750              *
2751              * Similarly, 'ss' may match the single char and byte LATIN SMALL
2752              * LETTER SHARP S.  We decrease the min length by 1 for each
2753              * occurrence of 'ss' found */
2754
2755 #ifdef EBCDIC /* RD tunifold greek 0390 and 03B0 */
2756 #           define U390_first_byte 0xb4
2757             const U8 U390_tail[] = "\x68\xaf\x49\xaf\x42";
2758 #           define U3B0_first_byte 0xb5
2759             const U8 U3B0_tail[] = "\x46\xaf\x49\xaf\x42";
2760 #else
2761 #           define U390_first_byte 0xce
2762             const U8 U390_tail[] = "\xb9\xcc\x88\xcc\x81";
2763 #           define U3B0_first_byte 0xcf
2764             const U8 U3B0_tail[] = "\x85\xcc\x88\xcc\x81";
2765 #endif
2766             const U8 len = sizeof(U390_tail); /* (-1 for NUL; +1 for 1st byte;
2767                                                  yields a net of 0 */
2768             /* Examine the string for one of the problematic sequences */
2769             for (s = s0;
2770                  s < s_end - 1; /* Can stop 1 before the end, as minimum length
2771                                  * sequence we are looking for is 2 */
2772                  s += UTF8SKIP(s))
2773             {
2774
2775                 /* Look for the first byte in each problematic sequence */
2776                 switch (*s) {
2777                     /* We don't have to worry about other things that fold to
2778                      * 's' (such as the long s, U+017F), as all above-latin1
2779                      * code points have been pre-folded */
2780                     case 's':
2781                     case 'S':
2782
2783                         /* Current character is an 's' or 'S'.  If next one is
2784                          * as well, we have the dreaded sequence */
2785                         if (((*(s+1) & S_or_s_mask) == s_masked)
2786                             /* These two node types don't have special handling
2787                              * for 'ss' */
2788                             && OP(scan) != EXACTFL && OP(scan) != EXACTFA)
2789                         {
2790                             *min_subtract += 1;
2791                             OP(scan) = EXACTFU_SS;
2792                             s++;    /* No need to look at this character again */
2793                         }
2794                         break;
2795
2796                     case U390_first_byte:
2797                         if (s_end - s >= len
2798
2799                             /* The 1's are because are skipping comparing the
2800                              * first byte */
2801                             && memEQ(s + 1, U390_tail, len - 1))
2802                         {
2803                             goto greek_sequence;
2804                         }
2805                         break;
2806
2807                     case U3B0_first_byte:
2808                         if (! (s_end - s >= len
2809                                && memEQ(s + 1, U3B0_tail, len - 1)))
2810                         {
2811                             break;
2812                         }
2813                       greek_sequence:
2814                         *min_subtract += 4;
2815
2816                         /* This can't currently be handled by trie's, so change
2817                          * the node type to indicate this.  If EXACTFA and
2818                          * EXACTFL were ever to be handled by trie's, this
2819                          * would have to be changed.  If this node has already
2820                          * been changed to EXACTFU_SS in this loop, leave it as
2821                          * is.  (I (khw) think it doesn't matter in regexec.c
2822                          * for UTF patterns, but no need to change it */
2823                         if (OP(scan) == EXACTFU) {
2824                             OP(scan) = EXACTFU_NO_TRIE;
2825                         }
2826                         s += 6; /* We already know what this sequence is.  Skip
2827                                    the rest of it */
2828                         break;
2829                 }
2830             }
2831         }
2832         else if (OP(scan) != EXACTFL && OP(scan) != EXACTFA) {
2833
2834             /* Here, the pattern is not UTF-8.  We need to look only for the
2835              * 'ss' sequence, and in the EXACTF case, the sharp s, which can be
2836              * in the final position.  Otherwise we can stop looking 1 byte
2837              * earlier because have to find both the first and second 's' */
2838             const U8* upper = (OP(scan) == EXACTF) ? s_end : s_end -1;
2839
2840             for (s = s0; s < upper; s++) {
2841                 switch (*s) {
2842                     case 'S':
2843                     case 's':
2844                         if (s_end - s > 1
2845                             && ((*(s+1) & S_or_s_mask) == s_masked))
2846                         {
2847                             *min_subtract += 1;
2848
2849                             /* EXACTF nodes need to know that the minimum
2850                              * length changed so that a sharp s in the string
2851                              * can match this ss in the pattern, but they
2852                              * remain EXACTF nodes, as they are not trie'able,
2853                              * so don't have to invent a new node type to
2854                              * exclude them from the trie code */
2855                             if (OP(scan) != EXACTF) {
2856                                 OP(scan) = EXACTFU_SS;
2857                             }
2858                             s++;
2859                         }
2860                         break;
2861                     case LATIN_SMALL_LETTER_SHARP_S:
2862                         if (OP(scan) == EXACTF) {
2863                             *has_exactf_sharp_s = TRUE;
2864                         }
2865                         break;
2866                 }
2867             }
2868         }
2869     }
2870
2871 #ifdef DEBUGGING
2872     /* Allow dumping but overwriting the collection of skipped
2873      * ops and/or strings with fake optimized ops */
2874     n = scan + NODE_SZ_STR(scan);
2875     while (n <= stop) {
2876         OP(n) = OPTIMIZED;
2877         FLAGS(n) = 0;
2878         NEXT_OFF(n) = 0;
2879         n++;
2880     }
2881 #endif
2882     DEBUG_OPTIMISE_r(if (merged){DEBUG_PEEP("finl",scan,depth)});
2883     return stopnow;
2884 }
2885
2886 /* REx optimizer.  Converts nodes into quicker variants "in place".
2887    Finds fixed substrings.  */
2888
2889 /* Stops at toplevel WHILEM as well as at "last". At end *scanp is set
2890    to the position after last scanned or to NULL. */
2891
2892 #define INIT_AND_WITHP \
2893     assert(!and_withp); \
2894     Newx(and_withp,1,struct regnode_charclass_class); \
2895     SAVEFREEPV(and_withp)
2896
2897 /* this is a chain of data about sub patterns we are processing that
2898    need to be handled separately/specially in study_chunk. Its so
2899    we can simulate recursion without losing state.  */
2900 struct scan_frame;
2901 typedef struct scan_frame {
2902     regnode *last;  /* last node to process in this frame */
2903     regnode *next;  /* next node to process when last is reached */
2904     struct scan_frame *prev; /*previous frame*/
2905     I32 stop; /* what stopparen do we use */
2906 } scan_frame;
2907
2908
2909 #define SCAN_COMMIT(s, data, m) scan_commit(s, data, m, is_inf)
2910
2911 #define CASE_SYNST_FNC(nAmE)                                       \
2912 case nAmE:                                                         \
2913     if (flags & SCF_DO_STCLASS_AND) {                              \
2914             for (value = 0; value < 256; value++)                  \
2915                 if (!is_ ## nAmE ## _cp(value))                       \
2916                     ANYOF_BITMAP_CLEAR(data->start_class, value);  \
2917     }                                                              \
2918     else {                                                         \
2919             for (value = 0; value < 256; value++)                  \
2920                 if (is_ ## nAmE ## _cp(value))                        \
2921                     ANYOF_BITMAP_SET(data->start_class, value);    \
2922     }                                                              \
2923     break;                                                         \
2924 case N ## nAmE:                                                    \
2925     if (flags & SCF_DO_STCLASS_AND) {                              \
2926             for (value = 0; value < 256; value++)                   \
2927                 if (is_ ## nAmE ## _cp(value))                         \
2928                     ANYOF_BITMAP_CLEAR(data->start_class, value);   \
2929     }                                                               \
2930     else {                                                          \
2931             for (value = 0; value < 256; value++)                   \
2932                 if (!is_ ## nAmE ## _cp(value))                        \
2933                     ANYOF_BITMAP_SET(data->start_class, value);     \
2934     }                                                               \
2935     break
2936
2937
2938
2939 STATIC I32
2940 S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
2941                         I32 *minlenp, I32 *deltap,
2942                         regnode *last,
2943                         scan_data_t *data,
2944                         I32 stopparen,
2945                         U8* recursed,
2946                         struct regnode_charclass_class *and_withp,
2947                         U32 flags, U32 depth)
2948                         /* scanp: Start here (read-write). */
2949                         /* deltap: Write maxlen-minlen here. */
2950                         /* last: Stop before this one. */
2951                         /* data: string data about the pattern */
2952                         /* stopparen: treat close N as END */
2953                         /* recursed: which subroutines have we recursed into */
2954                         /* and_withp: Valid if flags & SCF_DO_STCLASS_OR */
2955 {
2956     dVAR;
2957     I32 min = 0, pars = 0, code;
2958     regnode *scan = *scanp, *next;
2959     I32 delta = 0;
2960     int is_inf = (flags & SCF_DO_SUBSTR) && (data->flags & SF_IS_INF);
2961     int is_inf_internal = 0;            /* The studied chunk is infinite */
2962     I32 is_par = OP(scan) == OPEN ? ARG(scan) : 0;
2963     scan_data_t data_fake;
2964     SV *re_trie_maxbuff = NULL;
2965     regnode *first_non_open = scan;
2966     I32 stopmin = I32_MAX;
2967     scan_frame *frame = NULL;
2968     GET_RE_DEBUG_FLAGS_DECL;
2969
2970     PERL_ARGS_ASSERT_STUDY_CHUNK;
2971
2972 #ifdef DEBUGGING
2973     StructCopy(&zero_scan_data, &data_fake, scan_data_t);
2974 #endif
2975
2976     if ( depth == 0 ) {
2977         while (first_non_open && OP(first_non_open) == OPEN)
2978             first_non_open=regnext(first_non_open);
2979     }
2980
2981
2982   fake_study_recurse:
2983     while ( scan && OP(scan) != END && scan < last ){
2984         UV min_subtract = 0;    /* How much to subtract from the minimum node
2985                                    length to get a real minimum (because the
2986                                    folded version may be shorter) */
2987         bool has_exactf_sharp_s = FALSE;
2988         /* Peephole optimizer: */
2989         DEBUG_STUDYDATA("Peep:", data,depth);
2990         DEBUG_PEEP("Peep",scan,depth);
2991
2992         /* Its not clear to khw or hv why this is done here, and not in the
2993          * clauses that deal with EXACT nodes.  khw's guess is that it's
2994          * because of a previous design */
2995         JOIN_EXACT(scan,&min_subtract, &has_exactf_sharp_s, 0);
2996
2997         /* Follow the next-chain of the current node and optimize
2998            away all the NOTHINGs from it.  */
2999         if (OP(scan) != CURLYX) {
3000             const int max = (reg_off_by_arg[OP(scan)]
3001                        ? I32_MAX
3002                        /* I32 may be smaller than U16 on CRAYs! */
3003                        : (I32_MAX < U16_MAX ? I32_MAX : U16_MAX));
3004             int off = (reg_off_by_arg[OP(scan)] ? ARG(scan) : NEXT_OFF(scan));
3005             int noff;
3006             regnode *n = scan;
3007
3008             /* Skip NOTHING and LONGJMP. */
3009             while ((n = regnext(n))
3010                    && ((PL_regkind[OP(n)] == NOTHING && (noff = NEXT_OFF(n)))
3011                        || ((OP(n) == LONGJMP) && (noff = ARG(n))))
3012                    && off + noff < max)
3013                 off += noff;
3014             if (reg_off_by_arg[OP(scan)])
3015                 ARG(scan) = off;
3016             else
3017                 NEXT_OFF(scan) = off;
3018         }
3019
3020
3021
3022         /* The principal pseudo-switch.  Cannot be a switch, since we
3023            look into several different things.  */
3024         if (OP(scan) == BRANCH || OP(scan) == BRANCHJ
3025                    || OP(scan) == IFTHEN) {
3026             next = regnext(scan);
3027             code = OP(scan);
3028             /* demq: the op(next)==code check is to see if we have "branch-branch" AFAICT */
3029
3030             if (OP(next) == code || code == IFTHEN) {
3031                 /* NOTE - There is similar code to this block below for handling
3032                    TRIE nodes on a re-study.  If you change stuff here check there
3033                    too. */
3034                 I32 max1 = 0, min1 = I32_MAX, num = 0;
3035                 struct regnode_charclass_class accum;
3036                 regnode * const startbranch=scan;
3037
3038                 if (flags & SCF_DO_SUBSTR)
3039                     SCAN_COMMIT(pRExC_state, data, minlenp); /* Cannot merge strings after this. */
3040                 if (flags & SCF_DO_STCLASS)
3041                     cl_init_zero(pRExC_state, &accum);
3042
3043                 while (OP(scan) == code) {
3044                     I32 deltanext, minnext, f = 0, fake;
3045                     struct regnode_charclass_class this_class;
3046
3047                     num++;
3048                     data_fake.flags = 0;
3049                     if (data) {
3050                         data_fake.whilem_c = data->whilem_c;
3051                         data_fake.last_closep = data->last_closep;
3052                     }
3053                     else
3054                         data_fake.last_closep = &fake;
3055
3056                     data_fake.pos_delta = delta;
3057                     next = regnext(scan);
3058                     scan = NEXTOPER(scan);
3059                     if (code != BRANCH)
3060                         scan = NEXTOPER(scan);
3061                     if (flags & SCF_DO_STCLASS) {
3062                         cl_init(pRExC_state, &this_class);
3063                         data_fake.start_class = &this_class;
3064                         f = SCF_DO_STCLASS_AND;
3065                     }
3066                     if (flags & SCF_WHILEM_VISITED_POS)
3067                         f |= SCF_WHILEM_VISITED_POS;
3068
3069                     /* we suppose the run is continuous, last=next...*/
3070                     minnext = study_chunk(pRExC_state, &scan, minlenp, &deltanext,
3071                                           next, &data_fake,
3072                                           stopparen, recursed, NULL, f,depth+1);
3073                     if (min1 > minnext)
3074                         min1 = minnext;
3075                     if (max1 < minnext + deltanext)
3076                         max1 = minnext + deltanext;
3077                     if (deltanext == I32_MAX)
3078                         is_inf = is_inf_internal = 1;
3079                     scan = next;
3080                     if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
3081                         pars++;
3082                     if (data_fake.flags & SCF_SEEN_ACCEPT) {
3083                         if ( stopmin > minnext) 
3084                             stopmin = min + min1;
3085                         flags &= ~SCF_DO_SUBSTR;
3086                         if (data)
3087                             data->flags |= SCF_SEEN_ACCEPT;
3088                     }
3089                     if (data) {
3090                         if (data_fake.flags & SF_HAS_EVAL)
3091                             data->flags |= SF_HAS_EVAL;
3092                         data->whilem_c = data_fake.whilem_c;
3093                     }
3094                     if (flags & SCF_DO_STCLASS)
3095                         cl_or(pRExC_state, &accum, &this_class);
3096                 }
3097                 if (code == IFTHEN && num < 2) /* Empty ELSE branch */
3098                     min1 = 0;
3099                 if (flags & SCF_DO_SUBSTR) {
3100                     data->pos_min += min1;
3101                     data->pos_delta += max1 - min1;
3102                     if (max1 != min1 || is_inf)
3103                         data->longest = &(data->longest_float);
3104                 }
3105                 min += min1;
3106                 delta += max1 - min1;
3107                 if (flags & SCF_DO_STCLASS_OR) {
3108                     cl_or(pRExC_state, data->start_class, &accum);
3109                     if (min1) {
3110                         cl_and(data->start_class, and_withp);
3111                         flags &= ~SCF_DO_STCLASS;
3112                     }
3113                 }
3114                 else if (flags & SCF_DO_STCLASS_AND) {
3115                     if (min1) {
3116                         cl_and(data->start_class, &accum);
3117                         flags &= ~SCF_DO_STCLASS;
3118                     }
3119                     else {
3120                         /* Switch to OR mode: cache the old value of
3121                          * data->start_class */
3122                         INIT_AND_WITHP;
3123                         StructCopy(data->start_class, and_withp,
3124                                    struct regnode_charclass_class);
3125                         flags &= ~SCF_DO_STCLASS_AND;
3126                         StructCopy(&accum, data->start_class,
3127                                    struct regnode_charclass_class);
3128                         flags |= SCF_DO_STCLASS_OR;
3129                         data->start_class->flags |= ANYOF_EOS;
3130                     }
3131                 }
3132
3133                 if (PERL_ENABLE_TRIE_OPTIMISATION && OP( startbranch ) == BRANCH ) {
3134                 /* demq.
3135
3136                    Assuming this was/is a branch we are dealing with: 'scan' now
3137                    points at the item that follows the branch sequence, whatever
3138                    it is. We now start at the beginning of the sequence and look
3139                    for subsequences of
3140
3141                    BRANCH->EXACT=>x1
3142                    BRANCH->EXACT=>x2
3143                    tail
3144
3145                    which would be constructed from a pattern like /A|LIST|OF|WORDS/
3146
3147                    If we can find such a subsequence we need to turn the first
3148                    element into a trie and then add the subsequent branch exact
3149                    strings to the trie.
3150
3151                    We have two cases
3152
3153                      1. patterns where the whole set of branches can be converted. 
3154
3155                      2. patterns where only a subset can be converted.
3156
3157                    In case 1 we can replace the whole set with a single regop
3158                    for the trie. In case 2 we need to keep the start and end
3159                    branches so
3160
3161                      'BRANCH EXACT; BRANCH EXACT; BRANCH X'
3162                      becomes BRANCH TRIE; BRANCH X;
3163
3164                   There is an additional case, that being where there is a 
3165                   common prefix, which gets split out into an EXACT like node
3166                   preceding the TRIE node.
3167
3168                   If x(1..n)==tail then we can do a simple trie, if not we make
3169                   a "jump" trie, such that when we match the appropriate word
3170                   we "jump" to the appropriate tail node. Essentially we turn
3171                   a nested if into a case structure of sorts.
3172
3173                 */
3174
3175                     int made=0;
3176                     if (!re_trie_maxbuff) {
3177                         re_trie_maxbuff = get_sv(RE_TRIE_MAXBUF_NAME, 1);
3178                         if (!SvIOK(re_trie_maxbuff))
3179                             sv_setiv(re_trie_maxbuff, RE_TRIE_MAXBUF_INIT);
3180                     }
3181                     if ( SvIV(re_trie_maxbuff)>=0  ) {
3182                         regnode *cur;
3183                         regnode *first = (regnode *)NULL;
3184                         regnode *last = (regnode *)NULL;
3185                         regnode *tail = scan;
3186                         U8 optype = 0;
3187                         U32 count=0;
3188
3189 #ifdef DEBUGGING
3190                         SV * const mysv = sv_newmortal();       /* for dumping */
3191 #endif
3192                         /* var tail is used because there may be a TAIL
3193                            regop in the way. Ie, the exacts will point to the
3194                            thing following the TAIL, but the last branch will
3195                            point at the TAIL. So we advance tail. If we
3196                            have nested (?:) we may have to move through several
3197                            tails.
3198                          */
3199
3200                         while ( OP( tail ) == TAIL ) {
3201                             /* this is the TAIL generated by (?:) */
3202                             tail = regnext( tail );
3203                         }
3204
3205                         
3206                         DEBUG_OPTIMISE_r({
3207                             regprop(RExC_rx, mysv, tail );
3208                             PerlIO_printf( Perl_debug_log, "%*s%s%s\n",
3209                                 (int)depth * 2 + 2, "", 
3210                                 "Looking for TRIE'able sequences. Tail node is: ", 
3211                                 SvPV_nolen_const( mysv )
3212                             );
3213                         });
3214                         
3215                         /*
3216
3217                            step through the branches, cur represents each
3218                            branch, noper is the first thing to be matched
3219                            as part of that branch and noper_next is the
3220                            regnext() of that node. if noper is an EXACT
3221                            and noper_next is the same as scan (our current
3222                            position in the regex) then the EXACT branch is
3223                            a possible optimization target. Once we have
3224                            two or more consecutive such branches we can
3225                            create a trie of the EXACT's contents and stich
3226                            it in place. If the sequence represents all of
3227                            the branches we eliminate the whole thing and
3228                            replace it with a single TRIE. If it is a
3229                            subsequence then we need to stitch it in. This
3230                            means the first branch has to remain, and needs
3231                            to be repointed at the item on the branch chain
3232                            following the last branch optimized. This could
3233                            be either a BRANCH, in which case the
3234                            subsequence is internal, or it could be the
3235                            item following the branch sequence in which
3236                            case the subsequence is at the end.
3237
3238                         */
3239
3240                         /* dont use tail as the end marker for this traverse */
3241                         for ( cur = startbranch ; cur != scan ; cur = regnext( cur ) ) {
3242                             regnode * const noper = NEXTOPER( cur );
3243 #if defined(DEBUGGING) || defined(NOJUMPTRIE)
3244                             regnode * const noper_next = regnext( noper );
3245 #endif
3246
3247                             DEBUG_OPTIMISE_r({
3248                                 regprop(RExC_rx, mysv, cur);
3249                                 PerlIO_printf( Perl_debug_log, "%*s- %s (%d)",
3250                                    (int)depth * 2 + 2,"", SvPV_nolen_const( mysv ), REG_NODE_NUM(cur) );
3251
3252                                 regprop(RExC_rx, mysv, noper);
3253                                 PerlIO_printf( Perl_debug_log, " -> %s",
3254                                     SvPV_nolen_const(mysv));
3255
3256                                 if ( noper_next ) {
3257                                   regprop(RExC_rx, mysv, noper_next );
3258                                   PerlIO_printf( Perl_debug_log,"\t=> %s\t",
3259                                     SvPV_nolen_const(mysv));
3260                                 }
3261                                 PerlIO_printf( Perl_debug_log, "(First==%d,Last==%d,Cur==%d)\n",
3262                                    REG_NODE_NUM(first), REG_NODE_NUM(last), REG_NODE_NUM(cur) );
3263                             });
3264                             if ( (((first && optype!=NOTHING) ? OP( noper ) == optype
3265                                          : PL_regkind[ OP( noper ) ] == EXACT )
3266                                   || OP(noper) == NOTHING )
3267 #ifdef NOJUMPTRIE
3268                                   && noper_next == tail
3269 #endif
3270                                   && count < U16_MAX)
3271                             {
3272                                 count++;
3273                                 if ( !first || optype == NOTHING ) {
3274                                     if (!first) first = cur;
3275                                     optype = OP( noper );
3276                                 } else {
3277                                     last = cur;
3278                                 }
3279                             } else {
3280 /* 
3281     Currently the trie logic handles case insensitive matching properly only
3282     when the pattern is UTF-8 and the node is EXACTFU (thus forcing unicode
3283     semantics).
3284
3285     If/when this is fixed the following define can be swapped
3286     in below to fully enable trie logic.
3287
3288 #define TRIE_TYPE_IS_SAFE 1
3289
3290 Note that join_exact() assumes that the other types of EXACTFish nodes are not
3291 used in tries, so that would have to be updated if this changed
3292
3293 */
3294 #define TRIE_TYPE_IS_SAFE ((UTF && optype == EXACTFU) || optype==EXACT)
3295
3296                                 if ( last && TRIE_TYPE_IS_SAFE ) {
3297                                     make_trie( pRExC_state, 
3298                                             startbranch, first, cur, tail, count, 
3299                                             optype, depth+1 );
3300                                 }
3301                                 if ( PL_regkind[ OP( noper ) ] == EXACT
3302 #ifdef NOJUMPTRIE
3303                                      && noper_next == tail
3304 #endif
3305                                 ){
3306                                     count = 1;
3307                                     first = cur;
3308                                     optype = OP( noper );
3309                                 } else {
3310                                     count = 0;
3311                                     first = NULL;
3312                                     optype = 0;
3313                                 }
3314                                 last = NULL;
3315                             }
3316                         }
3317                         DEBUG_OPTIMISE_r({
3318                             regprop(RExC_rx, mysv, cur);
3319                             PerlIO_printf( Perl_debug_log,
3320                               "%*s- %s (%d) <SCAN FINISHED>\n", (int)depth * 2 + 2,
3321                               "", SvPV_nolen_const( mysv ),REG_NODE_NUM(cur));
3322
3323                         });
3324                         
3325                         if ( last && TRIE_TYPE_IS_SAFE ) {
3326                             made= make_trie( pRExC_state, startbranch, first, scan, tail, count, optype, depth+1 );
3327 #ifdef TRIE_STUDY_OPT
3328                             if ( ((made == MADE_EXACT_TRIE && 
3329                                  startbranch == first) 
3330                                  || ( first_non_open == first )) && 
3331                                  depth==0 ) {
3332                                 flags |= SCF_TRIE_RESTUDY;
3333                                 if ( startbranch == first 
3334                                      && scan == tail ) 
3335                                 {
3336                                     RExC_seen &=~REG_TOP_LEVEL_BRANCHES;
3337                                 }
3338                             }
3339 #endif
3340                         }
3341                     }
3342                     
3343                 } /* do trie */
3344                 
3345             }
3346             else if ( code == BRANCHJ ) {  /* single branch is optimized. */
3347                 scan = NEXTOPER(NEXTOPER(scan));
3348             } else                      /* single branch is optimized. */
3349                 scan = NEXTOPER(scan);
3350             continue;
3351         } else if (OP(scan) == SUSPEND || OP(scan) == GOSUB || OP(scan) == GOSTART) {
3352             scan_frame *newframe = NULL;
3353             I32 paren;
3354             regnode *start;
3355             regnode *end;
3356
3357             if (OP(scan) != SUSPEND) {
3358             /* set the pointer */
3359                 if (OP(scan) == GOSUB) {
3360                     paren = ARG(scan);
3361                     RExC_recurse[ARG2L(scan)] = scan;
3362                     start = RExC_open_parens[paren-1];
3363                     end   = RExC_close_parens[paren-1];
3364                 } else {
3365                     paren = 0;
3366                     start = RExC_rxi->program + 1;
3367                     end   = RExC_opend;
3368                 }
3369                 if (!recursed) {
3370                     Newxz(recursed, (((RExC_npar)>>3) +1), U8);
3371                     SAVEFREEPV(recursed);
3372                 }
3373                 if (!PAREN_TEST(recursed,paren+1)) {
3374                     PAREN_SET(recursed,paren+1);
3375                     Newx(newframe,1,scan_frame);
3376                 } else {
3377                     if (flags & SCF_DO_SUBSTR) {
3378                         SCAN_COMMIT(pRExC_state,data,minlenp);
3379                         data->longest = &(data->longest_float);
3380                     }
3381                     is_inf = is_inf_internal = 1;
3382                     if (flags & SCF_DO_STCLASS_OR) /* Allow everything */
3383                         cl_anything(pRExC_state, data->start_class);
3384                     flags &= ~SCF_DO_STCLASS;
3385                 }
3386             } else {
3387                 Newx(newframe,1,scan_frame);
3388                 paren = stopparen;
3389                 start = scan+2;
3390                 end = regnext(scan);
3391             }
3392             if (newframe) {
3393                 assert(start);
3394                 assert(end);
3395                 SAVEFREEPV(newframe);
3396                 newframe->next = regnext(scan);
3397                 newframe->last = last;
3398                 newframe->stop = stopparen;
3399                 newframe->prev = frame;
3400
3401                 frame = newframe;
3402                 scan =  start;
3403                 stopparen = paren;
3404                 last = end;
3405
3406                 continue;
3407             }
3408         }
3409         else if (OP(scan) == EXACT) {
3410             I32 l = STR_LEN(scan);
3411             UV uc;
3412             if (UTF) {
3413                 const U8 * const s = (U8*)STRING(scan);
3414                 l = utf8_length(s, s + l);
3415                 uc = utf8_to_uvchr(s, NULL);
3416             } else {
3417                 uc = *((U8*)STRING(scan));
3418             }
3419             min += l;
3420             if (flags & SCF_DO_SUBSTR) { /* Update longest substr. */
3421                 /* The code below prefers earlier match for fixed
3422                    offset, later match for variable offset.  */
3423                 if (data->last_end == -1) { /* Update the start info. */
3424                     data->last_start_min = data->pos_min;
3425                     data->last_start_max = is_inf
3426                         ? I32_MAX : data->pos_min + data->pos_delta;
3427                 }
3428                 sv_catpvn(data->last_found, STRING(scan), STR_LEN(scan));
3429                 if (UTF)
3430                     SvUTF8_on(data->last_found);
3431                 {
3432                     SV * const sv = data->last_found;
3433                     MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ?
3434                         mg_find(sv, PERL_MAGIC_utf8) : NULL;
3435                     if (mg && mg->mg_len >= 0)
3436                         mg->mg_len += utf8_length((U8*)STRING(scan),
3437                                                   (U8*)STRING(scan)+STR_LEN(scan));
3438                 }
3439                 data->last_end = data->pos_min + l;
3440                 data->pos_min += l; /* As in the first entry. */
3441                 data->flags &= ~SF_BEFORE_EOL;
3442             }
3443             if (flags & SCF_DO_STCLASS_AND) {
3444                 /* Check whether it is compatible with what we know already! */
3445                 int compat = 1;
3446
3447
3448                 /* If compatible, we or it in below.  It is compatible if is
3449                  * in the bitmp and either 1) its bit or its fold is set, or 2)
3450                  * it's for a locale.  Even if there isn't unicode semantics
3451                  * here, at runtime there may be because of matching against a
3452                  * utf8 string, so accept a possible false positive for
3453                  * latin1-range folds */
3454                 if (uc >= 0x100 ||
3455                     (!(data->start_class->flags & (ANYOF_CLASS | ANYOF_LOCALE))
3456                     && !ANYOF_BITMAP_TEST(data->start_class, uc)
3457                     && (!(data->start_class->flags & ANYOF_LOC_NONBITMAP_FOLD)
3458                         || !ANYOF_BITMAP_TEST(data->start_class, PL_fold_latin1[uc])))
3459                     )
3460                 {
3461                     compat = 0;
3462                 }
3463                 ANYOF_CLASS_ZERO(data->start_class);
3464                 ANYOF_BITMAP_ZERO(data->start_class);
3465                 if (compat)
3466                     ANYOF_BITMAP_SET(data->start_class, uc);
3467                 else if (uc >= 0x100) {
3468                     int i;
3469
3470                     /* Some Unicode code points fold to the Latin1 range; as
3471                      * XXX temporary code, instead of figuring out if this is
3472                      * one, just assume it is and set all the start class bits
3473                      * that could be some such above 255 code point's fold
3474                      * which will generate fals positives.  As the code
3475                      * elsewhere that does compute the fold settles down, it
3476                      * can be extracted out and re-used here */
3477                     for (i = 0; i < 256; i++){
3478                         if (_HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(i)) {
3479                             ANYOF_BITMAP_SET(data->start_class, i);
3480                         }
3481                     }
3482                 }
3483                 data->start_class->flags &= ~ANYOF_EOS;
3484                 if (uc < 0x100)
3485                   data->start_class->flags &= ~ANYOF_UNICODE_ALL;
3486             }
3487             else if (flags & SCF_DO_STCLASS_OR) {
3488                 /* false positive possible if the class is case-folded */
3489                 if (uc < 0x100)
3490                     ANYOF_BITMAP_SET(data->start_class, uc);
3491                 else
3492                     data->start_class->flags |= ANYOF_UNICODE_ALL;
3493                 data->start_class->flags &= ~ANYOF_EOS;
3494                 cl_and(data->start_class, and_withp);
3495             }
3496             flags &= ~SCF_DO_STCLASS;
3497         }
3498         else if (PL_regkind[OP(scan)] == EXACT) { /* But OP != EXACT! */
3499             I32 l = STR_LEN(scan);
3500             UV uc = *((U8*)STRING(scan));
3501
3502             /* Search for fixed substrings supports EXACT only. */
3503             if (flags & SCF_DO_SUBSTR) {
3504                 assert(data);
3505                 SCAN_COMMIT(pRExC_state, data, minlenp);
3506             }
3507             if (UTF) {
3508                 const U8 * const s = (U8 *)STRING(scan);
3509                 l = utf8_length(s, s + l);
3510                 uc = utf8_to_uvchr(s, NULL);
3511             }
3512             else if (has_exactf_sharp_s) {
3513                 RExC_seen |= REG_SEEN_EXACTF_SHARP_S;
3514             }
3515             min += l - min_subtract;
3516             if (min < 0) {
3517                 min = 0;
3518             }
3519             delta += min_subtract;
3520             if (flags & SCF_DO_SUBSTR) {
3521                 data->pos_min += l - min_subtract;
3522                 if (data->pos_min < 0) {
3523                     data->pos_min = 0;
3524                 }
3525                 data->pos_delta += min_subtract;
3526                 if (min_subtract) {
3527                     data->longest = &(data->longest_float);
3528                 }
3529             }
3530             if (flags & SCF_DO_STCLASS_AND) {
3531                 /* Check whether it is compatible with what we know already! */
3532                 int compat = 1;
3533                 if (uc >= 0x100 ||
3534                  (!(data->start_class->flags & (ANYOF_CLASS | ANYOF_LOCALE))
3535                   && !ANYOF_BITMAP_TEST(data->start_class, uc)
3536                   && !ANYOF_BITMAP_TEST(data->start_class, PL_fold_latin1[uc])))
3537                 {
3538                     compat = 0;
3539                 }
3540                 ANYOF_CLASS_ZERO(data->start_class);
3541                 ANYOF_BITMAP_ZERO(data->start_class);
3542                 if (compat) {
3543                     ANYOF_BITMAP_SET(data->start_class, uc);
3544                     data->start_class->flags &= ~ANYOF_EOS;
3545                     data->start_class->flags |= ANYOF_LOC_NONBITMAP_FOLD;
3546                     if (OP(scan) == EXACTFL) {
3547                         /* XXX This set is probably no longer necessary, and
3548                          * probably wrong as LOCALE now is on in the initial
3549                          * state */
3550                         data->start_class->flags |= ANYOF_LOCALE;
3551                     }
3552                     else {
3553
3554                         /* Also set the other member of the fold pair.  In case
3555                          * that unicode semantics is called for at runtime, use
3556                          * the full latin1 fold.  (Can't do this for locale,
3557                          * because not known until runtime) */
3558                         ANYOF_BITMAP_SET(data->start_class, PL_fold_latin1[uc]);
3559
3560                         /* All other (EXACTFL handled above) folds except under
3561                          * /iaa that include s, S, and sharp_s also may include
3562                          * the others */
3563                         if (OP(scan) != EXACTFA) {
3564                             if (uc == 's' || uc == 'S') {
3565                                 ANYOF_BITMAP_SET(data->start_class,
3566                                                  LATIN_SMALL_LETTER_SHARP_S);
3567                             }
3568                             else if (uc == LATIN_SMALL_LETTER_SHARP_S) {
3569                                 ANYOF_BITMAP_SET(data->start_class, 's');
3570                                 ANYOF_BITMAP_SET(data->start_class, 'S');
3571                             }
3572                         }
3573                     }
3574                 }
3575                 else if (uc >= 0x100) {
3576                     int i;
3577                     for (i = 0; i < 256; i++){
3578                         if (_HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(i)) {
3579                             ANYOF_BITMAP_SET(data->start_class, i);
3580                         }
3581                     }
3582                 }
3583             }
3584             else if (flags & SCF_DO_STCLASS_OR) {
3585                 if (data->start_class->flags & ANYOF_LOC_NONBITMAP_FOLD) {
3586                     /* false positive possible if the class is case-folded.
3587                        Assume that the locale settings are the same... */
3588                     if (uc < 0x100) {
3589                         ANYOF_BITMAP_SET(data->start_class, uc);
3590                         if (OP(scan) != EXACTFL) {
3591
3592                             /* And set the other member of the fold pair, but
3593                              * can't do that in locale because not known until
3594                              * run-time */
3595                             ANYOF_BITMAP_SET(data->start_class,
3596                                              PL_fold_latin1[uc]);
3597
3598                             /* All folds except under /iaa that include s, S,
3599                              * and sharp_s also may include the others */
3600                             if (OP(scan) != EXACTFA) {
3601                                 if (uc == 's' || uc == 'S') {
3602                                     ANYOF_BITMAP_SET(data->start_class,
3603                                                    LATIN_SMALL_LETTER_SHARP_S);
3604                                 }
3605                                 else if (uc == LATIN_SMALL_LETTER_SHARP_S) {
3606                                     ANYOF_BITMAP_SET(data->start_class, 's');
3607                                     ANYOF_BITMAP_SET(data->start_class, 'S');
3608                                 }
3609                             }
3610                         }
3611                     }
3612                     data->start_class->flags &= ~ANYOF_EOS;
3613                 }
3614                 cl_and(data->start_class, and_withp);
3615             }
3616             flags &= ~SCF_DO_STCLASS;
3617         }
3618         else if (REGNODE_VARIES(OP(scan))) {
3619             I32 mincount, maxcount, minnext, deltanext, fl = 0;
3620             I32 f = flags, pos_before = 0;
3621             regnode * const oscan = scan;
3622             struct regnode_charclass_class this_class;
3623             struct regnode_charclass_class *oclass = NULL;
3624             I32 next_is_eval = 0;
3625
3626             switch (PL_regkind[OP(scan)]) {
3627             case WHILEM:                /* End of (?:...)* . */
3628                 scan = NEXTOPER(scan);
3629                 goto finish;
3630             case PLUS:
3631                 if (flags & (SCF_DO_SUBSTR | SCF_DO_STCLASS)) {
3632                     next = NEXTOPER(scan);
3633                     if (OP(next) == EXACT || (flags & SCF_DO_STCLASS)) {
3634                         mincount = 1;
3635                         maxcount = REG_INFTY;
3636                         next = regnext(scan);
3637                         scan = NEXTOPER(scan);
3638                         goto do_curly;
3639                     }
3640                 }
3641                 if (flags & SCF_DO_SUBSTR)
3642                     data->pos_min++;
3643                 min++;
3644                 /* Fall through. */
3645             case STAR:
3646                 if (flags & SCF_DO_STCLASS) {
3647                     mincount = 0;
3648                     maxcount = REG_INFTY;
3649                     next = regnext(scan);
3650                     scan = NEXTOPER(scan);
3651                     goto do_curly;
3652                 }
3653                 is_inf = is_inf_internal = 1;
3654                 scan = regnext(scan);
3655                 if (flags & SCF_DO_SUBSTR) {
3656                     SCAN_COMMIT(pRExC_state, data, minlenp); /* Cannot extend fixed substrings */
3657                     data->longest = &(data->longest_float);
3658                 }
3659                 goto optimize_curly_tail;
3660             case CURLY:
3661                 if (stopparen>0 && (OP(scan)==CURLYN || OP(scan)==CURLYM)
3662                     && (scan->flags == stopparen))
3663                 {
3664                     mincount = 1;
3665                     maxcount = 1;
3666                 } else {
3667                     mincount = ARG1(scan);
3668                     maxcount = ARG2(scan);
3669                 }
3670                 next = regnext(scan);
3671                 if (OP(scan) == CURLYX) {
3672                     I32 lp = (data ? *(data->last_closep) : 0);
3673                     scan->flags = ((lp <= (I32)U8_MAX) ? (U8)lp : U8_MAX);
3674                 }
3675                 scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
3676                 next_is_eval = (OP(scan) == EVAL);
3677               do_curly:
3678                 if (flags & SCF_DO_SUBSTR) {
3679                     if (mincount == 0) SCAN_COMMIT(pRExC_state,data,minlenp); /* Cannot extend fixed substrings */
3680                     pos_before = data->pos_min;
3681                 }
3682                 if (data) {
3683                     fl = data->flags;
3684                     data->flags &= ~(SF_HAS_PAR|SF_IN_PAR|SF_HAS_EVAL);
3685                     if (is_inf)
3686                         data->flags |= SF_IS_INF;
3687                 }
3688                 if (flags & SCF_DO_STCLASS) {
3689                     cl_init(pRExC_state, &this_class);
3690                     oclass = data->start_class;
3691                     data->start_class = &this_class;
3692                     f |= SCF_DO_STCLASS_AND;
3693                     f &= ~SCF_DO_STCLASS_OR;
3694                 }
3695                 /* Exclude from super-linear cache processing any {n,m}
3696                    regops for which the combination of input pos and regex
3697                    pos is not enough information to determine if a match
3698                    will be possible.
3699
3700                    For example, in the regex /foo(bar\s*){4,8}baz/ with the
3701                    regex pos at the \s*, the prospects for a match depend not
3702                    only on the input position but also on how many (bar\s*)
3703                    repeats into the {4,8} we are. */
3704                if ((mincount > 1) || (maxcount > 1 && maxcount != REG_INFTY))
3705                     f &= ~SCF_WHILEM_VISITED_POS;
3706
3707                 /* This will finish on WHILEM, setting scan, or on NULL: */
3708                 minnext = study_chunk(pRExC_state, &scan, minlenp, &deltanext, 
3709                                       last, data, stopparen, recursed, NULL,
3710                                       (mincount == 0
3711                                         ? (f & ~SCF_DO_SUBSTR) : f),depth+1);
3712
3713                 if (flags & SCF_DO_STCLASS)
3714                     data->start_class = oclass;
3715                 if (mincount == 0 || minnext == 0) {
3716                     if (flags & SCF_DO_STCLASS_OR) {
3717                         cl_or(pRExC_state, data->start_class, &this_class);
3718                     }
3719                     else if (flags & SCF_DO_STCLASS_AND) {
3720                         /* Switch to OR mode: cache the old value of
3721                          * data->start_class */
3722                         INIT_AND_WITHP;
3723                         StructCopy(data->start_class, and_withp,
3724                                    struct regnode_charclass_class);
3725                         flags &= ~SCF_DO_STCLASS_AND;
3726                         StructCopy(&this_class, data->start_class,
3727                                    struct regnode_charclass_class);
3728                         flags |= SCF_DO_STCLASS_OR;
3729                         data->start_class->flags |= ANYOF_EOS;
3730                     }
3731                 } else {                /* Non-zero len */
3732                     if (flags & SCF_DO_STCLASS_OR) {
3733                         cl_or(pRExC_state, data->start_class, &this_class);
3734                         cl_and(data->start_class, and_withp);
3735                     }
3736                     else if (flags & SCF_DO_STCLASS_AND)
3737                         cl_and(data->start_class, &this_class);
3738                     flags &= ~SCF_DO_STCLASS;
3739                 }
3740                 if (!scan)              /* It was not CURLYX, but CURLY. */
3741                     scan = next;
3742                 if ( /* ? quantifier ok, except for (?{ ... }) */
3743                     (next_is_eval || !(mincount == 0 && maxcount == 1))
3744                     && (minnext == 0) && (deltanext == 0)
3745                     && data && !(data->flags & (SF_HAS_PAR|SF_IN_PAR))
3746                     && maxcount <= REG_INFTY/3) /* Complement check for big count */
3747                 {
3748                     ckWARNreg(RExC_parse,
3749                               "Quantifier unexpected on zero-length expression");
3750                 }
3751
3752                 min += minnext * mincount;
3753                 is_inf_internal |= ((maxcount == REG_INFTY
3754                                      && (minnext + deltanext) > 0)
3755                                     || deltanext == I32_MAX);
3756                 is_inf |= is_inf_internal;
3757                 delta += (minnext + deltanext) * maxcount - minnext * mincount;
3758
3759                 /* Try powerful optimization CURLYX => CURLYN. */
3760                 if (  OP(oscan) == CURLYX && data
3761                       && data->flags & SF_IN_PAR
3762                       && !(data->flags & SF_HAS_EVAL)
3763                       && !deltanext && minnext == 1 ) {
3764                     /* Try to optimize to CURLYN.  */
3765                     regnode *nxt = NEXTOPER(oscan) + EXTRA_STEP_2ARGS;
3766                     regnode * const nxt1 = nxt;
3767 #ifdef DEBUGGING
3768                     regnode *nxt2;
3769 #endif
3770
3771                     /* Skip open. */
3772                     nxt = regnext(nxt);
3773                     if (!REGNODE_SIMPLE(OP(nxt))
3774                         && !(PL_regkind[OP(nxt)] == EXACT
3775                              && STR_LEN(nxt) == 1))
3776                         goto nogo;
3777 #ifdef DEBUGGING
3778                     nxt2 = nxt;
3779 #endif
3780                     nxt = regnext(nxt);
3781                     if (OP(nxt) != CLOSE)
3782                         goto nogo;
3783                     if (RExC_open_parens) {
3784                         RExC_open_parens[ARG(nxt1)-1]=oscan; /*open->CURLYM*/
3785                         RExC_close_parens[ARG(nxt1)-1]=nxt+2; /*close->while*/
3786                     }
3787                     /* Now we know that nxt2 is the only contents: */
3788                     oscan->flags = (U8)ARG(nxt);
3789                     OP(oscan) = CURLYN;
3790                     OP(nxt1) = NOTHING; /* was OPEN. */
3791
3792 #ifdef DEBUGGING
3793                     OP(nxt1 + 1) = OPTIMIZED; /* was count. */
3794                     NEXT_OFF(nxt1+ 1) = 0; /* just for consistency. */
3795                     NEXT_OFF(nxt2) = 0; /* just for consistency with CURLY. */
3796                     OP(nxt) = OPTIMIZED;        /* was CLOSE. */
3797                     OP(nxt + 1) = OPTIMIZED; /* was count. */
3798                     NEXT_OFF(nxt+ 1) = 0; /* just for consistency. */
3799 #endif
3800                 }
3801               nogo:
3802
3803                 /* Try optimization CURLYX => CURLYM. */
3804                 if (  OP(oscan) == CURLYX && data
3805                       && !(data->flags & SF_HAS_PAR)
3806                       && !(data->flags & SF_HAS_EVAL)
3807                       && !deltanext     /* atom is fixed width */
3808                       && minnext != 0   /* CURLYM can't handle zero width */
3809                 ) {
3810                     /* XXXX How to optimize if data == 0? */
3811                     /* Optimize to a simpler form.  */
3812                     regnode *nxt = NEXTOPER(oscan) + EXTRA_STEP_2ARGS; /* OPEN */
3813                     regnode *nxt2;
3814
3815                     OP(oscan) = CURLYM;
3816                     while ( (nxt2 = regnext(nxt)) /* skip over embedded stuff*/
3817                             && (OP(nxt2) != WHILEM))
3818                         nxt = nxt2;
3819                     OP(nxt2)  = SUCCEED; /* Whas WHILEM */
3820                     /* Need to optimize away parenths. */
3821                     if ((data->flags & SF_IN_PAR) && OP(nxt) == CLOSE) {
3822                         /* Set the parenth number.  */
3823                         regnode *nxt1 = NEXTOPER(oscan) + EXTRA_STEP_2ARGS; /* OPEN*/
3824
3825                         oscan->flags = (U8)ARG(nxt);
3826                         if (RExC_open_parens) {
3827                             RExC_open_parens[ARG(nxt1)-1]=oscan; /*open->CURLYM*/
3828                             RExC_close_parens[ARG(nxt1)-1]=nxt2+1; /*close->NOTHING*/
3829                         }
3830                         OP(nxt1) = OPTIMIZED;   /* was OPEN. */
3831                         OP(nxt) = OPTIMIZED;    /* was CLOSE. */
3832
3833 #ifdef DEBUGGING
3834                         OP(nxt1 + 1) = OPTIMIZED; /* was count. */
3835                         OP(nxt + 1) = OPTIMIZED; /* was count. */
3836                         NEXT_OFF(nxt1 + 1) = 0; /* just for consistency. */
3837                         NEXT_OFF(nxt + 1) = 0; /* just for consistency. */
3838 #endif
3839 #if 0
3840                         while ( nxt1 && (OP(nxt1) != WHILEM)) {
3841                             regnode *nnxt = regnext(nxt1);
3842                             if (nnxt == nxt) {
3843                                 if (reg_off_by_arg[OP(nxt1)])
3844                                     ARG_SET(nxt1, nxt2 - nxt1);
3845                                 else if (nxt2 - nxt1 < U16_MAX)
3846                                     NEXT_OFF(nxt1) = nxt2 - nxt1;
3847                                 else
3848                                     OP(nxt) = NOTHING;  /* Cannot beautify */
3849                             }
3850                             nxt1 = nnxt;
3851                         }
3852 #endif
3853                         /* Optimize again: */
3854                         study_chunk(pRExC_state, &nxt1, minlenp, &deltanext, nxt,
3855                                     NULL, stopparen, recursed, NULL, 0,depth+1);
3856                     }
3857                     else
3858                         oscan->flags = 0;
3859                 }