]> git.vpit.fr Git - perl/modules/re-engine-Hooks.git/blob - src/5017011/regexec.c
Don't support old development releases anymore
[perl/modules/re-engine-Hooks.git] / src / 5017011 / regexec.c
1 /*    regexec.c
2  */
3
4 /*
5  *      One Ring to rule them all, One Ring to find them
6  &
7  *     [p.v of _The Lord of the Rings_, opening poem]
8  *     [p.50 of _The Lord of the Rings_, I/iii: "The Shadow of the Past"]
9  *     [p.254 of _The Lord of the Rings_, II/ii: "The Council of Elrond"]
10  */
11
12 /* This file contains functions for executing a regular expression.  See
13  * also regcomp.c which funnily enough, contains functions for compiling
14  * a regular expression.
15  *
16  * This file is also copied at build time to ext/re/re_exec.c, where
17  * it's built with -DPERL_EXT_RE_BUILD -DPERL_EXT_RE_DEBUG -DPERL_EXT.
18  * This causes the main functions to be compiled under new names and with
19  * debugging support added, which makes "use re 'debug'" work.
20  */
21
22 /* NOTE: this is derived from Henry Spencer's regexp code, and should not
23  * confused with the original package (see point 3 below).  Thanks, Henry!
24  */
25
26 /* Additional note: this code is very heavily munged from Henry's version
27  * in places.  In some spots I've traded clarity for efficiency, so don't
28  * blame Henry for some of the lack of readability.
29  */
30
31 /* The names of the functions have been changed from regcomp and
32  * regexec to  pregcomp and pregexec in order to avoid conflicts
33  * with the POSIX routines of the same names.
34 */
35
36 #ifdef PERL_EXT_RE_BUILD
37 #include "re_top.h"
38 #endif
39
40 /* At least one required character in the target string is expressible only in
41  * UTF-8. */
42 static const char* const non_utf8_target_but_utf8_required
43                 = "Can't match, because target string needs to be in UTF-8\n";
44
45 #define NON_UTF8_TARGET_BUT_UTF8_REQUIRED(target) STMT_START { \
46     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s", non_utf8_target_but_utf8_required));\
47     goto target; \
48 } STMT_END
49
50 /*
51  * pregcomp and pregexec -- regsub and regerror are not used in perl
52  *
53  *      Copyright (c) 1986 by University of Toronto.
54  *      Written by Henry Spencer.  Not derived from licensed software.
55  *
56  *      Permission is granted to anyone to use this software for any
57  *      purpose on any computer system, and to redistribute it freely,
58  *      subject to the following restrictions:
59  *
60  *      1. The author is not responsible for the consequences of use of
61  *              this software, no matter how awful, even if they arise
62  *              from defects in it.
63  *
64  *      2. The origin of this software must not be misrepresented, either
65  *              by explicit claim or by omission.
66  *
67  *      3. Altered versions must be plainly marked as such, and must not
68  *              be misrepresented as being the original software.
69  *
70  ****    Alterations to Henry's code are...
71  ****
72  ****    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
73  ****    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
74  ****    by Larry Wall and others
75  ****
76  ****    You may distribute under the terms of either the GNU General Public
77  ****    License or the Artistic License, as specified in the README file.
78  *
79  * Beware that some of this code is subtly aware of the way operator
80  * precedence is structured in regular expressions.  Serious changes in
81  * regular-expression syntax might require a total rethink.
82  */
83 #include "EXTERN.h"
84 #define PERL_IN_REGEXEC_C
85 #include "perl.h"
86 #include "re_defs.h"
87
88 #ifdef PERL_IN_XSUB_RE
89 #  include "re_comp.h"
90 #else
91 #  include "regcomp.h"
92 #endif
93
94 #include "inline_invlist.c"
95 #include "unicode_constants.h"
96
97 #define HAS_NONLATIN1_FOLD_CLOSURE(i) _HAS_NONLATIN1_FOLD_CLOSURE_ONLY_FOR_USE_BY_REGCOMP_DOT_C_AND_REGEXEC_DOT_C(i)
98
99 #ifndef STATIC
100 #define STATIC  static
101 #endif
102
103 /* Valid for non-utf8 strings: avoids the reginclass
104  * call if there are no complications: i.e., if everything matchable is
105  * straight forward in the bitmap */
106 #define REGINCLASS(prog,p,c)  (ANYOF_FLAGS(p) ? reginclass(prog,p,c,0)   \
107                                               : ANYOF_BITMAP_TEST(p,*(c)))
108
109 /*
110  * Forwards.
111  */
112
113 #define CHR_SVLEN(sv) (utf8_target ? sv_len_utf8(sv) : SvCUR(sv))
114 #define CHR_DIST(a,b) (PL_reg_match_utf8 ? utf8_distance(a,b) : a - b)
115
116 #define HOPc(pos,off) \
117         (char *)(PL_reg_match_utf8 \
118             ? reghop3((U8*)pos, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr)) \
119             : (U8*)(pos + off))
120 #define HOPBACKc(pos, off) \
121         (char*)(PL_reg_match_utf8\
122             ? reghopmaybe3((U8*)pos, -off, (U8*)PL_bostr) \
123             : (pos - off >= PL_bostr)           \
124                 ? (U8*)pos - off                \
125                 : NULL)
126
127 #define HOP3(pos,off,lim) (PL_reg_match_utf8 ? reghop3((U8*)(pos), off, (U8*)(lim)) : (U8*)(pos + off))
128 #define HOP3c(pos,off,lim) ((char*)HOP3(pos,off,lim))
129
130
131 #define NEXTCHR_EOS -10 /* nextchr has fallen off the end */
132 #define NEXTCHR_IS_EOS (nextchr < 0)
133
134 #define SET_nextchr \
135     nextchr = ((locinput < PL_regeol) ? UCHARAT(locinput) : NEXTCHR_EOS)
136
137 #define SET_locinput(p) \
138     locinput = (p);  \
139     SET_nextchr
140
141
142 #define LOAD_UTF8_CHARCLASS(swash_ptr, property_name) STMT_START {            \
143         if (!swash_ptr) {                                                     \
144             U8 flags = _CORE_SWASH_INIT_ACCEPT_INVLIST;                       \
145             swash_ptr = _core_swash_init("utf8", property_name, &PL_sv_undef, \
146                                          1, 0, NULL, &flags);                 \
147             assert(swash_ptr);                                                \
148         }                                                                     \
149     } STMT_END
150
151 /* If in debug mode, we test that a known character properly matches */
152 #ifdef DEBUGGING
153 #   define LOAD_UTF8_CHARCLASS_DEBUG_TEST(swash_ptr,                          \
154                                           property_name,                      \
155                                           utf8_char_in_property)              \
156         LOAD_UTF8_CHARCLASS(swash_ptr, property_name);                        \
157         assert(swash_fetch(swash_ptr, (U8 *) utf8_char_in_property, TRUE));
158 #else
159 #   define LOAD_UTF8_CHARCLASS_DEBUG_TEST(swash_ptr,                          \
160                                           property_name,                      \
161                                           utf8_char_in_property)              \
162         LOAD_UTF8_CHARCLASS(swash_ptr, property_name)
163 #endif
164
165 #define LOAD_UTF8_CHARCLASS_ALNUM() LOAD_UTF8_CHARCLASS_DEBUG_TEST(           \
166                                         PL_utf8_swash_ptrs[_CC_WORDCHAR],     \
167                                         swash_property_names[_CC_WORDCHAR],   \
168                                         GREEK_SMALL_LETTER_IOTA_UTF8)
169
170 #define LOAD_UTF8_CHARCLASS_GCB()  /* Grapheme cluster boundaries */          \
171     STMT_START {                                                              \
172         LOAD_UTF8_CHARCLASS_DEBUG_TEST(PL_utf8_X_regular_begin,               \
173                                        "_X_regular_begin",                    \
174                                        GREEK_SMALL_LETTER_IOTA_UTF8);         \
175         LOAD_UTF8_CHARCLASS_DEBUG_TEST(PL_utf8_X_extend,                      \
176                                        "_X_extend",                           \
177                                        COMBINING_GRAVE_ACCENT_UTF8);          \
178     } STMT_END
179
180 #define PLACEHOLDER     /* Something for the preprocessor to grab onto */
181 /* TODO: Combine JUMPABLE and HAS_TEXT to cache OP(rn) */
182
183 /* for use after a quantifier and before an EXACT-like node -- japhy */
184 /* it would be nice to rework regcomp.sym to generate this stuff. sigh
185  *
186  * NOTE that *nothing* that affects backtracking should be in here, specifically
187  * VERBS must NOT be included. JUMPABLE is used to determine  if we can ignore a
188  * node that is in between two EXACT like nodes when ascertaining what the required
189  * "follow" character is. This should probably be moved to regex compile time
190  * although it may be done at run time beause of the REF possibility - more
191  * investigation required. -- demerphq
192 */
193 #define JUMPABLE(rn) (      \
194     OP(rn) == OPEN ||       \
195     (OP(rn) == CLOSE && (!cur_eval || cur_eval->u.eval.close_paren != ARG(rn))) || \
196     OP(rn) == EVAL ||   \
197     OP(rn) == SUSPEND || OP(rn) == IFMATCH || \
198     OP(rn) == PLUS || OP(rn) == MINMOD || \
199     OP(rn) == KEEPS || \
200     (PL_regkind[OP(rn)] == CURLY && ARG1(rn) > 0) \
201 )
202 #define IS_EXACT(rn) (PL_regkind[OP(rn)] == EXACT)
203
204 #define HAS_TEXT(rn) ( IS_EXACT(rn) || PL_regkind[OP(rn)] == REF )
205
206 #if 0 
207 /* Currently these are only used when PL_regkind[OP(rn)] == EXACT so
208    we don't need this definition. */
209 #define IS_TEXT(rn)   ( OP(rn)==EXACT   || OP(rn)==REF   || OP(rn)==NREF   )
210 #define IS_TEXTF(rn)  ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn)==EXACTFU_TRICKYFOLD || OP(rn)==EXACTFA || OP(rn)==EXACTF || OP(rn)==REFF  || OP(rn)==NREFF )
211 #define IS_TEXTFL(rn) ( OP(rn)==EXACTFL || OP(rn)==REFFL || OP(rn)==NREFFL )
212
213 #else
214 /* ... so we use this as its faster. */
215 #define IS_TEXT(rn)   ( OP(rn)==EXACT   )
216 #define IS_TEXTFU(rn)  ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn)==EXACTFU_TRICKYFOLD || OP(rn) == EXACTFA)
217 #define IS_TEXTF(rn)  ( OP(rn)==EXACTF  )
218 #define IS_TEXTFL(rn) ( OP(rn)==EXACTFL )
219
220 #endif
221
222 /*
223   Search for mandatory following text node; for lookahead, the text must
224   follow but for lookbehind (rn->flags != 0) we skip to the next step.
225 */
226 #define FIND_NEXT_IMPT(rn) STMT_START { \
227     while (JUMPABLE(rn)) { \
228         const OPCODE type = OP(rn); \
229         if (type == SUSPEND || PL_regkind[type] == CURLY) \
230             rn = NEXTOPER(NEXTOPER(rn)); \
231         else if (type == PLUS) \
232             rn = NEXTOPER(rn); \
233         else if (type == IFMATCH) \
234             rn = (rn->flags == 0) ? NEXTOPER(NEXTOPER(rn)) : rn + ARG(rn); \
235         else rn += NEXT_OFF(rn); \
236     } \
237 } STMT_END 
238
239 /* These constants are for finding GCB=LV and GCB=LVT in the CLUMP regnode.
240  * These are for the pre-composed Hangul syllables, which are all in a
241  * contiguous block and arranged there in such a way so as to facilitate
242  * alorithmic determination of their characteristics.  As such, they don't need
243  * a swash, but can be determined by simple arithmetic.  Almost all are
244  * GCB=LVT, but every 28th one is a GCB=LV */
245 #define SBASE 0xAC00    /* Start of block */
246 #define SCount 11172    /* Length of block */
247 #define TCount 28
248
249 static void restore_pos(pTHX_ void *arg);
250
251 #define REGCP_PAREN_ELEMS 3
252 #define REGCP_OTHER_ELEMS 3
253 #define REGCP_FRAME_ELEMS 1
254 /* REGCP_FRAME_ELEMS are not part of the REGCP_OTHER_ELEMS and
255  * are needed for the regexp context stack bookkeeping. */
256
257 STATIC CHECKPOINT
258 S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen)
259 {
260     dVAR;
261     const int retval = PL_savestack_ix;
262     const int paren_elems_to_push =
263                 (maxopenparen - parenfloor) * REGCP_PAREN_ELEMS;
264     const UV total_elems = paren_elems_to_push + REGCP_OTHER_ELEMS;
265     const UV elems_shifted = total_elems << SAVE_TIGHT_SHIFT;
266     I32 p;
267     GET_RE_DEBUG_FLAGS_DECL;
268
269     PERL_ARGS_ASSERT_REGCPPUSH;
270
271     if (paren_elems_to_push < 0)
272         Perl_croak(aTHX_ "panic: paren_elems_to_push, %i < 0",
273                    paren_elems_to_push);
274
275     if ((elems_shifted >> SAVE_TIGHT_SHIFT) != total_elems)
276         Perl_croak(aTHX_ "panic: paren_elems_to_push offset %"UVuf
277                    " out of range (%lu-%ld)",
278                    total_elems,
279                    (unsigned long)maxopenparen,
280                    (long)parenfloor);
281
282     SSGROW(total_elems + REGCP_FRAME_ELEMS);
283     
284     DEBUG_BUFFERS_r(
285         if ((int)maxopenparen > (int)parenfloor)
286             PerlIO_printf(Perl_debug_log,
287                 "rex=0x%"UVxf" offs=0x%"UVxf": saving capture indices:\n",
288                 PTR2UV(rex),
289                 PTR2UV(rex->offs)
290             );
291     );
292     for (p = parenfloor+1; p <= (I32)maxopenparen;  p++) {
293 /* REGCP_PARENS_ELEMS are pushed per pairs of parentheses. */
294         SSPUSHINT(rex->offs[p].end);
295         SSPUSHINT(rex->offs[p].start);
296         SSPUSHINT(rex->offs[p].start_tmp);
297         DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
298             "    \\%"UVuf": %"IVdf"(%"IVdf")..%"IVdf"\n",
299             (UV)p,
300             (IV)rex->offs[p].start,
301             (IV)rex->offs[p].start_tmp,
302             (IV)rex->offs[p].end
303         ));
304     }
305 /* REGCP_OTHER_ELEMS are pushed in any case, parentheses or no. */
306     SSPUSHINT(maxopenparen);
307     SSPUSHINT(rex->lastparen);
308     SSPUSHINT(rex->lastcloseparen);
309     SSPUSHUV(SAVEt_REGCONTEXT | elems_shifted); /* Magic cookie. */
310
311     return retval;
312 }
313
314 /* These are needed since we do not localize EVAL nodes: */
315 #define REGCP_SET(cp)                                           \
316     DEBUG_STATE_r(                                              \
317             PerlIO_printf(Perl_debug_log,                       \
318                 "  Setting an EVAL scope, savestack=%"IVdf"\n", \
319                 (IV)PL_savestack_ix));                          \
320     cp = PL_savestack_ix
321
322 #define REGCP_UNWIND(cp)                                        \
323     DEBUG_STATE_r(                                              \
324         if (cp != PL_savestack_ix)                              \
325             PerlIO_printf(Perl_debug_log,                       \
326                 "  Clearing an EVAL scope, savestack=%"IVdf"..%"IVdf"\n", \
327                 (IV)(cp), (IV)PL_savestack_ix));                \
328     regcpblow(cp)
329
330 #define UNWIND_PAREN(lp, lcp)               \
331     for (n = rex->lastparen; n > lp; n--)   \
332         rex->offs[n].end = -1;              \
333     rex->lastparen = n;                     \
334     rex->lastcloseparen = lcp;
335
336
337 STATIC void
338 S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p)
339 {
340     dVAR;
341     UV i;
342     U32 paren;
343     GET_RE_DEBUG_FLAGS_DECL;
344
345     PERL_ARGS_ASSERT_REGCPPOP;
346
347     /* Pop REGCP_OTHER_ELEMS before the parentheses loop starts. */
348     i = SSPOPUV;
349     assert((i & SAVE_MASK) == SAVEt_REGCONTEXT); /* Check that the magic cookie is there. */
350     i >>= SAVE_TIGHT_SHIFT; /* Parentheses elements to pop. */
351     rex->lastcloseparen = SSPOPINT;
352     rex->lastparen = SSPOPINT;
353     *maxopenparen_p = SSPOPINT;
354
355     i -= REGCP_OTHER_ELEMS;
356     /* Now restore the parentheses context. */
357     DEBUG_BUFFERS_r(
358         if (i || rex->lastparen + 1 <= rex->nparens)
359             PerlIO_printf(Perl_debug_log,
360                 "rex=0x%"UVxf" offs=0x%"UVxf": restoring capture indices to:\n",
361                 PTR2UV(rex),
362                 PTR2UV(rex->offs)
363             );
364     );
365     paren = *maxopenparen_p;
366     for ( ; i > 0; i -= REGCP_PAREN_ELEMS) {
367         I32 tmps;
368         rex->offs[paren].start_tmp = SSPOPINT;
369         rex->offs[paren].start = SSPOPINT;
370         tmps = SSPOPINT;
371         if (paren <= rex->lastparen)
372             rex->offs[paren].end = tmps;
373         DEBUG_BUFFERS_r( PerlIO_printf(Perl_debug_log,
374             "    \\%"UVuf": %"IVdf"(%"IVdf")..%"IVdf"%s\n",
375             (UV)paren,
376             (IV)rex->offs[paren].start,
377             (IV)rex->offs[paren].start_tmp,
378             (IV)rex->offs[paren].end,
379             (paren > rex->lastparen ? "(skipped)" : ""));
380         );
381         paren--;
382     }
383 #if 1
384     /* It would seem that the similar code in regtry()
385      * already takes care of this, and in fact it is in
386      * a better location to since this code can #if 0-ed out
387      * but the code in regtry() is needed or otherwise tests
388      * requiring null fields (pat.t#187 and split.t#{13,14}
389      * (as of patchlevel 7877)  will fail.  Then again,
390      * this code seems to be necessary or otherwise
391      * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
392      * --jhi updated by dapm */
393     for (i = rex->lastparen + 1; i <= rex->nparens; i++) {
394         if (i > *maxopenparen_p)
395             rex->offs[i].start = -1;
396         rex->offs[i].end = -1;
397         DEBUG_BUFFERS_r( PerlIO_printf(Perl_debug_log,
398             "    \\%"UVuf": %s   ..-1 undeffing\n",
399             (UV)i,
400             (i > *maxopenparen_p) ? "-1" : "  "
401         ));
402     }
403 #endif
404 }
405
406 /* restore the parens and associated vars at savestack position ix,
407  * but without popping the stack */
408
409 STATIC void
410 S_regcp_restore(pTHX_ regexp *rex, I32 ix, U32 *maxopenparen_p)
411 {
412     I32 tmpix = PL_savestack_ix;
413     PL_savestack_ix = ix;
414     regcppop(rex, maxopenparen_p);
415     PL_savestack_ix = tmpix;
416 }
417
418 #define regcpblow(cp) LEAVE_SCOPE(cp)   /* Ignores regcppush()ed data. */
419
420 STATIC bool
421 S_isFOO_lc(pTHX_ const U8 classnum, const U8 character)
422 {
423     /* Returns a boolean as to whether or not 'character' is a member of the
424      * Posix character class given by 'classnum' that should be equivalent to a
425      * value in the typedef '_char_class_number'.
426      *
427      * Ideally this could be replaced by a just an array of function pointers
428      * to the C library functions that implement the macros this calls.
429      * However, to compile, the precise function signatures are required, and
430      * these may vary from platform to to platform.  To avoid having to figure
431      * out what those all are on each platform, I (khw) am using this method,
432      * which adds an extra layer of function call overhead (unless the C
433      * optimizer strips it away).  But we don't particularly care about
434      * performance with locales anyway. */
435
436     switch ((_char_class_number) classnum) {
437         case _CC_ENUM_ALPHANUMERIC: return isALPHANUMERIC_LC(character);
438         case _CC_ENUM_ALPHA:     return isALPHA_LC(character);
439         case _CC_ENUM_ASCII:     return isASCII_LC(character);
440         case _CC_ENUM_BLANK:     return isBLANK_LC(character);
441         case _CC_ENUM_CASED:     return isLOWER_LC(character)
442                                         || isUPPER_LC(character);
443         case _CC_ENUM_CNTRL:     return isCNTRL_LC(character);
444         case _CC_ENUM_DIGIT:     return isDIGIT_LC(character);
445         case _CC_ENUM_GRAPH:     return isGRAPH_LC(character);
446         case _CC_ENUM_LOWER:     return isLOWER_LC(character);
447         case _CC_ENUM_PRINT:     return isPRINT_LC(character);
448         case _CC_ENUM_PSXSPC:    return isPSXSPC_LC(character);
449         case _CC_ENUM_PUNCT:     return isPUNCT_LC(character);
450         case _CC_ENUM_SPACE:     return isSPACE_LC(character);
451         case _CC_ENUM_UPPER:     return isUPPER_LC(character);
452         case _CC_ENUM_WORDCHAR:  return isWORDCHAR_LC(character);
453         case _CC_ENUM_XDIGIT:    return isXDIGIT_LC(character);
454         default:    /* VERTSPACE should never occur in locales */
455             Perl_croak(aTHX_ "panic: isFOO_lc() has an unexpected character class '%d'", classnum);
456     }
457
458     assert(0); /* NOTREACHED */
459     return FALSE;
460 }
461
462 STATIC bool
463 S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character)
464 {
465     /* Returns a boolean as to whether or not the (well-formed) UTF-8-encoded
466      * 'character' is a member of the Posix character class given by 'classnum'
467      * that should be equivalent to a value in the typedef
468      * '_char_class_number'.
469      *
470      * This just calls isFOO_lc on the code point for the character if it is in
471      * the range 0-255.  Outside that range, all characters avoid Unicode
472      * rules, ignoring any locale.  So use the Unicode function if this class
473      * requires a swash, and use the Unicode macro otherwise. */
474
475     PERL_ARGS_ASSERT_ISFOO_UTF8_LC;
476
477     if (UTF8_IS_INVARIANT(*character)) {
478         return isFOO_lc(classnum, *character);
479     }
480     else if (UTF8_IS_DOWNGRADEABLE_START(*character)) {
481         return isFOO_lc(classnum,
482                         TWO_BYTE_UTF8_TO_UNI(*character, *(character + 1)));
483     }
484
485     if (classnum < _FIRST_NON_SWASH_CC) {
486
487         /* Initialize the swash unless done already */
488         if (! PL_utf8_swash_ptrs[classnum]) {
489             U8 flags = _CORE_SWASH_INIT_ACCEPT_INVLIST;
490             PL_utf8_swash_ptrs[classnum] = _core_swash_init("utf8",
491                 swash_property_names[classnum], &PL_sv_undef, 1, 0, NULL, &flags);
492         }
493
494         return cBOOL(swash_fetch(PL_utf8_swash_ptrs[classnum], (U8 *)
495                                  character,
496                                  TRUE /* is UTF */ ));
497     }
498
499     switch ((_char_class_number) classnum) {
500         case _CC_ENUM_SPACE:
501         case _CC_ENUM_PSXSPC:    return is_XPERLSPACE_high(character);
502
503         case _CC_ENUM_BLANK:     return is_HORIZWS_high(character);
504         case _CC_ENUM_XDIGIT:    return is_XDIGIT_high(character);
505         case _CC_ENUM_VERTSPACE: return is_VERTWS_high(character);
506         default:                 return 0;  /* Things like CNTRL are always
507                                                below 256 */
508     }
509
510     assert(0); /* NOTREACHED */
511     return FALSE;
512 }
513
514 /*
515  * pregexec and friends
516  */
517
518 #ifndef PERL_IN_XSUB_RE
519 /*
520  - pregexec - match a regexp against a string
521  */
522 I32
523 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char *strend,
524          char *strbeg, I32 minend, SV *screamer, U32 nosave)
525 /* stringarg: the point in the string at which to begin matching */
526 /* strend:    pointer to null at end of string */
527 /* strbeg:    real beginning of string */
528 /* minend:    end of match must be >= minend bytes after stringarg. */
529 /* screamer:  SV being matched: only used for utf8 flag, pos() etc; string
530  *            itself is accessed via the pointers above */
531 /* nosave:    For optimizations. */
532 {
533     PERL_ARGS_ASSERT_PREGEXEC;
534
535     return
536         regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, NULL,
537                       nosave ? 0 : REXEC_COPY_STR);
538 }
539 #endif
540
541 /*
542  * Need to implement the following flags for reg_anch:
543  *
544  * USE_INTUIT_NOML              - Useful to call re_intuit_start() first
545  * USE_INTUIT_ML
546  * INTUIT_AUTORITATIVE_NOML     - Can trust a positive answer
547  * INTUIT_AUTORITATIVE_ML
548  * INTUIT_ONCE_NOML             - Intuit can match in one location only.
549  * INTUIT_ONCE_ML
550  *
551  * Another flag for this function: SECOND_TIME (so that float substrs
552  * with giant delta may be not rechecked).
553  */
554
555 /* Assumptions: if ANCH_GPOS, then strpos is anchored. XXXX Check GPOS logic */
556
557 /* If SCREAM, then SvPVX_const(sv) should be compatible with strpos and strend.
558    Otherwise, only SvCUR(sv) is used to get strbeg. */
559
560 /* XXXX We assume that strpos is strbeg unless sv. */
561
562 /* XXXX Some places assume that there is a fixed substring.
563         An update may be needed if optimizer marks as "INTUITable"
564         RExen without fixed substrings.  Similarly, it is assumed that
565         lengths of all the strings are no more than minlen, thus they
566         cannot come from lookahead.
567         (Or minlen should take into account lookahead.) 
568   NOTE: Some of this comment is not correct. minlen does now take account
569   of lookahead/behind. Further research is required. -- demerphq
570
571 */
572
573 /* A failure to find a constant substring means that there is no need to make
574    an expensive call to REx engine, thus we celebrate a failure.  Similarly,
575    finding a substring too deep into the string means that fewer calls to
576    regtry() should be needed.
577
578    REx compiler's optimizer found 4 possible hints:
579         a) Anchored substring;
580         b) Fixed substring;
581         c) Whether we are anchored (beginning-of-line or \G);
582         d) First node (of those at offset 0) which may distinguish positions;
583    We use a)b)d) and multiline-part of c), and try to find a position in the
584    string which does not contradict any of them.
585  */
586
587 /* Most of decisions we do here should have been done at compile time.
588    The nodes of the REx which we used for the search should have been
589    deleted from the finite automaton. */
590
591 char *
592 Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV *sv, char *strpos,
593                      char *strend, const U32 flags, re_scream_pos_data *data)
594 {
595     dVAR;
596     struct regexp *const prog = ReANY(rx);
597     I32 start_shift = 0;
598     /* Should be nonnegative! */
599     I32 end_shift   = 0;
600     char *s;
601     SV *check;
602     char *strbeg;
603     char *t;
604     const bool utf8_target = (sv && SvUTF8(sv)) ? 1 : 0; /* if no sv we have to assume bytes */
605     I32 ml_anch;
606     char *other_last = NULL;    /* other substr checked before this */
607     char *check_at = NULL;              /* check substr found at this pos */
608     char *checked_upto = NULL;          /* how far into the string we have already checked using find_byclass*/
609     const I32 multiline = prog->extflags & RXf_PMf_MULTILINE;
610     RXi_GET_DECL(prog,progi);
611     bool is_utf8_pat;
612 #ifdef DEBUGGING
613     const char * const i_strpos = strpos;
614 #endif
615     GET_RE_DEBUG_FLAGS_DECL;
616
617     PERL_ARGS_ASSERT_RE_INTUIT_START;
618     PERL_UNUSED_ARG(flags);
619     PERL_UNUSED_ARG(data);
620
621     RX_MATCH_UTF8_set(rx,utf8_target);
622
623     is_utf8_pat = cBOOL(RX_UTF8(rx));
624
625     DEBUG_EXECUTE_r( 
626         debug_start_match(rx, utf8_target, strpos, strend,
627             sv ? "Guessing start of match in sv for"
628                : "Guessing start of match in string for");
629               );
630
631     /* CHR_DIST() would be more correct here but it makes things slow. */
632     if (prog->minlen > strend - strpos) {
633         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
634                               "String too short... [re_intuit_start]\n"));
635         goto fail;
636     }
637
638     /* XXX we need to pass strbeg as a separate arg: the following is
639      * guesswork and can be wrong... */
640     if (sv && SvPOK(sv)) {
641         char * p   = SvPVX(sv);
642         STRLEN cur = SvCUR(sv); 
643         if (p <= strpos && strpos < p + cur) {
644             strbeg = p;
645             assert(p <= strend && strend <= p + cur);
646         }
647         else
648             strbeg = strend - cur;
649     }
650     else 
651         strbeg = strpos;
652
653     PL_regeol = strend;
654     if (utf8_target) {
655         if (!prog->check_utf8 && prog->check_substr)
656             to_utf8_substr(prog);
657         check = prog->check_utf8;
658     } else {
659         if (!prog->check_substr && prog->check_utf8) {
660             if (! to_byte_substr(prog)) {
661                 NON_UTF8_TARGET_BUT_UTF8_REQUIRED(fail);
662             }
663         }
664         check = prog->check_substr;
665     }
666     if (prog->extflags & RXf_ANCH) {    /* Match at beg-of-str or after \n */
667         ml_anch = !( (prog->extflags & RXf_ANCH_SINGLE)
668                      || ( (prog->extflags & RXf_ANCH_BOL)
669                           && !multiline ) );    /* Check after \n? */
670
671         if (!ml_anch) {
672           if ( !(prog->extflags & RXf_ANCH_GPOS) /* Checked by the caller */
673                 && !(prog->intflags & PREGf_IMPLICIT) /* not a real BOL */
674                /* SvCUR is not set on references: SvRV and SvPVX_const overlap */
675                && sv && !SvROK(sv)
676                && (strpos != strbeg)) {
677               DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not at start...\n"));
678               goto fail;
679           }
680           if (prog->check_offset_min == prog->check_offset_max
681               && !(prog->extflags & RXf_CANY_SEEN)
682               && ! multiline)   /* /m can cause \n's to match that aren't
683                                    accounted for in the string max length.
684                                    See [perl #115242] */
685           {
686             /* Substring at constant offset from beg-of-str... */
687             I32 slen;
688
689             s = HOP3c(strpos, prog->check_offset_min, strend);
690             
691             if (SvTAIL(check)) {
692                 slen = SvCUR(check);    /* >= 1 */
693
694                 if ( strend - s > slen || strend - s < slen - 1
695                      || (strend - s == slen && strend[-1] != '\n')) {
696                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String too long...\n"));
697                     goto fail_finish;
698                 }
699                 /* Now should match s[0..slen-2] */
700                 slen--;
701                 if (slen && (*SvPVX_const(check) != *s
702                              || (slen > 1
703                                  && memNE(SvPVX_const(check), s, slen)))) {
704                   report_neq:
705                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String not equal...\n"));
706                     goto fail_finish;
707                 }
708             }
709             else if (*SvPVX_const(check) != *s
710                      || ((slen = SvCUR(check)) > 1
711                          && memNE(SvPVX_const(check), s, slen)))
712                 goto report_neq;
713             check_at = s;
714             goto success_at_start;
715           }
716         }
717         /* Match is anchored, but substr is not anchored wrt beg-of-str. */
718         s = strpos;
719         start_shift = prog->check_offset_min; /* okay to underestimate on CC */
720         end_shift = prog->check_end_shift;
721         
722         if (!ml_anch) {
723             const I32 end = prog->check_offset_max + CHR_SVLEN(check)
724                                          - (SvTAIL(check) != 0);
725             const I32 eshift = CHR_DIST((U8*)strend, (U8*)s) - end;
726
727             if (end_shift < eshift)
728                 end_shift = eshift;
729         }
730     }
731     else {                              /* Can match at random position */
732         ml_anch = 0;
733         s = strpos;
734         start_shift = prog->check_offset_min;  /* okay to underestimate on CC */
735         end_shift = prog->check_end_shift;
736         
737         /* end shift should be non negative here */
738     }
739
740 #ifdef QDEBUGGING       /* 7/99: reports of failure (with the older version) */
741     if (end_shift < 0)
742         Perl_croak(aTHX_ "panic: end_shift: %"IVdf" pattern:\n%s\n ",
743                    (IV)end_shift, RX_PRECOMP(prog));
744 #endif
745
746   restart:
747     /* Find a possible match in the region s..strend by looking for
748        the "check" substring in the region corrected by start/end_shift. */
749     
750     {
751         I32 srch_start_shift = start_shift;
752         I32 srch_end_shift = end_shift;
753         U8* start_point;
754         U8* end_point;
755         if (srch_start_shift < 0 && strbeg - s > srch_start_shift) {
756             srch_end_shift -= ((strbeg - s) - srch_start_shift); 
757             srch_start_shift = strbeg - s;
758         }
759     DEBUG_OPTIMISE_MORE_r({
760         PerlIO_printf(Perl_debug_log, "Check offset min: %"IVdf" Start shift: %"IVdf" End shift %"IVdf" Real End Shift: %"IVdf"\n",
761             (IV)prog->check_offset_min,
762             (IV)srch_start_shift,
763             (IV)srch_end_shift, 
764             (IV)prog->check_end_shift);
765     });       
766         
767         if (prog->extflags & RXf_CANY_SEEN) {
768             start_point= (U8*)(s + srch_start_shift);
769             end_point= (U8*)(strend - srch_end_shift);
770         } else {
771             start_point= HOP3(s, srch_start_shift, srch_start_shift < 0 ? strbeg : strend);
772             end_point= HOP3(strend, -srch_end_shift, strbeg);
773         }
774         DEBUG_OPTIMISE_MORE_r({
775             PerlIO_printf(Perl_debug_log, "fbm_instr len=%d str=<%.*s>\n", 
776                 (int)(end_point - start_point),
777                 (int)(end_point - start_point) > 20 ? 20 : (int)(end_point - start_point), 
778                 start_point);
779         });
780
781         s = fbm_instr( start_point, end_point,
782                       check, multiline ? FBMrf_MULTILINE : 0);
783     }
784     /* Update the count-of-usability, remove useless subpatterns,
785         unshift s.  */
786
787     DEBUG_EXECUTE_r({
788         RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
789             SvPVX_const(check), RE_SV_DUMPLEN(check), 30);
790         PerlIO_printf(Perl_debug_log, "%s %s substr %s%s%s",
791                           (s ? "Found" : "Did not find"),
792             (check == (utf8_target ? prog->anchored_utf8 : prog->anchored_substr)
793                 ? "anchored" : "floating"),
794             quoted,
795             RE_SV_TAIL(check),
796             (s ? " at offset " : "...\n") ); 
797     });
798
799     if (!s)
800         goto fail_finish;
801     /* Finish the diagnostic message */
802     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%ld...\n", (long)(s - i_strpos)) );
803
804     /* XXX dmq: first branch is for positive lookbehind...
805        Our check string is offset from the beginning of the pattern.
806        So we need to do any stclass tests offset forward from that 
807        point. I think. :-(
808      */
809     
810         
811     
812     check_at=s;
813      
814
815     /* Got a candidate.  Check MBOL anchoring, and the *other* substr.
816        Start with the other substr.
817        XXXX no SCREAM optimization yet - and a very coarse implementation
818        XXXX /ttx+/ results in anchored="ttx", floating="x".  floating will
819                 *always* match.  Probably should be marked during compile...
820        Probably it is right to do no SCREAM here...
821      */
822
823     if (utf8_target ? (prog->float_utf8 && prog->anchored_utf8)
824                 : (prog->float_substr && prog->anchored_substr)) 
825     {
826         /* Take into account the "other" substring. */
827         /* XXXX May be hopelessly wrong for UTF... */
828         if (!other_last)
829             other_last = strpos;
830         if (check == (utf8_target ? prog->float_utf8 : prog->float_substr)) {
831           do_other_anchored:
832             {
833                 char * const last = HOP3c(s, -start_shift, strbeg);
834                 char *last1, *last2;
835                 char * const saved_s = s;
836                 SV* must;
837
838                 t = s - prog->check_offset_max;
839                 if (s - strpos > prog->check_offset_max  /* signed-corrected t > strpos */
840                     && (!utf8_target
841                         || ((t = (char*)reghopmaybe3((U8*)s, -(prog->check_offset_max), (U8*)strpos))
842                             && t > strpos)))
843                     NOOP;
844                 else
845                     t = strpos;
846                 t = HOP3c(t, prog->anchored_offset, strend);
847                 if (t < other_last)     /* These positions already checked */
848                     t = other_last;
849                 last2 = last1 = HOP3c(strend, -prog->minlen, strbeg);
850                 if (last < last1)
851                     last1 = last;
852                 /* XXXX It is not documented what units *_offsets are in.  
853                    We assume bytes, but this is clearly wrong. 
854                    Meaning this code needs to be carefully reviewed for errors.
855                    dmq.
856                   */
857  
858                 /* On end-of-str: see comment below. */
859                 must = utf8_target ? prog->anchored_utf8 : prog->anchored_substr;
860                 if (must == &PL_sv_undef) {
861                     s = (char*)NULL;
862                     DEBUG_r(must = prog->anchored_utf8);        /* for debug */
863                 }
864                 else
865                     s = fbm_instr(
866                         (unsigned char*)t,
867                         HOP3(HOP3(last1, prog->anchored_offset, strend)
868                                 + SvCUR(must), -(SvTAIL(must)!=0), strbeg),
869                         must,
870                         multiline ? FBMrf_MULTILINE : 0
871                     );
872                 DEBUG_EXECUTE_r({
873                     RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
874                         SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
875                     PerlIO_printf(Perl_debug_log, "%s anchored substr %s%s",
876                         (s ? "Found" : "Contradicts"),
877                         quoted, RE_SV_TAIL(must));
878                 });                 
879                 
880                             
881                 if (!s) {
882                     if (last1 >= last2) {
883                         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
884                                                 ", giving up...\n"));
885                         goto fail_finish;
886                     }
887                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
888                         ", trying floating at offset %ld...\n",
889                         (long)(HOP3c(saved_s, 1, strend) - i_strpos)));
890                     other_last = HOP3c(last1, prog->anchored_offset+1, strend);
891                     s = HOP3c(last, 1, strend);
892                     goto restart;
893                 }
894                 else {
895                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
896                           (long)(s - i_strpos)));
897                     t = HOP3c(s, -prog->anchored_offset, strbeg);
898                     other_last = HOP3c(s, 1, strend);
899                     s = saved_s;
900                     if (t == strpos)
901                         goto try_at_start;
902                     goto try_at_offset;
903                 }
904             }
905         }
906         else {          /* Take into account the floating substring. */
907             char *last, *last1;
908             char * const saved_s = s;
909             SV* must;
910
911             t = HOP3c(s, -start_shift, strbeg);
912             last1 = last =
913                 HOP3c(strend, -prog->minlen + prog->float_min_offset, strbeg);
914             if (CHR_DIST((U8*)last, (U8*)t) > prog->float_max_offset)
915                 last = HOP3c(t, prog->float_max_offset, strend);
916             s = HOP3c(t, prog->float_min_offset, strend);
917             if (s < other_last)
918                 s = other_last;
919  /* XXXX It is not documented what units *_offsets are in.  Assume bytes.  */
920             must = utf8_target ? prog->float_utf8 : prog->float_substr;
921             /* fbm_instr() takes into account exact value of end-of-str
922                if the check is SvTAIL(ed).  Since false positives are OK,
923                and end-of-str is not later than strend we are OK. */
924             if (must == &PL_sv_undef) {
925                 s = (char*)NULL;
926                 DEBUG_r(must = prog->float_utf8);       /* for debug message */
927             }
928             else
929                 s = fbm_instr((unsigned char*)s,
930                               (unsigned char*)last + SvCUR(must)
931                                   - (SvTAIL(must)!=0),
932                               must, multiline ? FBMrf_MULTILINE : 0);
933             DEBUG_EXECUTE_r({
934                 RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
935                     SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
936                 PerlIO_printf(Perl_debug_log, "%s floating substr %s%s",
937                     (s ? "Found" : "Contradicts"),
938                     quoted, RE_SV_TAIL(must));
939             });
940             if (!s) {
941                 if (last1 == last) {
942                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
943                                             ", giving up...\n"));
944                     goto fail_finish;
945                 }
946                 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
947                     ", trying anchored starting at offset %ld...\n",
948                     (long)(saved_s + 1 - i_strpos)));
949                 other_last = last;
950                 s = HOP3c(t, 1, strend);
951                 goto restart;
952             }
953             else {
954                 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
955                       (long)(s - i_strpos)));
956                 other_last = s; /* Fix this later. --Hugo */
957                 s = saved_s;
958                 if (t == strpos)
959                     goto try_at_start;
960                 goto try_at_offset;
961             }
962         }
963     }
964
965     
966     t= (char*)HOP3( s, -prog->check_offset_max, (prog->check_offset_max<0) ? strend : strpos);
967         
968     DEBUG_OPTIMISE_MORE_r(
969         PerlIO_printf(Perl_debug_log, 
970             "Check offset min:%"IVdf" max:%"IVdf" S:%"IVdf" t:%"IVdf" D:%"IVdf" end:%"IVdf"\n",
971             (IV)prog->check_offset_min,
972             (IV)prog->check_offset_max,
973             (IV)(s-strpos),
974             (IV)(t-strpos),
975             (IV)(t-s),
976             (IV)(strend-strpos)
977         )
978     );
979
980     if (s - strpos > prog->check_offset_max  /* signed-corrected t > strpos */
981         && (!utf8_target
982             || ((t = (char*)reghopmaybe3((U8*)s, -prog->check_offset_max, (U8*) ((prog->check_offset_max<0) ? strend : strpos)))
983                  && t > strpos))) 
984     {
985         /* Fixed substring is found far enough so that the match
986            cannot start at strpos. */
987       try_at_offset:
988         if (ml_anch && t[-1] != '\n') {
989             /* Eventually fbm_*() should handle this, but often
990                anchored_offset is not 0, so this check will not be wasted. */
991             /* XXXX In the code below we prefer to look for "^" even in
992                presence of anchored substrings.  And we search even
993                beyond the found float position.  These pessimizations
994                are historical artefacts only.  */
995           find_anchor:
996             while (t < strend - prog->minlen) {
997                 if (*t == '\n') {
998                     if (t < check_at - prog->check_offset_min) {
999                         if (utf8_target ? prog->anchored_utf8 : prog->anchored_substr) {
1000                             /* Since we moved from the found position,
1001                                we definitely contradict the found anchored
1002                                substr.  Due to the above check we do not
1003                                contradict "check" substr.
1004                                Thus we can arrive here only if check substr
1005                                is float.  Redo checking for "other"=="fixed".
1006                              */
1007                             strpos = t + 1;                     
1008                             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld, rescanning for anchored from offset %ld...\n",
1009                                 PL_colors[0], PL_colors[1], (long)(strpos - i_strpos), (long)(strpos - i_strpos + prog->anchored_offset)));
1010                             goto do_other_anchored;
1011                         }
1012                         /* We don't contradict the found floating substring. */
1013                         /* XXXX Why not check for STCLASS? */
1014                         s = t + 1;
1015                         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld...\n",
1016                             PL_colors[0], PL_colors[1], (long)(s - i_strpos)));
1017                         goto set_useful;
1018                     }
1019                     /* Position contradicts check-string */
1020                     /* XXXX probably better to look for check-string
1021                        than for "\n", so one should lower the limit for t? */
1022                     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m, restarting lookup for check-string at offset %ld...\n",
1023                         PL_colors[0], PL_colors[1], (long)(t + 1 - i_strpos)));
1024                     other_last = strpos = s = t + 1;
1025                     goto restart;
1026                 }
1027                 t++;
1028             }
1029             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Did not find /%s^%s/m...\n",
1030                         PL_colors[0], PL_colors[1]));
1031             goto fail_finish;
1032         }
1033         else {
1034             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Starting position does not contradict /%s^%s/m...\n",
1035                         PL_colors[0], PL_colors[1]));
1036         }
1037         s = t;
1038       set_useful:
1039         ++BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr);        /* hooray/5 */
1040     }
1041     else {
1042         /* The found string does not prohibit matching at strpos,
1043            - no optimization of calling REx engine can be performed,
1044            unless it was an MBOL and we are not after MBOL,
1045            or a future STCLASS check will fail this. */
1046       try_at_start:
1047         /* Even in this situation we may use MBOL flag if strpos is offset
1048            wrt the start of the string. */
1049         if (ml_anch && sv && !SvROK(sv) /* See prev comment on SvROK */
1050             && (strpos != strbeg) && strpos[-1] != '\n'
1051             /* May be due to an implicit anchor of m{.*foo}  */
1052             && !(prog->intflags & PREGf_IMPLICIT))
1053         {
1054             t = strpos;
1055             goto find_anchor;
1056         }
1057         DEBUG_EXECUTE_r( if (ml_anch)
1058             PerlIO_printf(Perl_debug_log, "Position at offset %ld does not contradict /%s^%s/m...\n",
1059                           (long)(strpos - i_strpos), PL_colors[0], PL_colors[1]);
1060         );
1061       success_at_start:
1062         if (!(prog->intflags & PREGf_NAUGHTY)   /* XXXX If strpos moved? */
1063             && (utf8_target ? (
1064                 prog->check_utf8                /* Could be deleted already */
1065                 && --BmUSEFUL(prog->check_utf8) < 0
1066                 && (prog->check_utf8 == prog->float_utf8)
1067             ) : (
1068                 prog->check_substr              /* Could be deleted already */
1069                 && --BmUSEFUL(prog->check_substr) < 0
1070                 && (prog->check_substr == prog->float_substr)
1071             )))
1072         {
1073             /* If flags & SOMETHING - do not do it many times on the same match */
1074             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "... Disabling check substring...\n"));
1075             /* XXX Does the destruction order has to change with utf8_target? */
1076             SvREFCNT_dec(utf8_target ? prog->check_utf8 : prog->check_substr);
1077             SvREFCNT_dec(utf8_target ? prog->check_substr : prog->check_utf8);
1078             prog->check_substr = prog->check_utf8 = NULL;       /* disable */
1079             prog->float_substr = prog->float_utf8 = NULL;       /* clear */
1080             check = NULL;                       /* abort */
1081             s = strpos;
1082             /* XXXX If the check string was an implicit check MBOL, then we need to unset the relevant flag
1083                     see http://bugs.activestate.com/show_bug.cgi?id=87173 */
1084             if (prog->intflags & PREGf_IMPLICIT)
1085                 prog->extflags &= ~RXf_ANCH_MBOL;
1086             /* XXXX This is a remnant of the old implementation.  It
1087                     looks wasteful, since now INTUIT can use many
1088                     other heuristics. */
1089             prog->extflags &= ~RXf_USE_INTUIT;
1090             /* XXXX What other flags might need to be cleared in this branch? */
1091         }
1092         else
1093             s = strpos;
1094     }
1095
1096     /* Last resort... */
1097     /* XXXX BmUSEFUL already changed, maybe multiple change is meaningful... */
1098     /* trie stclasses are too expensive to use here, we are better off to
1099        leave it to regmatch itself */
1100     if (progi->regstclass && PL_regkind[OP(progi->regstclass)]!=TRIE) {
1101         /* minlen == 0 is possible if regstclass is \b or \B,
1102            and the fixed substr is ''$.
1103            Since minlen is already taken into account, s+1 is before strend;
1104            accidentally, minlen >= 1 guaranties no false positives at s + 1
1105            even for \b or \B.  But (minlen? 1 : 0) below assumes that
1106            regstclass does not come from lookahead...  */
1107         /* If regstclass takes bytelength more than 1: If charlength==1, OK.
1108            This leaves EXACTF-ish only, which are dealt with in find_byclass().  */
1109         const U8* const str = (U8*)STRING(progi->regstclass);
1110         const int cl_l = (PL_regkind[OP(progi->regstclass)] == EXACT
1111                     ? CHR_DIST(str+STR_LEN(progi->regstclass), str)
1112                     : 1);
1113         char * endpos;
1114         if (prog->anchored_substr || prog->anchored_utf8 || ml_anch)
1115             endpos= HOP3c(s, (prog->minlen ? cl_l : 0), strend);
1116         else if (prog->float_substr || prog->float_utf8)
1117             endpos= HOP3c(HOP3c(check_at, -start_shift, strbeg), cl_l, strend);
1118         else 
1119             endpos= strend;
1120                     
1121         if (checked_upto < s)
1122            checked_upto = s;
1123         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "start_shift: %"IVdf" check_at: %"IVdf" s: %"IVdf" endpos: %"IVdf" checked_upto: %"IVdf"\n",
1124                                       (IV)start_shift, (IV)(check_at - strbeg), (IV)(s - strbeg), (IV)(endpos - strbeg), (IV)(checked_upto- strbeg)));
1125
1126         t = s;
1127         s = find_byclass(prog, progi->regstclass, checked_upto, endpos,
1128                             NULL, is_utf8_pat);
1129         if (s) {
1130             checked_upto = s;
1131         } else {
1132 #ifdef DEBUGGING
1133             const char *what = NULL;
1134 #endif
1135             if (endpos == strend) {
1136                 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1137                                 "Could not match STCLASS...\n") );
1138                 goto fail;
1139             }
1140             DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1141                                    "This position contradicts STCLASS...\n") );
1142             if ((prog->extflags & RXf_ANCH) && !ml_anch)
1143                 goto fail;
1144             checked_upto = HOPBACKc(endpos, start_shift);
1145             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "start_shift: %"IVdf" check_at: %"IVdf" endpos: %"IVdf" checked_upto: %"IVdf"\n",
1146                                       (IV)start_shift, (IV)(check_at - strbeg), (IV)(endpos - strbeg), (IV)(checked_upto- strbeg)));
1147             /* Contradict one of substrings */
1148             if (prog->anchored_substr || prog->anchored_utf8) {
1149                 if ((utf8_target ? prog->anchored_utf8 : prog->anchored_substr) == check) {
1150                     DEBUG_EXECUTE_r( what = "anchored" );
1151                   hop_and_restart:
1152                     s = HOP3c(t, 1, strend);
1153                     if (s + start_shift + end_shift > strend) {
1154                         /* XXXX Should be taken into account earlier? */
1155                         DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1156                                                "Could not match STCLASS...\n") );
1157                         goto fail;
1158                     }
1159                     if (!check)
1160                         goto giveup;
1161                     DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1162                                 "Looking for %s substr starting at offset %ld...\n",
1163                                  what, (long)(s + start_shift - i_strpos)) );
1164                     goto restart;
1165                 }
1166                 /* Have both, check_string is floating */
1167                 if (t + start_shift >= check_at) /* Contradicts floating=check */
1168                     goto retry_floating_check;
1169                 /* Recheck anchored substring, but not floating... */
1170                 s = check_at;
1171                 if (!check)
1172                     goto giveup;
1173                 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1174                           "Looking for anchored substr starting at offset %ld...\n",
1175                           (long)(other_last - i_strpos)) );
1176                 goto do_other_anchored;
1177             }
1178             /* Another way we could have checked stclass at the
1179                current position only: */
1180             if (ml_anch) {
1181                 s = t = t + 1;
1182                 if (!check)
1183                     goto giveup;
1184                 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
1185                           "Looking for /%s^%s/m starting at offset %ld...\n",
1186                           PL_colors[0], PL_colors[1], (long)(t - i_strpos)) );
1187                 goto try_at_offset;
1188             }
1189             if (!(utf8_target ? prog->float_utf8 : prog->float_substr)) /* Could have been deleted */
1190                 goto fail;
1191             /* Check is floating substring. */
1192           retry_floating_check:
1193             t = check_at - start_shift;
1194             DEBUG_EXECUTE_r( what = "floating" );
1195             goto hop_and_restart;
1196         }
1197         if (t != s) {
1198             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
1199                         "By STCLASS: moving %ld --> %ld\n",
1200                                   (long)(t - i_strpos), (long)(s - i_strpos))
1201                    );
1202         }
1203         else {
1204             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
1205                                   "Does not contradict STCLASS...\n"); 
1206                    );
1207         }
1208     }
1209   giveup:
1210     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s%s:%s match at offset %ld\n",
1211                           PL_colors[4], (check ? "Guessed" : "Giving up"),
1212                           PL_colors[5], (long)(s - i_strpos)) );
1213     return s;
1214
1215   fail_finish:                          /* Substring not found */
1216     if (prog->check_substr || prog->check_utf8)         /* could be removed already */
1217         BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr) += 5; /* hooray */
1218   fail:
1219     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch rejected by optimizer%s\n",
1220                           PL_colors[4], PL_colors[5]));
1221     return NULL;
1222 }
1223
1224 #define DECL_TRIE_TYPE(scan) \
1225     const enum { trie_plain, trie_utf8, trie_utf8_fold, trie_latin_utf8_fold } \
1226                     trie_type = ((scan->flags == EXACT) \
1227                               ? (utf8_target ? trie_utf8 : trie_plain) \
1228                               : (utf8_target ? trie_utf8_fold : trie_latin_utf8_fold))
1229
1230 #define REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc, uscan, len, uvc, charid, foldlen, foldbuf, uniflags) \
1231 STMT_START {                               \
1232     STRLEN skiplen;                                                                 \
1233     switch (trie_type) {                                                            \
1234     case trie_utf8_fold:                                                            \
1235         if ( foldlen>0 ) {                                                          \
1236             uvc = utf8n_to_uvuni( (const U8*) uscan, UTF8_MAXLEN, &len, uniflags ); \
1237             foldlen -= len;                                                         \
1238             uscan += len;                                                           \
1239             len=0;                                                                  \
1240         } else {                                                                    \
1241             uvc = to_utf8_fold( (const U8*) uc, foldbuf, &foldlen );                \
1242             len = UTF8SKIP(uc);                                                     \
1243             skiplen = UNISKIP( uvc );                                               \
1244             foldlen -= skiplen;                                                     \
1245             uscan = foldbuf + skiplen;                                              \
1246         }                                                                           \
1247         break;                                                                      \
1248     case trie_latin_utf8_fold:                                                      \
1249         if ( foldlen>0 ) {                                                          \
1250             uvc = utf8n_to_uvuni( (const U8*) uscan, UTF8_MAXLEN, &len, uniflags ); \
1251             foldlen -= len;                                                         \
1252             uscan += len;                                                           \
1253             len=0;                                                                  \
1254         } else {                                                                    \
1255             len = 1;                                                                \
1256             uvc = _to_fold_latin1( (U8) *uc, foldbuf, &foldlen, 1);                 \
1257             skiplen = UNISKIP( uvc );                                               \
1258             foldlen -= skiplen;                                                     \
1259             uscan = foldbuf + skiplen;                                              \
1260         }                                                                           \
1261         break;                                                                      \
1262     case trie_utf8:                                                                 \
1263         uvc = utf8n_to_uvuni( (const U8*) uc, UTF8_MAXLEN, &len, uniflags );        \
1264         break;                                                                      \
1265     case trie_plain:                                                                \
1266         uvc = (UV)*uc;                                                              \
1267         len = 1;                                                                    \
1268     }                                                                               \
1269     if (uvc < 256) {                                                                \
1270         charid = trie->charmap[ uvc ];                                              \
1271     }                                                                               \
1272     else {                                                                          \
1273         charid = 0;                                                                 \
1274         if (widecharmap) {                                                          \
1275             SV** const svpp = hv_fetch(widecharmap,                                 \
1276                         (char*)&uvc, sizeof(UV), 0);                                \
1277             if (svpp)                                                               \
1278                 charid = (U16)SvIV(*svpp);                                          \
1279         }                                                                           \
1280     }                                                                               \
1281 } STMT_END
1282
1283 #define REXEC_FBC_EXACTISH_SCAN(CoNd)                     \
1284 STMT_START {                                              \
1285     while (s <= e) {                                      \
1286         if ( (CoNd)                                       \
1287              && (ln == 1 || folder(s, pat_string, ln))    \
1288              && (!reginfo || regtry(reginfo, &s)) )       \
1289             goto got_it;                                  \
1290         s++;                                              \
1291     }                                                     \
1292 } STMT_END
1293
1294 #define REXEC_FBC_UTF8_SCAN(CoDe)                     \
1295 STMT_START {                                          \
1296     while (s < strend) {                              \
1297         CoDe                                          \
1298         s += UTF8SKIP(s);                             \
1299     }                                                 \
1300 } STMT_END
1301
1302 #define REXEC_FBC_SCAN(CoDe)                          \
1303 STMT_START {                                          \
1304     while (s < strend) {                              \
1305         CoDe                                          \
1306         s++;                                          \
1307     }                                                 \
1308 } STMT_END
1309
1310 #define REXEC_FBC_UTF8_CLASS_SCAN(CoNd)               \
1311 REXEC_FBC_UTF8_SCAN(                                  \
1312     if (CoNd) {                                       \
1313         if (tmp && (!reginfo || regtry(reginfo, &s))) \
1314             goto got_it;                              \
1315         else                                          \
1316             tmp = doevery;                            \
1317     }                                                 \
1318     else                                              \
1319         tmp = 1;                                      \
1320 )
1321
1322 #define REXEC_FBC_CLASS_SCAN(CoNd)                    \
1323 REXEC_FBC_SCAN(                                       \
1324     if (CoNd) {                                       \
1325         if (tmp && (!reginfo || regtry(reginfo, &s)))  \
1326             goto got_it;                              \
1327         else                                          \
1328             tmp = doevery;                            \
1329     }                                                 \
1330     else                                              \
1331         tmp = 1;                                      \
1332 )
1333
1334 #define REXEC_FBC_TRYIT               \
1335 if ((!reginfo || regtry(reginfo, &s))) \
1336     goto got_it
1337
1338 #define REXEC_FBC_CSCAN(CoNdUtF8,CoNd)                         \
1339     if (utf8_target) {                                             \
1340         REXEC_FBC_UTF8_CLASS_SCAN(CoNdUtF8);                   \
1341     }                                                          \
1342     else {                                                     \
1343         REXEC_FBC_CLASS_SCAN(CoNd);                            \
1344     }
1345     
1346 #define DUMP_EXEC_POS(li,s,doutf8) \
1347     dump_exec_pos(li,s,(PL_regeol),(PL_bostr),(PL_reg_starttry),doutf8)
1348
1349
1350 #define UTF8_NOLOAD(TEST_NON_UTF8, IF_SUCCESS, IF_FAIL) \
1351         tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n';                         \
1352         tmp = TEST_NON_UTF8(tmp);                                              \
1353         REXEC_FBC_UTF8_SCAN(                                                   \
1354             if (tmp == ! TEST_NON_UTF8((U8) *s)) { \
1355                 tmp = !tmp;                                                    \
1356                 IF_SUCCESS;                                                    \
1357             }                                                                  \
1358             else {                                                             \
1359                 IF_FAIL;                                                       \
1360             }                                                                  \
1361         );                                                                     \
1362
1363 #define UTF8_LOAD(TeSt1_UtF8, TeSt2_UtF8, IF_SUCCESS, IF_FAIL) \
1364         if (s == PL_bostr) {                                                   \
1365             tmp = '\n';                                                        \
1366         }                                                                      \
1367         else {                                                                 \
1368             U8 * const r = reghop3((U8*)s, -1, (U8*)PL_bostr);                 \
1369             tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, UTF8_ALLOW_DEFAULT);       \
1370         }                                                                      \
1371         tmp = TeSt1_UtF8;                                                      \
1372         LOAD_UTF8_CHARCLASS_ALNUM();                                                                \
1373         REXEC_FBC_UTF8_SCAN(                                                   \
1374             if (tmp == ! (TeSt2_UtF8)) { \
1375                 tmp = !tmp;                                                    \
1376                 IF_SUCCESS;                                                    \
1377             }                                                                  \
1378             else {                                                             \
1379                 IF_FAIL;                                                       \
1380             }                                                                  \
1381         );                                                                     \
1382
1383 /* The only difference between the BOUND and NBOUND cases is that
1384  * REXEC_FBC_TRYIT is called when matched in BOUND, and when non-matched in
1385  * NBOUND.  This is accomplished by passing it in either the if or else clause,
1386  * with the other one being empty */
1387 #define FBC_BOUND(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1388     FBC_BOUND_COMMON(UTF8_LOAD(TEST1_UTF8, TEST2_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER), TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER)
1389
1390 #define FBC_BOUND_NOLOAD(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1391     FBC_BOUND_COMMON(UTF8_NOLOAD(TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER), TEST_NON_UTF8, REXEC_FBC_TRYIT, PLACEHOLDER)
1392
1393 #define FBC_NBOUND(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1394     FBC_BOUND_COMMON(UTF8_LOAD(TEST1_UTF8, TEST2_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT), TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT)
1395
1396 #define FBC_NBOUND_NOLOAD(TEST_NON_UTF8, TEST1_UTF8, TEST2_UTF8) \
1397     FBC_BOUND_COMMON(UTF8_NOLOAD(TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT), TEST_NON_UTF8, PLACEHOLDER, REXEC_FBC_TRYIT)
1398
1399
1400 /* Common to the BOUND and NBOUND cases.  Unfortunately the UTF8 tests need to
1401  * be passed in completely with the variable name being tested, which isn't
1402  * such a clean interface, but this is easier to read than it was before.  We
1403  * are looking for the boundary (or non-boundary between a word and non-word
1404  * character.  The utf8 and non-utf8 cases have the same logic, but the details
1405  * must be different.  Find the "wordness" of the character just prior to this
1406  * one, and compare it with the wordness of this one.  If they differ, we have
1407  * a boundary.  At the beginning of the string, pretend that the previous
1408  * character was a new-line */
1409 #define FBC_BOUND_COMMON(UTF8_CODE, TEST_NON_UTF8, IF_SUCCESS, IF_FAIL) \
1410     if (utf8_target) {                                                         \
1411                 UTF8_CODE \
1412     }                                                                          \
1413     else {  /* Not utf8 */                                                     \
1414         tmp = (s != PL_bostr) ? UCHARAT(s - 1) : '\n';                         \
1415         tmp = TEST_NON_UTF8(tmp);                                              \
1416         REXEC_FBC_SCAN(                                                        \
1417             if (tmp == ! TEST_NON_UTF8((U8) *s)) {                             \
1418                 tmp = !tmp;                                                    \
1419                 IF_SUCCESS;                                                    \
1420             }                                                                  \
1421             else {                                                             \
1422                 IF_FAIL;                                                       \
1423             }                                                                  \
1424         );                                                                     \
1425     }                                                                          \
1426     if ((!prog->minlen && tmp) && (!reginfo || regtry(reginfo, &s)))           \
1427         goto got_it;
1428
1429 /* We know what class REx starts with.  Try to find this position... */
1430 /* if reginfo is NULL, its a dryrun */
1431 /* annoyingly all the vars in this routine have different names from their counterparts
1432    in regmatch. /grrr */
1433
1434 STATIC char *
1435 S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, 
1436     const char *strend, regmatch_info *reginfo, bool is_utf8_pat)
1437 {
1438     dVAR;
1439     const I32 doevery = (prog->intflags & PREGf_SKIP) == 0;
1440     char *pat_string;   /* The pattern's exactish string */
1441     char *pat_end;          /* ptr to end char of pat_string */
1442     re_fold_t folder;   /* Function for computing non-utf8 folds */
1443     const U8 *fold_array;   /* array for folding ords < 256 */
1444     STRLEN ln;
1445     STRLEN lnc;
1446     U8 c1;
1447     U8 c2;
1448     char *e;
1449     I32 tmp = 1;        /* Scratch variable? */
1450     const bool utf8_target = PL_reg_match_utf8;
1451     UV utf8_fold_flags = 0;
1452     bool to_complement = FALSE; /* Invert the result?  Taking the xor of this
1453                                    with a result inverts that result, as 0^1 =
1454                                    1 and 1^1 = 0 */
1455     _char_class_number classnum;
1456
1457     RXi_GET_DECL(prog,progi);
1458
1459     PERL_ARGS_ASSERT_FIND_BYCLASS;
1460
1461     /* We know what class it must start with. */
1462     switch (OP(c)) {
1463     case ANYOF:
1464     case ANYOF_SYNTHETIC:
1465     case ANYOF_WARN_SUPER:
1466         if (utf8_target) {
1467             REXEC_FBC_UTF8_CLASS_SCAN(
1468                       reginclass(prog, c, (U8*)s, utf8_target));
1469         }
1470         else {
1471             REXEC_FBC_CLASS_SCAN(REGINCLASS(prog, c, (U8*)s));
1472         }
1473         break;
1474     case CANY:
1475         REXEC_FBC_SCAN(
1476             if (tmp && (!reginfo || regtry(reginfo, &s)))
1477                 goto got_it;
1478             else
1479                 tmp = doevery;
1480         );
1481         break;
1482
1483     case EXACTFA:
1484         if (is_utf8_pat || utf8_target) {
1485             utf8_fold_flags = FOLDEQ_UTF8_NOMIX_ASCII;
1486             goto do_exactf_utf8;
1487         }
1488         fold_array = PL_fold_latin1;    /* Latin1 folds are not affected by */
1489         folder = foldEQ_latin1;         /* /a, except the sharp s one which */
1490         goto do_exactf_non_utf8;        /* isn't dealt with by these */
1491
1492     case EXACTF:
1493         if (utf8_target) {
1494
1495             /* regcomp.c already folded this if pattern is in UTF-8 */
1496             utf8_fold_flags = 0;
1497             goto do_exactf_utf8;
1498         }
1499         fold_array = PL_fold;
1500         folder = foldEQ;
1501         goto do_exactf_non_utf8;
1502
1503     case EXACTFL:
1504         if (is_utf8_pat || utf8_target) {
1505             utf8_fold_flags = FOLDEQ_UTF8_LOCALE;
1506             goto do_exactf_utf8;
1507         }
1508         fold_array = PL_fold_locale;
1509         folder = foldEQ_locale;
1510         goto do_exactf_non_utf8;
1511
1512     case EXACTFU_SS:
1513         if (is_utf8_pat) {
1514             utf8_fold_flags = FOLDEQ_S2_ALREADY_FOLDED;
1515         }
1516         goto do_exactf_utf8;
1517
1518     case EXACTFU_TRICKYFOLD:
1519     case EXACTFU:
1520         if (is_utf8_pat || utf8_target) {
1521             utf8_fold_flags = is_utf8_pat ? FOLDEQ_S2_ALREADY_FOLDED : 0;
1522             goto do_exactf_utf8;
1523         }
1524
1525         /* Any 'ss' in the pattern should have been replaced by regcomp,
1526          * so we don't have to worry here about this single special case
1527          * in the Latin1 range */
1528         fold_array = PL_fold_latin1;
1529         folder = foldEQ_latin1;
1530
1531         /* FALL THROUGH */
1532
1533     do_exactf_non_utf8: /* Neither pattern nor string are UTF8, and there
1534                            are no glitches with fold-length differences
1535                            between the target string and pattern */
1536
1537         /* The idea in the non-utf8 EXACTF* cases is to first find the
1538          * first character of the EXACTF* node and then, if necessary,
1539          * case-insensitively compare the full text of the node.  c1 is the
1540          * first character.  c2 is its fold.  This logic will not work for
1541          * Unicode semantics and the german sharp ss, which hence should
1542          * not be compiled into a node that gets here. */
1543         pat_string = STRING(c);
1544         ln  = STR_LEN(c);       /* length to match in octets/bytes */
1545
1546         /* We know that we have to match at least 'ln' bytes (which is the
1547          * same as characters, since not utf8).  If we have to match 3
1548          * characters, and there are only 2 availabe, we know without
1549          * trying that it will fail; so don't start a match past the
1550          * required minimum number from the far end */
1551         e = HOP3c(strend, -((I32)ln), s);
1552
1553         if (!reginfo && e < s) {
1554             e = s;                      /* Due to minlen logic of intuit() */
1555         }
1556
1557         c1 = *pat_string;
1558         c2 = fold_array[c1];
1559         if (c1 == c2) { /* If char and fold are the same */
1560             REXEC_FBC_EXACTISH_SCAN(*(U8*)s == c1);
1561         }
1562         else {
1563             REXEC_FBC_EXACTISH_SCAN(*(U8*)s == c1 || *(U8*)s == c2);
1564         }
1565         break;
1566
1567     do_exactf_utf8:
1568     {
1569         unsigned expansion;
1570
1571         /* If one of the operands is in utf8, we can't use the simpler folding
1572          * above, due to the fact that many different characters can have the
1573          * same fold, or portion of a fold, or different- length fold */
1574         pat_string = STRING(c);
1575         ln  = STR_LEN(c);       /* length to match in octets/bytes */
1576         pat_end = pat_string + ln;
1577         lnc = is_utf8_pat       /* length to match in characters */
1578                 ? utf8_length((U8 *) pat_string, (U8 *) pat_end)
1579                 : ln;
1580
1581         /* We have 'lnc' characters to match in the pattern, but because of
1582          * multi-character folding, each character in the target can match
1583          * up to 3 characters (Unicode guarantees it will never exceed
1584          * this) if it is utf8-encoded; and up to 2 if not (based on the
1585          * fact that the Latin 1 folds are already determined, and the
1586          * only multi-char fold in that range is the sharp-s folding to
1587          * 'ss'.  Thus, a pattern character can match as little as 1/3 of a
1588          * string character.  Adjust lnc accordingly, rounding up, so that
1589          * if we need to match at least 4+1/3 chars, that really is 5. */
1590         expansion = (utf8_target) ? UTF8_MAX_FOLD_CHAR_EXPAND : 2;
1591         lnc = (lnc + expansion - 1) / expansion;
1592
1593         /* As in the non-UTF8 case, if we have to match 3 characters, and
1594          * only 2 are left, it's guaranteed to fail, so don't start a
1595          * match that would require us to go beyond the end of the string
1596          */
1597         e = HOP3c(strend, -((I32)lnc), s);
1598
1599         if (!reginfo && e < s) {
1600             e = s;                      /* Due to minlen logic of intuit() */
1601         }
1602
1603         /* XXX Note that we could recalculate e to stop the loop earlier,
1604          * as the worst case expansion above will rarely be met, and as we
1605          * go along we would usually find that e moves further to the left.
1606          * This would happen only after we reached the point in the loop
1607          * where if there were no expansion we should fail.  Unclear if
1608          * worth the expense */
1609
1610         while (s <= e) {
1611             char *my_strend= (char *)strend;
1612             if (foldEQ_utf8_flags(s, &my_strend, 0,  utf8_target,
1613                   pat_string, NULL, ln, is_utf8_pat, utf8_fold_flags)
1614                 && (!reginfo || regtry(reginfo, &s)) )
1615             {
1616                 goto got_it;
1617             }
1618             s += (utf8_target) ? UTF8SKIP(s) : 1;
1619         }
1620         break;
1621     }
1622     case BOUNDL:
1623         RXp_MATCH_TAINTED_on(prog);
1624         FBC_BOUND(isWORDCHAR_LC,
1625                   isWORDCHAR_LC_uvchr(UNI_TO_NATIVE(tmp)),
1626                   isWORDCHAR_LC_utf8((U8*)s));
1627         break;
1628     case NBOUNDL:
1629         RXp_MATCH_TAINTED_on(prog);
1630         FBC_NBOUND(isWORDCHAR_LC,
1631                    isWORDCHAR_LC_uvchr(UNI_TO_NATIVE(tmp)),
1632                    isWORDCHAR_LC_utf8((U8*)s));
1633         break;
1634     case BOUND:
1635         FBC_BOUND(isWORDCHAR,
1636                   isWORDCHAR_uni(tmp),
1637                   cBOOL(swash_fetch(PL_utf8_swash_ptrs[_CC_WORDCHAR], (U8*)s, utf8_target)));
1638         break;
1639     case BOUNDA:
1640         FBC_BOUND_NOLOAD(isWORDCHAR_A,
1641                          isWORDCHAR_A(tmp),
1642                          isWORDCHAR_A((U8*)s));
1643         break;
1644     case NBOUND:
1645         FBC_NBOUND(isWORDCHAR,
1646                    isWORDCHAR_uni(tmp),
1647                    cBOOL(swash_fetch(PL_utf8_swash_ptrs[_CC_WORDCHAR], (U8*)s, utf8_target)));
1648         break;
1649     case NBOUNDA:
1650         FBC_NBOUND_NOLOAD(isWORDCHAR_A,
1651                           isWORDCHAR_A(tmp),
1652                           isWORDCHAR_A((U8*)s));
1653         break;
1654     case BOUNDU:
1655         FBC_BOUND(isWORDCHAR_L1,
1656                   isWORDCHAR_uni(tmp),
1657                   cBOOL(swash_fetch(PL_utf8_swash_ptrs[_CC_WORDCHAR], (U8*)s, utf8_target)));
1658         break;
1659     case NBOUNDU:
1660         FBC_NBOUND(isWORDCHAR_L1,
1661                    isWORDCHAR_uni(tmp),
1662                    cBOOL(swash_fetch(PL_utf8_swash_ptrs[_CC_WORDCHAR], (U8*)s, utf8_target)));
1663         break;
1664     case LNBREAK:
1665         REXEC_FBC_CSCAN(is_LNBREAK_utf8_safe(s, strend),
1666                         is_LNBREAK_latin1_safe(s, strend)
1667         );
1668         break;
1669
1670     /* The argument to all the POSIX node types is the class number to pass to
1671      * _generic_isCC() to build a mask for searching in PL_charclass[] */
1672
1673     case NPOSIXL:
1674         to_complement = 1;
1675         /* FALLTHROUGH */
1676
1677     case POSIXL:
1678         RXp_MATCH_TAINTED_on(prog);
1679         REXEC_FBC_CSCAN(to_complement ^ cBOOL(isFOO_utf8_lc(FLAGS(c), (U8 *) s)),
1680                         to_complement ^ cBOOL(isFOO_lc(FLAGS(c), *s)));
1681         break;
1682
1683     case NPOSIXD:
1684         to_complement = 1;
1685         /* FALLTHROUGH */
1686
1687     case POSIXD:
1688         if (utf8_target) {
1689             goto posix_utf8;
1690         }
1691         goto posixa;
1692
1693     case NPOSIXA:
1694         if (utf8_target) {
1695             /* The complement of something that matches only ASCII matches all
1696              * UTF-8 variant code points, plus everything in ASCII that isn't
1697              * in the class */
1698             REXEC_FBC_UTF8_CLASS_SCAN(! UTF8_IS_INVARIANT(*s)
1699                                       || ! _generic_isCC_A(*s, FLAGS(c)));
1700             break;
1701         }
1702
1703         to_complement = 1;
1704         /* FALLTHROUGH */
1705
1706     case POSIXA:
1707       posixa:
1708         /* Don't need to worry about utf8, as it can match only a single
1709          * byte invariant character. */
1710         REXEC_FBC_CLASS_SCAN(
1711                         to_complement ^ cBOOL(_generic_isCC_A(*s, FLAGS(c))));
1712         break;
1713
1714     case NPOSIXU:
1715         to_complement = 1;
1716         /* FALLTHROUGH */
1717
1718     case POSIXU:
1719         if (! utf8_target) {
1720             REXEC_FBC_CLASS_SCAN(to_complement ^ cBOOL(_generic_isCC(*s,
1721                                                                     FLAGS(c))));
1722         }
1723         else {
1724
1725       posix_utf8:
1726             classnum = (_char_class_number) FLAGS(c);
1727             if (classnum < _FIRST_NON_SWASH_CC) {
1728                 while (s < strend) {
1729
1730                     /* We avoid loading in the swash as long as possible, but
1731                      * should we have to, we jump to a separate loop.  This
1732                      * extra 'if' statement is what keeps this code from being
1733                      * just a call to REXEC_FBC_UTF8_CLASS_SCAN() */
1734                     if (UTF8_IS_ABOVE_LATIN1(*s)) {
1735                         goto found_above_latin1;
1736                     }
1737                     if ((UTF8_IS_INVARIANT(*s)
1738                          && to_complement ^ cBOOL(_generic_isCC((U8) *s,
1739                                                                 classnum)))
1740                         || (UTF8_IS_DOWNGRADEABLE_START(*s)
1741                             && to_complement ^ cBOOL(
1742                                 _generic_isCC(TWO_BYTE_UTF8_TO_UNI(*s, *(s + 1)),
1743                                               classnum))))
1744                     {
1745                         if (tmp && (!reginfo || regtry(reginfo, &s)))
1746                             goto got_it;
1747                         else {
1748                             tmp = doevery;
1749                         }
1750                     }
1751                     else {
1752                         tmp = 1;
1753                     }
1754                     s += UTF8SKIP(s);
1755                 }
1756             }
1757             else switch (classnum) {    /* These classes are implemented as
1758                                            macros */
1759                 case _CC_ENUM_SPACE: /* XXX would require separate code if we
1760                                         revert the change of \v matching this */
1761                     /* FALL THROUGH */
1762
1763                 case _CC_ENUM_PSXSPC:
1764                     REXEC_FBC_UTF8_CLASS_SCAN(
1765                                         to_complement ^ cBOOL(isSPACE_utf8(s)));
1766                     break;
1767
1768                 case _CC_ENUM_BLANK:
1769                     REXEC_FBC_UTF8_CLASS_SCAN(
1770                                         to_complement ^ cBOOL(isBLANK_utf8(s)));
1771                     break;
1772
1773                 case _CC_ENUM_XDIGIT:
1774                     REXEC_FBC_UTF8_CLASS_SCAN(
1775                                        to_complement ^ cBOOL(isXDIGIT_utf8(s)));
1776                     break;
1777
1778                 case _CC_ENUM_VERTSPACE:
1779                     REXEC_FBC_UTF8_CLASS_SCAN(
1780                                        to_complement ^ cBOOL(isVERTWS_utf8(s)));
1781                     break;
1782
1783                 case _CC_ENUM_CNTRL:
1784                     REXEC_FBC_UTF8_CLASS_SCAN(
1785                                         to_complement ^ cBOOL(isCNTRL_utf8(s)));
1786                     break;
1787
1788                 default:
1789                     Perl_croak(aTHX_ "panic: find_byclass() node %d='%s' has an unexpected character class '%d'", OP(c), PL_reg_name[OP(c)], classnum);
1790                     assert(0); /* NOTREACHED */
1791             }
1792         }
1793         break;
1794
1795       found_above_latin1:   /* Here we have to load a swash to get the result
1796                                for the current code point */
1797         if (! PL_utf8_swash_ptrs[classnum]) {
1798             U8 flags = _CORE_SWASH_INIT_ACCEPT_INVLIST;
1799             PL_utf8_swash_ptrs[classnum] =
1800                     _core_swash_init("utf8", swash_property_names[classnum],
1801                                      &PL_sv_undef, 1, 0, NULL, &flags);
1802         }
1803
1804         /* This is a copy of the loop above for swash classes, though using the
1805          * FBC macro instead of being expanded out.  Since we've loaded the
1806          * swash, we don't have to check for that each time through the loop */
1807         REXEC_FBC_UTF8_CLASS_SCAN(
1808                 to_complement ^ cBOOL(_generic_utf8(
1809                                       classnum,
1810                                       s,
1811                                       swash_fetch(PL_utf8_swash_ptrs[classnum],
1812                                                   (U8 *) s, TRUE))));
1813         break;
1814
1815     case AHOCORASICKC:
1816     case AHOCORASICK:
1817         {
1818             DECL_TRIE_TYPE(c);
1819             /* what trie are we using right now */
1820             reg_ac_data *aho = (reg_ac_data*)progi->data->data[ ARG( c ) ];
1821             reg_trie_data *trie = (reg_trie_data*)progi->data->data[ aho->trie ];
1822             HV *widecharmap = MUTABLE_HV(progi->data->data[ aho->trie + 1 ]);
1823
1824             const char *last_start = strend - trie->minlen;
1825 #ifdef DEBUGGING
1826             const char *real_start = s;
1827 #endif
1828             STRLEN maxlen = trie->maxlen;
1829             SV *sv_points;
1830             U8 **points; /* map of where we were in the input string
1831                             when reading a given char. For ASCII this
1832                             is unnecessary overhead as the relationship
1833                             is always 1:1, but for Unicode, especially
1834                             case folded Unicode this is not true. */
1835             U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
1836             U8 *bitmap=NULL;
1837
1838
1839             GET_RE_DEBUG_FLAGS_DECL;
1840
1841             /* We can't just allocate points here. We need to wrap it in
1842              * an SV so it gets freed properly if there is a croak while
1843              * running the match */
1844             ENTER;
1845             SAVETMPS;
1846             sv_points=newSV(maxlen * sizeof(U8 *));
1847             SvCUR_set(sv_points,
1848                 maxlen * sizeof(U8 *));
1849             SvPOK_on(sv_points);
1850             sv_2mortal(sv_points);
1851             points=(U8**)SvPV_nolen(sv_points );
1852             if ( trie_type != trie_utf8_fold
1853                  && (trie->bitmap || OP(c)==AHOCORASICKC) )
1854             {
1855                 if (trie->bitmap)
1856                     bitmap=(U8*)trie->bitmap;
1857                 else
1858                     bitmap=(U8*)ANYOF_BITMAP(c);
1859             }
1860             /* this is the Aho-Corasick algorithm modified a touch
1861                to include special handling for long "unknown char" sequences.
1862                The basic idea being that we use AC as long as we are dealing
1863                with a possible matching char, when we encounter an unknown char
1864                (and we have not encountered an accepting state) we scan forward
1865                until we find a legal starting char.
1866                AC matching is basically that of trie matching, except that when
1867                we encounter a failing transition, we fall back to the current
1868                states "fail state", and try the current char again, a process
1869                we repeat until we reach the root state, state 1, or a legal
1870                transition. If we fail on the root state then we can either
1871                terminate if we have reached an accepting state previously, or
1872                restart the entire process from the beginning if we have not.
1873
1874              */
1875             while (s <= last_start) {
1876                 const U32 uniflags = UTF8_ALLOW_DEFAULT;
1877                 U8 *uc = (U8*)s;
1878                 U16 charid = 0;
1879                 U32 base = 1;
1880                 U32 state = 1;
1881                 UV uvc = 0;
1882                 STRLEN len = 0;
1883                 STRLEN foldlen = 0;
1884                 U8 *uscan = (U8*)NULL;
1885                 U8 *leftmost = NULL;
1886 #ifdef DEBUGGING
1887                 U32 accepted_word= 0;
1888 #endif
1889                 U32 pointpos = 0;
1890
1891                 while ( state && uc <= (U8*)strend ) {
1892                     int failed=0;
1893                     U32 word = aho->states[ state ].wordnum;
1894
1895                     if( state==1 ) {
1896                         if ( bitmap ) {
1897                             DEBUG_TRIE_EXECUTE_r(
1898                                 if ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1899                                     dump_exec_pos( (char *)uc, c, strend, real_start,
1900                                         (char *)uc, utf8_target );
1901                                     PerlIO_printf( Perl_debug_log,
1902                                         " Scanning for legal start char...\n");
1903                                 }
1904                             );
1905                             if (utf8_target) {
1906                                 while ( uc <= (U8*)last_start && !BITMAP_TEST(bitmap,*uc) ) {
1907                                     uc += UTF8SKIP(uc);
1908                                 }
1909                             } else {
1910                                 while ( uc <= (U8*)last_start  && !BITMAP_TEST(bitmap,*uc) ) {
1911                                     uc++;
1912                                 }
1913                             }
1914                             s= (char *)uc;
1915                         }
1916                         if (uc >(U8*)last_start) break;
1917                     }
1918
1919                     if ( word ) {
1920                         U8 *lpos= points[ (pointpos - trie->wordinfo[word].len) % maxlen ];
1921                         if (!leftmost || lpos < leftmost) {
1922                             DEBUG_r(accepted_word=word);
1923                             leftmost= lpos;
1924                         }
1925                         if (base==0) break;
1926
1927                     }
1928                     points[pointpos++ % maxlen]= uc;
1929                     if (foldlen || uc < (U8*)strend) {
1930                         REXEC_TRIE_READ_CHAR(trie_type, trie,
1931                                          widecharmap, uc,
1932                                          uscan, len, uvc, charid, foldlen,
1933                                          foldbuf, uniflags);
1934                         DEBUG_TRIE_EXECUTE_r({
1935                             dump_exec_pos( (char *)uc, c, strend,
1936                                         real_start, s, utf8_target);
1937                             PerlIO_printf(Perl_debug_log,
1938                                 " Charid:%3u CP:%4"UVxf" ",
1939                                  charid, uvc);
1940                         });
1941                     }
1942                     else {
1943                         len = 0;
1944                         charid = 0;
1945                     }
1946
1947
1948                     do {
1949 #ifdef DEBUGGING
1950                         word = aho->states[ state ].wordnum;
1951 #endif
1952                         base = aho->states[ state ].trans.base;
1953
1954                         DEBUG_TRIE_EXECUTE_r({
1955                             if (failed)
1956                                 dump_exec_pos( (char *)uc, c, strend, real_start,
1957                                     s,   utf8_target );
1958                             PerlIO_printf( Perl_debug_log,
1959                                 "%sState: %4"UVxf", word=%"UVxf,
1960                                 failed ? " Fail transition to " : "",
1961                                 (UV)state, (UV)word);
1962                         });
1963                         if ( base ) {
1964                             U32 tmp;
1965                             I32 offset;
1966                             if (charid &&
1967                                  ( ((offset = base + charid
1968                                     - 1 - trie->uniquecharcount)) >= 0)
1969                                  && ((U32)offset < trie->lasttrans)
1970                                  && trie->trans[offset].check == state
1971                                  && (tmp=trie->trans[offset].next))
1972                             {
1973                                 DEBUG_TRIE_EXECUTE_r(
1974                                     PerlIO_printf( Perl_debug_log," - legal\n"));
1975                                 state = tmp;
1976                                 break;
1977                             }
1978                             else {
1979                                 DEBUG_TRIE_EXECUTE_r(
1980                                     PerlIO_printf( Perl_debug_log," - fail\n"));
1981                                 failed = 1;
1982                                 state = aho->fail[state];
1983                             }
1984                         }
1985                         else {
1986                             /* we must be accepting here */
1987                             DEBUG_TRIE_EXECUTE_r(
1988                                     PerlIO_printf( Perl_debug_log," - accepting\n"));
1989                             failed = 1;
1990                             break;
1991                         }
1992                     } while(state);
1993                     uc += len;
1994                     if (failed) {
1995                         if (leftmost)
1996                             break;
1997                         if (!state) state = 1;
1998                     }
1999                 }
2000                 if ( aho->states[ state ].wordnum ) {
2001                     U8 *lpos = points[ (pointpos - trie->wordinfo[aho->states[ state ].wordnum].len) % maxlen ];
2002                     if (!leftmost || lpos < leftmost) {
2003                         DEBUG_r(accepted_word=aho->states[ state ].wordnum);
2004                         leftmost = lpos;
2005                     }
2006                 }
2007                 if (leftmost) {
2008                     s = (char*)leftmost;
2009                     DEBUG_TRIE_EXECUTE_r({
2010                         PerlIO_printf(
2011                             Perl_debug_log,"Matches word #%"UVxf" at position %"IVdf". Trying full pattern...\n",
2012                             (UV)accepted_word, (IV)(s - real_start)
2013                         );
2014                     });
2015                     if (!reginfo || regtry(reginfo, &s)) {
2016                         FREETMPS;
2017                         LEAVE;
2018                         goto got_it;
2019                     }
2020                     s = HOPc(s,1);
2021                     DEBUG_TRIE_EXECUTE_r({
2022                         PerlIO_printf( Perl_debug_log,"Pattern failed. Looking for new start point...\n");
2023                     });
2024                 } else {
2025                     DEBUG_TRIE_EXECUTE_r(
2026                         PerlIO_printf( Perl_debug_log,"No match.\n"));
2027                     break;
2028                 }
2029             }
2030             FREETMPS;
2031             LEAVE;
2032         }
2033         break;
2034     default:
2035         Perl_croak(aTHX_ "panic: unknown regstclass %d", (int)OP(c));
2036         break;
2037     }
2038     return 0;
2039   got_it:
2040     return s;
2041 }
2042
2043
2044 /*
2045  - regexec_flags - match a regexp against a string
2046  */
2047 I32
2048 Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend,
2049               char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
2050 /* stringarg: the point in the string at which to begin matching */
2051 /* strend:    pointer to null at end of string */
2052 /* strbeg:    real beginning of string */
2053 /* minend:    end of match must be >= minend bytes after stringarg. */
2054 /* sv:        SV being matched: only used for utf8 flag, pos() etc; string
2055  *            itself is accessed via the pointers above */
2056 /* data:      May be used for some additional optimizations.
2057               Currently its only used, with a U32 cast, for transmitting
2058               the ganch offset when doing a /g match. This will change */
2059 /* nosave:    For optimizations. */
2060
2061 {
2062     dVAR;
2063     struct regexp *const prog = ReANY(rx);
2064     char *s;
2065     regnode *c;
2066     char *startpos = stringarg;
2067     I32 minlen;         /* must match at least this many chars */
2068     I32 dontbother = 0; /* how many characters not to try at end */
2069     I32 end_shift = 0;                  /* Same for the end. */         /* CC */
2070     I32 scream_pos = -1;                /* Internal iterator of scream. */
2071     char *scream_olds = NULL;
2072     const bool utf8_target = cBOOL(DO_UTF8(sv));
2073     I32 multiline;
2074     RXi_GET_DECL(prog,progi);
2075     regmatch_info reginfo;  /* create some info to pass to regtry etc */
2076     regexp_paren_pair *swap = NULL;
2077     GET_RE_DEBUG_FLAGS_DECL;
2078
2079     PERL_ARGS_ASSERT_REGEXEC_FLAGS;
2080     PERL_UNUSED_ARG(data);
2081
2082     /* Be paranoid... */
2083     if (prog == NULL || startpos == NULL) {
2084         Perl_croak(aTHX_ "NULL regexp parameter");
2085         return 0;
2086     }
2087
2088     multiline = prog->extflags & RXf_PMf_MULTILINE;
2089     reginfo.prog = rx;   /* Yes, sorry that this is confusing.  */
2090
2091     RX_MATCH_UTF8_set(rx, utf8_target);
2092     DEBUG_EXECUTE_r( 
2093         debug_start_match(rx, utf8_target, startpos, strend,
2094         "Matching");
2095     );
2096
2097     minlen = prog->minlen;
2098     
2099     if (strend - startpos < (minlen+(prog->check_offset_min<0?prog->check_offset_min:0))) {
2100         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
2101                               "String too short [regexec_flags]...\n"));
2102         goto phooey;
2103     }
2104
2105     
2106     /* Check validity of program. */
2107     if (UCHARAT(progi->program) != REG_MAGIC) {
2108         Perl_croak(aTHX_ "corrupted regexp program");
2109     }
2110
2111     RX_MATCH_TAINTED_off(rx);
2112     PL_reg_state.re_state_eval_setup_done = FALSE;
2113     PL_reg_maxiter = 0;
2114
2115     reginfo.is_utf8_pat = cBOOL(RX_UTF8(rx));
2116     reginfo.warned = FALSE;
2117     /* Mark beginning of line for ^ and lookbehind. */
2118     reginfo.bol = startpos; /* XXX not used ??? */
2119     PL_bostr  = strbeg;
2120     reginfo.sv = sv;
2121
2122     /* Mark end of line for $ (and such) */
2123     PL_regeol = strend;
2124
2125     /* see how far we have to get to not match where we matched before */
2126     reginfo.till = startpos+minend;
2127
2128     /* If there is a "must appear" string, look for it. */
2129     s = startpos;
2130
2131     if (prog->extflags & RXf_GPOS_SEEN) { /* Need to set reginfo->ganch */
2132         MAGIC *mg;
2133         if (flags & REXEC_IGNOREPOS){   /* Means: check only at start */
2134             reginfo.ganch = startpos + prog->gofs;
2135             DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2136               "GPOS IGNOREPOS: reginfo.ganch = startpos + %"UVxf"\n",(UV)prog->gofs));
2137         } else if (sv && SvTYPE(sv) >= SVt_PVMG
2138                   && SvMAGIC(sv)
2139                   && (mg = mg_find(sv, PERL_MAGIC_regex_global))
2140                   && mg->mg_len >= 0) {
2141             reginfo.ganch = strbeg + mg->mg_len;        /* Defined pos() */
2142             DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2143                 "GPOS MAGIC: reginfo.ganch = strbeg + %"IVdf"\n",(IV)mg->mg_len));
2144
2145             if (prog->extflags & RXf_ANCH_GPOS) {
2146                 if (s > reginfo.ganch)
2147                     goto phooey;
2148                 s = reginfo.ganch - prog->gofs;
2149                 DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2150                      "GPOS ANCH_GPOS: s = ganch - %"UVxf"\n",(UV)prog->gofs));
2151                 if (s < strbeg)
2152                     goto phooey;
2153             }
2154         }
2155         else if (data) {
2156             reginfo.ganch = strbeg + PTR2UV(data);
2157             DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2158                  "GPOS DATA: reginfo.ganch= strbeg + %"UVxf"\n",PTR2UV(data)));
2159
2160         } else {                                /* pos() not defined */
2161             reginfo.ganch = strbeg;
2162             DEBUG_GPOS_r(PerlIO_printf(Perl_debug_log,
2163                  "GPOS: reginfo.ganch = strbeg\n"));
2164         }
2165     }
2166     if (PL_curpm && (PM_GETRE(PL_curpm) == rx)) {
2167         /* We have to be careful. If the previous successful match
2168            was from this regex we don't want a subsequent partially
2169            successful match to clobber the old results.
2170            So when we detect this possibility we add a swap buffer
2171            to the re, and switch the buffer each match. If we fail,
2172            we switch it back; otherwise we leave it swapped.
2173         */
2174         swap = prog->offs;
2175         /* do we need a save destructor here for eval dies? */
2176         Newxz(prog->offs, (prog->nparens + 1), regexp_paren_pair);
2177         DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
2178             "rex=0x%"UVxf" saving  offs: orig=0x%"UVxf" new=0x%"UVxf"\n",
2179             PTR2UV(prog),
2180             PTR2UV(swap),
2181             PTR2UV(prog->offs)
2182         ));
2183     }
2184     if (!(flags & REXEC_CHECKED) && (prog->check_substr != NULL || prog->check_utf8 != NULL)) {
2185         re_scream_pos_data d;
2186
2187         d.scream_olds = &scream_olds;
2188         d.scream_pos = &scream_pos;
2189         s = re_intuit_start(rx, sv, s, strend, flags, &d);
2190         if (!s) {
2191             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not present...\n"));
2192             goto phooey;        /* not present */
2193         }
2194     }
2195
2196
2197
2198     /* Simplest case:  anchored match need be tried only once. */
2199     /*  [unless only anchor is BOL and multiline is set] */
2200     if (prog->extflags & (RXf_ANCH & ~RXf_ANCH_GPOS)) {
2201         if (s == startpos && regtry(&reginfo, &startpos))
2202             goto got_it;
2203         else if (multiline || (prog->intflags & PREGf_IMPLICIT)
2204                  || (prog->extflags & RXf_ANCH_MBOL)) /* XXXX SBOL? */
2205         {
2206             char *end;
2207
2208             if (minlen)
2209                 dontbother = minlen - 1;
2210             end = HOP3c(strend, -dontbother, strbeg) - 1;
2211             /* for multiline we only have to try after newlines */
2212             if (prog->check_substr || prog->check_utf8) {
2213                 /* because of the goto we can not easily reuse the macros for bifurcating the
2214                    unicode/non-unicode match modes here like we do elsewhere - demerphq */
2215                 if (utf8_target) {
2216                     if (s == startpos)
2217                         goto after_try_utf8;
2218                     while (1) {
2219                         if (regtry(&reginfo, &s)) {
2220                             goto got_it;
2221                         }
2222                       after_try_utf8:
2223                         if (s > end) {
2224                             goto phooey;
2225                         }
2226                         if (prog->extflags & RXf_USE_INTUIT) {
2227                             s = re_intuit_start(rx, sv, s + UTF8SKIP(s), strend, flags, NULL);
2228                             if (!s) {
2229                                 goto phooey;
2230                             }
2231                         }
2232                         else {
2233                             s += UTF8SKIP(s);
2234                         }
2235                     }
2236                 } /* end search for check string in unicode */
2237                 else {
2238                     if (s == startpos) {
2239                         goto after_try_latin;
2240                     }
2241                     while (1) {
2242                         if (regtry(&reginfo, &s)) {
2243                             goto got_it;
2244                         }
2245                       after_try_latin:
2246                         if (s > end) {
2247                             goto phooey;
2248                         }
2249                         if (prog->extflags & RXf_USE_INTUIT) {
2250                             s = re_intuit_start(rx, sv, s + 1, strend, flags, NULL);
2251                             if (!s) {
2252                                 goto phooey;
2253                             }
2254                         }
2255                         else {
2256                             s++;
2257                         }
2258                     }
2259                 } /* end search for check string in latin*/
2260             } /* end search for check string */
2261             else { /* search for newline */
2262                 if (s > startpos) {
2263                     /*XXX: The s-- is almost definitely wrong here under unicode - demeprhq*/
2264                     s--;
2265                 }
2266                 /* We can use a more efficient search as newlines are the same in unicode as they are in latin */
2267                 while (s <= end) { /* note it could be possible to match at the end of the string */
2268                     if (*s++ == '\n') { /* don't need PL_utf8skip here */
2269                         if (regtry(&reginfo, &s))
2270                             goto got_it;
2271                     }
2272                 }
2273             } /* end search for newline */
2274         } /* end anchored/multiline check string search */
2275         goto phooey;
2276     } else if (RXf_GPOS_CHECK == (prog->extflags & RXf_GPOS_CHECK)) 
2277     {
2278         /* the warning about reginfo.ganch being used without initialization
2279            is bogus -- we set it above, when prog->extflags & RXf_GPOS_SEEN 
2280            and we only enter this block when the same bit is set. */
2281         char *tmp_s = reginfo.ganch - prog->gofs;
2282
2283         if (tmp_s >= strbeg && regtry(&reginfo, &tmp_s))
2284             goto got_it;
2285         goto phooey;
2286     }
2287
2288     /* Messy cases:  unanchored match. */
2289     if ((prog->anchored_substr || prog->anchored_utf8) && prog->intflags & PREGf_SKIP) {
2290         /* we have /x+whatever/ */
2291         /* it must be a one character string (XXXX Except is_utf8_pat?) */
2292         char ch;
2293 #ifdef DEBUGGING
2294         int did_match = 0;
2295 #endif
2296         if (utf8_target) {
2297             if (! prog->anchored_utf8) {
2298                 to_utf8_substr(prog);
2299             }
2300             ch = SvPVX_const(prog->anchored_utf8)[0];
2301             REXEC_FBC_SCAN(
2302                 if (*s == ch) {
2303                     DEBUG_EXECUTE_r( did_match = 1 );
2304                     if (regtry(&reginfo, &s)) goto got_it;
2305                     s += UTF8SKIP(s);
2306                     while (s < strend && *s == ch)
2307                         s += UTF8SKIP(s);
2308                 }
2309             );
2310
2311         }
2312         else {
2313             if (! prog->anchored_substr) {
2314                 if (! to_byte_substr(prog)) {
2315                     NON_UTF8_TARGET_BUT_UTF8_REQUIRED(phooey);
2316                 }
2317             }
2318             ch = SvPVX_const(prog->anchored_substr)[0];
2319             REXEC_FBC_SCAN(
2320                 if (*s == ch) {
2321                     DEBUG_EXECUTE_r( did_match = 1 );
2322                     if (regtry(&reginfo, &s)) goto got_it;
2323                     s++;
2324                     while (s < strend && *s == ch)
2325                         s++;
2326                 }
2327             );
2328         }
2329         DEBUG_EXECUTE_r(if (!did_match)
2330                 PerlIO_printf(Perl_debug_log,
2331                                   "Did not find anchored character...\n")
2332                );
2333     }
2334     else if (prog->anchored_substr != NULL
2335               || prog->anchored_utf8 != NULL
2336               || ((prog->float_substr != NULL || prog->float_utf8 != NULL)
2337                   && prog->float_max_offset < strend - s)) {
2338         SV *must;
2339         I32 back_max;
2340         I32 back_min;
2341         char *last;
2342         char *last1;            /* Last position checked before */
2343 #ifdef DEBUGGING
2344         int did_match = 0;
2345 #endif
2346         if (prog->anchored_substr || prog->anchored_utf8) {
2347             if (utf8_target) {
2348                 if (! prog->anchored_utf8) {
2349                     to_utf8_substr(prog);
2350                 }
2351                 must = prog->anchored_utf8;
2352             }
2353             else {
2354                 if (! prog->anchored_substr) {
2355                     if (! to_byte_substr(prog)) {
2356                         NON_UTF8_TARGET_BUT_UTF8_REQUIRED(phooey);
2357                     }
2358                 }
2359                 must = prog->anchored_substr;
2360             }
2361             back_max = back_min = prog->anchored_offset;
2362         } else {
2363             if (utf8_target) {
2364                 if (! prog->float_utf8) {
2365                     to_utf8_substr(prog);
2366                 }
2367                 must = prog->float_utf8;
2368             }
2369             else {
2370                 if (! prog->float_substr) {
2371                     if (! to_byte_substr(prog)) {
2372                         NON_UTF8_TARGET_BUT_UTF8_REQUIRED(phooey);
2373                     }
2374                 }
2375                 must = prog->float_substr;
2376             }
2377             back_max = prog->float_max_offset;
2378             back_min = prog->float_min_offset;
2379         }
2380             
2381         if (back_min<0) {
2382             last = strend;
2383         } else {
2384             last = HOP3c(strend,        /* Cannot start after this */
2385                   -(I32)(CHR_SVLEN(must)
2386                          - (SvTAIL(must) != 0) + back_min), strbeg);
2387         }
2388         if (s > PL_bostr)
2389             last1 = HOPc(s, -1);
2390         else
2391             last1 = s - 1;      /* bogus */
2392
2393         /* XXXX check_substr already used to find "s", can optimize if
2394            check_substr==must. */
2395         scream_pos = -1;
2396         dontbother = end_shift;
2397         strend = HOPc(strend, -dontbother);
2398         while ( (s <= last) &&
2399                 (s = fbm_instr((unsigned char*)HOP3(s, back_min, (back_min<0 ? strbeg : strend)),
2400                                   (unsigned char*)strend, must,
2401                                   multiline ? FBMrf_MULTILINE : 0)) ) {
2402             DEBUG_EXECUTE_r( did_match = 1 );
2403             if (HOPc(s, -back_max) > last1) {
2404                 last1 = HOPc(s, -back_min);
2405                 s = HOPc(s, -back_max);
2406             }
2407             else {
2408                 char * const t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
2409
2410                 last1 = HOPc(s, -back_min);
2411                 s = t;
2412             }
2413             if (utf8_target) {
2414                 while (s <= last1) {
2415                     if (regtry(&reginfo, &s))
2416                         goto got_it;
2417                     if (s >= last1) {
2418                         s++; /* to break out of outer loop */
2419                         break;
2420                     }
2421                     s += UTF8SKIP(s);
2422                 }
2423             }
2424             else {
2425                 while (s <= last1) {
2426                     if (regtry(&reginfo, &s))
2427                         goto got_it;
2428                     s++;
2429                 }
2430             }
2431         }
2432         DEBUG_EXECUTE_r(if (!did_match) {
2433             RE_PV_QUOTED_DECL(quoted, utf8_target, PERL_DEBUG_PAD_ZERO(0),
2434                 SvPVX_const(must), RE_SV_DUMPLEN(must), 30);
2435             PerlIO_printf(Perl_debug_log, "Did not find %s substr %s%s...\n",
2436                               ((must == prog->anchored_substr || must == prog->anchored_utf8)
2437                                ? "anchored" : "floating"),
2438                 quoted, RE_SV_TAIL(must));
2439         });                 
2440         goto phooey;
2441     }
2442     else if ( (c = progi->regstclass) ) {
2443         if (minlen) {
2444             const OPCODE op = OP(progi->regstclass);
2445             /* don't bother with what can't match */
2446             if (PL_regkind[op] != EXACT && op != CANY && PL_regkind[op] != TRIE)
2447                 strend = HOPc(strend, -(minlen - 1));
2448         }
2449         DEBUG_EXECUTE_r({
2450             SV * const prop = sv_newmortal();
2451             regprop(prog, prop, c);
2452             {
2453                 RE_PV_QUOTED_DECL(quoted,utf8_target,PERL_DEBUG_PAD_ZERO(1),
2454                     s,strend-s,60);
2455                 PerlIO_printf(Perl_debug_log,
2456                     "Matching stclass %.*s against %s (%d bytes)\n",
2457                     (int)SvCUR(prop), SvPVX_const(prop),
2458                      quoted, (int)(strend - s));
2459             }
2460         });
2461         if (find_byclass(prog, c, s, strend, &reginfo, reginfo.is_utf8_pat))
2462             goto got_it;
2463         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass... [regexec_flags]\n"));
2464     }
2465     else {
2466         dontbother = 0;
2467         if (prog->float_substr != NULL || prog->float_utf8 != NULL) {
2468             /* Trim the end. */
2469             char *last= NULL;
2470             SV* float_real;
2471             STRLEN len;
2472             const char *little;
2473
2474             if (utf8_target) {
2475                 if (! prog->float_utf8) {
2476                     to_utf8_substr(prog);
2477                 }
2478                 float_real = prog->float_utf8;
2479             }
2480             else {
2481                 if (! prog->float_substr) {
2482                     if (! to_byte_substr(prog)) {
2483                         NON_UTF8_TARGET_BUT_UTF8_REQUIRED(phooey);
2484                     }
2485                 }
2486                 float_real = prog->float_substr;
2487             }
2488
2489             little = SvPV_const(float_real, len);
2490             if (SvTAIL(float_real)) {
2491                     /* This means that float_real contains an artificial \n on
2492                      * the end due to the presence of something like this:
2493                      * /foo$/ where we can match both "foo" and "foo\n" at the
2494                      * end of the string.  So we have to compare the end of the
2495                      * string first against the float_real without the \n and
2496                      * then against the full float_real with the string.  We
2497                      * have to watch out for cases where the string might be
2498                      * smaller than the float_real or the float_real without
2499                      * the \n. */
2500                     char *checkpos= strend - len;
2501                     DEBUG_OPTIMISE_r(
2502                         PerlIO_printf(Perl_debug_log,
2503                             "%sChecking for float_real.%s\n",
2504                             PL_colors[4], PL_colors[5]));
2505                     if (checkpos + 1 < strbeg) {
2506                         /* can't match, even if we remove the trailing \n
2507                          * string is too short to match */
2508                         DEBUG_EXECUTE_r(
2509                             PerlIO_printf(Perl_debug_log,
2510                                 "%sString shorter than required trailing substring, cannot match.%s\n",
2511                                 PL_colors[4], PL_colors[5]));
2512                         goto phooey;
2513                     } else if (memEQ(checkpos + 1, little, len - 1)) {
2514                         /* can match, the end of the string matches without the
2515                          * "\n" */
2516                         last = checkpos + 1;
2517                     } else if (checkpos < strbeg) {
2518                         /* cant match, string is too short when the "\n" is
2519                          * included */
2520                         DEBUG_EXECUTE_r(
2521                             PerlIO_printf(Perl_debug_log,
2522                                 "%sString does not contain required trailing substring, cannot match.%s\n",
2523                                 PL_colors[4], PL_colors[5]));
2524                         goto phooey;
2525                     } else if (!multiline) {
2526                         /* non multiline match, so compare with the "\n" at the
2527                          * end of the string */
2528                         if (memEQ(checkpos, little, len)) {
2529                             last= checkpos;
2530                         } else {
2531                             DEBUG_EXECUTE_r(
2532                                 PerlIO_printf(Perl_debug_log,
2533                                     "%sString does not contain required trailing substring, cannot match.%s\n",
2534                                     PL_colors[4], PL_colors[5]));
2535                             goto phooey;
2536                         }
2537                     } else {
2538                         /* multiline match, so we have to search for a place
2539                          * where the full string is located */
2540                         goto find_last;
2541                     }
2542             } else {
2543                   find_last:
2544                     if (len)
2545                         last = rninstr(s, strend, little, little + len);
2546                     else
2547                         last = strend;  /* matching "$" */
2548             }
2549             if (!last) {
2550                 /* at one point this block contained a comment which was
2551                  * probably incorrect, which said that this was a "should not
2552                  * happen" case.  Even if it was true when it was written I am
2553                  * pretty sure it is not anymore, so I have removed the comment
2554                  * and replaced it with this one. Yves */
2555                 DEBUG_EXECUTE_r(
2556                     PerlIO_printf(Perl_debug_log,
2557                         "String does not contain required substring, cannot match.\n"
2558                     ));
2559                 goto phooey;
2560             }
2561             dontbother = strend - last + prog->float_min_offset;
2562         }
2563         if (minlen && (dontbother < minlen))
2564             dontbother = minlen - 1;
2565         strend -= dontbother;              /* this one's always in bytes! */
2566         /* We don't know much -- general case. */
2567         if (utf8_target) {
2568             for (;;) {
2569                 if (regtry(&reginfo, &s))
2570                     goto got_it;
2571                 if (s >= strend)
2572                     break;
2573                 s += UTF8SKIP(s);
2574             };
2575         }
2576         else {
2577             do {
2578                 if (regtry(&reginfo, &s))
2579                     goto got_it;
2580             } while (s++ < strend);
2581         }
2582     }
2583
2584     /* Failure. */
2585     goto phooey;
2586
2587 got_it:
2588     DEBUG_BUFFERS_r(
2589         if (swap)
2590             PerlIO_printf(Perl_debug_log,
2591                 "rex=0x%"UVxf" freeing offs: 0x%"UVxf"\n",
2592                 PTR2UV(prog),
2593                 PTR2UV(swap)
2594             );
2595     );
2596     Safefree(swap);
2597
2598     if (PL_reg_state.re_state_eval_setup_done)
2599         restore_pos(aTHX_ prog);
2600     if (RXp_PAREN_NAMES(prog)) 
2601         (void)hv_iterinit(RXp_PAREN_NAMES(prog));
2602
2603     /* make sure $`, $&, $', and $digit will work later */
2604     if ( !(flags & REXEC_NOT_FIRST) ) {
2605         if (flags & REXEC_COPY_STR) {
2606 #ifdef PERL_ANY_COW
2607             if (SvCANCOW(sv)) {
2608                 if (DEBUG_C_TEST) {
2609                     PerlIO_printf(Perl_debug_log,
2610                                   "Copy on write: regexp capture, type %d\n",
2611                                   (int) SvTYPE(sv));
2612                 }
2613                 RX_MATCH_COPY_FREE(rx);
2614                 prog->saved_copy = sv_setsv_cow(prog->saved_copy, sv);
2615                 prog->subbeg = (char *)SvPVX_const(prog->saved_copy);
2616                 assert (SvPOKp(prog->saved_copy));
2617                 prog->sublen  = PL_regeol - strbeg;
2618                 prog->suboffset = 0;
2619                 prog->subcoffset = 0;
2620             } else
2621 #endif
2622             {
2623                 I32 min = 0;
2624                 I32 max = PL_regeol - strbeg;
2625                 I32 sublen;
2626
2627                 if (    (flags & REXEC_COPY_SKIP_POST)
2628                     && !(RX_EXTFLAGS(rx) & RXf_PMf_KEEPCOPY) /* //p */
2629                     && !(PL_sawampersand & SAWAMPERSAND_RIGHT)
2630                 ) { /* don't copy $' part of string */
2631                     U32 n = 0;
2632                     max = -1;
2633                     /* calculate the right-most part of the string covered
2634                      * by a capture. Due to look-ahead, this may be to
2635                      * the right of $&, so we have to scan all captures */
2636                     while (n <= prog->lastparen) {
2637                         if (prog->offs[n].end > max)
2638                             max = prog->offs[n].end;
2639                         n++;
2640                     }
2641                     if (max == -1)
2642                         max = (PL_sawampersand & SAWAMPERSAND_LEFT)
2643                                 ? prog->offs[0].start
2644                                 : 0;
2645                     assert(max >= 0 && max <= PL_regeol - strbeg);
2646                 }
2647
2648                 if (    (flags & REXEC_COPY_SKIP_PRE)
2649                     && !(RX_EXTFLAGS(rx) & RXf_PMf_KEEPCOPY) /* //p */
2650                     && !(PL_sawampersand & SAWAMPERSAND_LEFT)
2651                 ) { /* don't copy $` part of string */
2652                     U32 n = 0;
2653                     min = max;
2654                     /* calculate the left-most part of the string covered
2655                      * by a capture. Due to look-behind, this may be to
2656                      * the left of $&, so we have to scan all captures */
2657                     while (min && n <= prog->lastparen) {
2658                         if (   prog->offs[n].start != -1
2659                             && prog->offs[n].start < min)
2660                         {
2661                             min = prog->offs[n].start;
2662                         }
2663                         n++;
2664                     }
2665                     if ((PL_sawampersand & SAWAMPERSAND_RIGHT)
2666                         && min >  prog->offs[0].end
2667                     )
2668                         min = prog->offs[0].end;
2669
2670                 }
2671
2672                 assert(min >= 0 && min <= max && min <= PL_regeol - strbeg);
2673                 sublen = max - min;
2674
2675                 if (RX_MATCH_COPIED(rx)) {
2676                     if (sublen > prog->sublen)
2677                         prog->subbeg =
2678                                 (char*)saferealloc(prog->subbeg, sublen+1);
2679                 }
2680                 else
2681                     prog->subbeg = (char*)safemalloc(sublen+1);
2682                 Copy(strbeg + min, prog->subbeg, sublen, char);
2683                 prog->subbeg[sublen] = '\0';
2684                 prog->suboffset = min;
2685                 prog->sublen = sublen;
2686                 RX_MATCH_COPIED_on(rx);
2687             }
2688             prog->subcoffset = prog->suboffset;
2689             if (prog->suboffset && utf8_target) {
2690                 /* Convert byte offset to chars.
2691                  * XXX ideally should only compute this if @-/@+
2692                  * has been seen, a la PL_sawampersand ??? */
2693
2694                 /* If there's a direct correspondence between the
2695                  * string which we're matching and the original SV,
2696                  * then we can use the utf8 len cache associated with
2697                  * the SV. In particular, it means that under //g,
2698                  * sv_pos_b2u() will use the previously cached
2699                  * position to speed up working out the new length of
2700                  * subcoffset, rather than counting from the start of
2701                  * the string each time. This stops
2702                  *   $x = "\x{100}" x 1E6; 1 while $x =~ /(.)/g;
2703                  * from going quadratic */
2704                 if (SvPOKp(sv) && SvPVX(sv) == strbeg)
2705                     sv_pos_b2u(sv, &(prog->subcoffset));
2706                 else
2707                     prog->subcoffset = utf8_length((U8*)strbeg,
2708                                         (U8*)(strbeg+prog->suboffset));
2709             }
2710         }
2711         else {
2712             RX_MATCH_COPY_FREE(rx);
2713             prog->subbeg = strbeg;
2714             prog->suboffset = 0;
2715             prog->subcoffset = 0;
2716             prog->sublen = PL_regeol - strbeg;  /* strend may have been modified */
2717         }
2718     }
2719
2720     return 1;
2721
2722 phooey:
2723     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
2724                           PL_colors[4], PL_colors[5]));
2725     if (PL_reg_state.re_state_eval_setup_done)
2726         restore_pos(aTHX_ prog);
2727     if (swap) {
2728         /* we failed :-( roll it back */
2729         DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
2730             "rex=0x%"UVxf" rolling back offs: freeing=0x%"UVxf" restoring=0x%"UVxf"\n",
2731             PTR2UV(prog),
2732             PTR2UV(prog->offs),
2733             PTR2UV(swap)
2734         ));
2735         Safefree(prog->offs);
2736         prog->offs = swap;
2737     }
2738     return 0;
2739 }
2740
2741
2742 /* Set which rex is pointed to by PL_reg_state, handling ref counting.
2743  * Do inc before dec, in case old and new rex are the same */
2744 #define SET_reg_curpm(Re2) \
2745     if (PL_reg_state.re_state_eval_setup_done) {    \
2746         (void)ReREFCNT_inc(Re2);                    \
2747         ReREFCNT_dec(PM_GETRE(PL_reg_curpm));       \
2748         PM_SETRE((PL_reg_curpm), (Re2));            \
2749     }
2750
2751
2752 /*
2753  - regtry - try match at specific point
2754  */
2755 STATIC I32                      /* 0 failure, 1 success */
2756 S_regtry(pTHX_ regmatch_info *reginfo, char **startposp)
2757 {
2758     dVAR;
2759     CHECKPOINT lastcp;
2760     REGEXP *const rx = reginfo->prog;
2761     regexp *const prog = ReANY(rx);
2762     I32 result;
2763     RXi_GET_DECL(prog,progi);
2764     GET_RE_DEBUG_FLAGS_DECL;
2765
2766     PERL_ARGS_ASSERT_REGTRY;
2767
2768     reginfo->cutpoint=NULL;
2769
2770     if ((prog->extflags & RXf_EVAL_SEEN)
2771         && !PL_reg_state.re_state_eval_setup_done)
2772     {
2773         MAGIC *mg;
2774
2775         PL_reg_state.re_state_eval_setup_done = TRUE;
2776         if (reginfo->sv) {
2777             /* Make $_ available to executed code. */
2778             if (reginfo->sv != DEFSV) {
2779                 SAVE_DEFSV;
2780                 DEFSV_set(reginfo->sv);
2781             }
2782         
2783             if (!(SvTYPE(reginfo->sv) >= SVt_PVMG && SvMAGIC(reginfo->sv)
2784                   && (mg = mg_find(reginfo->sv, PERL_MAGIC_regex_global)))) {
2785                 /* prepare for quick setting of pos */
2786 #ifdef PERL_OLD_COPY_ON_WRITE
2787                 if (SvIsCOW(reginfo->sv))
2788                     sv_force_normal_flags(reginfo->sv, 0);
2789 #endif
2790                 mg = sv_magicext(reginfo->sv, NULL, PERL_MAGIC_regex_global,
2791                                  &PL_vtbl_mglob, NULL, 0);
2792                 mg->mg_len = -1;
2793             }
2794             PL_reg_magic    = mg;
2795             PL_reg_oldpos   = mg->mg_len;
2796             SAVEDESTRUCTOR_X(restore_pos, prog);
2797         }
2798         if (!PL_reg_curpm) {
2799             Newxz(PL_reg_curpm, 1, PMOP);
2800 #ifdef USE_ITHREADS
2801             {
2802                 SV* const repointer = &PL_sv_undef;
2803                 /* this regexp is also owned by the new PL_reg_curpm, which
2804                    will try to free it.  */
2805                 av_push(PL_regex_padav, repointer);
2806                 PL_reg_curpm->op_pmoffset = av_len(PL_regex_padav);
2807                 PL_regex_pad = AvARRAY(PL_regex_padav);
2808             }
2809 #endif      
2810         }
2811         SET_reg_curpm(rx);
2812         PL_reg_oldcurpm = PL_curpm;
2813         PL_curpm = PL_reg_curpm;
2814         if (RXp_MATCH_COPIED(prog)) {
2815             /*  Here is a serious problem: we cannot rewrite subbeg,
2816                 since it may be needed if this match fails.  Thus
2817                 $` inside (?{}) could fail... */
2818             PL_reg_oldsaved = prog->subbeg;
2819             PL_reg_oldsavedlen = prog->sublen;
2820             PL_reg_oldsavedoffset = prog->suboffset;
2821             PL_reg_oldsavedcoffset = prog->suboffset;
2822 #ifdef PERL_ANY_COW
2823             PL_nrs = prog->saved_copy;
2824 #endif
2825             RXp_MATCH_COPIED_off(prog);
2826         }
2827         else
2828             PL_reg_oldsaved = NULL;
2829         prog->subbeg = PL_bostr;
2830         prog->suboffset = 0;
2831         prog->subcoffset = 0;
2832         prog->sublen = PL_regeol - PL_bostr; /* strend may have been modified */
2833     }
2834 #ifdef DEBUGGING
2835     PL_reg_starttry = *startposp;
2836 #endif
2837     prog->offs[0].start = *startposp - PL_bostr;
2838     prog->lastparen = 0;
2839     prog->lastcloseparen = 0;
2840
2841     /* XXXX What this code is doing here?!!!  There should be no need
2842        to do this again and again, prog->lastparen should take care of
2843        this!  --ilya*/
2844
2845     /* Tests pat.t#187 and split.t#{13,14} seem to depend on this code.
2846      * Actually, the code in regcppop() (which Ilya may be meaning by
2847      * prog->lastparen), is not needed at all by the test suite
2848      * (op/regexp, op/pat, op/split), but that code is needed otherwise
2849      * this erroneously leaves $1 defined: "1" =~ /^(?:(\d)x)?\d$/
2850      * Meanwhile, this code *is* needed for the
2851      * above-mentioned test suite tests to succeed.  The common theme
2852      * on those tests seems to be returning null fields from matches.
2853      * --jhi updated by dapm */
2854 #if 1
2855     if (prog->nparens) {
2856         regexp_paren_pair *pp = prog->offs;
2857         I32 i;
2858         for (i = prog->nparens; i > (I32)prog->lastparen; i--) {
2859             ++pp;
2860             pp->start = -1;
2861             pp->end = -1;
2862         }
2863     }
2864 #endif
2865     REGCP_SET(lastcp);
2866     result = regmatch(reginfo, *startposp, progi->program + 1);
2867     if (result != -1) {
2868         prog->offs[0].end = result;
2869         return 1;
2870     }
2871     if (reginfo->cutpoint)
2872         *startposp= reginfo->cutpoint;
2873     REGCP_UNWIND(lastcp);
2874     return 0;
2875 }
2876
2877
2878 #define sayYES goto yes
2879 #define sayNO goto no
2880 #define sayNO_SILENT goto no_silent
2881
2882 /* we dont use STMT_START/END here because it leads to 
2883    "unreachable code" warnings, which are bogus, but distracting. */
2884 #define CACHEsayNO \
2885     if (ST.cache_mask) \
2886        PL_reg_poscache[ST.cache_offset] |= ST.cache_mask; \
2887     sayNO
2888
2889 /* this is used to determine how far from the left messages like
2890    'failed...' are printed. It should be set such that messages 
2891    are inline with the regop output that created them.
2892 */
2893 #define REPORT_CODE_OFF 32
2894
2895
2896 #define CHRTEST_UNINIT -1001 /* c1/c2 haven't been calculated yet */
2897 #define CHRTEST_VOID   -1000 /* the c1/c2 "next char" test should be skipped */
2898 #define CHRTEST_NOT_A_CP_1 -999
2899 #define CHRTEST_NOT_A_CP_2 -998
2900
2901 #define SLAB_FIRST(s) (&(s)->states[0])
2902 #define SLAB_LAST(s)  (&(s)->states[PERL_REGMATCH_SLAB_SLOTS-1])
2903
2904 /* grab a new slab and return the first slot in it */
2905
2906 STATIC regmatch_state *
2907 S_push_slab(pTHX)
2908 {
2909 #if PERL_VERSION < 9 && !defined(PERL_CORE)
2910     dMY_CXT;
2911 #endif
2912     regmatch_slab *s = PL_regmatch_slab->next;
2913     if (!s) {
2914         Newx(s, 1, regmatch_slab);
2915         s->prev = PL_regmatch_slab;
2916         s->next = NULL;
2917         PL_regmatch_slab->next = s;
2918     }
2919     PL_regmatch_slab = s;
2920     return SLAB_FIRST(s);
2921 }
2922
2923
2924 /* push a new state then goto it */
2925
2926 #define PUSH_STATE_GOTO(state, node, input) \
2927     pushinput = input; \
2928     scan = node; \
2929     st->resume_state = state; \
2930     goto push_state;
2931
2932 /* push a new state with success backtracking, then goto it */
2933
2934 #define PUSH_YES_STATE_GOTO(state, node, input) \
2935     pushinput = input; \
2936     scan = node; \
2937     st->resume_state = state; \
2938     goto push_yes_state;
2939
2940
2941
2942
2943 /*
2944
2945 regmatch() - main matching routine
2946
2947 This is basically one big switch statement in a loop. We execute an op,
2948 set 'next' to point the next op, and continue. If we come to a point which
2949 we may need to backtrack to on failure such as (A|B|C), we push a
2950 backtrack state onto the backtrack stack. On failure, we pop the top
2951 state, and re-enter the loop at the state indicated. If there are no more
2952 states to pop, we return failure.
2953
2954 Sometimes we also need to backtrack on success; for example /A+/, where
2955 after successfully matching one A, we need to go back and try to
2956 match another one; similarly for lookahead assertions: if the assertion
2957 completes successfully, we backtrack to the state just before the assertion
2958 and then carry on.  In these cases, the pushed state is marked as
2959 'backtrack on success too'. This marking is in fact done by a chain of
2960 pointers, each pointing to the previous 'yes' state. On success, we pop to
2961 the nearest yes state, discarding any intermediate failure-only states.
2962 Sometimes a yes state is pushed just to force some cleanup code to be
2963 called at the end of a successful match or submatch; e.g. (??{$re}) uses
2964 it to free the inner regex.
2965
2966 Note that failure backtracking rewinds the cursor position, while
2967 success backtracking leaves it alone.
2968
2969 A pattern is complete when the END op is executed, while a subpattern
2970 such as (?=foo) is complete when the SUCCESS op is executed. Both of these
2971 ops trigger the "pop to last yes state if any, otherwise return true"
2972 behaviour.
2973
2974 A common convention in this function is to use A and B to refer to the two
2975 subpatterns (or to the first nodes thereof) in patterns like /A*B/: so A is
2976 the subpattern to be matched possibly multiple times, while B is the entire
2977 rest of the pattern. Variable and state names reflect this convention.
2978
2979 The states in the main switch are the union of ops and failure/success of
2980 substates associated with with that op.  For example, IFMATCH is the op
2981 that does lookahead assertions /(?=A)B/ and so the IFMATCH state means
2982 'execute IFMATCH'; while IFMATCH_A is a state saying that we have just
2983 successfully matched A and IFMATCH_A_fail is a state saying that we have
2984 just failed to match A. Resume states always come in pairs. The backtrack
2985 state we push is marked as 'IFMATCH_A', but when that is popped, we resume
2986 at IFMATCH_A or IFMATCH_A_fail, depending on whether we are backtracking
2987 on success or failure.
2988
2989 The struct that holds a backtracking state is actually a big union, with
2990 one variant for each major type of op. The variable st points to the
2991 top-most backtrack struct. To make the code clearer, within each
2992 block of code we #define ST to alias the relevant union.
2993
2994 Here's a concrete example of a (vastly oversimplified) IFMATCH
2995 implementation:
2996
2997     switch (state) {
2998     ....
2999
3000 #define ST st->u.ifmatch
3001
3002     case IFMATCH: // we are executing the IFMATCH op, (?=A)B
3003         ST.foo = ...; // some state we wish to save
3004         ...
3005         // push a yes backtrack state with a resume value of
3006         // IFMATCH_A/IFMATCH_A_fail, then continue execution at the
3007         // first node of A:
3008         PUSH_YES_STATE_GOTO(IFMATCH_A, A, newinput);
3009         // NOTREACHED
3010
3011     case IFMATCH_A: // we have successfully executed A; now continue with B
3012         next = B;
3013         bar = ST.foo; // do something with the preserved value
3014         break;
3015
3016     case IFMATCH_A_fail: // A failed, so the assertion failed
3017         ...;   // do some housekeeping, then ...
3018         sayNO; // propagate the failure
3019
3020 #undef ST
3021
3022     ...
3023     }
3024
3025 For any old-timers reading this who are familiar with the old recursive
3026 approach, the code above is equivalent to:
3027
3028     case IFMATCH: // we are executing the IFMATCH op, (?=A)B
3029     {
3030         int foo = ...
3031         ...
3032         if (regmatch(A)) {
3033             next = B;
3034             bar = foo;
3035             break;
3036         }
3037         ...;   // do some housekeeping, then ...
3038         sayNO; // propagate the failure
3039     }
3040
3041 The topmost backtrack state, pointed to by st, is usually free. If you
3042 want to claim it, populate any ST.foo fields in it with values you wish to
3043 save, then do one of
3044
3045         PUSH_STATE_GOTO(resume_state, node, newinput);
3046         PUSH_YES_STATE_GOTO(resume_state, node, newinput);
3047
3048 which sets that backtrack state's resume value to 'resume_state', pushes a
3049 new free entry to the top of the backtrack stack, then goes to 'node'.
3050 On backtracking, the free slot is popped, and the saved state becomes the
3051 new free state. An ST.foo field in this new top state can be temporarily
3052 accessed to retrieve values, but once the main loop is re-entered, it
3053 becomes available for reuse.
3054
3055 Note that the depth of the backtrack stack constantly increases during the
3056 left-to-right execution of the pattern, rather than going up and down with
3057 the pattern nesting. For example the stack is at its maximum at Z at the
3058 end of the pattern, rather than at X in the following:
3059
3060     /(((X)+)+)+....(Y)+....Z/
3061
3062 The only exceptions to this are lookahead/behind assertions and the cut,
3063 (?>A), which pop all the backtrack states associated with A before
3064 continuing.
3065  
3066 Backtrack state structs are allocated in slabs of about 4K in size.
3067 PL_regmatch_state and st always point to the currently active state,
3068 and PL_regmatch_slab points to the slab currently containing
3069 PL_regmatch_state.  The first time regmatch() is called, the first slab is
3070 allocated, and is never freed until interpreter destruction. When the slab
3071 is full, a new one is allocated and chained to the end. At exit from
3072 regmatch(), slabs allocated since entry are freed.
3073
3074 */
3075  
3076
3077 #define DEBUG_STATE_pp(pp)                                  \
3078     DEBUG_STATE_r({                                         \
3079         DUMP_EXEC_POS(locinput, scan, utf8_target);                 \
3080         PerlIO_printf(Perl_debug_log,                       \
3081             "    %*s"pp" %s%s%s%s%s\n",                     \
3082             depth*2, "",                                    \
3083             PL_reg_name[st->resume_state],                     \
3084             ((st==yes_state||st==mark_state) ? "[" : ""),   \
3085             ((st==yes_state) ? "Y" : ""),                   \
3086             ((st==mark_state) ? "M" : ""),                  \
3087             ((st==yes_state||st==mark_state) ? "]" : "")    \
3088         );                                                  \
3089     });
3090
3091
3092 #define REG_NODE_NUM(x) ((x) ? (int)((x)-prog) : -1)
3093
3094 #ifdef DEBUGGING
3095
3096 STATIC void
3097 S_debug_start_match(pTHX_ const REGEXP *prog, const bool utf8_target,
3098     const char *start, const char *end, const char *blurb)
3099 {
3100     const bool utf8_pat = RX_UTF8(prog) ? 1 : 0;
3101
3102     PERL_ARGS_ASSERT_DEBUG_START_MATCH;
3103
3104     if (!PL_colorset)   
3105             reginitcolors();    
3106     {
3107         RE_PV_QUOTED_DECL(s0, utf8_pat, PERL_DEBUG_PAD_ZERO(0), 
3108             RX_PRECOMP_const(prog), RX_PRELEN(prog), 60);   
3109         
3110         RE_PV_QUOTED_DECL(s1, utf8_target, PERL_DEBUG_PAD_ZERO(1),
3111             start, end - start, 60); 
3112         
3113         PerlIO_printf(Perl_debug_log, 
3114             "%s%s REx%s %s against %s\n", 
3115                        PL_colors[4], blurb, PL_colors[5], s0, s1); 
3116         
3117         if (utf8_target||utf8_pat)
3118             PerlIO_printf(Perl_debug_log, "UTF-8 %s%s%s...\n",
3119                 utf8_pat ? "pattern" : "",
3120                 utf8_pat && utf8_target ? " and " : "",
3121                 utf8_target ? "string" : ""
3122             ); 
3123     }
3124 }
3125
3126 STATIC void
3127 S_dump_exec_pos(pTHX_ const char *locinput, 
3128                       const regnode *scan, 
3129                       const char *loc_regeol, 
3130                       const char *loc_bostr, 
3131                       const char *loc_reg_starttry,
3132                       const bool utf8_target)
3133 {
3134     const int docolor = *PL_colors[0] || *PL_colors[2] || *PL_colors[4];
3135     const int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
3136     int l = (loc_regeol - locinput) > taill ? taill : (loc_regeol - locinput);
3137     /* The part of the string before starttry has one color
3138        (pref0_len chars), between starttry and current
3139        position another one (pref_len - pref0_len chars),
3140        after the current position the third one.
3141        We assume that pref0_len <= pref_len, otherwise we
3142        decrease pref0_len.  */
3143     int pref_len = (locinput - loc_bostr) > (5 + taill) - l
3144         ? (5 + taill) - l : locinput - loc_bostr;
3145     int pref0_len;
3146
3147     PERL_ARGS_ASSERT_DUMP_EXEC_POS;
3148
3149     while (utf8_target && UTF8_IS_CONTINUATION(*(U8*)(locinput - pref_len)))
3150         pref_len++;
3151     pref0_len = pref_len  - (locinput - loc_reg_starttry);
3152     if (l + pref_len < (5 + taill) && l < loc_regeol - locinput)
3153         l = ( loc_regeol - locinput > (5 + taill) - pref_len
3154               ? (5 + taill) - pref_len : loc_regeol - locinput);
3155     while (utf8_target && UTF8_IS_CONTINUATION(*(U8*)(locinput + l)))
3156         l--;
3157     if (pref0_len < 0)
3158         pref0_len = 0;
3159     if (pref0_len > pref_len)
3160         pref0_len = pref_len;
3161     {
3162         const int is_uni = (utf8_target && OP(scan) != CANY) ? 1 : 0;
3163
3164         RE_PV_COLOR_DECL(s0,len0,is_uni,PERL_DEBUG_PAD(0),
3165             (locinput - pref_len),pref0_len, 60, 4, 5);
3166         
3167         RE_PV_COLOR_DECL(s1,len1,is_uni,PERL_DEBUG_PAD(1),
3168                     (locinput - pref_len + pref0_len),
3169                     pref_len - pref0_len, 60, 2, 3);
3170         
3171         RE_PV_COLOR_DECL(s2,len2,is_uni,PERL_DEBUG_PAD(2),
3172                     locinput, loc_regeol - locinput, 10, 0, 1);
3173
3174         const STRLEN tlen=len0+len1+len2;
3175         PerlIO_printf(Perl_debug_log,
3176                     "%4"IVdf" <%.*s%.*s%s%.*s>%*s|",
3177                     (IV)(locinput - loc_bostr),
3178                     len0, s0,
3179                     len1, s1,
3180                     (docolor ? "" : "> <"),
3181                     len2, s2,
3182                     (int)(tlen > 19 ? 0 :  19 - tlen),
3183                     "");
3184     }
3185 }
3186
3187 #endif
3188
3189 /* reg_check_named_buff_matched()
3190  * Checks to see if a named buffer has matched. The data array of 
3191  * buffer numbers corresponding to the buffer is expected to reside
3192  * in the regexp->data->data array in the slot stored in the ARG() of
3193  * node involved. Note that this routine doesn't actually care about the
3194  * name, that information is not preserved from compilation to execution.
3195  * Returns the index of the leftmost defined buffer with the given name
3196  * or 0 if non of the buffers matched.
3197  */
3198 STATIC I32
3199 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
3200 {
3201     I32 n;
3202     RXi_GET_DECL(rex,rexi);
3203     SV *sv_dat= MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
3204     I32 *nums=(I32*)SvPVX(sv_dat);
3205
3206     PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED;
3207
3208     for ( n=0; n<SvIVX(sv_dat); n++ ) {
3209         if ((I32)rex->lastparen >= nums[n] &&
3210             rex->offs[nums[n]].end != -1)
3211         {
3212             return nums[n];
3213         }
3214     }
3215     return 0;
3216 }
3217
3218
3219 /* free all slabs above current one  - called during LEAVE_SCOPE */
3220
3221 STATIC void
3222 S_clear_backtrack_stack(pTHX_ void *p)
3223 {
3224     regmatch_slab *s = PL_regmatch_slab->next;
3225     PERL_UNUSED_ARG(p);
3226
3227     if (!s)
3228         return;
3229     PL_regmatch_slab->next = NULL;
3230     while (s) {
3231         regmatch_slab * const osl = s;
3232         s = s->next;
3233         Safefree(osl);
3234     }
3235 }
3236 static bool
3237 S_setup_EXACTISH_ST_c1_c2(pTHX_ const regnode * const text_node, int *c1p,
3238         U8* c1_utf8, int *c2p, U8* c2_utf8, bool is_utf8_pat)
3239 {
3240     /* This function determines if there are one or two characters that match
3241      * the first character of the passed-in EXACTish node <text_node>, and if
3242      * so, returns them in the passed-in pointers.
3243      *
3244      * If it determines that no possible character in the target string can
3245      * match, it returns FALSE; otherwise TRUE.  (The FALSE situation occurs if
3246      * the first character in <text_node> requires UTF-8 to represent, and the
3247      * target string isn't in UTF-8.)
3248      *
3249      * If there are more than two characters that could match the beginning of
3250      * <text_node>, or if more context is required to determine a match or not,
3251      * it sets both *<c1p> and *<c2p> to CHRTEST_VOID.
3252      *
3253      * The motiviation behind this function is to allow the caller to set up
3254      * tight loops for matching.  If <text_node> is of type EXACT, there is
3255      * only one possible character that can match its first character, and so
3256      * the situation is quite simple.  But things get much more complicated if
3257      * folding is involved.  It may be that the first character of an EXACTFish
3258      * node doesn't participate in any possible fold, e.g., punctuation, so it
3259      * can be matched only by itself.  The vast majority of characters that are
3260      * in folds match just two things, their lower and upper-case equivalents.
3261      * But not all are like that; some have multiple possible matches, or match
3262      * sequences of more than one character.  This function sorts all that out.
3263      *
3264      * Consider the patterns A*B or A*?B where A and B are arbitrary.  In a
3265      * loop of trying to match A*, we know we can't exit where the thing
3266      * following it isn't a B.  And something can't be a B unless it is the
3267      * beginning of B.  By putting a quick test for that beginning in a tight
3268      * loop, we can rule out things that can't possibly be B without having to
3269      * break out of the loop, thus avoiding work.  Similarly, if A is a single
3270      * character, we can make a tight loop matching A*, using the outputs of
3271      * this function.
3272      *
3273      * If the target string to match isn't in UTF-8, and there aren't
3274      * complications which require CHRTEST_VOID, *<c1p> and *<c2p> are set to
3275      * the one or two possible octets (which are characters in this situation)
3276      * that can match.  In all cases, if there is only one character that can
3277      * match, *<c1p> and *<c2p> will be identical.
3278      *
3279      * If the target string is in UTF-8, the buffers pointed to by <c1_utf8>
3280      * and <c2_utf8> will contain the one or two UTF-8 sequences of bytes that
3281      * can match the beginning of <text_node>.  They should be declared with at
3282      * least length UTF8_MAXBYTES+1.  (If the target string isn't in UTF-8, it is
3283      * undefined what these contain.)  If one or both of the buffers are
3284      * invariant under UTF-8, *<c1p>, and *<c2p> will also be set to the
3285      * corresponding invariant.  If variant, the corresponding *<c1p> and/or
3286      * *<c2p> will be set to a negative number(s) that shouldn't match any code
3287      * point (unless inappropriately coerced to unsigned).   *<c1p> will equal
3288      * *<c2p> if and only if <c1_utf8> and <c2_utf8> are the same. */
3289
3290     const bool utf8_target = PL_reg_match_utf8;
3291
3292     UV c1 = CHRTEST_NOT_A_CP_1;
3293     UV c2 = CHRTEST_NOT_A_CP_2;
3294     bool use_chrtest_void = FALSE;
3295
3296     /* Used when we have both utf8 input and utf8 output, to avoid converting
3297      * to/from code points */
3298     bool utf8_has_been_setup = FALSE;
3299
3300     dVAR;
3301
3302     U8 *pat = (U8*)STRING(text_node);
3303
3304     if (OP(text_node) == EXACT) {
3305
3306         /* In an exact node, only one thing can be matched, that first
3307          * character.  If both the pat and the target are UTF-8, we can just
3308          * copy the input to the output, avoiding finding the code point of
3309          * that character */
3310         if (!is_utf8_pat) {
3311             c2 = c1 = *pat;
3312         }
3313         else if (utf8_target) {
3314             Copy(pat, c1_utf8, UTF8SKIP(pat), U8);
3315             Copy(pat, c2_utf8, UTF8SKIP(pat), U8);
3316             utf8_has_been_setup = TRUE;
3317         }
3318         else {
3319             c2 = c1 = valid_utf8_to_uvchr(pat, NULL);
3320         }
3321     }
3322     else /* an EXACTFish node */
3323          if ((is_utf8_pat
3324                     && is_MULTI_CHAR_FOLD_utf8_safe(pat,
3325                                                     pat + STR_LEN(text_node)))
3326              || (!is_utf8_pat
3327                     && is_MULTI_CHAR_FOLD_latin1_safe(pat,
3328                                                     pat + STR_LEN(text_node))))
3329     {
3330         /* Multi-character folds require more context to sort out.  Also
3331          * PL_utf8_foldclosures used below doesn't handle them, so have to be
3332          * handled outside this routine */
3333         use_chrtest_void = TRUE;
3334     }
3335     else { /* an EXACTFish node which doesn't begin with a multi-char fold */
3336         c1 = is_utf8_pat ? valid_utf8_to_uvchr(pat, NULL) : *pat;
3337         if (c1 > 256) {
3338             /* Load the folds hash, if not already done */
3339             SV** listp;
3340             if (! PL_utf8_foldclosures) {
3341                 if (! PL_utf8_tofold) {
3342                     U8 dummy[UTF8_MAXBYTES+1];
3343
3344                     /* Force loading this by folding an above-Latin1 char */
3345                     to_utf8_fold((U8*) HYPHEN_UTF8, dummy, NULL);
3346                     assert(PL_utf8_tofold); /* Verify that worked */
3347                 }
3348                 PL_utf8_foldclosures = _swash_inversion_hash(PL_utf8_tofold);
3349             }
3350
3351             /* The fold closures data structure is a hash with the keys being
3352              * the UTF-8 of every character that is folded to, like 'k', and
3353              * the values each an array of all code points that fold to its
3354              * key.  e.g. [ 'k', 'K', KELVIN_SIGN ].  Multi-character folds are
3355              * not included */
3356             if ((! (listp = hv_fetch(PL_utf8_foldclosures,
3357                                      (char *) pat,
3358                                      UTF8SKIP(pat),
3359                                      FALSE))))
3360             {
3361                 /* Not found in the hash, therefore there are no folds
3362                  * containing it, so there is only a single character that
3363                  * could match */
3364                 c2 = c1;
3365             }
3366             else {  /* Does participate in folds */
3367                 AV* list = (AV*) *listp;
3368                 if (av_len(list) != 1) {
3369
3370                     /* If there aren't exactly two folds to this, it is outside
3371                      * the scope of this function */
3372                     use_chrtest_void = TRUE;
3373                 }
3374                 else {  /* There are two.  Get them */
3375                     SV** c_p = av_fetch(list, 0, FALSE);
3376                     if (c_p == NULL) {
3377                         Perl_croak(aTHX_ "panic: invalid PL_utf8_foldclosures structure");
3378                     }
3379                     c1 = SvUV(*c_p);
3380
3381                     c_p = av_fetch(list, 1, FALSE);
3382                     if (c_p == NULL) {
3383                         Perl_croak(aTHX_ "panic: invalid PL_utf8_foldclosures structure");
3384                     }
3385                     c2 = SvUV(*c_p);
3386
3387                     /* Folds that cross the 255/256 boundary are forbidden if
3388                      * EXACTFL, or EXACTFA and one is ASCIII.  Since the
3389                      * pattern character is above 256, and its only other match
3390                      * is below 256, the only legal match will be to itself.
3391                      * We have thrown away the original, so have to compute
3392                      * which is the one above 255 */
3393                     if ((c1 < 256) != (c2 < 256)) {
3394                         if (OP(text_node) == EXACTFL
3395                             || (OP(text_node) == EXACTFA
3396                                 && (isASCII(c1) || isASCII(c2))))
3397                         {
3398                             if (c1 < 256) {
3399                                 c1 = c2;
3400                             }
3401                             else {
3402                                 c2 = c1;
3403                             }
3404                         }
3405                     }
3406                 }
3407             }
3408         }
3409         else /* Here, c1 is < 255 */
3410              if (utf8_target
3411                  && HAS_NONLATIN1_FOLD_CLOSURE(c1)
3412                  && OP(text_node) != EXACTFL
3413                  && (OP(text_node) != EXACTFA || ! isASCII(c1)))
3414         {
3415             /* Here, there could be something above Latin1 in the target which
3416              * folds to this character in the pattern.  All such cases except
3417              * LATIN SMALL LETTER Y WITH DIAERESIS have more than two characters
3418              * involved in their folds, so are outside the scope of this
3419              * function */
3420             if (UNLIKELY(c1 == LATIN_SMALL_LETTER_Y_WITH_DIAERESIS)) {
3421                 c2 = LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS;
3422             }
3423             else {
3424                 use_chrtest_void = TRUE;
3425             }
3426         }
3427         else { /* Here nothing above Latin1 can fold to the pattern character */
3428             switch (OP(text_node)) {
3429
3430                 case EXACTFL:   /* /l rules */
3431                     c2 = PL_fold_locale[c1];
3432                     break;
3433
3434                 case EXACTF:
3435                     if (! utf8_target) {    /* /d rules */
3436                         c2 = PL_fold[c1];
3437                         break;
3438                     }
3439                     /* FALLTHROUGH */
3440                     /* /u rules for all these.  This happens to work for
3441                      * EXACTFA as nothing in Latin1 folds to ASCII */
3442                 case EXACTFA:
3443                 case EXACTFU_TRICKYFOLD:
3444                 case EXACTFU_SS:
3445                 case EXACTFU:
3446                     c2 = PL_fold_latin1[c1];
3447                     break;
3448
3449                 default:
3450                     Perl_croak(aTHX_ "panic: Unexpected op %u", OP(text_node));
3451                     assert(0); /* NOTREACHED */
3452             }
3453         }
3454     }
3455
3456     /* Here have figured things out.  Set up the returns */
3457     if (use_chrtest_void) {
3458         *c2p = *c1p = CHRTEST_VOID;
3459     }
3460     else if (utf8_target) {
3461         if (! utf8_has_been_setup) {    /* Don't have the utf8; must get it */
3462             uvchr_to_utf8(c1_utf8, c1);
3463             uvchr_to_utf8(c2_utf8, c2);
3464         }
3465
3466         /* Invariants are stored in both the utf8 and byte outputs; Use
3467          * negative numbers otherwise for the byte ones.  Make sure that the
3468          * byte ones are the same iff the utf8 ones are the same */
3469         *c1p = (UTF8_IS_INVARIANT(*c1_utf8)) ? *c1_utf8 : CHRTEST_NOT_A_CP_1;
3470         *c2p = (UTF8_IS_INVARIANT(*c2_utf8))
3471                 ? *c2_utf8
3472                 : (c1 == c2)
3473                   ? CHRTEST_NOT_A_CP_1
3474                   : CHRTEST_NOT_A_CP_2;
3475     }
3476     else if (c1 > 255) {
3477        if (c2 > 255) {  /* both possibilities are above what a non-utf8 string
3478                            can represent */
3479            return FALSE;
3480        }
3481
3482        *c1p = *c2p = c2;    /* c2 is the only representable value */
3483     }
3484     else {  /* c1 is representable; see about c2 */
3485        *c1p = c1;
3486        *c2p = (c2 < 256) ? c2 : c1;
3487     }
3488
3489     return TRUE;
3490 }
3491
3492 /* returns -1 on failure, $+[0] on success */
3493 STATIC I32
3494 S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
3495 {
3496 #if PERL_VERSION < 9 && !defined(PERL_CORE)
3497     dMY_CXT;
3498 #endif
3499     dVAR;
3500     const bool utf8_target = PL_reg_match_utf8;
3501     const U32 uniflags = UTF8_ALLOW_DEFAULT;
3502     REGEXP *rex_sv = reginfo->prog;
3503     regexp *rex = ReANY(rex_sv);
3504     RXi_GET_DECL(rex,rexi);
3505     I32 oldsave;
3506     /* the current state. This is a cached copy of PL_regmatch_state */
3507     regmatch_state *st;
3508     /* cache heavy used fields of st in registers */
3509     regnode *scan;
3510     regnode *next;
3511     U32 n = 0;  /* general value; init to avoid compiler warning */
3512     I32 ln = 0; /* len or last;  init to avoid compiler warning */
3513     char *locinput = startpos;
3514     char *pushinput; /* where to continue after a PUSH */
3515     I32 nextchr;   /* is always set to UCHARAT(locinput) */
3516
3517     bool result = 0;        /* return value of S_regmatch */
3518     int depth = 0;          /* depth of backtrack stack */
3519     U32 nochange_depth = 0; /* depth of GOSUB recursion with nochange */
3520     const U32 max_nochange_depth =
3521         (3 * rex->nparens > MAX_RECURSE_EVAL_NOCHANGE_DEPTH) ?
3522         3 * rex->nparens : MAX_RECURSE_EVAL_NOCHANGE_DEPTH;
3523     regmatch_state *yes_state = NULL; /* state to pop to on success of
3524                                                             subpattern */
3525     /* mark_state piggy backs on the yes_state logic so that when we unwind 
3526        the stack on success we can update the mark_state as we go */
3527     regmatch_state *mark_state = NULL; /* last mark state we have seen */
3528     regmatch_state *cur_eval = NULL; /* most recent EVAL_AB state */
3529     struct regmatch_state  *cur_curlyx = NULL; /* most recent curlyx */
3530     U32 state_num;
3531     bool no_final = 0;      /* prevent failure from backtracking? */
3532     bool do_cutgroup = 0;   /* no_final only until next branch/trie entry */
3533     char *startpoint = locinput;
3534     SV *popmark = NULL;     /* are we looking for a mark? */
3535     SV *sv_commit = NULL;   /* last mark name seen in failure */
3536     SV *sv_yes_mark = NULL; /* last mark name we have seen 
3537                                during a successful match */
3538     U32 lastopen = 0;       /* last open we saw */
3539     bool has_cutgroup = RX_HAS_CUTGROUP(rex) ? 1 : 0;   
3540     SV* const oreplsv = GvSV(PL_replgv);
3541     /* these three flags are set by various ops to signal information to
3542      * the very next op. They have a useful lifetime of exactly one loop
3543      * iteration, and are not preserved or restored by state pushes/pops
3544      */
3545     bool sw = 0;            /* the condition value in (?(cond)a|b) */
3546     bool minmod = 0;        /* the next "{n,m}" is a "{n,m}?" */
3547     int logical = 0;        /* the following EVAL is:
3548                                 0: (?{...})
3549                                 1: (?(?{...})X|Y)
3550                                 2: (??{...})
3551                                or the following IFMATCH/UNLESSM is:
3552                                 false: plain (?=foo)
3553                                 true:  used as a condition: (?(?=foo))
3554                             */
3555     PAD* last_pad = NULL;
3556     dMULTICALL;
3557     I32 gimme = G_SCALAR;
3558     CV *caller_cv = NULL;       /* who called us */
3559     CV *last_pushed_cv = NULL;  /* most recently called (?{}) CV */
3560     CHECKPOINT runops_cp;       /* savestack position before executing EVAL */
3561     U32 maxopenparen = 0;       /* max '(' index seen so far */
3562     int to_complement;  /* Invert the result? */
3563     _char_class_number classnum;
3564     bool is_utf8_pat = reginfo->is_utf8_pat;
3565
3566 #ifdef DEBUGGING
3567     GET_RE_DEBUG_FLAGS_DECL;
3568 #endif
3569
3570     /* shut up 'may be used uninitialized' compiler warnings for dMULTICALL */
3571     multicall_oldcatch = 0;
3572     multicall_cv = NULL;
3573     cx = NULL;
3574     PERL_UNUSED_VAR(multicall_cop);
3575     PERL_UNUSED_VAR(newsp);
3576
3577
3578     PERL_ARGS_ASSERT_REGMATCH;
3579
3580     DEBUG_OPTIMISE_r( DEBUG_EXECUTE_r({
3581             PerlIO_printf(Perl_debug_log,"regmatch start\n");
3582     }));
3583     /* on first ever call to regmatch, allocate first slab */
3584     if (!PL_regmatch_slab) {
3585         Newx(PL_regmatch_slab, 1, regmatch_slab);
3586         PL_regmatch_slab->prev = NULL;
3587         PL_regmatch_slab->next = NULL;
3588         PL_regmatch_state = SLAB_FIRST(PL_regmatch_slab);
3589     }
3590
3591     oldsave = PL_savestack_ix;
3592     SAVEDESTRUCTOR_X(S_clear_backtrack_stack, NULL);
3593     SAVEVPTR(PL_regmatch_slab);
3594     SAVEVPTR(PL_regmatch_state);
3595
3596     /* grab next free state slot */
3597     st = ++PL_regmatch_state;
3598     if (st >  SLAB_LAST(PL_regmatch_slab))
3599         st = PL_regmatch_state = S_push_slab(aTHX);
3600
3601     /* Note that nextchr is a byte even in UTF */
3602     SET_nextchr;
3603     scan = prog;
3604     while (scan != NULL) {
3605
3606         DEBUG_EXECUTE_r( {
3607             SV * const prop = sv_newmortal();
3608             regnode *rnext=regnext(scan);
3609             DUMP_EXEC_POS( locinput, scan, utf8_target );
3610             regprop(rex, prop, scan);
3611             
3612             PerlIO_printf(Perl_debug_log,
3613                     "%3"IVdf":%*s%s(%"IVdf")\n",
3614                     (IV)(scan - rexi->program), depth*2, "",
3615                     SvPVX_const(prop),
3616                     (PL_regkind[OP(scan)] == END || !rnext) ? 
3617                         0 : (IV)(rnext - rexi->program));
3618         });
3619
3620         next = scan + NEXT_OFF(scan);
3621         if (next == scan)
3622             next = NULL;
3623         state_num = OP(scan);
3624
3625         REH_CALL_EXEC_NODE_HOOK(rex, scan, reginfo, st);
3626       reenter_switch:
3627         to_complement = 0;
3628
3629         SET_nextchr;
3630         assert(nextchr < 256 && (nextchr >= 0 || nextchr == NEXTCHR_EOS));
3631
3632         switch (state_num) {
3633         case BOL: /*  /^../  */
3634             if (locinput == PL_bostr)
3635             {
3636                 /* reginfo->till = reginfo->bol; */
3637                 break;
3638             }
3639             sayNO;
3640
3641         case MBOL: /*  /^../m  */
3642             if (locinput == PL_bostr ||
3643                 (!NEXTCHR_IS_EOS && locinput[-1] == '\n'))
3644             {
3645                 break;
3646             }
3647             sayNO;
3648
3649         case SBOL: /*  /^../s  */
3650             if (locinput == PL_bostr)
3651                 break;
3652             sayNO;
3653
3654         case GPOS: /*  \G  */
3655             if (locinput == reginfo->ganch)
3656                 break;
3657             sayNO;
3658
3659         case KEEPS: /*   \K  */
3660             /* update the startpoint */
3661             st->u.keeper.val = rex->offs[0].start;
3662             rex->offs[0].start = locinput - PL_bostr;
3663             PUSH_STATE_GOTO(KEEPS_next, next, locinput);
3664             assert(0); /*NOTREACHED*/
3665         case KEEPS_next_fail:
3666             /* rollback the start point change */
3667             rex->offs[0].start = st->u.keeper.val;
3668             sayNO_SILENT;
3669             assert(0); /*NOTREACHED*/
3670
3671         case EOL: /* /..$/  */
3672                 goto seol;
3673
3674         case MEOL: /* /..$/m  */
3675             if (!NEXTCHR_IS_EOS && nextchr != '\n')
3676                 sayNO;
3677             break;
3678
3679         case SEOL: /* /..$/s  */
3680           seol:
3681             if (!NEXTCHR_IS_EOS && nextchr != '\n')
3682                 sayNO;
3683             if (PL_regeol - locinput > 1)
3684                 sayNO;
3685             break;
3686
3687         case EOS: /*  \z  */
3688             if (!NEXTCHR_IS_EOS)
3689                 sayNO;
3690             break;
3691
3692         case SANY: /*  /./s  */
3693             if (NEXTCHR_IS_EOS)
3694                 sayNO;
3695             goto increment_locinput;
3696
3697         case CANY: /*  \C  */
3698             if (NEXTCHR_IS_EOS)
3699                 sayNO;
3700             locinput++;
3701             break;
3702
3703         case REG_ANY: /*  /./  */
3704             if ((NEXTCHR_IS_EOS) || nextchr == '\n')
3705                 sayNO;
3706             goto increment_locinput;
3707
3708
3709 #undef  ST
3710 #define ST st->u.trie
3711         case TRIEC: /* (ab|cd) with known charclass */
3712             /* In this case the charclass data is available inline so
3713                we can fail fast without a lot of extra overhead. 
3714              */
3715             if(!NEXTCHR_IS_EOS && !ANYOF_BITMAP_TEST(scan, nextchr)) {
3716                 DEBUG_EXECUTE_r(
3717                     PerlIO_printf(Perl_debug_log,
3718                               "%*s  %sfailed to match trie start class...%s\n",
3719                               REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
3720                 );
3721                 sayNO_SILENT;
3722                 assert(0); /* NOTREACHED */
3723             }
3724             /* FALL THROUGH */
3725         case TRIE:  /* (ab|cd)  */
3726             /* the basic plan of execution of the trie is:
3727              * At the beginning, run though all the states, and
3728              * find the longest-matching word. Also remember the position
3729              * of the shortest matching word. For example, this pattern:
3730              *    1  2 3 4    5
3731              *    ab|a|x|abcd|abc
3732              * when matched against the string "abcde", will generate
3733              * accept states for all words except 3, with the longest
3734              * matching word being 4, and the shortest being 2 (with
3735              * the position being after char 1 of the string).
3736              *
3737              * Then for each matching word, in word order (i.e. 1,2,4,5),
3738              * we run the remainder of the pattern; on each try setting
3739              * the current position to the character following the word,
3740              * returning to try the next word on failure.
3741              *
3742              * We avoid having to build a list of words at runtime by
3743              * using a compile-time structure, wordinfo[].prev, which
3744              * gives, for each word, the previous accepting word (if any).
3745              * In the case above it would contain the mappings 1->2, 2->0,
3746              * 3->0, 4->5, 5->1.  We can use this table to generate, from
3747              * the longest word (4 above), a list of all words, by
3748              * following the list of prev pointers; this gives us the
3749              * unordered list 4,5,1,2. Then given the current word we have
3750              * just tried, we can go through the list and find the
3751              * next-biggest word to try (so if we just failed on word 2,
3752              * the next in the list is 4).
3753              *
3754              * Since at runtime we don't record the matching position in
3755              * the string for each word, we have to work that out for
3756              * each word we're about to process. The wordinfo table holds
3757              * the character length of each word; given that we recorded
3758              * at the start: the position of the shortest word and its
3759              * length in chars, we just need to move the pointer the
3760              * difference between the two char lengths. Depending on
3761              * Unicode status and folding, that's cheap or expensive.
3762              *
3763              * This algorithm is optimised for the case where are only a
3764              * small number of accept states, i.e. 0,1, or maybe 2.
3765              * With lots of accepts states, and having to try all of them,
3766              * it becomes quadratic on number of accept states to find all
3767              * the next words.
3768              */
3769
3770             {
3771                 /* what type of TRIE am I? (utf8 makes this contextual) */
3772                 DECL_TRIE_TYPE(scan);
3773
3774                 /* what trie are we using right now */
3775                 reg_trie_data * const trie
3776                     = (reg_trie_data*)rexi->data->data[ ARG( scan ) ];
3777                 HV * widecharmap = MUTABLE_HV(rexi->data->data[ ARG( scan ) + 1 ]);
3778                 U32 state = trie->startstate;
3779
3780                 if (   trie->bitmap
3781                     && (NEXTCHR_IS_EOS || !TRIE_BITMAP_TEST(trie, nextchr)))
3782                 {
3783                     if (trie->states[ state ].wordnum) {
3784                          DEBUG_EXECUTE_r(
3785                             PerlIO_printf(Perl_debug_log,
3786                                           "%*s  %smatched empty string...%s\n",
3787                                           REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
3788                         );
3789                         if (!trie->jump)
3790                             break;
3791                     } else {
3792                         DEBUG_EXECUTE_r(
3793                             PerlIO_printf(Perl_debug_log,
3794                                           "%*s  %sfailed to match trie start class...%s\n",
3795                                           REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5])
3796                         );
3797                         sayNO_SILENT;
3798                    }
3799                 }
3800
3801             { 
3802                 U8 *uc = ( U8* )locinput;
3803
3804                 STRLEN len = 0;
3805                 STRLEN foldlen = 0;
3806                 U8 *uscan = (U8*)NULL;
3807                 U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
3808                 U32 charcount = 0; /* how many input chars we have matched */
3809                 U32 accepted = 0; /* have we seen any accepting states? */
3810
3811                 ST.jump = trie->jump;
3812                 ST.me = scan;
3813                 ST.firstpos = NULL;
3814                 ST.longfold = FALSE; /* char longer if folded => it's harder */
3815                 ST.nextword = 0;
3816
3817                 /* fully traverse the TRIE; note the position of the
3818                    shortest accept state and the wordnum of the longest
3819                    accept state */
3820
3821                 while ( state && uc <= (U8*)PL_regeol ) {
3822                     U32 base = trie->states[ state ].trans.base;
3823                     UV uvc = 0;
3824                     U16 charid = 0;
3825                     U16 wordnum;
3826                     wordnum = trie->states[ state ].wordnum;
3827
3828                     if (wordnum) { /* it's an accept state */
3829                         if (!accepted) {
3830                             accepted = 1;
3831                             /* record first match position */
3832                             if (ST.longfold) {
3833                                 ST.firstpos = (U8*)locinput;
3834                                 ST.firstchars = 0;
3835                             }
3836                             else {
3837                                 ST.firstpos = uc;
3838                                 ST.firstchars = charcount;
3839                             }
3840                         }
3841                         if (!ST.nextword || wordnum < ST.nextword)
3842                             ST.nextword = wordnum;
3843                         ST.topword = wordnum;
3844                     }
3845
3846                     DEBUG_TRIE_EXECUTE_r({
3847                                 DUMP_EXEC_POS( (char *)uc, scan, utf8_target );
3848                                 PerlIO_printf( Perl_debug_log,
3849                                     "%*s  %sState: %4"UVxf" Accepted: %c ",
3850                                     2+depth * 2, "", PL_colors[4],
3851                                     (UV)state, (accepted ? 'Y' : 'N'));
3852                     });
3853
3854                     /* read a char and goto next state */
3855                     if ( base && (foldlen || uc < (U8*)PL_regeol)) {
3856                         I32 offset;
3857                         REXEC_TRIE_READ_CHAR(trie_type, trie, widecharmap, uc,
3858                                              uscan, len, uvc, charid, foldlen,
3859                                              foldbuf, uniflags);
3860                         charcount++;
3861                         if (foldlen>0)
3862                             ST.longfold = TRUE;
3863                         if (charid &&
3864                              ( ((offset =
3865                               base + charid - 1 - trie->uniquecharcount)) >= 0)
3866
3867                              && ((U32)offset < trie->lasttrans)
3868                              && trie->trans[offset].check == state)
3869                         {
3870                             state = trie->trans[offset].next;
3871                         }
3872                         else {
3873                             state = 0;
3874                         }
3875                         uc += len;
3876
3877                     }
3878                     else {
3879                         state = 0;
3880                     }
3881                     DEBUG_TRIE_EXECUTE_r(
3882                         PerlIO_printf( Perl_debug_log,
3883                             "Charid:%3x CP:%4"UVxf" After State: %4"UVxf"%s\n",
3884                             charid, uvc, (UV)state, PL_colors[5] );
3885                     );
3886                 }
3887                 if (!accepted)
3888                    sayNO;
3889
3890                 /* calculate total number of accept states */
3891                 {
3892                     U16 w = ST.topword;
3893                     accepted = 0;
3894                     while (w) {
3895                         w = trie->wordinfo[w].prev;
3896                         accepted++;
3897                     }
3898                     ST.accepted = accepted;
3899                 }
3900
3901                 DEBUG_EXECUTE_r(
3902                     PerlIO_printf( Perl_debug_log,
3903                         "%*s  %sgot %"IVdf" possible matches%s\n",
3904                         REPORT_CODE_OFF + depth * 2, "",
3905                         PL_colors[4], (IV)ST.accepted, PL_colors[5] );
3906                 );
3907                 goto trie_first_try; /* jump into the fail handler */
3908             }}
3909             assert(0); /* NOTREACHED */
3910
3911         case TRIE_next_fail: /* we failed - try next alternative */
3912         {
3913             U8 *uc;
3914             if ( ST.jump) {
3915                 REGCP_UNWIND(ST.cp);
3916                 UNWIND_PAREN(ST.lastparen, ST.lastcloseparen);
3917             }
3918             if (!--ST.accepted) {
3919                 DEBUG_EXECUTE_r({
3920                     PerlIO_printf( Perl_debug_log,
3921                         "%*s  %sTRIE failed...%s\n",
3922                         REPORT_CODE_OFF+depth*2, "", 
3923                         PL_colors[4],
3924                         PL_colors[5] );
3925                 });
3926                 sayNO_SILENT;
3927             }
3928             {
3929                 /* Find next-highest word to process.  Note that this code
3930                  * is O(N^2) per trie run (O(N) per branch), so keep tight */
3931                 U16 min = 0;
3932                 U16 word;
3933                 U16 const nextword = ST.nextword;
3934                 reg_trie_wordinfo * const wordinfo
3935                     = ((reg_trie_data*)rexi->data->data[ARG(ST.me)])->wordinfo;
3936                 for (word=ST.topword; word; word=wordinfo[word].prev) {
3937                     if (word > nextword && (!min || word < min))
3938                         min = word;
3939                 }
3940                 ST.nextword = min;
3941             }
3942
3943           trie_first_try:
3944             if (do_cutgroup) {
3945                 do_cutgroup = 0;
3946                 no_final = 0;
3947             }
3948
3949             if ( ST.jump) {
3950                 ST.lastparen = rex->lastparen;
3951                 ST.lastcloseparen = rex->lastcloseparen;
3952                 REGCP_SET(ST.cp);
3953             }
3954
3955             /* find start char of end of current word */
3956             {
3957                 U32 chars; /* how many chars to skip */
3958                 reg_trie_data * const trie
3959                     = (reg_trie_data*)rexi->data->data[ARG(ST.me)];
3960
3961                 assert((trie->wordinfo[ST.nextword].len - trie->prefixlen)
3962                             >=  ST.firstchars);
3963                 chars = (trie->wordinfo[ST.nextword].len - trie->prefixlen)
3964                             - ST.firstchars;
3965                 uc = ST.firstpos;
3966
3967                 if (ST.longfold) {
3968                     /* the hard option - fold each char in turn and find
3969                      * its folded length (which may be different */
3970                     U8 foldbuf[UTF8_MAXBYTES_CASE + 1];
3971                     STRLEN foldlen;
3972                     STRLEN len;
3973                     UV uvc;
3974                     U8 *uscan;
3975
3976                     while (chars) {
3977                         if (utf8_target) {
3978                             uvc = utf8n_to_uvuni((U8*)uc, UTF8_MAXLEN, &len,
3979                                                     uniflags);
3980                             uc += len;
3981                         }
3982                         else {
3983                             uvc = *uc;
3984                             uc++;
3985                         }
3986                         uvc = to_uni_fold(uvc, foldbuf, &foldlen);
3987                         uscan = foldbuf;
3988                         while (foldlen) {
3989                             if (!--chars)
3990                                 break;
3991                             uvc = utf8n_to_uvuni(uscan, UTF8_MAXLEN, &len,
3992                                             uniflags);
3993                             uscan += len;
3994                             foldlen -= len;
3995                         }
3996                     }
3997                 }
3998                 else {
3999                     if (utf8_target)
4000                         while (chars--)
4001                             uc += UTF8SKIP(uc);
4002                     else
4003                         uc += chars;
4004                 }
4005             }
4006
4007             scan = ST.me + ((ST.jump && ST.jump[ST.nextword])
4008                             ? ST.jump[ST.nextword]
4009                             : NEXT_OFF(ST.me));
4010
4011             DEBUG_EXECUTE_r({
4012                 PerlIO_printf( Perl_debug_log,
4013                     "%*s  %sTRIE matched word #%d, continuing%s\n",
4014                     REPORT_CODE_OFF+depth*2, "", 
4015                     PL_colors[4],
4016                     ST.nextword,
4017                     PL_colors[5]
4018                     );
4019             });
4020
4021             if (ST.accepted > 1 || has_cutgroup) {
4022                 PUSH_STATE_GOTO(TRIE_next, scan, (char*)uc);
4023                 assert(0); /* NOTREACHED */
4024             }
4025             /* only one choice left - just continue */
4026             DEBUG_EXECUTE_r({
4027                 AV *const trie_words
4028                     = MUTABLE_AV(rexi->data->data[ARG(ST.me)+TRIE_WORDS_OFFSET]);
4029                 SV ** const tmp = av_fetch( trie_words,
4030                     ST.nextword-1, 0 );
4031                 SV *sv= tmp ? sv_newmortal() : NULL;
4032
4033                 PerlIO_printf( Perl_debug_log,
4034                     "%*s  %sonly one match left, short-circuiting: #%d <%s>%s\n",
4035                     REPORT_CODE_OFF+depth*2, "", PL_colors[4],
4036                     ST.nextword,
4037                     tmp ? pv_pretty(sv, SvPV_nolen_const(*tmp), SvCUR(*tmp), 0,
4038                             PL_colors[0], PL_colors[1],
4039                             (SvUTF8(*tmp) ? PERL_PV_ESCAPE_UNI : 0)|PERL_PV_ESCAPE_NONASCII
4040                         ) 
4041                     : "not compiled under -Dr",
4042                     PL_colors[5] );
4043             });
4044
4045             locinput = (char*)uc;
4046             continue; /* execute rest of RE */
4047             assert(0); /* NOTREACHED */
4048         }
4049 #undef  ST
4050
4051         case EXACT: {            /*  /abc/        */
4052             char *s = STRING(scan);
4053             ln = STR_LEN(scan);
4054             if (utf8_target != is_utf8_pat) {
4055                 /* The target and the pattern have differing utf8ness. */
4056                 char *l = locinput;
4057                 const char * const e = s + ln;
4058
4059                 if (utf8_target) {
4060                     /* The target is utf8, the pattern is not utf8.
4061                      * Above-Latin1 code points can't match the pattern;
4062                      * invariants match exactly, and the other Latin1 ones need
4063                      * to be downgraded to a single byte in order to do the
4064                      * comparison.  (If we could be confident that the target
4065                      * is not malformed, this could be refactored to have fewer
4066                      * tests by just assuming that if the first bytes match, it
4067                      * is an invariant, but there are tests in the test suite
4068                      * dealing with (??{...}) which violate this) */
4069                     while (s < e) {
4070                         if (l >= PL_regeol || UTF8_IS_ABOVE_LATIN1(* (U8*) l)) {
4071                             sayNO;
4072                         }
4073                         if (UTF8_IS_INVARIANT(*(U8*)l)) {
4074                             if (*l != *s) {
4075                                 sayNO;
4076                             }
4077                             l++;
4078                         }
4079                         else {
4080                             if (TWO_BYTE_UTF8_TO_UNI(*l, *(l+1)) != * (U8*) s) {
4081                                 sayNO;
4082                             }
4083                             l += 2;
4084                         }
4085                         s++;
4086                     }
4087                 }
4088                 else {
4089                     /* The target is not utf8, the pattern is utf8. */
4090                     while (s < e) {
4091                         if (l >= PL_regeol || UTF8_IS_ABOVE_LATIN1(* (U8*) s))
4092                         {
4093                             sayNO;
4094                         }
4095                         if (UTF8_IS_INVARIANT(*(U8*)s)) {
4096                             if (*s != *l) {
4097                                 sayNO;
4098                             }
4099                             s++;
4100                         }
4101                         else {
4102                             if (TWO_BYTE_UTF8_TO_UNI(*s, *(s+1)) != * (U8*) l) {
4103                                 sayNO;
4104                             }
4105                             s += 2;
4106                         }
4107                         l++;
4108                     }
4109                 }
4110                 locinput = l;
4111             }
4112             else {
4113                 /* The target and the pattern have the same utf8ness. */
4114                 /* Inline the first character, for speed. */
4115                 if (PL_regeol - locinput < ln
4116                     || UCHARAT(s) != nextchr
4117                     || (ln > 1 && memNE(s, locinput, ln)))
4118                 {
4119                     sayNO;
4120                 }
4121                 locinput += ln;
4122             }
4123             break;
4124             }
4125
4126         case EXACTFL: {          /*  /abc/il      */
4127             re_fold_t folder;
4128             const U8 * fold_array;
4129             const char * s;
4130             U32 fold_utf8_flags;
4131
4132             RX_MATCH_TAINTED_on(reginfo->prog);
4133             folder = foldEQ_locale;
4134             fold_array = PL_fold_locale;
4135             fold_utf8_flags = FOLDEQ_UTF8_LOCALE;
4136             goto do_exactf;
4137
4138         case EXACTFU_SS:         /*  /\x{df}/iu   */
4139         case EXACTFU_TRICKYFOLD: /*  /\x{390}/iu  */
4140         case EXACTFU:            /*  /abc/iu      */
4141             folder = foldEQ_latin1;
4142             fold_array = PL_fold_latin1;
4143             fold_utf8_flags = is_utf8_pat ? FOLDEQ_S1_ALREADY_FOLDED : 0;
4144             goto do_exactf;
4145
4146         case EXACTFA:            /*  /abc/iaa     */
4147             folder = foldEQ_latin1;
4148             fold_array = PL_fold_latin1;
4149             fold_utf8_flags = FOLDEQ_UTF8_NOMIX_ASCII;
4150             goto do_exactf;
4151
4152         case EXACTF:             /*  /abc/i       */
4153             folder = foldEQ;
4154             fold_array = PL_fold;
4155             fold_utf8_flags = 0;
4156
4157           do_exactf:
4158             s = STRING(scan);
4159             ln = STR_LEN(scan);
4160
4161             if (utf8_target || is_utf8_pat || state_num == EXACTFU_SS) {
4162               /* Either target or the pattern are utf8, or has the issue where
4163                * the fold lengths may differ. */
4164                 const char * const l = locinput;
4165                 char *e = PL_regeol;
4166
4167                 if (! foldEQ_utf8_flags(s, 0,  ln, is_utf8_pat,
4168                                         l, &e, 0,  utf8_target, fold_utf8_flags))
4169                 {
4170                     sayNO;
4171                 }
4172                 locinput = e;
4173                 break;
4174             }
4175
4176             /* Neither the target nor the pattern are utf8 */
4177             if (UCHARAT(s) != nextchr
4178                 && !NEXTCHR_IS_EOS
4179                 && UCHARAT(s) != fold_array[nextchr])
4180             {
4181                 sayNO;
4182             }
4183             if (PL_regeol - locinput < ln)
4184                 sayNO;
4185             if (ln > 1 && ! folder(s, locinput, ln))
4186                 sayNO;
4187             locinput += ln;
4188             break;
4189         }
4190
4191         /* XXX Could improve efficiency by separating these all out using a
4192          * macro or in-line function.  At that point regcomp.c would no longer
4193          * have to set the FLAGS fields of these */
4194         case BOUNDL:  /*  /\b/l  */
4195         case NBOUNDL: /*  /\B/l  */
4196             RX_MATCH_TAINTED_on(reginfo->prog);
4197             /* FALL THROUGH */
4198         case BOUND:   /*  /\b/   */
4199         case BOUNDU:  /*  /\b/u  */
4200         case BOUNDA:  /*  /\b/a  */
4201         case NBOUND:  /*  /\B/   */
4202         case NBOUNDU: /*  /\B/u  */
4203         case NBOUNDA: /*  /\B/a  */
4204             /* was last char in word? */
4205             if (utf8_target
4206                 && FLAGS(scan) != REGEX_ASCII_RESTRICTED_CHARSET
4207                 && FLAGS(scan) != REGEX_ASCII_MORE_RESTRICTED_CHARSET)
4208             {
4209                 if (locinput == PL_bostr)
4210                     ln = '\n';
4211                 else {
4212                     const U8 * const r = reghop3((U8*)locinput, -1, (U8*)PL_bostr);
4213
4214                     ln = utf8n_to_uvchr(r, UTF8SKIP(r), 0, uniflags);
4215                 }
4216                 if (FLAGS(scan) != REGEX_LOCALE_CHARSET) {
4217                     ln = isWORDCHAR_uni(ln);
4218                     if (NEXTCHR_IS_EOS)
4219                         n = 0;
4220                     else {
4221                         LOAD_UTF8_CHARCLASS_ALNUM();
4222                         n = swash_fetch(PL_utf8_swash_ptrs[_CC_WORDCHAR], (U8*)locinput,
4223                                                                 utf8_target);
4224                     }
4225                 }
4226                 else {
4227                     ln = isWORDCHAR_LC_uvchr(UNI_TO_NATIVE(ln));
4228                     n = NEXTCHR_IS_EOS ? 0 : isWORDCHAR_LC_utf8((U8*)locinput);
4229                 }
4230             }
4231             else {
4232
4233                 /* Here the string isn't utf8, or is utf8 and only ascii
4234                  * characters are to match \w.  In the latter case looking at
4235                  * the byte just prior to the current one may be just the final
4236                  * byte of a multi-byte character.  This is ok.  There are two
4237                  * cases:
4238                  * 1) it is a single byte character, and then the test is doing
4239                  *      just what it's supposed to.
4240                  * 2) it is a multi-byte character, in which case the final
4241                  *      byte is never mistakable for ASCII, and so the test
4242                  *      will say it is not a word character, which is the
4243                  *      correct answer. */
4244                 ln = (locinput != PL_bostr) ?
4245                     UCHARAT(locinput - 1) : '\n';
4246                 switch (FLAGS(scan)) {
4247                     case REGEX_UNICODE_CHARSET:
4248                         ln = isWORDCHAR_L1(ln);
4249                         n = NEXTCHR_IS_EOS ? 0 : isWORDCHAR_L1(nextchr);
4250                         break;
4251                     case REGEX_LOCALE_CHARSET:
4252                         ln = isWORDCHAR_LC(ln);
4253                         n = NEXTCHR_IS_EOS ? 0 : isWORDCHAR_LC(nextchr);
4254                         break;
4255                     case REGEX_DEPENDS_CHARSET:
4256                         ln = isWORDCHAR(ln);
4257                         n = NEXTCHR_IS_EOS ? 0 : isWORDCHAR(nextchr);
4258                         break;
4259                     case REGEX_ASCII_RESTRICTED_CHARSET:
4260                     case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
4261                         ln = isWORDCHAR_A(ln);
4262                         n = NEXTCHR_IS_EOS ? 0 : isWORDCHAR_A(nextchr);
4263                         break;
4264                     default:
4265                         Perl_croak(aTHX_ "panic: Unexpected FLAGS %u in op %u", FLAGS(scan), OP(scan));
4266                         break;
4267                 }
4268             }
4269             /* Note requires that all BOUNDs be lower than all NBOUNDs in
4270              * regcomp.sym */
4271             if (((!ln) == (!n)) == (OP(scan) < NBOUND))
4272                     sayNO;
4273             break;
4274
4275         case ANYOF:  /*  /[abc]/       */
4276         case ANYOF_WARN_SUPER:
4277             if (NEXTCHR_IS_EOS)
4278                 sayNO;
4279             if (utf8_target) {
4280                 if (!reginclass(rex, scan, (U8*)locinput, utf8_target))
4281                     sayNO;
4282                 locinput += UTF8SKIP(locinput);
4283             }
4284             else {
4285                 if (!REGINCLASS(rex, scan, (U8*)locinput))
4286                     sayNO;
4287                 locinput++;
4288             }
4289             break;
4290
4291         /* The argument (FLAGS) to all the POSIX node types is the class number
4292          * */
4293
4294         case NPOSIXL:   /* \W or [:^punct:] etc. under /l */
4295             to_complement = 1;
4296             /* FALLTHROUGH */
4297
4298         case POSIXL:    /* \w or [:punct:] etc. under /l */
4299             if (NEXTCHR_IS_EOS)
4300                 sayNO;
4301
4302             /* The locale hasn't influenced the outcome before this, so defer
4303              * tainting until now */
4304             RX_MATCH_TAINTED_on(reginfo->prog);
4305
4306             /* Use isFOO_lc() for characters within Latin1.  (Note that
4307              * UTF8_IS_INVARIANT works even on non-UTF-8 strings, or else
4308              * wouldn't be invariant) */
4309             if (UTF8_IS_INVARIANT(nextchr) || ! utf8_target) {
4310                 if (! (to_complement ^ cBOOL(isFOO_lc(FLAGS(scan), (U8) nextchr)))) {
4311                     sayNO;
4312                 }
4313             }
4314             else if (UTF8_IS_DOWNGRADEABLE_START(nextchr)) {
4315                 if (! (to_complement ^ cBOOL(isFOO_lc(FLAGS(scan),
4316                                         (U8) TWO_BYTE_UTF8_TO_UNI(nextchr,
4317                                                             *(locinput + 1))))))
4318                 {
4319                     sayNO;
4320                 }
4321             }
4322             else { /* Here, must be an above Latin-1 code point */
4323                 goto utf8_posix_not_eos;
4324             }
4325
4326             /* Here, must be utf8 */
4327             locinput += UTF8SKIP(locinput);
4328             break;
4329
4330         case NPOSIXD:   /* \W or [:^punct:] etc. under /d */
4331             to_complement = 1;
4332             /* FALLTHROUGH */
4333
4334         case POSIXD:    /* \w or [:punct:] etc. under /d */
4335             if (utf8_target) {
4336                 goto utf8_posix;
4337             }
4338             goto posixa;
4339
4340         case NPOSIXA:   /* \W or [:^punct:] etc. under /a */
4341
4342             if (NEXTCHR_IS_EOS) {
4343                 sayNO;
4344             }
4345
4346             /* All UTF-8 variants match */
4347             if (! UTF8_IS_INVARIANT(nextchr)) {
4348                 goto increment_locinput;
4349             }
4350
4351             to_complement = 1;
4352             /* FALLTHROUGH */
4353
4354         case POSIXA:    /* \w or [:punct:] etc. under /a */
4355
4356           posixa:
4357             /* We get here through POSIXD, NPOSIXD, and NPOSIXA when not in
4358              * UTF-8, and also from NPOSIXA even in UTF-8 when the current
4359              * character is a single byte */
4360
4361             if (NEXTCHR_IS_EOS
4362                 || ! (to_complement ^ cBOOL(_generic_isCC_A(nextchr,
4363                                                             FLAGS(scan)))))
4364             {
4365                 sayNO;
4366             }
4367
4368             /* Here we are either not in utf8, or we matched a utf8-invariant,
4369              * so the next char is the next byte */
4370             locinput++;
4371             break;
4372
4373         case NPOSIXU:   /* \W or [:^punct:] etc. under /u */
4374             to_complement = 1;
4375             /* FALLTHROUGH */
4376
4377         case POSIXU:    /* \w or [:punct:] etc. under /u */
4378           utf8_posix:
4379             if (NEXTCHR_IS_EOS) {
4380                 sayNO;
4381             }
4382           utf8_posix_not_eos:
4383
4384             /* Use _generic_isCC() for characters within Latin1.  (Note that
4385              * UTF8_IS_INVARIANT works even on non-UTF-8 strings, or else
4386              * wouldn't be invariant) */
4387             if (UTF8_IS_INVARIANT(nextchr) || ! utf8_target) {
4388                 if (! (to_complement ^ cBOOL(_generic_isCC(nextchr,
4389                                                            FLAGS(scan)))))
4390                 {
4391                     sayNO;
4392                 }
4393                 locinput++;
4394             }
4395             else if (UTF8_IS_DOWNGRADEABLE_START(nextchr)) {
4396                 if (! (to_complement
4397                        ^ cBOOL(_generic_isCC(TWO_BYTE_UTF8_TO_UNI(nextchr,
4398                                                                *(locinput + 1)),
4399                                               FLAGS(scan)))))
4400                 {
4401                     sayNO;
4402                 }
4403                 locinput += 2;
4404             }
4405             else {  /* Handle above Latin-1 code points */
4406                 classnum = (_char_class_number) FLAGS(scan);
4407                 if (classnum < _FIRST_NON_SWASH_CC) {
4408
4409                     /* Here, uses a swash to find such code points.  Load if if
4410                      * not done already */
4411                     if (! PL_utf8_swash_ptrs[classnum]) {
4412                         U8 flags = _CORE_SWASH_INIT_ACCEPT_INVLIST;
4413                         PL_utf8_swash_ptrs[classnum]
4414                                 = _core_swash_init("utf8",
4415                                         swash_property_names[classnum],
4416                                         &PL_sv_undef, 1, 0, NULL, &flags);
4417                     }
4418                     if (! (to_complement
4419                            ^ cBOOL(swash_fetch(PL_utf8_swash_ptrs[classnum],
4420                                                (U8 *) locinput, TRUE))))
4421                     {
4422                         sayNO;
4423                     }
4424                 }
4425                 else {  /* Here, uses macros to find above Latin-1 code points */
4426                     switch (classnum) {
4427                         case _CC_ENUM_SPACE:    /* XXX would require separate
4428                                                    code if we revert the change
4429                                                    of \v matching this */
4430                         case _CC_ENUM_PSXSPC:
4431                             if (! (to_complement
4432                                         ^ cBOOL(is_XPERLSPACE_high(locinput))))
4433                             {
4434                                 sayNO;
4435                             }
4436                             break;
4437                         case _CC_ENUM_BLANK:
4438                             if (! (to_complement
4439                                             ^ cBOOL(is_HORIZWS_high(locinput))))
4440                             {
4441                                 sayNO;
4442                             }
4443                             break;
4444                         case _CC_ENUM_XDIGIT:
4445                             if (! (to_complement
4446                                             ^ cBOOL(is_XDIGIT_high(locinput))))
4447                             {
4448                                 sayNO;
4449                             }
4450                             break;
4451                         case _CC_ENUM_VERTSPACE:
4452                             if (! (to_complement
4453                                             ^ cBOOL(is_VERTWS_high(locinput))))
4454                             {
4455                                 sayNO;
4456                             }
4457                             break;
4458                         default:    /* The rest, e.g. [:cntrl:], can't match
4459                                        above Latin1 */
4460                             if (! to_complement) {
4461                                 sayNO;
4462                             }
4463                             break;
4464                     }
4465                 }
4466                 locinput += UTF8SKIP(locinput);
4467             }
4468             break;
4469
4470         case CLUMP: /* Match \X: logical Unicode character.  This is defined as
4471                        a Unicode extended Grapheme Cluster */
4472             /* From http://www.unicode.org/reports/tr29 (5.2 version).  An
4473               extended Grapheme Cluster is:
4474
4475             CR LF
4476             | Prepend* Begin Extend*
4477             | .
4478
4479             Begin is:           ( Special_Begin | ! Control )
4480             Special_Begin is:   ( Regional-Indicator+ | Hangul-syllable )
4481             Extend is:          ( Grapheme_Extend | Spacing_Mark )
4482             Control is:         [ GCB_Control | CR | LF ]
4483             Hangul-syllable is: ( T+ | ( L* ( L | ( LVT | ( V | LV ) V* ) T* ) ))
4484
4485                If we create a 'Regular_Begin' = Begin - Special_Begin, then
4486                we can rewrite
4487
4488                    Begin is ( Regular_Begin + Special Begin )
4489
4490                It turns out that 98.4% of all Unicode code points match
4491                Regular_Begin.  Doing it this way eliminates a table match in
4492                the previous implementation for almost all Unicode code points.
4493
4494                There is a subtlety with Prepend* which showed up in testing.
4495                Note that the Begin, and only the Begin is required in:
4496                 | Prepend* Begin Extend*
4497                Also, Begin contains '! Control'.  A Prepend must be a
4498                '!  Control', which means it must also be a Begin.  What it
4499                comes down to is that if we match Prepend* and then find no
4500                suitable Begin afterwards, that if we backtrack the last
4501                Prepend, that one will be a suitable Begin.
4502             */
4503
4504             if (NEXTCHR_IS_EOS)
4505                 sayNO;
4506             if  (! utf8_target) {
4507
4508                 /* Match either CR LF  or '.', as all the other possibilities
4509                  * require utf8 */
4510                 locinput++;         /* Match the . or CR */
4511                 if (nextchr == '\r' /* And if it was CR, and the next is LF,
4512                                        match the LF */
4513                     && locinput < PL_regeol
4514                     && UCHARAT(locinput) == '\n')
4515                 {
4516                     locinput++;
4517                 }
4518             }
4519             else {
4520
4521                 /* Utf8: See if is ( CR LF ); already know that locinput <
4522                  * PL_regeol, so locinput+1 is in bounds */
4523                 if ( nextchr == '\r' && locinput+1 < PL_regeol
4524                      && UCHARAT(locinput + 1) == '\n')
4525                 {
4526                     locinput += 2;
4527                 }
4528                 else {
4529                     STRLEN len;
4530
4531                     /* In case have to backtrack to beginning, then match '.' */
4532                     char *starting = locinput;
4533
4534                     /* In case have to backtrack the last prepend */
4535                     char *previous_prepend = NULL;
4536
4537                     LOAD_UTF8_CHARCLASS_GCB();
4538
4539                     /* Match (prepend)*   */
4540                     while (locinput < PL_regeol
4541                            && (len = is_GCB_Prepend_utf8(locinput)))
4542                     {
4543                         previous_prepend = locinput;
4544                         locinput += len;
4545                     }
4546
4547                     /* As noted above, if we matched a prepend character, but
4548                      * the next thing won't match, back off the last prepend we
4549                      * matched, as it is guaranteed to match the begin */
4550                     if (previous_prepend
4551                         && (locinput >=  PL_regeol
4552                             || (! swash_fetch(PL_utf8_X_regular_begin,
4553                                              (U8*)locinput, utf8_target)
4554                                  && ! is_GCB_SPECIAL_BEGIN_START_utf8(locinput)))
4555                         )
4556                     {
4557                         locinput = previous_prepend;
4558                     }
4559
4560                     /* Note that here we know PL_regeol > locinput, as we
4561                      * tested that upon input to this switch case, and if we
4562                      * moved locinput forward, we tested the result just above
4563                      * and it either passed, or we backed off so that it will
4564                      * now pass */
4565                     if (swash_fetch(PL_utf8_X_regular_begin,
4566                                     (U8*)locinput, utf8_target)) {
4567                         locinput += UTF8SKIP(locinput);
4568                     }
4569                     else if (! is_GCB_SPECIAL_BEGIN_START_utf8(locinput)) {
4570
4571                         /* Here did not match the required 'Begin' in the
4572                          * second term.  So just match the very first
4573                          * character, the '.' of the final term of the regex */
4574                         locinput = starting + UTF8SKIP(starting);
4575                         goto exit_utf8;
4576                     } else {
4577
4578                         /* Here is a special begin.  It can be composed of
4579                          * several individual characters.  One possibility is
4580                          * RI+ */
4581                         if ((len = is_GCB_RI_utf8(locinput))) {
4582                             locinput += len;
4583                             while (locinput < PL_regeol
4584                                    && (len = is_GCB_RI_utf8(locinput)))
4585                             {
4586                                 locinput += len;
4587                             }
4588                         } else if ((len = is_GCB_T_utf8(locinput))) {
4589                             /* Another possibility is T+ */
4590                             locinput += len;
4591                             while (locinput < PL_regeol
4592                                 && (len = is_GCB_T_utf8(locinput)))
4593                             {
4594                                 locinput += len;
4595                             }
4596                         } else {
4597
4598                             /* Here, neither RI+ nor T+; must be some other
4599                              * Hangul.  That means it is one of the others: L,
4600                              * LV, LVT or V, and matches:
4601                              * L* (L | LVT T* | V * V* T* | LV  V* T*) */
4602
4603                             /* Match L*           */
4604                             while (locinput < PL_regeol
4605                                    && (len = is_GCB_L_utf8(locinput)))
4606                             {
4607                                 locinput += len;
4608                             }
4609
4610                             /* Here, have exhausted L*.  If the next character
4611                              * is not an LV, LVT nor V, it means we had to have
4612                              * at least one L, so matches L+ in the original
4613                              * equation, we have a complete hangul syllable.
4614                              * Are done. */
4615
4616                             if (locinput < PL_regeol
4617                                 && is_GCB_LV_LVT_V_utf8(locinput))
4618                             {
4619                                 /* Otherwise keep going.  Must be LV, LVT or V.
4620                                  * See if LVT, by first ruling out V, then LV */
4621                                 if (! is_GCB_V_utf8(locinput)
4622                                         /* All but every TCount one is LV */
4623                                     && (valid_utf8_to_uvchr((U8 *) locinput,
4624                                                                          NULL)
4625                                                                         - SBASE)
4626                                         % TCount != 0)
4627                                 {
4628                                     locinput += UTF8SKIP(locinput);
4629                                 } else {
4630
4631                                     /* Must be  V or LV.  Take it, then match
4632                                      * V*     */
4633                                     locinput += UTF8SKIP(locinput);
4634                                     while (locinput < PL_regeol
4635                                            && (len = is_GCB_V_utf8(locinput)))
4636                                     {
4637                                         locinput += len;
4638                                     }
4639                                 }
4640
4641                                 /* And any of LV, LVT, or V can be followed
4642                                  * by T*            */
4643                                 while (locinput < PL_regeol
4644                                        && (len = is_GCB_T_utf8(locinput)))
4645                                 {
4646                                     locinput += len;
4647                                 }
4648                             }
4649                         }
4650                     }
4651
4652                     /* Match any extender */
4653                     while (locinput < PL_regeol
4654                             && swash_fetch(PL_utf8_X_extend,
4655                                             (U8*)locinput, utf8_target))
4656                     {
4657                         locinput += UTF8SKIP(locinput);
4658                     }
4659                 }
4660             exit_utf8:
4661                 if (locinput > PL_regeol) sayNO;
4662             }
4663             break;
4664             
4665         case NREFFL:  /*  /\g{name}/il  */
4666         {   /* The capture buffer cases.  The ones beginning with N for the
4667                named buffers just convert to the equivalent numbered and
4668                pretend they were called as the corresponding numbered buffer
4669                op.  */
4670             /* don't initialize these in the declaration, it makes C++
4671                unhappy */
4672             char *s;
4673             char type;
4674             re_fold_t folder;
4675             const U8 *fold_array;
4676             UV utf8_fold_flags;
4677
4678             RX_MATCH_TAINTED_on(reginfo->prog);
4679             folder = foldEQ_locale;
4680             fold_array = PL_fold_locale;
4681             type = REFFL;
4682             utf8_fold_flags = FOLDEQ_UTF8_LOCALE;
4683             goto do_nref;
4684
4685         case NREFFA:  /*  /\g{name}/iaa  */
4686             folder = foldEQ_latin1;
4687             fold_array = PL_fold_latin1;
4688             type = REFFA;
4689             utf8_fold_flags = FOLDEQ_UTF8_NOMIX_ASCII;
4690             goto do_nref;
4691
4692         case NREFFU:  /*  /\g{name}/iu  */
4693             folder = foldEQ_latin1;
4694             fold_array = PL_fold_latin1;
4695             type = REFFU;
4696             utf8_fold_flags = 0;
4697             goto do_nref;
4698
4699         case NREFF:  /*  /\g{name}/i  */
4700             folder = foldEQ;
4701             fold_array = PL_fold;
4702             type = REFF;
4703             utf8_fold_flags = 0;
4704             goto do_nref;
4705
4706         case NREF:  /*  /\g{name}/   */
4707             type = REF;
4708             folder = NULL;
4709             fold_array = NULL;
4710             utf8_fold_flags = 0;
4711           do_nref:
4712
4713             /* For the named back references, find the corresponding buffer
4714              * number */
4715             n = reg_check_named_buff_matched(rex,scan);
4716
4717             if ( ! n ) {
4718                 sayNO;
4719             }
4720             goto do_nref_ref_common;
4721
4722         case REFFL:  /*  /\1/il  */
4723             RX_MATCH_TAINTED_on(reginfo->prog);
4724             folder = foldEQ_locale;
4725             fold_array = PL_fold_locale;
4726             utf8_fold_flags = FOLDEQ_UTF8_LOCALE;
4727             goto do_ref;
4728
4729         case REFFA:  /*  /\1/iaa  */
4730             folder = foldEQ_latin1;
4731             fold_array = PL_fold_latin1;
4732             utf8_fold_flags = FOLDEQ_UTF8_NOMIX_ASCII;
4733             goto do_ref;
4734
4735         case REFFU:  /*  /\1/iu  */
4736             folder = foldEQ_latin1;
4737             fold_array = PL_fold_latin1;
4738             utf8_fold_flags = 0;
4739             goto do_ref;
4740
4741         case REFF:  /*  /\1/i  */
4742             folder = foldEQ;
4743             fold_array = PL_fold;
4744             utf8_fold_flags = 0;
4745             goto do_ref;
4746
4747         case REF:  /*  /\1/    */
4748             folder = NULL;
4749             fold_array = NULL;
4750             utf8_fold_flags = 0;
4751
4752           do_ref:
4753             type = OP(scan);
4754             n = ARG(scan);  /* which paren pair */
4755
4756           do_nref_ref_common:
4757             ln = rex->offs[n].start;
4758             PL_reg_leftiter = PL_reg_maxiter;           /* Void cache */
4759             if (rex->lastparen < n || ln == -1)
4760                 sayNO;                  /* Do not match unless seen CLOSEn. */
4761             if (ln == rex->offs[n].end)
4762                 break;
4763
4764             s = PL_bostr + ln;
4765             if (type != REF     /* REF can do byte comparison */
4766                 && (utf8_target || type == REFFU))
4767             { /* XXX handle REFFL better */
4768                 char * limit = PL_regeol;
4769
4770                 /* This call case insensitively compares the entire buffer
4771                     * at s, with the current input starting at locinput, but
4772                     * not going off the end given by PL_regeol, and returns in
4773                     * <limit> upon success, how much of the current input was
4774                     * matched */
4775                 if (! foldEQ_utf8_flags(s, NULL, rex->offs[n].end - ln, utf8_target,
4776                                     locinput, &limit, 0, utf8_target, utf8_fold_flags))
4777                 {
4778                     sayNO;
4779                 }
4780                 locinput = limit;
4781                 break;
4782             }
4783
4784             /* Not utf8:  Inline the first character, for speed. */
4785             if (!NEXTCHR_IS_EOS &&
4786                 UCHARAT(s) != nextchr &&
4787                 (type == REF ||
4788                  UCHARAT(s) != fold_array[nextchr]))
4789                 sayNO;
4790             ln = rex->offs[n].end - ln;
4791             if (locinput + ln > PL_regeol)
4792                 sayNO;
4793             if (ln > 1 && (type == REF
4794                            ? memNE(s, locinput, ln)
4795                            : ! folder(s, locinput, ln)))
4796                 sayNO;
4797             locinput += ln;
4798             break;
4799         }
4800
4801         case NOTHING: /* null op; e.g. the 'nothing' following
4802                        * the '*' in m{(a+|b)*}' */
4803             break;
4804         case TAIL: /* placeholder while compiling (A|B|C) */
4805             break;
4806
4807         case BACK: /* ??? doesn't appear to be used ??? */
4808             break;
4809
4810 #undef  ST
4811 #define ST st->u.eval
4812         {
4813             SV *ret;
4814             REGEXP *re_sv;
4815             regexp *re;
4816             regexp_internal *rei;
4817             regnode *startpoint;
4818
4819         case GOSTART: /*  (?R)  */
4820         case GOSUB: /*    /(...(?1))/   /(...(?&foo))/   */
4821             if (cur_eval && cur_eval->locinput==locinput) {
4822                 if (cur_eval->u.eval.close_paren == (U32)ARG(scan)) 
4823                     Perl_croak(aTHX_ "Infinite recursion in regex");
4824                 if ( ++nochange_depth > max_nochange_depth )
4825                     Perl_croak(aTHX_ 
4826                         "Pattern subroutine nesting without pos change"
4827                         " exceeded limit in regex");
4828             } else {
4829                 nochange_depth = 0;
4830             }
4831             re_sv = rex_sv;
4832             re = rex;
4833             rei = rexi;
4834             if (OP(scan)==GOSUB) {
4835                 startpoint = scan + ARG2L(scan);
4836                 ST.close_paren = ARG(scan);
4837             } else {
4838                 startpoint = rei->program+1;
4839                 ST.close_paren = 0;
4840             }
4841             goto eval_recurse_doit;
4842             assert(0); /* NOTREACHED */
4843
4844         case EVAL:  /*   /(?{A})B/   /(??{A})B/  and /(?(?{A})X|Y)B/   */        
4845             if (cur_eval && cur_eval->locinput==locinput) {
4846                 if ( ++nochange_depth > max_nochange_depth )
4847                     Perl_croak(aTHX_ "EVAL without pos change exceeded limit in regex");
4848             } else {
4849                 nochange_depth = 0;
4850             }    
4851             {
4852                 /* execute the code in the {...} */
4853
4854                 dSP;
4855                 IV before;
4856                 OP * const oop = PL_op;
4857                 COP * const ocurcop = PL_curcop;
4858                 OP *nop;
4859                 char *saved_regeol = PL_regeol;
4860                 struct re_save_state saved_state;
4861                 CV *newcv;
4862
4863                 /* save *all* paren positions */
4864                 regcppush(rex, 0, maxopenparen);
4865                 REGCP_SET(runops_cp);
4866
4867                 /* To not corrupt the existing regex state while executing the
4868                  * eval we would normally put it on the save stack, like with
4869                  * save_re_context. However, re-evals have a weird scoping so we
4870                  * can't just add ENTER/LEAVE here. With that, things like
4871                  *
4872                  *    (?{$a=2})(a(?{local$a=$a+1}))*aak*c(?{$b=$a})
4873                  *
4874                  * would break, as they expect the localisation to be unwound
4875                  * only when the re-engine backtracks through the bit that
4876                  * localised it.
4877                  *
4878                  * What we do instead is just saving the state in a local c
4879                  * variable.
4880                  */
4881                 Copy(&PL_reg_state, &saved_state, 1, struct re_save_state);
4882
4883                 if (!caller_cv)
4884                     caller_cv = find_runcv(NULL);
4885
4886                 n = ARG(scan);
4887
4888                 if (rexi->data->what[n] == 'r') { /* code from an external qr */
4889                     newcv = (ReANY(
4890                                                 (REGEXP*)(rexi->data->data[n])
4891                                             ))->qr_anoncv
4892                                         ;
4893                     nop = (OP*)rexi->data->data[n+1];
4894                 }
4895                 else if (rexi->data->what[n] == 'l') { /* literal code */
4896                     newcv = caller_cv;
4897                     nop = (OP*)rexi->data->data[n];
4898                     assert(CvDEPTH(newcv));
4899                 }
4900                 else {
4901                     /* literal with own CV */
4902                     assert(rexi->data->what[n] == 'L');
4903                     newcv = rex->qr_anoncv;
4904                     nop = (OP*)rexi->data->data[n];
4905                 }
4906
4907                 /* normally if we're about to execute code from the same
4908                  * CV that we used previously, we just use the existing
4909                  * CX stack entry. However, its possible that in the
4910                  * meantime we may have backtracked, popped from the save
4911                  * stack, and undone the SAVECOMPPAD(s) associated with
4912                  * PUSH_MULTICALL; in which case PL_comppad no longer
4913                  * points to newcv's pad. */
4914                 if (newcv != last_pushed_cv || PL_comppad != last_pad)
4915                 {
4916                     I32 depth = (newcv == caller_cv) ? 0 : 1;
4917                     if (last_pushed_cv) {
4918                         CHANGE_MULTICALL_WITHDEPTH(newcv, depth);
4919                     }
4920                     else {
4921                         PUSH_MULTICALL_WITHDEPTH(newcv, depth);
4922                     }
4923                     last_pushed_cv = newcv;
4924                 }
4925                 else {
4926                     /* these assignments are just to silence compiler
4927                      * warnings */
4928                     multicall_cop = NULL;
4929                     newsp = NULL;
4930                 }
4931                 last_pad = PL_comppad;
4932
4933                 /* the initial nextstate you would normally execute
4934                  * at the start of an eval (which would cause error
4935                  * messages to come from the eval), may be optimised
4936                  * away from the execution path in the regex code blocks;
4937                  * so manually set PL_curcop to it initially */
4938                 {
4939                     OP *o = cUNOPx(nop)->op_first;
4940                     assert(o->op_type == OP_NULL);
4941                     if (o->op_targ == OP_SCOPE) {
4942                         o = cUNOPo->op_first;
4943                     }
4944                     else {
4945                         assert(o->op_targ == OP_LEAVE);
4946                         o = cUNOPo->op_first;
4947                         assert(o->op_type == OP_ENTER);
4948                         o = o->op_sibling;
4949                     }
4950
4951                     if (o->op_type != OP_STUB) {
4952                         assert(    o->op_type == OP_NEXTSTATE
4953                                 || o->op_type == OP_DBSTATE
4954                                 || (o->op_type == OP_NULL
4955                                     &&  (  o->op_targ == OP_NEXTSTATE
4956                                         || o->op_targ == OP_DBSTATE
4957                                         )
4958                                     )
4959                         );
4960                         PL_curcop = (COP*)o;
4961                     }
4962                 }
4963                 nop = nop->op_next;
4964
4965                 DEBUG_STATE_r( PerlIO_printf(Perl_debug_log, 
4966                     "  re EVAL PL_op=0x%"UVxf"\n", PTR2UV(nop)) );
4967
4968                 rex->offs[0].end = PL_reg_magic->mg_len = locinput - PL_bostr;
4969
4970                 if (sv_yes_mark) {
4971                     SV *sv_mrk = get_sv("REGMARK", 1);
4972                     sv_setsv(sv_mrk, sv_yes_mark);
4973                 }
4974
4975                 /* we don't use MULTICALL here as we want to call the
4976                  * first op of the block of interest, rather than the
4977                  * first op of the sub */
4978                 before = (IV)(SP-PL_stack_base);
4979                 PL_op = nop;
4980                 CALLRUNOPS(aTHX);                       /* Scalar context. */
4981                 SPAGAIN;
4982                 if ((IV)(SP-PL_stack_base) == before)
4983                     ret = &PL_sv_undef;   /* protect against empty (?{}) blocks. */
4984                 else {
4985                     ret = POPs;
4986                     PUTBACK;
4987                 }
4988
4989                 /* before restoring everything, evaluate the returned
4990                  * value, so that 'uninit' warnings don't use the wrong
4991                  * PL_op or pad. Also need to process any magic vars
4992                  * (e.g. $1) *before* parentheses are restored */
4993
4994                 PL_op = NULL;
4995
4996                 re_sv = NULL;
4997                 if (logical == 0)        /*   (?{})/   */
4998                     sv_setsv(save_scalar(PL_replgv), ret); /* $^R */
4999                 else if (logical == 1) { /*   /(?(?{...})X|Y)/    */
5000                     sw = cBOOL(SvTRUE(ret));
5001                     logical = 0;
5002                 }
5003                 else {                   /*  /(??{})  */
5004                     /*  if its overloaded, let the regex compiler handle
5005                      *  it; otherwise extract regex, or stringify  */
5006                     if (!SvAMAGIC(ret)) {
5007                         SV *sv = ret;
5008                         if (SvROK(sv))
5009                             sv = SvRV(sv);
5010                         if (SvTYPE(sv) == SVt_REGEXP)
5011                             re_sv = (REGEXP*) sv;
5012                         else if (SvSMAGICAL(sv)) {
5013                             MAGIC *mg = mg_find(sv, PERL_MAGIC_qr);
5014                             if (mg)
5015                                 re_sv = (REGEXP *) mg->mg_obj;
5016                         }
5017
5018                         /* force any magic, undef warnings here */
5019                         if (!re_sv) {
5020                             ret = sv_mortalcopy(ret);
5021                             (void) SvPV_force_nolen(ret);
5022                         }
5023                     }
5024
5025                 }
5026
5027                 Copy(&saved_state, &PL_reg_state, 1, struct re_save_state);
5028
5029                 /* *** Note that at this point we don't restore
5030                  * PL_comppad, (or pop the CxSUB) on the assumption it may
5031                  * be used again soon. This is safe as long as nothing
5032                  * in the regexp code uses the pad ! */
5033                 PL_op = oop;
5034                 PL_curcop = ocurcop;
5035                 PL_regeol = saved_regeol;
5036                 S_regcp_restore(aTHX_ rex, runops_cp, &maxopenparen);
5037
5038                 if (logical != 2)
5039                     break;
5040             }
5041
5042                 /* only /(??{})/  from now on */
5043                 logical = 0;
5044                 {
5045                     /* extract RE object from returned value; compiling if
5046                      * necessary */
5047
5048                     if (re_sv) {
5049                         re_sv = reg_temp_copy(NULL, re_sv);
5050                     }
5051                     else {
5052                         U32 pm_flags = 0;
5053
5054                         if (SvUTF8(ret) && IN_BYTES) {
5055                             /* In use 'bytes': make a copy of the octet
5056                              * sequence, but without the flag on */
5057                             STRLEN len;
5058                             const char *const p = SvPV(ret, len);
5059                             ret = newSVpvn_flags(p, len, SVs_TEMP);
5060                         }
5061                         if (rex->intflags & PREGf_USE_RE_EVAL)
5062                             pm_flags |= PMf_USE_RE_EVAL;
5063
5064                         /* if we got here, it should be an engine which
5065                          * supports compiling code blocks and stuff */
5066                         assert(rex->engine && rex->engine->op_comp);
5067                         assert(!(scan->flags & ~RXf_PMf_COMPILETIME));
5068                         re_sv = rex->engine->op_comp(aTHX_ &ret, 1, NULL,
5069                                     rex->engine, NULL, NULL,
5070                                     /* copy /msix etc to inner pattern */
5071                                     scan->flags,
5072                                     pm_flags);
5073
5074                         if (!(SvFLAGS(ret)
5075                               & (SVs_TEMP | SVs_PADTMP | SVf_READONLY
5076                                  | SVs_GMG))) {
5077                             /* This isn't a first class regexp. Instead, it's
5078                                caching a regexp onto an existing, Perl visible
5079                                scalar.  */
5080                             sv_magic(ret, MUTABLE_SV(re_sv), PERL_MAGIC_qr, 0, 0);
5081                         }
5082                         /* safe to do now that any $1 etc has been
5083                          * interpolated into the new pattern string and
5084                          * compiled */
5085                         S_regcp_restore(aTHX_ rex, runops_cp, &maxopenparen);
5086                     }
5087                     SAVEFREESV(re_sv);
5088                     re = ReANY(re_sv);
5089                 }
5090                 RXp_MATCH_COPIED_off(re);
5091                 re->subbeg = rex->subbeg;
5092                 re->sublen = rex->sublen;
5093                 re->suboffset = rex->suboffset;
5094                 re->subcoffset = rex->subcoffset;
5095                 rei = RXi_GET(re);
5096                 DEBUG_EXECUTE_r(
5097                     debug_start_match(re_sv, utf8_target, locinput, PL_regeol,
5098                         "Matching embedded");
5099                 );              
5100                 startpoint = rei->program + 1;
5101                 ST.close_paren = 0; /* only used for GOSUB */
5102
5103         eval_recurse_doit: /* Share code with GOSUB below this line */                          
5104                 /* run the pattern returned from (??{...}) */
5105
5106                 /* Save *all* the positions. */
5107                 ST.cp = regcppush(rex, 0, maxopenparen);
5108                 REGCP_SET(ST.lastcp);
5109                 
5110                 re->lastparen = 0;
5111                 re->lastcloseparen = 0;
5112
5113                 maxopenparen = 0;
5114
5115                 /* XXXX This is too dramatic a measure... */
5116                 PL_reg_maxiter = 0;
5117
5118                 ST.saved_utf8_pat = is_utf8_pat;
5119                 is_utf8_pat = cBOOL(RX_UTF8(re_sv));
5120
5121                 ST.prev_rex = rex_sv;
5122                 ST.prev_curlyx = cur_curlyx;
5123                 rex_sv = re_sv;
5124                 SET_reg_curpm(rex_sv);
5125                 rex = re;
5126                 rexi = rei;
5127                 cur_curlyx = NULL;
5128                 ST.B = next;
5129                 ST.prev_eval = cur_eval;
5130                 cur_eval = st;
5131                 /* now continue from first node in postoned RE */
5132                 PUSH_YES_STATE_GOTO(EVAL_AB, startpoint, locinput);
5133                 assert(0); /* NOTREACHED */
5134         }
5135
5136         case EVAL_AB: /* cleanup after a successful (??{A})B */
5137             /* note: this is called twice; first after popping B, then A */
5138             is_utf8_pat = ST.saved_utf8_pat;
5139             rex_sv = ST.prev_rex;
5140             SET_reg_curpm(rex_sv);
5141             rex = ReANY(rex_sv);
5142             rexi = RXi_GET(rex);
5143             regcpblow(ST.cp);
5144             cur_eval = ST.prev_eval;
5145             cur_curlyx = ST.prev_curlyx;
5146
5147             /* XXXX This is too dramatic a measure... */
5148             PL_reg_maxiter = 0;
5149             if ( nochange_depth )
5150                 nochange_depth--;
5151             sayYES;
5152
5153
5154         case EVAL_AB_fail: /* unsuccessfully ran A or B in (??{A})B */
5155             /* note: this is called twice; first after popping B, then A */
5156             is_utf8_pat = ST.saved_utf8_pat;
5157             rex_sv = ST.prev_rex;
5158             SET_reg_curpm(rex_sv);
5159             rex = ReANY(rex_sv);
5160             rexi = RXi_GET(rex); 
5161
5162             REGCP_UNWIND(ST.lastcp);
5163             regcppop(rex, &maxopenparen);
5164             cur_eval = ST.prev_eval;
5165             cur_curlyx = ST.prev_curlyx;
5166             /* XXXX This is too dramatic a measure... */
5167             PL_reg_maxiter = 0;
5168             if ( nochange_depth )
5169                 nochange_depth--;
5170             sayNO_SILENT;
5171 #undef ST
5172
5173         case OPEN: /*  (  */
5174             n = ARG(scan);  /* which paren pair */
5175             rex->offs[n].start_tmp = locinput - PL_bostr;
5176             if (n > maxopenparen)
5177                 maxopenparen = n;
5178             DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log,
5179                 "rex=0x%"UVxf" offs=0x%"UVxf": \\%"UVuf": set %"IVdf" tmp; maxopenparen=%"UVuf"\n",
5180                 PTR2UV(rex),
5181                 PTR2UV(rex->offs),
5182                 (UV)n,
5183                 (IV)rex->offs[n].start_tmp,
5184                 (UV)maxopenparen
5185             ));
5186             lastopen = n;
5187             break;
5188
5189 /* XXX really need to log other places start/end are set too */
5190 #define CLOSE_CAPTURE \
5191     rex->offs[n].start = rex->offs[n].start_tmp; \
5192     rex->offs[n].end = locinput - PL_bostr; \
5193     DEBUG_BUFFERS_r(PerlIO_printf(Perl_debug_log, \
5194         "rex=0x%"UVxf" offs=0x%"UVxf": \\%"UVuf": set %"IVdf"..%"IVdf"\n", \
5195         PTR2UV(rex), \
5196         PTR2UV(rex->offs), \
5197         (UV)n, \
5198         (IV)rex->offs[n].start, \
5199         (IV)rex->offs[n].end \
5200     ))
5201
5202         case CLOSE:  /*  )  */
5203             n = ARG(scan);  /* which paren pair */
5204             CLOSE_CAPTURE;
5205             if (n > rex->lastparen)
5206                 rex->lastparen = n;
5207             rex->lastcloseparen = n;
5208             if (cur_eval && cur_eval->u.eval.close_paren == n) {
5209                 goto fake_end;
5210             }    
5211             break;
5212
5213         case ACCEPT:  /*  (*ACCEPT)  */
5214             if (ARG(scan)){
5215                 regnode *cursor;
5216                 for (cursor=scan;
5217                      cursor && OP(cursor)!=END; 
5218                      cursor=regnext(cursor)) 
5219                 {
5220                     if ( OP(cursor)==CLOSE ){
5221                         n = ARG(cursor);
5222                         if ( n <= lastopen ) {
5223                             CLOSE_CAPTURE;
5224                             if (n > rex->lastparen)
5225                                 rex->lastparen = n;
5226                             rex->lastcloseparen = n;
5227                             if ( n == ARG(scan) || (cur_eval &&
5228                                 cur_eval->u.eval.close_paren == n))
5229                                 break;
5230                         }
5231                     }
5232                 }
5233             }
5234             goto fake_end;
5235             /*NOTREACHED*/          
5236
5237         case GROUPP:  /*  (?(1))  */
5238             n = ARG(scan);  /* which paren pair */
5239             sw = cBOOL(rex->lastparen >= n && rex->offs[n].end != -1);
5240             break;
5241
5242         case NGROUPP:  /*  (?(<name>))  */
5243             /* reg_check_named_buff_matched returns 0 for no match */
5244             sw = cBOOL(0 < reg_check_named_buff_matched(rex,scan));
5245             break;
5246
5247         case INSUBP:   /*  (?(R))  */
5248             n = ARG(scan);
5249             sw = (cur_eval && (!n || cur_eval->u.eval.close_paren == n));
5250             break;
5251
5252         case DEFINEP:  /*  (?(DEFINE))  */
5253             sw = 0;
5254             break;
5255
5256         case IFTHEN:   /*  (?(cond)A|B)  */
5257             PL_reg_leftiter = PL_reg_maxiter;           /* Void cache */
5258             if (sw)
5259                 next = NEXTOPER(NEXTOPER(scan));
5260             else {
5261                 next = scan + ARG(scan);
5262                 if (OP(next) == IFTHEN) /* Fake one. */
5263                     next = NEXTOPER(NEXTOPER(next));
5264             }
5265             break;
5266
5267         case LOGICAL:  /* modifier for EVAL and IFMATCH */
5268             logical = scan->flags;
5269             break;
5270
5271 /*******************************************************************
5272
5273 The CURLYX/WHILEM pair of ops handle the most generic case of the /A*B/
5274 pattern, where A and B are subpatterns. (For simple A, CURLYM or
5275 STAR/PLUS/CURLY/CURLYN are used instead.)
5276
5277 A*B is compiled as <CURLYX><A><WHILEM><B>
5278
5279 On entry to the subpattern, CURLYX is called. This pushes a CURLYX
5280 state, which contains the current count, initialised to -1. It also sets
5281 cur_curlyx to point to this state, with any previous value saved in the
5282 state block.
5283
5284 CURLYX then jumps straight to the WHILEM op, rather than executing A,
5285 since the pattern may possibly match zero times (i.e. it's a while {} loop
5286 rather than a do {} while loop).
5287
5288 Each entry to WHILEM represents a successful match of A. The count in the
5289 CURLYX block is incremented, another WHILEM state is pushed, and execution
5290 passes to A or B depending on greediness and the current count.
5291
5292 For example, if matching against the string a1a2a3b (where the aN are
5293 substrings that match /A/), then the match progresses as follows: (the
5294 pushed states are interspersed with the bits of strings matched so far):
5295
5296     <CURLYX cnt=-1>
5297     <CURLYX cnt=0><WHILEM>
5298     <CURLYX cnt=1><WHILEM> a1 <WHILEM>
5299     <CURLYX cnt=2><WHILEM> a1 <WHILEM> a2 <WHILEM>
5300     <CURLYX cnt=3><WHILEM> a1 <WHILEM> a2 <WHILEM> a3 <WHILEM>
5301     <CURLYX cnt=3><WHILEM> a1 <WHILEM> a2 <WHILEM> a3 <WHILEM> b
5302
5303 (Contrast this with something like CURLYM, which maintains only a single
5304 backtrack state:
5305
5306     <CURLYM cnt=0> a1
5307     a1 <CURLYM cnt=1> a2
5308     a1 a2 <CURLYM cnt=2> a3
5309     a1 a2 a3 <CURLYM cnt=3> b
5310 )
5311
5312 Each WHILEM state block marks a point to backtrack to upon partial failure
5313 of A or B, and also contains some minor state data related to that
5314 iteration.  The CURLYX block, pointed to by cur_curlyx, contains the
5315 overall state, such as the count, and pointers to the A and B ops.
5316
5317 This is complicated slightly by nested CURLYX/WHILEM's. Since cur_curlyx
5318 must always point to the *current* CURLYX block, the rules are:
5319
5320 When executing CURLYX, save the old cur_curlyx in the CURLYX state block,
5321 and set cur_curlyx to point the new block.
5322
5323 When popping the CURLYX block after a successful or unsuccessful match,
5324 restore the previous cur_curlyx.
5325
5326 When WHILEM is about to execute B, save the current cur_curlyx, and set it
5327 to the outer one saved in the CURLYX block.
5328
5329 When popping the WHILEM block after a successful or unsuccessful B match,
5330 restore the previous cur_curlyx.
5331
5332 Here's an example for the pattern (AI* BI)*BO
5333 I and O refer to inner and outer, C and W refer to CURLYX and WHILEM:
5334
5335 cur_
5336 curlyx backtrack stack
5337 ------ ---------------
5338 NULL   
5339 CO     <CO prev=NULL> <WO>
5340 CI     <CO prev=NULL> <WO> <CI prev=CO> <WI> ai 
5341 CO     <CO prev=NULL> <WO> <CI prev=CO> <WI> ai <WI prev=CI> bi 
5342 NULL   <CO prev=NULL> <WO> <CI prev=CO> <WI> ai <WI prev=CI> bi <WO prev=CO> bo
5343
5344 At this point the pattern succeeds, and we work back down the stack to
5345 clean up, restoring as we go:
5346
5347 CO     <CO prev=NULL> <WO> <CI prev=CO> <WI> ai <WI prev=CI> bi 
5348 CI     <CO prev=NULL> <WO> <CI prev=CO> <WI> ai 
5349 CO     <CO prev=NULL> <WO>
5350 NULL   
5351
5352 *******************************************************************/
5353
5354 #define ST st->u.curlyx
5355
5356         case CURLYX:    /* start of /A*B/  (for complex A) */
5357         {
5358             /* No need to save/restore up to this paren */
5359             I32 parenfloor = scan->flags;
5360             
5361             assert(next); /* keep Coverity happy */
5362             if (OP(PREVOPER(next)) == NOTHING) /* LONGJMP */
5363                 next += ARG(next);
5364
5365             /* XXXX Probably it is better to teach regpush to support
5366                parenfloor > maxopenparen ... */
5367             if (parenfloor > (I32)rex->lastparen)
5368                 parenfloor = rex->lastparen; /* Pessimization... */
5369
5370             ST.prev_curlyx= cur_curlyx;
5371             cur_curlyx = st;
5372             ST.cp = PL_savestack_ix;
5373
5374             /* these fields contain the state of the current curly.
5375              * they are accessed by subsequent WHILEMs */
5376             ST.parenfloor = parenfloor;
5377             ST.me = scan;
5378             ST.B = next;
5379             ST.minmod = minmod;
5380             minmod = 0;
5381             ST.count = -1;      /* this will be updated by WHILEM */
5382             ST.lastloc = NULL;  /* this will be updated by WHILEM */
5383
5384             PUSH_YES_STATE_GOTO(CURLYX_end, PREVOPER(next), locinput);
5385             assert(0); /* NOTREACHED */
5386         }
5387
5388         case CURLYX_end: /* just finished matching all of A*B */
5389             cur_curlyx = ST.prev_curlyx;
5390             sayYES;
5391             assert(0); /* NOTREACHED */
5392
5393         case CURLYX_end_fail: /* just failed to match all of A*B */
5394             regcpblow(ST.cp);
5395             cur_curlyx = ST.prev_curlyx;
5396             sayNO;
5397             assert(0); /* NOTREACHED */
5398
5399
5400 #undef ST
5401 #define ST st->u.whilem
5402
5403         case WHILEM:     /* just matched an A in /A*B/  (for complex A) */
5404         {
5405             /* see the discussion above about CURLYX/WHILEM */
5406             I32 n;
5407             int min = ARG1(cur_curlyx->u.curlyx.me);
5408             int max = ARG2(cur_curlyx->u.curlyx.me);
5409             regnode *A = NEXTOPER(cur_curlyx->u.curlyx.me) + EXTRA_STEP_2ARGS;
5410
5411             assert(cur_curlyx); /* keep Coverity happy */
5412             n = ++cur_curlyx->u.curlyx.count; /* how many A's matched */
5413             ST.save_lastloc = cur_curlyx->u.curlyx.lastloc;
5414             ST.cache_offset = 0;
5415             ST.cache_mask = 0;
5416             
5417
5418             DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
5419                   "%*s  whilem: matched %ld out of %d..%d\n",
5420                   REPORT_CODE_OFF+depth*2, "", (long)n, min, max)
5421             );
5422
5423             /* First just match a string of min A's. */
5424
5425             if (n < min) {
5426                 ST.cp = regcppush(rex, cur_curlyx->u.curlyx.parenfloor,
5427                                     maxopenparen);
5428                 cur_curlyx->u.curlyx.lastloc = locinput;
5429                 REGCP_SET(ST.lastcp);
5430
5431                 PUSH_STATE_GOTO(WHILEM_A_pre, A, locinput);
5432                 assert(0); /* NOTREACHED */
5433             }
5434
5435             /* If degenerate A matches "", assume A done. */
5436
5437             if (locinput == cur_curlyx->u.curlyx.lastloc) {
5438                 DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
5439                    "%*s  whilem: empty match detected, trying continuation...\n",
5440                    REPORT_CODE_OFF+depth*2, "")
5441                 );
5442                 goto do_whilem_B_max;
5443             }
5444
5445             /* super-linear cache processing */
5446
5447             if (scan->flags) {
5448
5449                 if (!PL_reg_maxiter) {
5450                     /* start the countdown: Postpone detection until we
5451                      * know the match is not *that* much linear. */
5452                     PL_reg_maxiter = (PL_regeol - PL_bostr + 1) * (scan->flags>>4);
5453                     /* possible overflow for long strings and many CURLYX's */
5454                     if (PL_reg_maxiter < 0)
5455                         PL_reg_maxiter = I32_MAX;
5456                     PL_reg_leftiter = PL_reg_maxiter;
5457                 }
5458
5459                 if (PL_reg_leftiter-- == 0) {
5460                     /* initialise cache */
5461                     const I32 size = (PL_reg_maxiter + 7)/8;
5462                     if (PL_reg_poscache) {
5463                         if ((I32)PL_reg_poscache_size < size) {
5464                             Renew(PL_reg_poscache, size, char);
5465                             PL_reg_poscache_size = size;
5466                         }
5467                         Zero(PL_reg_poscache, size, char);
5468                     }
5469                     else {
5470                         PL_reg_poscache_size = size;
5471                         Newxz(PL_reg_poscache, size, char);
5472                     }
5473                     DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
5474       "%swhilem: Detected a super-linear match, switching on caching%s...\n",
5475                               PL_colors[4], PL_colors[5])
5476                     );
5477                 }
5478
5479                 if (PL_reg_leftiter < 0) {
5480                     /* have we already failed at this position? */
5481                     I32 offset, mask;
5482                     offset  = (scan->flags & 0xf) - 1
5483                                 + (locinput - PL_bostr)  * (scan->flags>>4);
5484                     mask    = 1 << (offset % 8);
5485                     offset /= 8;
5486                     if (PL_reg_poscache[offset] & mask) {
5487                         DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
5488                             "%*s  whilem: (cache) already tried at this position...\n",
5489                             REPORT_CODE_OFF+depth*2, "")
5490                         );
5491                         sayNO; /* cache records failure */
5492                     }
5493                     ST.cache_offset = offset;
5494                     ST.cache_mask   = mask;
5495                 }
5496             }
5497
5498             /* Prefer B over A for minimal matching. */
5499
5500             if (cur_curlyx->u.curlyx.minmod) {
5501                 ST.save_curlyx = cur_curlyx;
5502                 cur_curlyx = cur_curlyx->u.curlyx.prev_curlyx;
5503                 ST.cp = regcppush(rex, ST.save_curlyx->u.curlyx.parenfloor,
5504                             maxopenparen);
5505                 REGCP_SET(ST.lastcp);
5506                 PUSH_YES_STATE_GOTO(WHILEM_B_min, ST.save_curlyx->u.curlyx.B,
5507                                     locinput);
5508                 assert(0); /* NOTREACHED */
5509             }
5510
5511             /* Prefer A over B for maximal matching. */
5512
5513             if (n < max) { /* More greed allowed? */
5514                 ST.cp = regcppush(rex, cur_curlyx->u.curlyx.parenfloor,
5515                             maxopenparen);
5516                 cur_curlyx->u.curlyx.lastloc = locinput;
5517                 REGCP_SET(ST.lastcp);
5518                 PUSH_STATE_GOTO(WHILEM_A_max, A, locinput);
5519                 assert(0); /* NOTREACHED */
5520             }
5521             goto do_whilem_B_max;
5522         }
5523         assert(0); /* NOTREACHED */
5524
5525         case WHILEM_B_min: /* just matched B in a minimal match */
5526         case WHILEM_B_max: /* just matched B in a maximal match */
5527             cur_curlyx = ST.save_curlyx;
5528             sayYES;
5529             assert(0); /* NOTREACHED */
5530
5531         case WHILEM_B_max_fail: /* just failed to match B in a maximal match */
5532             cur_curlyx = ST.save_curlyx;
5533             cur_curlyx->u.curlyx.lastloc = ST.save_lastloc;
5534             cur_curlyx->u.curlyx.count--;
5535             CACHEsayNO;
5536             assert(0); /* NOTREACHED */
5537
5538         case WHILEM_A_min_fail: /* just failed to match A in a minimal match */
5539             /* FALL THROUGH */
5540         case WHILEM_A_pre_fail: /* just failed to match even minimal A */
5541             REGCP_UNWIND(ST.lastcp);
5542             regcppop(rex, &maxopenparen);
5543             cur_curlyx->u.curlyx.lastloc = ST.save_lastloc;
5544             cur_curlyx->u.curlyx.count--;
5545             CACHEsayNO;
5546             assert(0); /* NOTREACHED */
5547
5548         case WHILEM_A_max_fail: /* just failed to match A in a maximal match */
5549             REGCP_UNWIND(ST.lastcp);
5550             regcppop(rex, &maxopenparen); /* Restore some previous $<digit>s? */
5551             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
5552                 "%*s  whilem: failed, trying continuation...\n",
5553                 REPORT_CODE_OFF+depth*2, "")
5554             );
5555           do_whilem_B_max:
5556             if (cur_curlyx->u.curlyx.count >= REG_INFTY
5557                 && ckWARN(WARN_REGEXP)
5558                 && !reginfo->warned)
5559             {
5560                 reginfo->warned = TRUE;
5561                 Perl_warner(aTHX_ packWARN(WARN_REGEXP),
5562                      "Complex regular subexpression recursion limit (%d) "
5563                      "exceeded",
5564                      REG_INFTY - 1);
5565             }
5566
5567             /* now try B */
5568             ST.save_curlyx = cur_curlyx;
5569             cur_curlyx = cur_curlyx->u.curlyx.prev_curlyx;
5570             PUSH_YES_STATE_GOTO(WHILEM_B_max, ST.save_curlyx->u.curlyx.B,
5571                                 locinput);
5572             assert(0); /* NOTREACHED */
5573
5574         case WHILEM_B_min_fail: /* just failed to match B in a minimal match */
5575             cur_curlyx = ST.save_curlyx;
5576             REGCP_UNWIND(ST.lastcp);
5577             regcppop(rex, &maxopenparen);
5578
5579             if (cur_curlyx->u.curlyx.count >= /*max*/ARG2(cur_curlyx->u.curlyx.me)) {
5580                 /* Maximum greed exceeded */
5581                 if (cur_curlyx->u.curlyx.count >= REG_INFTY
5582                     && ckWARN(WARN_REGEXP)
5583                     && !reginfo->warned)
5584                 {
5585                     reginfo->warned     = TRUE;
5586                     Perl_warner(aTHX_ packWARN(WARN_REGEXP),
5587                         "Complex regular subexpression recursion "
5588                         "limit (%d) exceeded",
5589                         REG_INFTY - 1);
5590                 }
5591                 cur_curlyx->u.curlyx.count--;
5592                 CACHEsayNO;
5593             }
5594
5595             DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
5596                 "%*s  trying longer...\n", REPORT_CODE_OFF+depth*2, "")
5597             );
5598             /* Try grabbing another A and see if it helps. */
5599             cur_curlyx->u.curlyx.lastloc = locinput;
5600             ST.cp = regcppush(rex, cur_curlyx->u.curlyx.parenfloor,
5601                             maxopenparen);
5602             REGCP_SET(ST.lastcp);
5603             PUSH_STATE_GOTO(WHILEM_A_min,
5604                 /*A*/ NEXTOPER(ST.save_curlyx->u.curlyx.me) + EXTRA_STEP_2ARGS,
5605                 locinput);
5606             assert(0); /* NOTREACHED */
5607
5608 #undef  ST
5609 #define ST st->u.branch
5610
5611         case BRANCHJ:       /*  /(...|A|...)/ with long next pointer */
5612             next = scan + ARG(scan);
5613             if (next == scan)
5614                 next = NULL;
5615             scan = NEXTOPER(scan);
5616             /* FALL THROUGH */
5617
5618         case BRANCH:        /*  /(...|A|...)/ */
5619             scan = NEXTOPER(scan); /* scan now points to inner node */
5620             ST.lastparen = rex->lastparen;
5621             ST.lastcloseparen = rex->lastcloseparen;
5622             ST.next_branch = next;
5623             REGCP_SET(ST.cp);
5624
5625             /* Now go into the branch */
5626             if (has_cutgroup) {
5627                 PUSH_YES_STATE_GOTO(BRANCH_next, scan, locinput);
5628             } else {
5629                 PUSH_STATE_GOTO(BRANCH_next, scan, locinput);
5630             }
5631             assert(0); /* NOTREACHED */
5632
5633         case CUTGROUP:  /*  /(*THEN)/  */
5634             sv_yes_mark = st->u.mark.mark_name = scan->flags ? NULL :
5635                 MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
5636             PUSH_STATE_GOTO(CUTGROUP_next, next, locinput);
5637             assert(0); /* NOTREACHED */
5638
5639         case CUTGROUP_next_fail:
5640             do_cutgroup = 1;
5641             no_final = 1;
5642             if (st->u.mark.mark_name)
5643                 sv_commit = st->u.mark.mark_name;
5644             sayNO;          
5645             assert(0); /* NOTREACHED */
5646
5647         case BRANCH_next:
5648             sayYES;
5649             assert(0); /* NOTREACHED */
5650
5651         case BRANCH_next_fail: /* that branch failed; try the next, if any */
5652             if (do_cutgroup) {
5653                 do_cutgroup = 0;
5654                 no_final = 0;
5655             }
5656             REGCP_UNWIND(ST.cp);
5657             UNWIND_PAREN(ST.lastparen, ST.lastcloseparen);
5658             scan = ST.next_branch;
5659             /* no more branches? */
5660             if (!scan || (OP(scan) != BRANCH && OP(scan) != BRANCHJ)) {
5661                 DEBUG_EXECUTE_r({
5662                     PerlIO_printf( Perl_debug_log,
5663                         "%*s  %sBRANCH failed...%s\n",
5664                         REPORT_CODE_OFF+depth*2, "", 
5665                         PL_colors[4],
5666                         PL_colors[5] );
5667                 });
5668                 sayNO_SILENT;
5669             }
5670             continue; /* execute next BRANCH[J] op */
5671             assert(0); /* NOTREACHED */
5672     
5673         case MINMOD: /* next op will be non-greedy, e.g. A*?  */
5674             minmod = 1;
5675             break;
5676
5677 #undef  ST
5678 #define ST st->u.curlym
5679
5680         case CURLYM:    /* /A{m,n}B/ where A is fixed-length */
5681
5682             /* This is an optimisation of CURLYX that enables us to push
5683              * only a single backtracking state, no matter how many matches
5684              * there are in {m,n}. It relies on the pattern being constant
5685              * length, with no parens to influence future backrefs
5686              */
5687
5688             ST.me = scan;
5689             scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
5690
5691             ST.lastparen      = rex->lastparen;
5692             ST.lastcloseparen = rex->lastcloseparen;
5693
5694             /* if paren positive, emulate an OPEN/CLOSE around A */
5695             if (ST.me->flags) {
5696                 U32 paren = ST.me->flags;
5697                 if (paren > maxopenparen)
5698                     maxopenparen = paren;
5699                 scan += NEXT_OFF(scan); /* Skip former OPEN. */
5700             }
5701             ST.A = scan;
5702             ST.B = next;
5703             ST.alen = 0;
5704             ST.count = 0;
5705             ST.minmod = minmod;
5706             minmod = 0;
5707             ST.c1 = CHRTEST_UNINIT;
5708             REGCP_SET(ST.cp);
5709
5710             if (!(ST.minmod ? ARG1(ST.me) : ARG2(ST.me))) /* min/max */
5711                 goto curlym_do_B;
5712
5713           curlym_do_A: /* execute the A in /A{m,n}B/  */
5714             PUSH_YES_STATE_GOTO(CURLYM_A, ST.A, locinput); /* match A */
5715             assert(0); /* NOTREACHED */
5716
5717         case CURLYM_A: /* we've just matched an A */
5718             ST.count++;
5719             /* after first match, determine A's length: u.curlym.alen */
5720             if (ST.count == 1) {
5721                 if (PL_reg_match_utf8) {
5722                     char *s = st->locinput;
5723                     while (s < locinput) {
5724                         ST.alen++;
5725                         s += UTF8SKIP(s);
5726                     }
5727                 }
5728                 else {
5729                     ST.alen = locinput - st->locinput;
5730                 }
5731                 if (ST.alen == 0)
5732                     ST.count = ST.minmod ? ARG1(ST.me) : ARG2(ST.me);
5733             }
5734             DEBUG_EXECUTE_r(
5735                 PerlIO_printf(Perl_debug_log,
5736                           "%*s  CURLYM now matched %"IVdf" times, len=%"IVdf"...\n",
5737                           (int)(REPORT_CODE_OFF+(depth*2)), "",
5738                           (IV) ST.count, (IV)ST.alen)
5739             );
5740
5741             if (cur_eval && cur_eval->u.eval.close_paren && 
5742                 cur_eval->u.eval.close_paren == (U32)ST.me->flags) 
5743                 goto fake_end;
5744                 
5745             {
5746                 I32 max = (ST.minmod ? ARG1(ST.me) : ARG2(ST.me));
5747                 if ( max == REG_INFTY || ST.count < max )
5748                     goto curlym_do_A; /* try to match another A */
5749             }
5750             goto curlym_do_B; /* try to match B */
5751
5752         case CURLYM_A_fail: /* just failed to match an A */
5753             REGCP_UNWIND(ST.cp);
5754
5755             if (ST.minmod || ST.count < ARG1(ST.me) /* min*/ 
5756                 || (cur_eval && cur_eval->u.eval.close_paren &&
5757                     cur_eval->u.eval.close_paren == (U32)ST.me->flags))
5758                 sayNO;
5759
5760           curlym_do_B: /* execute the B in /A{m,n}B/  */
5761             if (ST.c1 == CHRTEST_UNINIT) {
5762                 /* calculate c1 and c2 for possible match of 1st char
5763                  * following curly */
5764                 ST.c1 = ST.c2 = CHRTEST_VOID;
5765                 if (HAS_TEXT(ST.B) || JUMPABLE(ST.B)) {
5766                     regnode *text_node = ST.B;
5767                     if (! HAS_TEXT(text_node))
5768                         FIND_NEXT_IMPT(text_node);
5769                     /* this used to be 
5770                         
5771                         (HAS_TEXT(text_node) && PL_regkind[OP(text_node)] == EXACT)
5772                         
5773                         But the former is redundant in light of the latter.
5774                         
5775                         if this changes back then the macro for 
5776                         IS_TEXT and friends need to change.
5777                      */
5778                     if (PL_regkind[OP(text_node)] == EXACT) {
5779                         if (! S_setup_EXACTISH_ST_c1_c2(aTHX_
5780                            text_node, &ST.c1, ST.c1_utf8, &ST.c2, ST.c2_utf8,
5781                            is_utf8_pat))
5782                         {
5783                             sayNO;
5784                         }
5785                     }
5786                 }
5787             }
5788
5789             DEBUG_EXECUTE_r(
5790                 PerlIO_printf(Perl_debug_log,
5791                     "%*s  CURLYM trying tail with matches=%"IVdf"...\n",
5792                     (int)(REPORT_CODE_OFF+(depth*2)),
5793                     "", (IV)ST.count)
5794                 );
5795             if (! NEXTCHR_IS_EOS && ST.c1 != CHRTEST_VOID) {
5796                 if (! UTF8_IS_INVARIANT(nextchr) && utf8_target) {
5797                     if (memNE(locinput, ST.c1_utf8, UTF8SKIP(locinput))
5798                         && memNE(locinput, ST.c2_utf8, UTF8SKIP(locinput)))
5799                     {
5800                         /* simulate B failing */
5801                         DEBUG_OPTIMISE_r(
5802                             PerlIO_printf(Perl_debug_log,
5803                                 "%*s  CURLYM Fast bail next target=U+%"UVXf" c1=U+%"UVXf" c2=U+%"UVXf"\n",
5804                                 (int)(REPORT_CODE_OFF+(depth*2)),"",
5805                                 valid_utf8_to_uvchr((U8 *) locinput, NULL),
5806                                 valid_utf8_to_uvchr(ST.c1_utf8, NULL),
5807                                 valid_utf8_to_uvchr(ST.c2_utf8, NULL))
5808                         );
5809                         state_num = CURLYM_B_fail;
5810                         goto reenter_switch;
5811                     }
5812                 }
5813                 else if (nextchr != ST.c1 && nextchr != ST.c2) {
5814                     /* simulate B failing */
5815                     DEBUG_OPTIMISE_r(
5816                         PerlIO_printf(Perl_debug_log,
5817                             "%*s  CURLYM Fast bail next target=U+%X c1=U+%X c2=U+%X\n",
5818                             (int)(REPORT_CODE_OFF+(depth*2)),"",
5819                             (int) nextchr, ST.c1, ST.c2)
5820                     );
5821                     state_num = CURLYM_B_fail;
5822                     goto reenter_switch;
5823                 }
5824             }
5825
5826             if (ST.me->flags) {
5827                 /* emulate CLOSE: mark current A as captured */
5828                 I32 paren = ST.me->flags;
5829                 if (ST.count) {
5830                     rex->offs[paren].start
5831                         = HOPc(locinput, -ST.alen) - PL_bostr;
5832                     rex->offs[paren].end = locinput - PL_bostr;
5833                     if ((U32)paren > rex->lastparen)
5834                         rex->lastparen = paren;
5835                     rex->lastcloseparen = paren;
5836                 }
5837                 else
5838                     rex->offs[paren].end = -1;
5839                 if (cur_eval && cur_eval->u.eval.close_paren &&
5840                     cur_eval->u.eval.close_paren == (U32)ST.me->flags) 
5841                 {
5842                     if (ST.count) 
5843                         goto fake_end;
5844                     else
5845                         sayNO;
5846                 }
5847             }
5848             
5849             PUSH_STATE_GOTO(CURLYM_B, ST.B, locinput); /* match B */
5850             assert(0); /* NOTREACHED */
5851
5852         case CURLYM_B_fail: /* just failed to match a B */
5853             REGCP_UNWIND(ST.cp);
5854             UNWIND_PAREN(ST.lastparen, ST.lastcloseparen);
5855             if (ST.minmod) {
5856                 I32 max = ARG2(ST.me);
5857                 if (max != REG_INFTY && ST.count == max)
5858                     sayNO;
5859                 goto curlym_do_A; /* try to match a further A */
5860             }
5861             /* backtrack one A */
5862             if (ST.count == ARG1(ST.me) /* min */)
5863                 sayNO;
5864             ST.count--;
5865             SET_locinput(HOPc(locinput, -ST.alen));
5866             goto curlym_do_B; /* try to match B */
5867
5868 #undef ST
5869 #define ST st->u.curly
5870
5871 #define CURLY_SETPAREN(paren, success) \
5872     if (paren) { \
5873         if (success) { \
5874             rex->offs[paren].start = HOPc(locinput, -1) - PL_bostr; \
5875             rex->offs[paren].end = locinput - PL_bostr; \
5876             if (paren > rex->lastparen) \
5877                 rex->lastparen = paren; \
5878             rex->lastcloseparen = paren; \
5879         } \
5880         else { \
5881             rex->offs[paren].end = -1; \
5882             rex->lastparen      = ST.lastparen; \
5883             rex->lastcloseparen = ST.lastcloseparen; \
5884         } \
5885     }
5886
5887         case STAR:              /*  /A*B/ where A is width 1 char */
5888             ST.paren = 0;
5889             ST.min = 0;
5890             ST.max = REG_INFTY;
5891             scan = NEXTOPER(scan);
5892             goto repeat;
5893
5894         case PLUS:              /*  /A+B/ where A is width 1 char */
5895             ST.paren = 0;
5896             ST.min = 1;
5897             ST.max = REG_INFTY;
5898             scan = NEXTOPER(scan);
5899             goto repeat;
5900
5901         case CURLYN:            /*  /(A){m,n}B/ where A is width 1 char */
5902             ST.paren = scan->flags;     /* Which paren to set */
5903             ST.lastparen      = rex->lastparen;
5904             ST.lastcloseparen = rex->lastcloseparen;
5905             if (ST.paren > maxopenparen)
5906                 maxopenparen = ST.paren;
5907             ST.min = ARG1(scan);  /* min to match */
5908             ST.max = ARG2(scan);  /* max to match */
5909             if (cur_eval && cur_eval->u.eval.close_paren &&
5910                 cur_eval->u.eval.close_paren == (U32)ST.paren) {
5911                 ST.min=1;
5912                 ST.max=1;
5913             }
5914             scan = regnext(NEXTOPER(scan) + NODE_STEP_REGNODE);
5915             goto repeat;
5916
5917         case CURLY:             /*  /A{m,n}B/ where A is width 1 char */
5918             ST.paren = 0;
5919             ST.min = ARG1(scan);  /* min to match */
5920             ST.max = ARG2(scan);  /* max to match */
5921             scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
5922           repeat:
5923             /*
5924             * Lookahead to avoid useless match attempts
5925             * when we know what character comes next.
5926             *
5927             * Used to only do .*x and .*?x, but now it allows
5928             * for )'s, ('s and (?{ ... })'s to be in the way
5929             * of the quantifier and the EXACT-like node.  -- japhy
5930             */
5931
5932             assert(ST.min <= ST.max);
5933             if (! HAS_TEXT(next) && ! JUMPABLE(next)) {
5934                 ST.c1 = ST.c2 = CHRTEST_VOID;
5935             }
5936             else {
5937                 regnode *text_node = next;
5938
5939                 if (! HAS_TEXT(text_node)) 
5940                     FIND_NEXT_IMPT(text_node);
5941
5942                 if (! HAS_TEXT(text_node))
5943                     ST.c1 = ST.c2 = CHRTEST_VOID;
5944                 else {
5945                     if ( PL_regkind[OP(text_node)] != EXACT ) {
5946                         ST.c1 = ST.c2 = CHRTEST_VOID;
5947                     }
5948                     else {
5949                     
5950                     /*  Currently we only get here when 
5951                         
5952                         PL_rekind[OP(text_node)] == EXACT
5953                     
5954                         if this changes back then the macro for IS_TEXT and 
5955                         friends need to change. */
5956                         if (! S_setup_EXACTISH_ST_c1_c2(aTHX_
5957                            text_node, &ST.c1, ST.c1_utf8, &ST.c2, ST.c2_utf8,
5958                            is_utf8_pat))
5959                         {
5960                             sayNO;
5961                         }
5962                     }
5963                 }
5964             }
5965
5966             ST.A = scan;
5967             ST.B = next;
5968             if (minmod) {
5969                 char *li = locinput;
5970                 minmod = 0;
5971                 if (ST.min &&
5972                         regrepeat(rex, &li, ST.A, ST.min, depth, is_utf8_pat)
5973                             < ST.min)
5974                     sayNO;
5975                 SET_locinput(li);
5976                 ST.count = ST.min;
5977                 REGCP_SET(ST.cp);
5978                 if (ST.c1 == CHRTEST_VOID)
5979                     goto curly_try_B_min;
5980
5981                 ST.oldloc = locinput;
5982
5983                 /* set ST.maxpos to the furthest point along the
5984                  * string that could possibly match */
5985                 if  (ST.max == REG_INFTY) {
5986                     ST.maxpos = PL_regeol - 1;
5987                     if (utf8_target)
5988                         while (UTF8_IS_CONTINUATION(*(U8*)ST.maxpos))
5989                             ST.maxpos--;
5990                 }
5991                 else if (utf8_target) {
5992                     int m = ST.max - ST.min;
5993                     for (ST.maxpos = locinput;
5994                          m >0 && ST.maxpos < PL_regeol; m--)
5995                         ST.maxpos += UTF8SKIP(ST.maxpos);
5996                 }
5997                 else {
5998                     ST.maxpos = locinput + ST.max - ST.min;
5999                     if (ST.maxpos >= PL_regeol)
6000                         ST.maxpos = PL_regeol - 1;
6001                 }
6002                 goto curly_try_B_min_known;
6003
6004             }
6005             else {
6006                 /* avoid taking address of locinput, so it can remain
6007                  * a register var */
6008                 char *li = locinput;
6009                 ST.count = regrepeat(rex, &li, ST.A, ST.max, depth,
6010                                         is_utf8_pat);
6011                 if (ST.count < ST.min)
6012                     sayNO;
6013                 SET_locinput(li);
6014                 if ((ST.count > ST.min)
6015                     && (PL_regkind[OP(ST.B)] == EOL) && (OP(ST.B) != MEOL))
6016                 {
6017                     /* A{m,n} must come at the end of the string, there's
6018                      * no point in backing off ... */
6019                     ST.min = ST.count;
6020                     /* ...except that $ and \Z can match before *and* after
6021                        newline at the end.  Consider "\n\n" =~ /\n+\Z\n/.
6022                        We may back off by one in this case. */
6023                     if (UCHARAT(locinput - 1) == '\n' && OP(ST.B) != EOS)
6024                         ST.min--;
6025                 }
6026                 REGCP_SET(ST.cp);
6027                 goto curly_try_B_max;
6028             }
6029             assert(0); /* NOTREACHED */
6030
6031
6032         case CURLY_B_min_known_fail:
6033             /* failed to find B in a non-greedy match where c1,c2 valid */
6034
6035             REGCP_UNWIND(ST.cp);
6036             if (ST.paren) {
6037                 UNWIND_PAREN(ST.lastparen, ST.lastcloseparen);
6038             }
6039             /* Couldn't or didn't -- move forward. */
6040             ST.oldloc = locinput;
6041             if (utf8_target)
6042                 locinput += UTF8SKIP(locinput);
6043             else
6044                 locinput++;
6045             ST.count++;
6046           curly_try_B_min_known:
6047              /* find the next place where 'B' could work, then call B */
6048             {
6049                 int n;
6050                 if (utf8_target) {
6051                     n = (ST.oldloc == locinput) ? 0 : 1;
6052                     if (ST.c1 == ST.c2) {
6053                         /* set n to utf8_distance(oldloc, locinput) */
6054                         while (locinput <= ST.maxpos
6055                               && memNE(locinput, ST.c1_utf8, UTF8SKIP(locinput)))
6056                         {
6057                             locinput += UTF8SKIP(locinput);
6058                             n++;
6059                         }
6060                     }
6061                     else {
6062                         /* set n to utf8_distance(oldloc, locinput) */
6063                         while (locinput <= ST.maxpos
6064                               && memNE(locinput, ST.c1_utf8, UTF8SKIP(locinput))
6065                               && memNE(locinput, ST.c2_utf8, UTF8SKIP(locinput)))
6066                         {
6067                             locinput += UTF8SKIP(locinput);
6068                             n++;
6069                         }
6070                     }
6071                 }
6072                 else {  /* Not utf8_target */
6073                     if (ST.c1 == ST.c2) {
6074                         while (locinput <= ST.maxpos &&
6075                                UCHARAT(locinput) != ST.c1)
6076                             locinput++;
6077                     }
6078                     else {
6079                         while (locinput <= ST.maxpos
6080                                && UCHARAT(locinput) != ST.c1
6081                                && UCHARAT(locinput) != ST.c2)
6082                             locinput++;
6083                     }
6084                     n = locinput - ST.oldloc;
6085                 }
6086                 if (locinput > ST.maxpos)
6087                     sayNO;
6088                 if (n) {
6089                     /* In /a{m,n}b/, ST.oldloc is at "a" x m, locinput is
6090                      * at b; check that everything between oldloc and
6091                      * locinput matches */
6092                     char *li = ST.oldloc;
6093                     ST.count += n;
6094                     if (regrepeat(rex, &li, ST.A, n, depth, is_utf8_pat) < n)
6095                         sayNO;
6096                     assert(n == REG_INFTY || locinput == li);
6097                 }
6098                 CURLY_SETPAREN(ST.paren, ST.count);
6099                 if (cur_eval && cur_eval->u.eval.close_paren && 
6100                     cur_eval->u.eval.close_paren == (U32)ST.paren) {
6101                     goto fake_end;
6102                 }
6103                 PUSH_STATE_GOTO(CURLY_B_min_known, ST.B, locinput);
6104             }
6105             assert(0); /* NOTREACHED */
6106
6107
6108         case CURLY_B_min_fail:
6109             /* failed to find B in a non-greedy match where c1,c2 invalid */
6110
6111             REGCP_UNWIND(ST.cp);
6112             if (ST.paren) {
6113                 UNWIND_PAREN(ST.lastparen, ST.lastcloseparen);
6114             }
6115             /* failed -- move forward one */
6116             {
6117                 char *li = locinput;
6118                 if (!regrepeat(rex, &li, ST.A, 1, depth, is_utf8_pat)) {
6119                     sayNO;
6120                 }
6121                 locinput = li;
6122             }
6123             {
6124                 ST.count++;
6125                 if (ST.count <= ST.max || (ST.max == REG_INFTY &&
6126                         ST.count > 0)) /* count overflow ? */
6127                 {
6128                   curly_try_B_min:
6129                     CURLY_SETPAREN(ST.paren, ST.count);
6130                     if (cur_eval && cur_eval->u.eval.close_paren &&
6131                         cur_eval->u.eval.close_paren == (U32)ST.paren) {
6132                         goto fake_end;
6133                     }
6134                     PUSH_STATE_GOTO(CURLY_B_min, ST.B, locinput);
6135                 }
6136             }
6137             sayNO;
6138             assert(0); /* NOTREACHED */
6139
6140
6141         curly_try_B_max:
6142             /* a successful greedy match: now try to match B */
6143             if (cur_eval && cur_eval->u.eval.close_paren &&
6144                 cur_eval->u.eval.close_paren == (U32)ST.paren) {
6145                 goto fake_end;
6146             }
6147             {
6148                 bool could_match = locinput < PL_regeol;
6149
6150                 /* If it could work, try it. */
6151                 if (ST.c1 != CHRTEST_VOID && could_match) {
6152                     if (! UTF8_IS_INVARIANT(UCHARAT(locinput)) && utf8_target)
6153                     {
6154                         could_match = memEQ(locinput,
6155                                             ST.c1_utf8,
6156                                             UTF8SKIP(locinput))
6157                                     || memEQ(locinput,
6158                                              ST.c2_utf8,
6159                                              UTF8SKIP(locinput));
6160                     }
6161                     else {
6162                         could_match = UCHARAT(locinput) == ST.c1
6163                                       || UCHARAT(locinput) == ST.c2;
6164                     }
6165                 }
6166                 if (ST.c1 == CHRTEST_VOID || could_match) {
6167                     CURLY_SETPAREN(ST.paren, ST.count);
6168                     PUSH_STATE_GOTO(CURLY_B_max, ST.B, locinput);
6169                     assert(0); /* NOTREACHED */
6170                 }
6171             }
6172             /* FALL THROUGH */
6173
6174         case CURLY_B_max_fail:
6175             /* failed to find B in a greedy match */
6176
6177             REGCP_UNWIND(ST.cp);
6178             if (ST.paren) {
6179                 UNWIND_PAREN(ST.lastparen, ST.lastcloseparen);
6180             }
6181             /*  back up. */
6182             if (--ST.count < ST.min)
6183                 sayNO;
6184             locinput = HOPc(locinput, -1);
6185             goto curly_try_B_max;
6186
6187 #undef ST
6188
6189         case END: /*  last op of main pattern  */
6190             fake_end:
6191             if (cur_eval) {
6192                 /* we've just finished A in /(??{A})B/; now continue with B */
6193                 st->u.eval.saved_utf8_pat = is_utf8_pat;
6194                 is_utf8_pat = cur_eval->u.eval.saved_utf8_pat;
6195
6196                 st->u.eval.prev_rex = rex_sv;           /* inner */
6197
6198                 /* Save *all* the positions. */
6199                 st->u.eval.cp = regcppush(rex, 0, maxopenparen);
6200                 rex_sv = cur_eval->u.eval.prev_rex;
6201                 SET_reg_curpm(rex_sv);
6202                 rex = ReANY(rex_sv);
6203                 rexi = RXi_GET(rex);
6204                 cur_curlyx = cur_eval->u.eval.prev_curlyx;
6205
6206                 REGCP_SET(st->u.eval.lastcp);
6207
6208                 /* Restore parens of the outer rex without popping the
6209                  * savestack */
6210                 S_regcp_restore(aTHX_ rex, cur_eval->u.eval.lastcp,
6211                                         &maxopenparen);
6212
6213                 st->u.eval.prev_eval = cur_eval;
6214                 cur_eval = cur_eval->u.eval.prev_eval;
6215                 DEBUG_EXECUTE_r(
6216                     PerlIO_printf(Perl_debug_log, "%*s  EVAL trying tail ... %"UVxf"\n",
6217                                       REPORT_CODE_OFF+depth*2, "",PTR2UV(cur_eval)););
6218                 if ( nochange_depth )
6219                     nochange_depth--;
6220
6221                 PUSH_YES_STATE_GOTO(EVAL_AB, st->u.eval.prev_eval->u.eval.B,
6222                                     locinput); /* match B */
6223             }
6224
6225             if (locinput < reginfo->till) {
6226                 DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
6227                                       "%sMatch possible, but length=%ld is smaller than requested=%ld, failing!%s\n",
6228                                       PL_colors[4],
6229                                       (long)(locinput - PL_reg_starttry),
6230                                       (long)(reginfo->till - PL_reg_starttry),
6231                                       PL_colors[5]));
6232                                               
6233                 sayNO_SILENT;           /* Cannot match: too short. */
6234             }
6235             sayYES;                     /* Success! */
6236
6237         case SUCCEED: /* successful SUSPEND/UNLESSM/IFMATCH/CURLYM */
6238             DEBUG_EXECUTE_r(
6239             PerlIO_printf(Perl_debug_log,
6240                 "%*s  %ssubpattern success...%s\n",
6241                 REPORT_CODE_OFF+depth*2, "", PL_colors[4], PL_colors[5]));
6242             sayYES;                     /* Success! */
6243
6244 #undef  ST
6245 #define ST st->u.ifmatch
6246
6247         {
6248             char *newstart;
6249
6250         case SUSPEND:   /* (?>A) */
6251             ST.wanted = 1;
6252             newstart = locinput;
6253             goto do_ifmatch;    
6254
6255         case UNLESSM:   /* -ve lookaround: (?!A), or with flags, (?<!A) */
6256             ST.wanted = 0;
6257             goto ifmatch_trivial_fail_test;
6258
6259         case IFMATCH:   /* +ve lookaround: (?=A), or with flags, (?<=A) */
6260             ST.wanted = 1;
6261           ifmatch_trivial_fail_test:
6262             if (scan->flags) {
6263                 char * const s = HOPBACKc(locinput, scan->flags);
6264                 if (!s) {
6265                     /* trivial fail */
6266                     if (logical) {
6267                         logical = 0;
6268                         sw = 1 - cBOOL(ST.wanted);
6269                     }
6270                     else if (ST.wanted)
6271                         sayNO;
6272                     next = scan + ARG(scan);
6273                     if (next == scan)
6274                         next = NULL;
6275                     break;
6276                 }
6277                 newstart = s;
6278             }
6279             else
6280                 newstart = locinput;
6281
6282           do_ifmatch:
6283             ST.me = scan;
6284             ST.logical = logical;
6285             logical = 0; /* XXX: reset state of logical once it has been saved into ST */
6286             
6287             /* execute body of (?...A) */
6288             PUSH_YES_STATE_GOTO(IFMATCH_A, NEXTOPER(NEXTOPER(scan)), newstart);
6289             assert(0); /* NOTREACHED */
6290         }
6291
6292         case IFMATCH_A_fail: /* body of (?...A) failed */
6293             ST.wanted = !ST.wanted;
6294             /* FALL THROUGH */
6295
6296         case IFMATCH_A: /* body of (?...A) succeeded */
6297             if (ST.logical) {
6298                 sw = cBOOL(ST.wanted);
6299             }
6300             else if (!ST.wanted)
6301                 sayNO;
6302
6303             if (OP(ST.me) != SUSPEND) {
6304                 /* restore old position except for (?>...) */
6305                 locinput = st->locinput;
6306             }
6307             scan = ST.me + ARG(ST.me);
6308             if (scan == ST.me)
6309                 scan = NULL;
6310             continue; /* execute B */
6311
6312 #undef ST
6313
6314         case LONGJMP: /*  alternative with many branches compiles to
6315                        * (BRANCHJ; EXACT ...; LONGJMP ) x N */
6316             next = scan + ARG(scan);
6317             if (next == scan)
6318                 next = NULL;
6319             break;
6320
6321         case COMMIT:  /*  (*COMMIT)  */
6322             reginfo->cutpoint = PL_regeol;
6323             /* FALLTHROUGH */
6324
6325         case PRUNE:   /*  (*PRUNE)   */
6326             if (!scan->flags)
6327                 sv_yes_mark = sv_commit = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
6328             PUSH_STATE_GOTO(COMMIT_next, next, locinput);
6329             assert(0); /* NOTREACHED */
6330
6331         case COMMIT_next_fail:
6332             no_final = 1;    
6333             /* FALLTHROUGH */       
6334
6335         case OPFAIL:   /* (*FAIL)  */
6336             sayNO;
6337             assert(0); /* NOTREACHED */
6338
6339 #define ST st->u.mark
6340         case MARKPOINT: /*  (*MARK:foo)  */
6341             ST.prev_mark = mark_state;
6342             ST.mark_name = sv_commit = sv_yes_mark 
6343                 = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
6344             mark_state = st;
6345             ST.mark_loc = locinput;
6346             PUSH_YES_STATE_GOTO(MARKPOINT_next, next, locinput);
6347             assert(0); /* NOTREACHED */
6348
6349         case MARKPOINT_next:
6350             mark_state = ST.prev_mark;
6351             sayYES;
6352             assert(0); /* NOTREACHED */
6353
6354         case MARKPOINT_next_fail:
6355             if (popmark && sv_eq(ST.mark_name,popmark)) 
6356             {
6357                 if (ST.mark_loc > startpoint)
6358                     reginfo->cutpoint = HOPBACKc(ST.mark_loc, 1);
6359                 popmark = NULL; /* we found our mark */
6360                 sv_commit = ST.mark_name;
6361
6362                 DEBUG_EXECUTE_r({
6363                         PerlIO_printf(Perl_debug_log,
6364                             "%*s  %ssetting cutpoint to mark:%"SVf"...%s\n",
6365                             REPORT_CODE_OFF+depth*2, "", 
6366                             PL_colors[4], SVfARG(sv_commit), PL_colors[5]);
6367                 });
6368             }
6369             mark_state = ST.prev_mark;
6370             sv_yes_mark = mark_state ? 
6371                 mark_state->u.mark.mark_name : NULL;
6372             sayNO;
6373             assert(0); /* NOTREACHED */
6374
6375         case SKIP:  /*  (*SKIP)  */
6376             if (scan->flags) {
6377                 /* (*SKIP) : if we fail we cut here*/
6378                 ST.mark_name = NULL;
6379                 ST.mark_loc = locinput;
6380                 PUSH_STATE_GOTO(SKIP_next,next, locinput);
6381             } else {
6382                 /* (*SKIP:NAME) : if there is a (*MARK:NAME) fail where it was, 
6383                    otherwise do nothing.  Meaning we need to scan 
6384                  */
6385                 regmatch_state *cur = mark_state;
6386                 SV *find = MUTABLE_SV(rexi->data->data[ ARG( scan ) ]);
6387                 
6388                 while (cur) {
6389                     if ( sv_eq( cur->u.mark.mark_name, 
6390                                 find ) ) 
6391                     {
6392                         ST.mark_name = find;
6393                         PUSH_STATE_GOTO( SKIP_next, next, locinput);
6394                     }
6395                     cur = cur->u.mark.prev_mark;
6396                 }
6397             }    
6398             /* Didn't find our (*MARK:NAME) so ignore this (*SKIP:NAME) */
6399             break;    
6400
6401         case SKIP_next_fail:
6402             if (ST.mark_name) {
6403                 /* (*CUT:NAME) - Set up to search for the name as we 
6404                    collapse the stack*/
6405                 popmark = ST.mark_name;    
6406             } else {
6407                 /* (*CUT) - No name, we cut here.*/
6408                 if (ST.mark_loc > startpoint)
6409                     reginfo->cutpoint = HOPBACKc(ST.mark_loc, 1);
6410                 /* but we set sv_commit to latest mark_name if there
6411                    is one so they can test to see how things lead to this
6412                    cut */    
6413                 if (mark_state) 
6414                     sv_commit=mark_state->u.mark.mark_name;                 
6415             } 
6416             no_final = 1; 
6417             sayNO;
6418             assert(0); /* NOTREACHED */
6419 #undef ST
6420
6421         case LNBREAK: /* \R */
6422             if ((n=is_LNBREAK_safe(locinput, PL_regeol, utf8_target))) {
6423                 locinput += n;
6424             } else
6425                 sayNO;
6426             break;
6427
6428         default:
6429             PerlIO_printf(Perl_error_log, "%"UVxf" %d\n",
6430                           PTR2UV(scan), OP(scan));
6431             Perl_croak(aTHX_ "regexp memory corruption");
6432
6433         /* this is a point to jump to in order to increment
6434          * locinput by one character */
6435         increment_locinput:
6436             assert(!NEXTCHR_IS_EOS);
6437             if (utf8_target) {
6438                 locinput += PL_utf8skip[nextchr];
6439                 /* locinput is allowed to go 1 char off the end, but not 2+ */
6440                 if (locinput > PL_regeol)
6441                     sayNO;
6442             }
6443             else
6444                 locinput++;
6445             break;
6446             
6447         } /* end switch */ 
6448
6449         /* switch break jumps here */
6450         scan = next; /* prepare to execute the next op and ... */
6451         continue;    /* ... jump back to the top, reusing st */
6452         assert(0); /* NOTREACHED */
6453
6454       push_yes_state:
6455         /* push a state that backtracks on success */
6456         st->u.yes.prev_yes_state = yes_state;
6457         yes_state = st;
6458         /* FALL THROUGH */
6459       push_state:
6460         /* push a new regex state, then continue at scan  */
6461         {
6462             regmatch_state *newst;
6463
6464             DEBUG_STACK_r({
6465                 regmatch_state *cur = st;
6466                 regmatch_state *curyes = yes_state;
6467                 int curd = depth;
6468                 regmatch_slab *slab = PL_regmatch_slab;
6469                 for (;curd > -1;cur--,curd--) {
6470                     if (cur < SLAB_FIRST(slab)) {
6471                         slab = slab->prev;
6472                         cur = SLAB_LAST(slab);
6473                     }
6474                     PerlIO_printf(Perl_error_log, "%*s#%-3d %-10s %s\n",
6475                         REPORT_CODE_OFF + 2 + depth * 2,"",
6476                         curd, PL_reg_name[cur->resume_state],
6477                         (curyes == cur) ? "yes" : ""
6478                     );
6479                     if (curyes == cur)
6480                         curyes = cur->u.yes.prev_yes_state;
6481                 }
6482             } else 
6483                 DEBUG_STATE_pp("push")
6484             );
6485             depth++;
6486             st->locinput = locinput;
6487             newst = st+1; 
6488             if (newst >  SLAB_LAST(PL_regmatch_slab))
6489                 newst = S_push_slab(aTHX);
6490             PL_regmatch_state = newst;
6491
6492             locinput = pushinput;
6493             st = newst;
6494             continue;
6495             assert(0); /* NOTREACHED */
6496         }
6497     }
6498
6499     /*
6500     * We get here only if there's trouble -- normally "case END" is
6501     * the terminating point.
6502     */
6503     Perl_croak(aTHX_ "corrupted regexp pointers");
6504     /*NOTREACHED*/
6505     sayNO;
6506
6507 yes:
6508     if (yes_state) {
6509         /* we have successfully completed a subexpression, but we must now
6510          * pop to the state marked by yes_state and continue from there */
6511         assert(st != yes_state);
6512 #ifdef DEBUGGING
6513         while (st != yes_state) {
6514             st--;
6515             if (st < SLAB_FIRST(PL_regmatch_slab)) {
6516                 PL_regmatch_slab = PL_regmatch_slab->prev;
6517                 st = SLAB_LAST(PL_regmatch_slab);
6518             }
6519             DEBUG_STATE_r({
6520                 if (no_final) {
6521                     DEBUG_STATE_pp("pop (no final)");        
6522                 } else {
6523                     DEBUG_STATE_pp("pop (yes)");
6524                 }
6525             });
6526             depth--;
6527         }
6528 #else
6529         while (yes_state < SLAB_FIRST(PL_regmatch_slab)
6530             || yes_state > SLAB_LAST(PL_regmatch_slab))
6531         {
6532             /* not in this slab, pop slab */
6533             depth -= (st - SLAB_FIRST(PL_regmatch_slab) + 1);
6534             PL_regmatch_slab = PL_regmatch_slab->prev;
6535             st = SLAB_LAST(PL_regmatch_slab);
6536         }
6537         depth -= (st - yes_state);
6538 #endif
6539         st = yes_state;
6540         yes_state = st->u.yes.prev_yes_state;
6541         PL_regmatch_state = st;
6542         
6543         if (no_final)
6544             locinput= st->locinput;
6545         state_num = st->resume_state + no_final;
6546         goto reenter_switch;
6547     }
6548
6549     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch successful!%s\n",
6550                           PL_colors[4], PL_colors[5]));
6551
6552     if (PL_reg_state.re_state_eval_setup_done) {
6553         /* each successfully executed (?{...}) block does the equivalent of
6554          *   local $^R = do {...}
6555          * When popping the save stack, all these locals would be undone;
6556          * bypass this by setting the outermost saved $^R to the latest
6557          * value */
6558         if (oreplsv != GvSV(PL_replgv))
6559             sv_setsv(oreplsv, GvSV(PL_replgv));
6560     }
6561     result = 1;
6562     goto final_exit;
6563
6564 no:
6565     DEBUG_EXECUTE_r(
6566         PerlIO_printf(Perl_debug_log,
6567             "%*s  %sfailed...%s\n",
6568             REPORT_CODE_OFF+depth*2, "", 
6569             PL_colors[4], PL_colors[5])
6570         );
6571
6572 no_silent:
6573     if (no_final) {
6574         if (yes_state) {
6575             goto yes;
6576         } else {
6577             goto final_exit;
6578         }
6579     }    
6580     if (depth) {
6581         /* there's a previous state to backtrack to */
6582         st--;
6583         if (st < SLAB_FIRST(PL_regmatch_slab)) {
6584             PL_regmatch_slab = PL_regmatch_slab->prev;
6585             st = SLAB_LAST(PL_regmatch_slab);
6586         }
6587         PL_regmatch_state = st;
6588         locinput= st->locinput;
6589
6590         DEBUG_STATE_pp("pop");
6591         depth--;
6592         if (yes_state == st)
6593             yes_state = st->u.yes.prev_yes_state;
6594
6595         state_num = st->resume_state + 1; /* failure = success + 1 */
6596         goto reenter_switch;
6597     }
6598     result = 0;
6599
6600   final_exit:
6601     if (rex->intflags & PREGf_VERBARG_SEEN) {
6602         SV *sv_err = get_sv("REGERROR", 1);
6603         SV *sv_mrk = get_sv("REGMARK", 1);
6604         if (result) {
6605             sv_commit = &PL_sv_no;
6606             if (!sv_yes_mark) 
6607                 sv_yes_mark = &PL_sv_yes;
6608         } else {
6609             if (!sv_commit) 
6610                 sv_commit = &PL_sv_yes;
6611             sv_yes_mark = &PL_sv_no;
6612         }
6613         sv_setsv(sv_err, sv_commit);
6614         sv_setsv(sv_mrk, sv_yes_mark);
6615     }
6616
6617
6618     if (last_pushed_cv) {
6619         dSP;
6620         POP_MULTICALL;
6621         PERL_UNUSED_VAR(SP);
6622     }
6623
6624     /* clean up; in particular, free all slabs above current one */
6625     LEAVE_SCOPE(oldsave);
6626
6627     assert(!result ||  locinput - PL_bostr >= 0);
6628     return result ?  locinput - PL_bostr : -1;
6629 }
6630
6631 /*
6632  - regrepeat - repeatedly match something simple, report how many
6633  *
6634  * What 'simple' means is a node which can be the operand of a quantifier like
6635  * '+', or {1,3}
6636  *
6637  * startposp - pointer a pointer to the start position.  This is updated
6638  *             to point to the byte following the highest successful
6639  *             match.
6640  * p         - the regnode to be repeatedly matched against.
6641  * max       - maximum number of things to match.
6642  * depth     - (for debugging) backtracking depth.
6643  */
6644 STATIC I32
6645 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p,
6646                 I32 max, int depth, bool is_utf8_pat)
6647 {
6648     dVAR;
6649     char *scan;     /* Pointer to current position in target string */
6650     I32 c;
6651     char *loceol = PL_regeol;   /* local version */
6652     I32 hardcount = 0;  /* How many matches so far */
6653     bool utf8_target = PL_reg_match_utf8;
6654     int to_complement = 0;  /* Invert the result? */
6655     UV utf8_flags;
6656     _char_class_number classnum;
6657 #ifndef DEBUGGING
6658     PERL_UNUSED_ARG(depth);
6659 #endif
6660
6661     PERL_ARGS_ASSERT_REGREPEAT;
6662
6663     scan = *startposp;
6664     if (max == REG_INFTY)
6665         max = I32_MAX;
6666     else if (! utf8_target && scan + max < loceol)
6667         loceol = scan + max;
6668
6669     /* Here, for the case of a non-UTF-8 target we have adjusted <loceol> down
6670      * to the maximum of how far we should go in it (leaving it set to the real
6671      * end, if the maximum permissible would take us beyond that).  This allows
6672      * us to make the loop exit condition that we haven't gone past <loceol> to
6673      * also mean that we haven't exceeded the max permissible count, saving a
6674      * test each time through the loop.  But it assumes that the OP matches a
6675      * single byte, which is true for most of the OPs below when applied to a
6676      * non-UTF-8 target.  Those relatively few OPs that don't have this
6677      * characteristic will have to compensate.
6678      *
6679      * There is no adjustment for UTF-8 targets, as the number of bytes per
6680      * character varies.  OPs will have to test both that the count is less
6681      * than the max permissible (using <hardcount> to keep track), and that we
6682      * are still within the bounds of the string (using <loceol>.  A few OPs
6683      * match a single byte no matter what the encoding.  They can omit the max
6684      * test if, for the UTF-8 case, they do the adjustment that was skipped
6685      * above.
6686      *
6687      * Thus, the code above sets things up for the common case; and exceptional
6688      * cases need extra work; the common case is to make sure <scan> doesn't
6689      * go past <loceol>, and for UTF-8 to also use <hardcount> to make sure the
6690      * count doesn't exceed the maximum permissible */
6691
6692     switch (OP(p)) {
6693     case REG_ANY:
6694         if (utf8_target) {
6695             while (scan < loceol && hardcount < max && *scan != '\n') {
6696                 scan += UTF8SKIP(scan);
6697                 hardcount++;
6698             }
6699         } else {
6700             while (scan < loceol && *scan != '\n')
6701                 scan++;
6702         }
6703         break;
6704     case SANY:
6705         if (utf8_target) {
6706             while (scan < loceol && hardcount < max) {
6707                 scan += UTF8SKIP(scan);
6708                 hardcount++;
6709             }
6710         }
6711         else
6712             scan = loceol;
6713         break;
6714     case CANY:  /* Move <scan> forward <max> bytes, unless goes off end */
6715         if (utf8_target && scan + max < loceol) {
6716
6717             /* <loceol> hadn't been adjusted in the UTF-8 case */
6718             scan +=  max;
6719         }
6720         else {
6721             scan = loceol;
6722         }
6723         break;
6724     case EXACT:
6725         assert(STR_LEN(p) == is_utf8_pat ? UTF8SKIP(STRING(p)) : 1);
6726
6727         c = (U8)*STRING(p);
6728
6729         /* Can use a simple loop if the pattern char to match on is invariant
6730          * under UTF-8, or both target and pattern aren't UTF-8.  Note that we
6731          * can use UTF8_IS_INVARIANT() even if the pattern isn't UTF-8, as it's
6732          * true iff it doesn't matter if the argument is in UTF-8 or not */
6733         if (UTF8_IS_INVARIANT(c) || (! utf8_target && ! is_utf8_pat)) {
6734             if (utf8_target && scan + max < loceol) {
6735                 /* We didn't adjust <loceol> because is UTF-8, but ok to do so,
6736                  * since here, to match at all, 1 char == 1 byte */
6737                 loceol = scan + max;
6738             }
6739             while (scan < loceol && UCHARAT(scan) == c) {
6740                 scan++;
6741             }
6742         }
6743         else if (is_utf8_pat) {
6744             if (utf8_target) {
6745                 STRLEN scan_char_len;
6746
6747                 /* When both target and pattern are UTF-8, we have to do
6748                  * string EQ */
6749                 while (hardcount < max
6750                        && scan < loceol
6751                        && (scan_char_len = UTF8SKIP(scan)) <= STR_LEN(p)
6752                        && memEQ(scan, STRING(p), scan_char_len))
6753                 {
6754                     scan += scan_char_len;
6755                     hardcount++;
6756                 }
6757             }
6758             else if (! UTF8_IS_ABOVE_LATIN1(c)) {
6759
6760                 /* Target isn't utf8; convert the character in the UTF-8
6761                  * pattern to non-UTF8, and do a simple loop */
6762                 c = TWO_BYTE_UTF8_TO_UNI(c, *(STRING(p) + 1));
6763                 while (scan < loceol && UCHARAT(scan) == c) {
6764                     scan++;
6765                 }
6766             } /* else pattern char is above Latin1, can't possibly match the
6767                  non-UTF-8 target */
6768         }
6769         else {
6770
6771             /* Here, the string must be utf8; pattern isn't, and <c> is
6772              * different in utf8 than not, so can't compare them directly.
6773              * Outside the loop, find the two utf8 bytes that represent c, and
6774              * then look for those in sequence in the utf8 string */
6775             U8 high = UTF8_TWO_BYTE_HI(c);
6776             U8 low = UTF8_TWO_BYTE_LO(c);
6777
6778             while (hardcount < max
6779                     && scan + 1 < loceol
6780                     && UCHARAT(scan) == high
6781                     && UCHARAT(scan + 1) == low)
6782             {
6783                 scan += 2;
6784                 hardcount++;
6785             }
6786         }
6787         break;
6788
6789     case EXACTFA:
6790         utf8_flags = FOLDEQ_UTF8_NOMIX_ASCII;
6791         goto do_exactf;
6792
6793     case EXACTFL:
6794         RXp_MATCH_TAINTED_on(prog);
6795         utf8_flags = FOLDEQ_UTF8_LOCALE;
6796         goto do_exactf;
6797
6798     case EXACTF:
6799             utf8_flags = 0;
6800             goto do_exactf;
6801
6802     case EXACTFU_SS:
6803     case EXACTFU_TRICKYFOLD:
6804     case EXACTFU:
6805         utf8_flags = is_utf8_pat ? FOLDEQ_S2_ALREADY_FOLDED : 0;
6806
6807     do_exactf: {
6808         int c1, c2;
6809         U8 c1_utf8[UTF8_MAXBYTES+1], c2_utf8[UTF8_MAXBYTES+1];
6810
6811         assert(STR_LEN(p) == is_utf8_pat ? UTF8SKIP(STRING(p)) : 1);
6812
6813         if (S_setup_EXACTISH_ST_c1_c2(aTHX_ p, &c1, c1_utf8, &c2, c2_utf8,
6814                                         is_utf8_pat))
6815         {
6816             if (c1 == CHRTEST_VOID) {
6817                 /* Use full Unicode fold matching */
6818                 char *tmpeol = PL_regeol;
6819                 STRLEN pat_len = is_utf8_pat ? UTF8SKIP(STRING(p)) : 1;
6820                 while (hardcount < max
6821                         && foldEQ_utf8_flags(scan, &tmpeol, 0, utf8_target,
6822                                              STRING(p), NULL, pat_len,
6823                                              is_utf8_pat, utf8_flags))
6824                 {
6825                     scan = tmpeol;
6826                     tmpeol = PL_regeol;
6827                     hardcount++;
6828                 }
6829             }
6830             else if (utf8_target) {
6831                 if (c1 == c2) {
6832                     while (scan < loceol
6833                            && hardcount < max
6834                            && memEQ(scan, c1_utf8, UTF8SKIP(scan)))
6835                     {
6836                         scan += UTF8SKIP(scan);
6837                         hardcount++;
6838                     }
6839                 }
6840                 else {
6841                     while (scan < loceol
6842                            && hardcount < max
6843                            && (memEQ(scan, c1_utf8, UTF8SKIP(scan))
6844                                || memEQ(scan, c2_utf8, UTF8SKIP(scan))))
6845                     {
6846                         scan += UTF8SKIP(scan);
6847                         hardcount++;
6848                     }
6849                 }
6850             }
6851             else if (c1 == c2) {
6852                 while (scan < loceol && UCHARAT(scan) == c1) {
6853                     scan++;
6854                 }
6855             }
6856             else {
6857                 while (scan < loceol &&
6858                     (UCHARAT(scan) == c1 || UCHARAT(scan) == c2))
6859                 {
6860                     scan++;
6861                 }
6862             }
6863         }
6864         break;
6865     }
6866     case ANYOF:
6867     case ANYOF_WARN_SUPER:
6868         if (utf8_target) {
6869             while (hardcount < max
6870                    && scan < loceol
6871                    && reginclass(prog, p, (U8*)scan, utf8_target))
6872             {
6873                 scan += UTF8SKIP(scan);
6874                 hardcount++;
6875             }
6876         } else {
6877             while (scan < loceol && REGINCLASS(prog, p, (U8*)scan))
6878                 scan++;
6879         }
6880         break;
6881
6882     /* The argument (FLAGS) to all the POSIX node types is the class number */
6883
6884     case NPOSIXL:
6885         to_complement = 1;
6886         /* FALLTHROUGH */
6887
6888     case POSIXL:
6889         RXp_MATCH_TAINTED_on(prog);
6890         if (! utf8_target) {
6891             while (scan < loceol && to_complement ^ cBOOL(isFOO_lc(FLAGS(p),
6892                                                                    *scan)))
6893             {
6894                 scan++;
6895             }
6896         } else {
6897             while (hardcount < max && scan < loceol
6898                    && to_complement ^ cBOOL(isFOO_utf8_lc(FLAGS(p),
6899                                                                   (U8 *) scan)))
6900             {
6901                 scan += UTF8SKIP(scan);
6902                 hardcount++;
6903             }
6904         }
6905         break;
6906
6907     case POSIXD:
6908         if (utf8_target) {
6909             goto utf8_posix;
6910         }
6911         /* FALLTHROUGH */
6912
6913     case POSIXA:
6914         if (utf8_target && scan + max < loceol) {
6915
6916             /* We didn't adjust <loceol> at the beginning of this routine
6917              * because is UTF-8, but it is actually ok to do so, since here, to
6918              * match, 1 char == 1 byte. */
6919             loceol = scan + max;
6920         }
6921         while (scan < loceol && _generic_isCC_A((U8) *scan, FLAGS(p))) {
6922             scan++;
6923         }
6924         break;
6925
6926     case NPOSIXD:
6927         if (utf8_target) {
6928             to_complement = 1;
6929             goto utf8_posix;
6930         }
6931         /* FALL THROUGH */
6932
6933     case NPOSIXA:
6934         if (! utf8_target) {
6935             while (scan < loceol && ! _generic_isCC_A((U8) *scan, FLAGS(p))) {
6936                 scan++;
6937             }
6938         }
6939         else {
6940
6941             /* The complement of something that matches only ASCII matches all
6942              * UTF-8 variant code points, plus everything in ASCII that isn't
6943              * in the class. */
6944             while (hardcount < max && scan < loceol
6945                    && (! UTF8_IS_INVARIANT(*scan)
6946                        || ! _generic_isCC_A((U8) *scan, FLAGS(p))))
6947             {
6948                 scan += UTF8SKIP(scan);
6949                 hardcount++;
6950             }
6951         }
6952         break;
6953
6954     case NPOSIXU:
6955         to_complement = 1;
6956         /* FALLTHROUGH */
6957
6958     case POSIXU:
6959         if (! utf8_target) {
6960             while (scan < loceol && to_complement
6961                                 ^ cBOOL(_generic_isCC((U8) *scan, FLAGS(p))))
6962             {
6963                 scan++;
6964             }
6965         }
6966         else {
6967       utf8_posix:
6968             classnum = (_char_class_number) FLAGS(p);
6969             if (classnum < _FIRST_NON_SWASH_CC) {
6970
6971                 /* Here, a swash is needed for above-Latin1 code points.
6972                  * Process as many Latin1 code points using the built-in rules.
6973                  * Go to another loop to finish processing upon encountering
6974                  * the first Latin1 code point.  We could do that in this loop
6975                  * as well, but the other way saves having to test if the swash
6976                  * has been loaded every time through the loop: extra space to
6977                  * save a test. */
6978                 while (hardcount < max && scan < loceol) {
6979                     if (UTF8_IS_INVARIANT(*scan)) {
6980                         if (! (to_complement ^ cBOOL(_generic_isCC((U8) *scan,
6981                                                                    classnum))))
6982                         {
6983                             break;
6984                         }
6985                         scan++;
6986                     }
6987                     else if (UTF8_IS_DOWNGRADEABLE_START(*scan)) {
6988                         if (! (to_complement
6989                               ^ cBOOL(_generic_isCC(TWO_BYTE_UTF8_TO_UNI(*scan,
6990                                                                    *(scan + 1)),
6991                                                     classnum))))
6992                         {
6993                             break;
6994                         }
6995                         scan += 2;
6996                     }
6997                     else {
6998                         goto found_above_latin1;
6999                     }
7000
7001                     hardcount++;
7002                 }
7003             }
7004             else {
7005                 /* For these character classes, the knowledge of how to handle
7006                  * every code point is compiled in to Perl via a macro.  This
7007                  * code is written for making the loops as tight as possible.
7008                  * It could be refactored to save space instead */
7009                 switch (classnum) {
7010                     case _CC_ENUM_SPACE:    /* XXX would require separate code
7011                                                if we revert the change of \v
7012                                                matching this */
7013                         /* FALL THROUGH */
7014                     case _CC_ENUM_PSXSPC:
7015                         while (hardcount < max
7016                                && scan < loceol
7017                                && (to_complement ^ cBOOL(isSPACE_utf8(scan))))
7018                         {
7019                             scan += UTF8SKIP(scan);
7020                             hardcount++;
7021                         }
7022                         break;
7023                     case _CC_ENUM_BLANK:
7024                         while (hardcount < max
7025                                && scan < loceol
7026                                && (to_complement ^ cBOOL(isBLANK_utf8(scan))))
7027                         {
7028                             scan += UTF8SKIP(scan);
7029                             hardcount++;
7030                         }
7031                         break;
7032                     case _CC_ENUM_XDIGIT:
7033                         while (hardcount < max
7034                                && scan < loceol
7035                                && (to_complement ^ cBOOL(isXDIGIT_utf8(scan))))
7036                         {
7037                             scan += UTF8SKIP(scan);
7038                             hardcount++;
7039                         }
7040                         break;
7041                     case _CC_ENUM_VERTSPACE:
7042                         while (hardcount < max
7043                                && scan < loceol
7044                                && (to_complement ^ cBOOL(isVERTWS_utf8(scan))))
7045                         {
7046                             scan += UTF8SKIP(scan);
7047                             hardcount++;
7048                         }
7049                         break;
7050                     case _CC_ENUM_CNTRL:
7051                         while (hardcount < max
7052                                && scan < loceol
7053                                && (to_complement ^ cBOOL(isCNTRL_utf8(scan))))
7054                         {
7055                             scan += UTF8SKIP(scan);
7056                             hardcount++;
7057                         }
7058                         break;
7059                     default:
7060                         Perl_croak(aTHX_ "panic: regrepeat() node %d='%s' has an unexpected character class '%d'", OP(p), PL_reg_name[OP(p)], classnum);
7061                 }
7062             }
7063         }
7064         break;
7065
7066       found_above_latin1:   /* Continuation of POSIXU and NPOSIXU */
7067
7068         /* Load the swash if not already present */
7069         if (! PL_utf8_swash_ptrs[classnum]) {
7070             U8 flags = _CORE_SWASH_INIT_ACCEPT_INVLIST;
7071             PL_utf8_swash_ptrs[classnum] = _core_swash_init(
7072                                         "utf8", swash_property_names[classnum],
7073                                         &PL_sv_undef, 1, 0, NULL, &flags);
7074         }
7075
7076         while (hardcount < max && scan < loceol
7077                && to_complement ^ cBOOL(_generic_utf8(
7078                                        classnum,
7079                                        scan,
7080                                        swash_fetch(PL_utf8_swash_ptrs[classnum],
7081                                                    (U8 *) scan,
7082                                                    TRUE))))
7083         {
7084             scan += UTF8SKIP(scan);
7085             hardcount++;
7086         }
7087         break;
7088
7089     case LNBREAK:
7090         if (utf8_target) {
7091             while (hardcount < max && scan < loceol &&
7092                     (c=is_LNBREAK_utf8_safe(scan, loceol))) {
7093                 scan += c;
7094                 hardcount++;
7095             }
7096         } else {
7097             /* LNBREAK can match one or two latin chars, which is ok, but we
7098              * have to use hardcount in this situation, and throw away the
7099              * adjustment to <loceol> done before the switch statement */
7100             loceol = PL_regeol;
7101             while (scan < loceol && (c=is_LNBREAK_latin1_safe(scan, loceol))) {
7102                 scan+=c;
7103                 hardcount++;
7104             }
7105         }
7106         break;
7107
7108     case BOUND:
7109     case BOUNDA:
7110     case BOUNDL:
7111     case BOUNDU:
7112     case EOS:
7113     case GPOS:
7114     case KEEPS:
7115     case NBOUND:
7116     case NBOUNDA:
7117     case NBOUNDL:
7118     case NBOUNDU:
7119     case OPFAIL:
7120     case SBOL:
7121     case SEOL:
7122         /* These are all 0 width, so match right here or not at all. */
7123         break;
7124
7125     default:
7126         Perl_croak(aTHX_ "panic: regrepeat() called with unrecognized node type %d='%s'", OP(p), PL_reg_name[OP(p)]);
7127         assert(0); /* NOTREACHED */
7128
7129     }
7130
7131     if (hardcount)
7132         c = hardcount;
7133     else
7134         c = scan - *startposp;
7135     *startposp = scan;
7136
7137     DEBUG_r({
7138         GET_RE_DEBUG_FLAGS_DECL;
7139         DEBUG_EXECUTE_r({
7140             SV * const prop = sv_newmortal();
7141             regprop(prog, prop, p);
7142             PerlIO_printf(Perl_debug_log,
7143                         "%*s  %s can match %"IVdf" times out of %"IVdf"...\n",
7144                         REPORT_CODE_OFF + depth*2, "", SvPVX_const(prop),(IV)c,(IV)max);
7145         });
7146     });
7147
7148     return(c);
7149 }
7150
7151
7152 #if !defined(PERL_IN_XSUB_RE) || defined(PLUGGABLE_RE_EXTENSION)
7153 /*
7154 - regclass_swash - prepare the utf8 swash.  Wraps the shared core version to
7155 create a copy so that changes the caller makes won't change the shared one.
7156 If <altsvp> is non-null, will return NULL in it, for back-compat.
7157  */
7158 SV *
7159 Perl_regclass_swash(pTHX_ const regexp *prog, const regnode* node, bool doinit, SV** listsvp, SV **altsvp)
7160 {
7161     PERL_ARGS_ASSERT_REGCLASS_SWASH;
7162
7163     if (altsvp) {
7164         *altsvp = NULL;
7165     }
7166
7167     return newSVsv(core_regclass_swash(prog, node, doinit, listsvp));
7168 }
7169 #endif
7170
7171 STATIC SV *
7172 S_core_regclass_swash(pTHX_ const regexp *prog, const regnode* node, bool doinit, SV** listsvp)
7173 {
7174     /* Returns the swash for the input 'node' in the regex 'prog'.
7175      * If <doinit> is true, will attempt to create the swash if not already
7176      *    done.
7177      * If <listsvp> is non-null, will return the swash initialization string in
7178      *    it.
7179      * Tied intimately to how regcomp.c sets up the data structure */
7180
7181     dVAR;
7182     SV *sw  = NULL;
7183     SV *si  = NULL;
7184     SV*  invlist = NULL;
7185
7186     RXi_GET_DECL(prog,progi);
7187     const struct reg_data * const data = prog ? progi->data : NULL;
7188
7189     PERL_ARGS_ASSERT_CORE_REGCLASS_SWASH;
7190
7191     assert(ANYOF_NONBITMAP(node));
7192
7193     if (data && data->count) {
7194         const U32 n = ARG(node);
7195
7196         if (data->what[n] == 's') {
7197             SV * const rv = MUTABLE_SV(data->data[n]);
7198             AV * const av = MUTABLE_AV(SvRV(rv));
7199             SV **const ary = AvARRAY(av);
7200             U8 swash_init_flags = _CORE_SWASH_INIT_ACCEPT_INVLIST;
7201         
7202             si = *ary;  /* ary[0] = the string to initialize the swash with */
7203
7204             /* Elements 2 and 3 are either both present or both absent. [2] is
7205              * any inversion list generated at compile time; [3] indicates if
7206              * that inversion list has any user-defined properties in it. */
7207             if (av_len(av) >= 2) {
7208                 invlist = ary[2];
7209                 if (SvUV(ary[3])) {
7210                     swash_init_flags |= _CORE_SWASH_INIT_USER_DEFINED_PROPERTY;
7211                 }
7212             }
7213             else {
7214                 invlist = NULL;
7215             }
7216
7217             /* Element [1] is reserved for the set-up swash.  If already there,
7218              * return it; if not, create it and store it there */
7219             if (SvROK(ary[1])) {
7220                 sw = ary[1];
7221             }
7222             else if (si && doinit) {
7223
7224                 sw = _core_swash_init("utf8", /* the utf8 package */
7225                                       "", /* nameless */
7226                                       si,
7227                                       1, /* binary */
7228                                       0, /* not from tr/// */
7229                                       invlist,
7230                                       &swash_init_flags);
7231                 (void)av_store(av, 1, sw);
7232             }
7233         }
7234     }
7235         
7236     if (listsvp) {
7237         SV* matches_string = newSVpvn("", 0);
7238
7239         /* Use the swash, if any, which has to have incorporated into it all
7240          * possibilities */
7241         if ((! sw || (invlist = _get_swash_invlist(sw)) == NULL)
7242             && (si && si != &PL_sv_undef))
7243         {
7244
7245             /* If no swash, use the input initialization string, if available */
7246             sv_catsv(matches_string, si);
7247         }
7248
7249         /* Add the inversion list to whatever we have.  This may have come from
7250          * the swash, or from an input parameter */
7251         if (invlist) {
7252             sv_catsv(matches_string, _invlist_contents(invlist));
7253         }
7254         *listsvp = matches_string;
7255     }
7256
7257     return sw;
7258 }
7259
7260 /*
7261  - reginclass - determine if a character falls into a character class
7262  
7263   n is the ANYOF regnode
7264   p is the target string
7265   utf8_target tells whether p is in UTF-8.
7266
7267   Returns true if matched; false otherwise.
7268
7269   Note that this can be a synthetic start class, a combination of various
7270   nodes, so things you think might be mutually exclusive, such as locale,
7271   aren't.  It can match both locale and non-locale
7272
7273  */
7274
7275 STATIC bool
7276 S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8* const p, const bool utf8_target)
7277 {
7278     dVAR;
7279     const char flags = ANYOF_FLAGS(n);
7280     bool match = FALSE;
7281     UV c = *p;
7282
7283     PERL_ARGS_ASSERT_REGINCLASS;
7284
7285     /* If c is not already the code point, get it.  Note that
7286      * UTF8_IS_INVARIANT() works even if not in UTF-8 */
7287     if (! UTF8_IS_INVARIANT(c) && utf8_target) {
7288         STRLEN c_len = 0;
7289         c = utf8n_to_uvchr(p, UTF8_MAXBYTES, &c_len,
7290                 (UTF8_ALLOW_DEFAULT & UTF8_ALLOW_ANYUV)
7291                 | UTF8_ALLOW_FFFF | UTF8_CHECK_ONLY);
7292                 /* see [perl #37836] for UTF8_ALLOW_ANYUV; [perl #38293] for
7293                  * UTF8_ALLOW_FFFF */
7294         if (c_len == (STRLEN)-1)
7295             Perl_croak(aTHX_ "Malformed UTF-8 character (fatal)");
7296     }
7297
7298     /* If this character is potentially in the bitmap, check it */
7299     if (c < 256) {
7300         if (ANYOF_BITMAP_TEST(n, c))
7301             match = TRUE;
7302         else if (flags & ANYOF_NON_UTF8_LATIN1_ALL
7303                 && ! utf8_target
7304                 && ! isASCII(c))
7305         {
7306             match = TRUE;
7307         }
7308         else if (flags & ANYOF_LOCALE) {
7309             RXp_MATCH_TAINTED_on(prog);
7310
7311             if ((flags & ANYOF_LOC_FOLD)
7312                  && ANYOF_BITMAP_TEST(n, PL_fold_locale[c]))
7313             {
7314                 match = TRUE;
7315             }
7316             else if (ANYOF_CLASS_TEST_ANY_SET(n)) {
7317
7318                 /* The data structure is arranged so bits 0, 2, 4, ... are set
7319                  * if the class includes the Posix character class given by
7320                  * bit/2; and 1, 3, 5, ... are set if the class includes the
7321                  * complemented Posix class given by int(bit/2).  So we loop
7322                  * through the bits, each time changing whether we complement
7323                  * the result or not.  Suppose for the sake of illustration
7324                  * that bits 0-3 mean respectively, \w, \W, \s, \S.  If bit 0
7325                  * is set, it means there is a match for this ANYOF node if the
7326                  * character is in the class given by the expression (0 / 2 = 0
7327                  * = \w).  If it is in that class, isFOO_lc() will return 1,
7328                  * and since 'to_complement' is 0, the result will stay TRUE,
7329                  * and we exit the loop.  Suppose instead that bit 0 is 0, but
7330                  * bit 1 is 1.  That means there is a match if the character
7331                  * matches \W.  We won't bother to call isFOO_lc() on bit 0,
7332                  * but will on bit 1.  On the second iteration 'to_complement'
7333                  * will be 1, so the exclusive or will reverse things, so we
7334                  * are testing for \W.  On the third iteration, 'to_complement'
7335                  * will be 0, and we would be testing for \s; the fourth
7336                  * iteration would test for \S, etc.
7337                  *
7338                  * Note that this code assumes that all the classes are closed
7339                  * under folding.  For example, if a character matches \w, then
7340                  * its fold does too; and vice versa.  This should be true for
7341                  * any well-behaved locale for all the currently defined Posix
7342                  * classes, except for :lower: and :upper:, which are handled
7343                  * by the pseudo-class :cased: which matches if either of the
7344                  * other two does.  To get rid of this assumption, an outer
7345                  * loop could be used below to iterate over both the source
7346                  * character, and its fold (if different) */
7347
7348                 int count = 0;
7349                 int to_complement = 0;
7350                 while (count < ANYOF_MAX) {
7351                     if (ANYOF_CLASS_TEST(n, count)
7352                         && to_complement ^ cBOOL(isFOO_lc(count/2, (U8) c)))
7353                     {
7354                         match = TRUE;
7355                         break;
7356                     }
7357                     count++;
7358                     to_complement ^= 1;
7359                 }
7360             }
7361         }
7362     }
7363
7364     /* If the bitmap didn't (or couldn't) match, and something outside the
7365      * bitmap could match, try that.  Locale nodes specify completely the
7366      * behavior of code points in the bit map (otherwise, a utf8 target would
7367      * cause them to be treated as Unicode and not locale), except in
7368      * the very unlikely event when this node is a synthetic start class, which
7369      * could be a combination of locale and non-locale nodes.  So allow locale
7370      * to match for the synthetic start class, which will give a false
7371      * positive that will be resolved when the match is done again as not part
7372      * of the synthetic start class */
7373     if (!match) {
7374         if (utf8_target && (flags & ANYOF_UNICODE_ALL) && c >= 256) {
7375             match = TRUE;       /* Everything above 255 matches */
7376         }
7377         else if (ANYOF_NONBITMAP(n)
7378                  && ((flags & ANYOF_NONBITMAP_NON_UTF8)
7379                      || (utf8_target
7380                          && (c >=256
7381                              || (! (flags & ANYOF_LOCALE))
7382                              || OP(n) == ANYOF_SYNTHETIC))))
7383         {
7384             SV * const sw = core_regclass_swash(prog, n, TRUE, 0);
7385             if (sw) {
7386                 U8 * utf8_p;
7387                 if (utf8_target) {
7388                     utf8_p = (U8 *) p;
7389                 } else { /* Convert to utf8 */
7390                     STRLEN len = 1;
7391                     utf8_p = bytes_to_utf8(p, &len);
7392                 }
7393
7394                 if (swash_fetch(sw, utf8_p, TRUE)) {
7395                     match = TRUE;
7396                 }
7397
7398                 /* If we allocated a string above, free it */
7399                 if (! utf8_target) Safefree(utf8_p);
7400             }
7401         }
7402
7403         if (UNICODE_IS_SUPER(c)
7404             && OP(n) == ANYOF_WARN_SUPER
7405             && ckWARN_d(WARN_NON_UNICODE))
7406         {
7407             Perl_warner(aTHX_ packWARN(WARN_NON_UNICODE),
7408                 "Code point 0x%04"UVXf" is not Unicode, all \\p{} matches fail; all \\P{} matches succeed", c);
7409         }
7410     }
7411
7412     /* The xor complements the return if to invert: 1^1 = 0, 1^0 = 1 */
7413     return cBOOL(flags & ANYOF_INVERT) ^ match;
7414 }
7415
7416 STATIC U8 *
7417 S_reghop3(U8 *s, I32 off, const U8* lim)
7418 {
7419     /* return the position 'off' UTF-8 characters away from 's', forward if
7420      * 'off' >= 0, backwards if negative.  But don't go outside of position
7421      * 'lim', which better be < s  if off < 0 */
7422
7423     dVAR;
7424
7425     PERL_ARGS_ASSERT_REGHOP3;
7426
7427     if (off >= 0) {
7428         while (off-- && s < lim) {
7429             /* XXX could check well-formedness here */
7430             s += UTF8SKIP(s);
7431         }
7432     }
7433     else {
7434         while (off++ && s > lim) {
7435             s--;
7436             if (UTF8_IS_CONTINUED(*s)) {
7437                 while (s > lim && UTF8_IS_CONTINUATION(*s))
7438                     s--;
7439             }
7440             /* XXX could check well-formedness here */
7441         }
7442     }
7443     return s;
7444 }
7445
7446 #ifdef XXX_dmq
7447 /* there are a bunch of places where we use two reghop3's that should
7448    be replaced with this routine. but since thats not done yet 
7449    we ifdef it out - dmq
7450 */
7451 STATIC U8 *
7452 S_reghop4(U8 *s, I32 off, const U8* llim, const U8* rlim)
7453 {
7454     dVAR;
7455
7456     PERL_ARGS_ASSERT_REGHOP4;
7457
7458     if (off >= 0) {
7459         while (off-- && s < rlim) {
7460             /* XXX could check well-formedness here */
7461             s += UTF8SKIP(s);
7462         }
7463     }
7464     else {
7465         while (off++ && s > llim) {
7466             s--;
7467             if (UTF8_IS_CONTINUED(*s)) {
7468                 while (s > llim && UTF8_IS_CONTINUATION(*s))
7469                     s--;
7470             }
7471             /* XXX could check well-formedness here */
7472         }
7473     }
7474     return s;
7475 }
7476 #endif
7477
7478 STATIC U8 *
7479 S_reghopmaybe3(U8* s, I32 off, const U8* lim)
7480 {
7481     dVAR;
7482
7483     PERL_ARGS_ASSERT_REGHOPMAYBE3;
7484
7485     if (off >= 0) {
7486         while (off-- && s < lim) {
7487             /* XXX could check well-formedness here */
7488             s += UTF8SKIP(s);
7489         }
7490         if (off >= 0)
7491             return NULL;
7492     }
7493     else {
7494         while (off++ && s > lim) {
7495             s--;
7496             if (UTF8_IS_CONTINUED(*s)) {
7497                 while (s > lim && UTF8_IS_CONTINUATION(*s))
7498                     s--;
7499             }
7500             /* XXX could check well-formedness here */
7501         }
7502         if (off <= 0)
7503             return NULL;
7504     }
7505     return s;
7506 }
7507
7508 static void
7509 restore_pos(pTHX_ void *arg)
7510 {
7511     dVAR;
7512     regexp * const rex = (regexp *)arg;
7513     if (PL_reg_state.re_state_eval_setup_done) {
7514         if (PL_reg_oldsaved) {
7515             rex->subbeg = PL_reg_oldsaved;
7516             rex->sublen = PL_reg_oldsavedlen;
7517             rex->suboffset = PL_reg_oldsavedoffset;
7518             rex->subcoffset = PL_reg_oldsavedcoffset;
7519 #ifdef PERL_ANY_COW
7520             rex->saved_copy = PL_nrs;
7521 #endif
7522             RXp_MATCH_COPIED_on(rex);
7523         }
7524         PL_reg_magic->mg_len = PL_reg_oldpos;
7525         PL_reg_state.re_state_eval_setup_done = FALSE;
7526         PL_curpm = PL_reg_oldcurpm;
7527     }   
7528 }
7529
7530 STATIC void
7531 S_to_utf8_substr(pTHX_ regexp *prog)
7532 {
7533     /* Converts substr fields in prog from bytes to UTF-8, calling fbm_compile
7534      * on the converted value */
7535
7536     int i = 1;
7537
7538     PERL_ARGS_ASSERT_TO_UTF8_SUBSTR;
7539
7540     do {
7541         if (prog->substrs->data[i].substr
7542             && !prog->substrs->data[i].utf8_substr) {
7543             SV* const sv = newSVsv(prog->substrs->data[i].substr);
7544             prog->substrs->data[i].utf8_substr = sv;
7545             sv_utf8_upgrade(sv);
7546             if (SvVALID(prog->substrs->data[i].substr)) {
7547                 if (SvTAIL(prog->substrs->data[i].substr)) {
7548                     /* Trim the trailing \n that fbm_compile added last
7549                        time.  */
7550                     SvCUR_set(sv, SvCUR(sv) - 1);
7551                     /* Whilst this makes the SV technically "invalid" (as its
7552                        buffer is no longer followed by "\0") when fbm_compile()
7553                        adds the "\n" back, a "\0" is restored.  */
7554                     fbm_compile(sv, FBMcf_TAIL);
7555                 } else
7556                     fbm_compile(sv, 0);
7557             }
7558             if (prog->substrs->data[i].substr == prog->check_substr)
7559                 prog->check_utf8 = sv;
7560         }
7561     } while (i--);
7562 }
7563
7564 STATIC bool
7565 S_to_byte_substr(pTHX_ regexp *prog)
7566 {
7567     /* Converts substr fields in prog from UTF-8 to bytes, calling fbm_compile
7568      * on the converted value; returns FALSE if can't be converted. */
7569
7570     dVAR;
7571     int i = 1;
7572
7573     PERL_ARGS_ASSERT_TO_BYTE_SUBSTR;
7574
7575     do {
7576         if (prog->substrs->data[i].utf8_substr
7577             && !prog->substrs->data[i].substr) {
7578             SV* sv = newSVsv(prog->substrs->data[i].utf8_substr);
7579             if (! sv_utf8_downgrade(sv, TRUE)) {
7580                 return FALSE;
7581             }
7582             if (SvVALID(prog->substrs->data[i].utf8_substr)) {
7583                 if (SvTAIL(prog->substrs->data[i].utf8_substr)) {
7584                     /* Trim the trailing \n that fbm_compile added last
7585                         time.  */
7586                     SvCUR_set(sv, SvCUR(sv) - 1);
7587                     fbm_compile(sv, FBMcf_TAIL);
7588                 } else
7589                     fbm_compile(sv, 0);
7590             }
7591             prog->substrs->data[i].substr = sv;
7592             if (prog->substrs->data[i].utf8_substr == prog->check_utf8)
7593                 prog->check_substr = sv;
7594         }
7595     } while (i--);
7596
7597     return TRUE;
7598 }
7599
7600 /*
7601  * Local variables:
7602  * c-indentation-style: bsd
7603  * c-basic-offset: 4
7604  * indent-tabs-mode: nil
7605  * End:
7606  *
7607  * ex: set ts=8 sts=4 sw=4 et:
7608  */