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