In perl.git, the branch blead has been updated <http://perl5.git.perl.org/perl.git/commitdiff/4286711ac0be1bf8f37eadee54b2e9ebbb08e0d8?hp=6dcbb4af1832360387c3d6908d0265883509b607>
- Log ----------------------------------------------------------------- commit 4286711ac0be1bf8f37eadee54b2e9ebbb08e0d8 Author: Yves Orton <[email protected]> Date: Mon Oct 20 00:16:37 2014 +0200 regcomp.c: study_chunk(): Avoid unnecessary recursion. Avoid unnecessary recursion with regex subroutines. When we are inside of a DEFINE we do not need to, and should not, recurse. And once an infinite construct has been seen and we are not tracking the start class then we do not /need/ to, at the cost of possibly pessimizing minlen checks. For instance in /(?(DEFINE)(?<p>foo|wozzit))a+(?&p)/ entering 'p' via recursion would only tell us that the minlen was actually 4 instead of being 1, something that would not make us match incorrectly. This can be improved in a later commit. The side effect of not recursing in such situations is that large patterns such as that in RT #122283 compile in a reasonable amount of time. M regcomp.c commit 32c35d38c96a76c6f8360ea6854ad3f3fb462725 Author: Yves Orton <[email protected]> Date: Sun Oct 19 22:48:44 2014 +0200 regcomp.c: Add comment. M regcomp.c commit 64e04a51361b45dbbb94b038a93c7dc3cca0c7f9 Author: Yves Orton <[email protected]> Date: Sun Oct 19 22:48:14 2014 +0200 regcomp.c: study_chunk(): Reset the entire data struct, not just a bit of it. M regcomp.c commit fdfb4f2197409a1d793ee71f18be6e702a5461df Author: Yves Orton <[email protected]> Date: Sun Oct 19 22:45:35 2014 +0200 regcomp.c: Improve advanced re debug output use pv_pretty(), add better flags information, and a more compact recurse bitmap frame outpute, etc. M regcomp.c commit 4420a417a2575a2656eb120d4b4048ac9dfbd46e Author: Yves Orton <[email protected]> Date: Sun Oct 19 22:43:21 2014 +0200 dump.c: Add PERL_PV_PRETTY_EXACTSIZE option Sometimes we want things to fit exactly into a specific number of chars, elipses, quotes and all. Includes make regen update to make dsv argument nullok. M dump.c M embed.fnc M perl.h M proto.h commit 0a14d816d4f94b3847ccd7cea08086e2244d1e6e Author: Yves Orton <[email protected]> Date: Sun Oct 19 17:19:50 2014 +0200 regcomp.c: Fixup debug output so it matches other messages in context M regcomp.c commit 8b9781c905d8bc5e4fbf350df63e212283783324 Author: Yves Orton <[email protected]> Date: Wed Oct 15 23:03:35 2014 +0200 regcomp.c: Improve re debug output by showing buffer names if they exist Requires adding a new optional argument to regprop as we do not have a completed regexp object to give us the names, and we need to get it from RExC_state. M embed.fnc M embed.h M proto.h M regcomp.c M regexec.c commit e60d552100fc966cb2917d32cf2e708d20a6427f Author: Yves Orton <[email protected]> Date: Sun Oct 12 23:08:42 2014 +0200 regcomp.c: study_chunk(): improve branch-branch comment M regcomp.c commit d615717366f1596d4a1b18ce2ca5a224dc076107 Author: Yves Orton <[email protected]> Date: Sun Oct 12 23:05:11 2014 +0200 regcomp.c: study_chunk(): whitespace fixup for legibility M regcomp.c commit 3f910e62fcf6ddef8eaffcfa6554e5ff7df08a08 Author: Yves Orton <[email protected]> Date: Sun Oct 12 21:28:57 2014 +0200 regcomp.c: eliminate memory leak from GOSUB/GOSTART regops We can reuse previously allocated frames and avoid blowing up memory during regex compile of complex recursive patterns. A pattern like that reported in RT #122283 would chew up all avaiable memory allocating new frames each time it recursed. M regcomp.c commit c9f0d54c3bad1139a1b0758ca0d999437ed93c95 Author: Yves Orton <[email protected]> Date: Sun Oct 12 21:26:31 2014 +0200 regcomp.c: reuse temporary debugging temp sv's For dumping regex debug state we need some temporary SV's on hand to pass into regprop() which writes into an SV to do it's thing. Allocating a new mortal SV every time we want to do this is very wasteful, and manifests as a "leak" in very long compiles such as when debugging issues like RT #122283. By storing the SV's in RExC_state_t we can reuse them during the compilation process and avoid leaking memory for nothing. M regcomp.c commit abd6de04dbc807cb1270d565e5019376c04c77fd Author: Yves Orton <[email protected]> Date: Sun Oct 12 18:18:38 2014 +0200 regcomp.c: struct scan_frame: rename members for clarity Rename some members of scan_frame so it is easier to understand what they are for, in preparation for adding some more members. M regcomp.c ----------------------------------------------------------------------- Summary of changes: dump.c | 58 +++++--- embed.fnc | 7 +- embed.h | 2 +- perl.h | 28 ++-- proto.h | 15 +- regcomp.c | 489 ++++++++++++++++++++++++++++++++++++++++---------------------- regexec.c | 6 +- 7 files changed, 385 insertions(+), 220 deletions(-) diff --git a/dump.c b/dump.c index fe1c01b..4c5c76e 100644 --- a/dump.c +++ b/dump.c @@ -96,7 +96,10 @@ S_append_flags(pTHX_ SV *sv, U32 flags, const struct flag_to_name *start, Escapes at most the first "count" chars of pv and puts the results into dsv such that the size of the escaped string will not exceed "max" chars -and will not contain any incomplete escape sequences. +and will not contain any incomplete escape sequences. The number of bytes +escaped will be returned in the STRLEN *escaped parameter if it is not null. +When the dsv parameter is null no escaping actually occurs, but the number +of bytes that would be escaped were it not null will be calculated. If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string will also be escaped. @@ -151,7 +154,7 @@ Perl_pv_escape( pTHX_ SV *dsv, char const * const str, PERL_ARGS_ASSERT_PV_ESCAPE; - if (!(flags & PERL_PV_ESCAPE_NOCLEAR)) { + if (dsv && !(flags & PERL_PV_ESCAPE_NOCLEAR)) { /* This won't alter the UTF-8 flag */ sv_setpvs(dsv, ""); } @@ -221,7 +224,8 @@ Perl_pv_escape( pTHX_ SV *dsv, char const * const str, if ( max && (wrote + chsize > max) ) { break; } else if (chsize > 1) { - sv_catpvn(dsv, octbuf, chsize); + if (dsv) + sv_catpvn(dsv, octbuf, chsize); wrote += chsize; } else { /* If PERL_PV_ESCAPE_NOBACKSLASH is set then non-ASCII bytes @@ -230,7 +234,8 @@ Perl_pv_escape( pTHX_ SV *dsv, char const * const str, Or add a new API call sv_catpvc(). Think about that name, and how to keep it clear that it's unlike the s of catpvs, which is really an array of octets, not a string. */ - Perl_sv_catpvf( aTHX_ dsv, "%c", c); + if (dsv) + Perl_sv_catpvf( aTHX_ dsv, "%c", c); wrote++; } if ( flags & PERL_PV_ESCAPE_FIRSTCHAR ) @@ -238,7 +243,7 @@ Perl_pv_escape( pTHX_ SV *dsv, char const * const str, } if (escaped != NULL) *escaped= pv - str; - return SvPVX(dsv); + return dsv ? SvPVX(dsv) : NULL; } /* =for apidoc pv_pretty @@ -270,36 +275,51 @@ Perl_pv_pretty( pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags ) { - const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%'; + const U8 *quotes = (flags & PERL_PV_PRETTY_QUOTE) ? "\"\"" : + (flags & PERL_PV_PRETTY_LTGT) ? "<>" : NULL; STRLEN escaped; + STRLEN max_adjust= 0; + STRLEN orig_cur; PERL_ARGS_ASSERT_PV_PRETTY; if (!(flags & PERL_PV_PRETTY_NOCLEAR)) { - /* This won't alter the UTF-8 flag */ - sv_setpvs(dsv, ""); + /* This won't alter the UTF-8 flag */ + sv_setpvs(dsv, ""); } + orig_cur= SvCUR(dsv); - if ( dq == '"' ) - sv_catpvs(dsv, "\""); - else if ( flags & PERL_PV_PRETTY_LTGT ) - sv_catpvs(dsv, "<"); + if ( quotes ) + Perl_sv_catpvf(aTHX_ dsv, "%c", quotes[0]); if ( start_color != NULL ) sv_catpv(dsv, start_color); - - pv_escape( dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR ); - + + if ((flags & PERL_PV_PRETTY_EXACTSIZE)) { + if (quotes) + max_adjust += 2; + assert(max > max_adjust); + pv_escape( NULL, str, count, max - max_adjust, &escaped, flags ); + if ( (flags & PERL_PV_PRETTY_ELLIPSES) && ( escaped < count ) ) + max_adjust += 3; + assert(max > max_adjust); + } + + pv_escape( dsv, str, count, max - max_adjust, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR ); + if ( end_color != NULL ) sv_catpv(dsv, end_color); - if ( dq == '"' ) - sv_catpvs( dsv, "\""); - else if ( flags & PERL_PV_PRETTY_LTGT ) - sv_catpvs(dsv, ">"); + if ( quotes ) + Perl_sv_catpvf(aTHX_ dsv, "%c", quotes[1]); if ( (flags & PERL_PV_PRETTY_ELLIPSES) && ( escaped < count ) ) sv_catpvs(dsv, "..."); + + if ((flags & PERL_PV_PRETTY_EXACTSIZE)) { + while( SvCUR(dsv) - orig_cur < max ) + sv_catpvs(dsv," "); + } return SvPVX(dsv); } diff --git a/embed.fnc b/embed.fnc index bceca6b..faef450 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1219,7 +1219,6 @@ EXp |I32|reg_numbered_buff_length|NN REGEXP * const rx|NN const SV * const sv|co EXp |SV*|reg_qr_package|NN REGEXP * const rx : FIXME - why the E? -Ep |void |regprop |NULLOK const regexp *prog|NN SV* sv|NN const regnode* o|NULLOK const regmatch_info *reginfo Anp |void |repeatcpy |NN char* to|NN const char* from|I32 len|IV count AnpP |char* |rninstr |NN const char* big|NN const char* bigend \ |NN const char* little|NN const char* lend @@ -1750,7 +1749,7 @@ Apdbm |void |sv_usepvn_mg |NN SV *sv|NULLOK char *ptr|STRLEN len ApR |MGVTBL*|get_vtbl |int vtbl_id Apd |char* |pv_display |NN SV *dsv|NN const char *pv|STRLEN cur|STRLEN len \ |STRLEN pvlim -Apd |char* |pv_escape |NN SV *dsv|NN char const * const str\ +Apd |char* |pv_escape |NULLOK SV *dsv|NN char const * const str\ |const STRLEN count|const STRLEN max\ |NULLOK STRLEN * const escaped\ |const U32 flags @@ -2095,6 +2094,10 @@ p |OP * |tied_method|NN SV *methname|NN SV **sp \ |NN SV *const sv|NN const MAGIC *const mg \ |const U32 flags|U32 argc|... +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) +Ep |void |regprop |NULLOK const regexp *prog|NN SV* sv|NN const regnode* o|NULLOK const regmatch_info *reginfo \ + |NULLOK const RExC_state_t *pRExC_state +#endif #if defined(PERL_IN_REGCOMP_C) Es |regnode*|reg |NN RExC_state_t *pRExC_state \ |I32 paren|NN I32 *flagp|U32 depth diff --git a/embed.h b/embed.h index 8231b87..6594a6c 100644 --- a/embed.h +++ b/embed.h @@ -912,7 +912,6 @@ #define reg_numbered_buff_store(a,b,c) Perl_reg_numbered_buff_store(aTHX_ a,b,c) #define reg_qr_package(a) Perl_reg_qr_package(aTHX_ a) #define reg_temp_copy(a,b) Perl_reg_temp_copy(aTHX_ a,b) -#define regprop(a,b,c,d) Perl_regprop(aTHX_ a,b,c,d) #define report_uninit(a) Perl_report_uninit(aTHX_ a) #define sv_magicext_mglob(a) Perl_sv_magicext_mglob(aTHX_ a) #define validate_proto(a,b,c) Perl_validate_proto(aTHX_ a,b,c) @@ -1016,6 +1015,7 @@ # endif # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) #define _load_PL_utf8_foldclosures() Perl__load_PL_utf8_foldclosures(aTHX) +#define regprop(a,b,c,d,e) Perl_regprop(aTHX_ a,b,c,d,e) # endif # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) #define _get_swash_invlist(a) Perl__get_swash_invlist(aTHX_ a) diff --git a/perl.h b/perl.h index 0bd8a53..27aa70b 100644 --- a/perl.h +++ b/perl.h @@ -6295,26 +6295,26 @@ extern void moncontrol(int); * passed straight through to _escape. */ -#define PERL_PV_ESCAPE_QUOTE 0x0001 +#define PERL_PV_ESCAPE_QUOTE 0x000001 #define PERL_PV_PRETTY_QUOTE PERL_PV_ESCAPE_QUOTE -#define PERL_PV_PRETTY_ELLIPSES 0x0002 -#define PERL_PV_PRETTY_LTGT 0x0004 +#define PERL_PV_PRETTY_ELLIPSES 0x000002 +#define PERL_PV_PRETTY_LTGT 0x000004 +#define PERL_PV_PRETTY_EXACTSIZE 0x000008 -#define PERL_PV_ESCAPE_FIRSTCHAR 0x0008 +#define PERL_PV_ESCAPE_UNI 0x000100 +#define PERL_PV_ESCAPE_UNI_DETECT 0x000200 +#define PERL_PV_ESCAPE_NONASCII 0x000400 +#define PERL_PV_ESCAPE_FIRSTCHAR 0x000800 -#define PERL_PV_ESCAPE_UNI 0x0100 -#define PERL_PV_ESCAPE_UNI_DETECT 0x0200 -#define PERL_PV_ESCAPE_NONASCII 0x0400 - -#define PERL_PV_ESCAPE_ALL 0x1000 -#define PERL_PV_ESCAPE_NOBACKSLASH 0x2000 -#define PERL_PV_ESCAPE_NOCLEAR 0x4000 -#define PERL_PV_ESCAPE_RE 0x8000 +#define PERL_PV_ESCAPE_ALL 0x001000 +#define PERL_PV_ESCAPE_NOBACKSLASH 0x002000 +#define PERL_PV_ESCAPE_NOCLEAR 0x004000 +#define PERL_PV_PRETTY_NOCLEAR PERL_PV_ESCAPE_NOCLEAR +#define PERL_PV_ESCAPE_RE 0x008000 -#define PERL_PV_ESCAPE_DWIM 0x10000 +#define PERL_PV_ESCAPE_DWIM 0x010000 -#define PERL_PV_PRETTY_NOCLEAR PERL_PV_ESCAPE_NOCLEAR /* used by pv_display in dump.c*/ #define PERL_PV_PRETTY_DUMP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE diff --git a/proto.h b/proto.h index 0423160..b9e3048 100644 --- a/proto.h +++ b/proto.h @@ -3439,10 +3439,9 @@ PERL_CALLCONV char* Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, S assert(dsv); assert(pv) PERL_CALLCONV char* Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags) - __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_PV_ESCAPE \ - assert(dsv); assert(str) + assert(str) PERL_CALLCONV char* Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags) __attribute__nonnull__(pTHX_1) @@ -3626,12 +3625,6 @@ PERL_CALLCONV void Perl_reginitcolors(pTHX); PERL_CALLCONV regnode* Perl_regnext(pTHX_ regnode* p) __attribute__warn_unused_result__; -PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o, const regmatch_info *reginfo) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); -#define PERL_ARGS_ASSERT_REGPROP \ - assert(sv); assert(o) - PERL_CALLCONV void Perl_repeatcpy(char* to, const char* from, I32 len, IV count) __attribute__nonnull__(1) __attribute__nonnull__(2); @@ -7198,6 +7191,12 @@ PERL_CALLCONV SV* Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, co assert(node) PERL_CALLCONV void Perl__load_PL_utf8_foldclosures(pTHX); +PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state) + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_3); +#define PERL_ARGS_ASSERT_REGPROP \ + assert(sv); assert(o) + #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV SV* Perl__get_swash_invlist(pTHX_ SV* const swash) diff --git a/regcomp.c b/regcomp.c index ebda789..5fe3c9c 100644 --- a/regcomp.c +++ b/regcomp.c @@ -106,6 +106,22 @@ EXTERN_C const struct regexp_engine my_reg_engine; #define MIN(a,b) ((a) < (b) ? (a) : (b)) #endif +/* this is a chain of data about sub patterns we are processing that + need to be handled separately/specially in study_chunk. Its so + we can simulate recursion without losing state. */ +struct scan_frame; +typedef struct scan_frame { + regnode *last_regnode; /* last node to process in this frame */ + regnode *next_regnode; /* next node to process when last is reached */ + U32 prev_recursed_depth; + I32 stopparen; /* what stopparen do we use */ + U32 is_top_frame; /* what flags do we use? */ + + struct scan_frame *this_prev_frame; /* this previous frame */ + struct scan_frame *prev_frame; /* previous frame */ + struct scan_frame *next_frame; /* next frame */ +} scan_frame; + struct RExC_state_t { U32 flags; /* RXf_* are we folding, multilining? */ U32 pm_flags; /* PMf_* stuff from the calling PMOP */ @@ -152,7 +168,7 @@ struct RExC_state_t { regnode **recurse; /* Recurse regops */ I32 recurse_count; /* Number of recurse regops */ - U8 *study_chunk_recursed; /* bitmap of which parens we have moved + U8 *study_chunk_recursed; /* bitmap of which subs we have moved through */ U32 study_chunk_recursed_bytes; /* bytes in bitmap */ I32 in_lookbehind; @@ -165,6 +181,9 @@ struct RExC_state_t { int num_code_blocks; /* size of code_blocks[] */ int code_index; /* next code_blocks[] slot */ SSize_t maxlen; /* mininum possible number of chars in string to match */ + scan_frame *frame_head; + scan_frame *frame_last; + U32 frame_count; #ifdef ADD_TO_REGEXEC char *starttry; /* -Dr: where regtry was called. */ #define RExC_starttry (pRExC_state->starttry) @@ -175,10 +194,16 @@ struct RExC_state_t { I32 lastnum; AV *paren_name_list; /* idx -> name */ U32 study_chunk_recursed_count; + SV *mysv1; + SV *mysv2; #define RExC_lastparse (pRExC_state->lastparse) #define RExC_lastnum (pRExC_state->lastnum) #define RExC_paren_name_list (pRExC_state->paren_name_list) #define RExC_study_chunk_recursed_count (pRExC_state->study_chunk_recursed_count) +#define RExC_mysv (pRExC_state->mysv1) +#define RExC_mysv1 (pRExC_state->mysv1) +#define RExC_mysv2 (pRExC_state->mysv2) + #endif }; @@ -226,6 +251,9 @@ struct RExC_state_t { #define RExC_contains_i (pRExC_state->contains_i) #define RExC_override_recoding (pRExC_state->override_recoding) #define RExC_in_multi_char_class (pRExC_state->in_multi_char_class) +#define RExC_frame_head (pRExC_state->frame_head) +#define RExC_frame_last (pRExC_state->frame_last) +#define RExC_frame_count (pRExC_state->frame_count) #define ISMULT1(c) ((c) == '*' || (c) == '+' || (c) == '?') @@ -416,6 +444,10 @@ static const scan_data_t zero_scan_data = #define SCF_TRIE_RESTUDY 0x4000 /* Do restudy? */ #define SCF_SEEN_ACCEPT 0x8000 #define SCF_TRIE_DOING_RESTUDY 0x10000 +#define SCF_IN_DEFINE 0x20000 + + + #define UTF cBOOL(RExC_utf8) @@ -777,15 +809,44 @@ static const scan_data_t zero_scan_data = PerlIO_printf(Perl_debug_log,"\n"); \ }); +#define DEBUG_SHOW_STUDY_FLAG(flags,flag) \ + if ((flags) & flag) PerlIO_printf(Perl_debug_log, "%s ", #flag) + +#define DEBUG_SHOW_STUDY_FLAGS(flags,open_str,close_str) \ + if ( ( flags ) ) { \ + PerlIO_printf(Perl_debug_log, "%s", open_str); \ + DEBUG_SHOW_STUDY_FLAG(flags,SF_FL_BEFORE_SEOL); \ + DEBUG_SHOW_STUDY_FLAG(flags,SF_FL_BEFORE_MEOL); \ + DEBUG_SHOW_STUDY_FLAG(flags,SF_IS_INF); \ + DEBUG_SHOW_STUDY_FLAG(flags,SF_HAS_PAR); \ + DEBUG_SHOW_STUDY_FLAG(flags,SF_IN_PAR); \ + DEBUG_SHOW_STUDY_FLAG(flags,SF_HAS_EVAL); \ + DEBUG_SHOW_STUDY_FLAG(flags,SCF_DO_SUBSTR); \ + DEBUG_SHOW_STUDY_FLAG(flags,SCF_DO_STCLASS_AND); \ + DEBUG_SHOW_STUDY_FLAG(flags,SCF_DO_STCLASS_OR); \ + DEBUG_SHOW_STUDY_FLAG(flags,SCF_DO_STCLASS); \ + DEBUG_SHOW_STUDY_FLAG(flags,SCF_WHILEM_VISITED_POS); \ + DEBUG_SHOW_STUDY_FLAG(flags,SCF_TRIE_RESTUDY); \ + DEBUG_SHOW_STUDY_FLAG(flags,SCF_SEEN_ACCEPT); \ + DEBUG_SHOW_STUDY_FLAG(flags,SCF_TRIE_DOING_RESTUDY); \ + DEBUG_SHOW_STUDY_FLAG(flags,SCF_IN_DEFINE); \ + PerlIO_printf(Perl_debug_log, "%s", close_str); \ + } + + #define DEBUG_STUDYDATA(str,data,depth) \ DEBUG_OPTIMISE_MORE_r(if(data){ \ PerlIO_printf(Perl_debug_log, \ "%*s" str "Pos:%"IVdf"/%"IVdf \ - " Flags: 0x%"UVXf" Whilem_c: %"IVdf" Lcp: %"IVdf" %s", \ + " Flags: 0x%"UVXf, \ (int)(depth)*2, "", \ (IV)((data)->pos_min), \ (IV)((data)->pos_delta), \ - (UV)((data)->flags), \ + (UV)((data)->flags) \ + ); \ + DEBUG_SHOW_STUDY_FLAGS((data)->flags," [ ","]"); \ + PerlIO_printf(Perl_debug_log, \ + " Whilem_c: %"IVdf" Lcp: %"IVdf" %s", \ (IV)((data)->whilem_c), \ (IV)((data)->last_closep ? *((data)->last_closep) : -1), \ is_inf ? "INF " : "" \ @@ -3201,15 +3262,15 @@ S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *sour #define DEBUG_PEEP(str,scan,depth) \ DEBUG_OPTIMISE_r({if (scan){ \ - SV * const mysv=sv_newmortal(); \ regnode *Next = regnext(scan); \ - regprop(RExC_rx, mysv, scan, NULL); \ - PerlIO_printf(Perl_debug_log, "%*s" str ">%3d: %s (%d)\n", \ - (int)depth*2, "", REG_NODE_NUM(scan), SvPV_nolen_const(mysv),\ - Next ? (REG_NODE_NUM(Next)) : 0 ); \ + regprop(RExC_rx, RExC_mysv, scan, NULL, pRExC_state); \ + PerlIO_printf(Perl_debug_log, "%*s" str ">%3d: %s (%d)", \ + (int)depth*2, "", REG_NODE_NUM(scan), SvPV_nolen_const(RExC_mysv),\ + Next ? (REG_NODE_NUM(Next)) : 0 ); \ + DEBUG_SHOW_STUDY_FLAGS(flags," [ ","]");\ + PerlIO_printf(Perl_debug_log, "\n"); \ }}); - /* The below joins as many adjacent EXACTish nodes as possible into a single * one. The regop may be changed if the node(s) contain certain sequences that * require special handling. The joining is only done if: @@ -3650,17 +3711,17 @@ S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, Newx(and_withp,1, regnode_ssc); \ SAVEFREEPV(and_withp) -/* this is a chain of data about sub patterns we are processing that - need to be handled separately/specially in study_chunk. Its so - we can simulate recursion without losing state. */ -struct scan_frame; -typedef struct scan_frame { - regnode *last; /* last node to process in this frame */ - regnode *next; /* next node to process when last is reached */ - struct scan_frame *prev; /*previous frame*/ - U32 prev_recursed_depth; - I32 stop; /* what stopparen do we use */ -} scan_frame; + +static void +S_unwind_scan_frames(pTHX_ const void *p) +{ + scan_frame *f= (scan_frame *)p; + do { + scan_frame *n= f->next_frame; + Safefree(f); + f= n; + } while (f); +} STATIC SSize_t @@ -3697,9 +3758,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, PERL_ARGS_ASSERT_STUDY_CHUNK; -#ifdef DEBUGGING - StructCopy(&zero_scan_data, &data_fake, scan_data_t); -#endif + if ( depth == 0 ) { while (first_non_open && OP(first_non_open) == OPEN) first_non_open=regnext(first_non_open); @@ -3710,36 +3769,47 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, DEBUG_r( RExC_study_chunk_recursed_count++; ); + DEBUG_OPTIMISE_MORE_r( + { + PerlIO_printf(Perl_debug_log, + "%*sstudy_chunk stopparen=%ld recursed_count=%lu depth=%lu recursed_depth=%lu scan=%p last=%p", + ((int) depth*2), "", (long)stopparen, + (unsigned long)RExC_study_chunk_recursed_count, + (unsigned long)depth, (unsigned long)recursed_depth, + scan, + last); + if (recursed_depth) { + U32 i; + U32 j; + for ( j = 0 ; j < recursed_depth ; j++ ) { + for ( i = 0 ; i < (U32)RExC_npar ; i++ ) { + if ( + PAREN_TEST(RExC_study_chunk_recursed + + ( j * RExC_study_chunk_recursed_bytes), i ) + && ( + !j || + !PAREN_TEST(RExC_study_chunk_recursed + + (( j - 1 ) * RExC_study_chunk_recursed_bytes), i) + ) + ) { + PerlIO_printf(Perl_debug_log," %d",i); + break; + } + } + if ( j + 1 < recursed_depth ) { + PerlIO_printf(Perl_debug_log, ","); + } + } + } + PerlIO_printf(Perl_debug_log,"\n"); + } + ); while ( scan && OP(scan) != END && scan < last ){ UV min_subtract = 0; /* How mmany chars to subtract from the minimum node length to get a real minimum (because the folded version may be shorter) */ bool unfolded_multi_char = FALSE; /* Peephole optimizer: */ - DEBUG_OPTIMISE_MORE_r( - { - PerlIO_printf(Perl_debug_log, - "%*sstudy_chunk stopparen=%ld recursed_count=%lu depth=%lu recursed_depth=%lu ", - ((int) depth*2), "", (long)stopparen, - (unsigned long)RExC_study_chunk_recursed_count, - (unsigned long)depth, (unsigned long)recursed_depth); - if (recursed_depth) { - U32 i; - U32 j; - for ( j = 0 ; j < recursed_depth ; j++ ) { - PerlIO_printf(Perl_debug_log,"["); - for ( i = 0 ; i < (U32)RExC_npar ; i++ ) - PerlIO_printf(Perl_debug_log,"%d", - PAREN_TEST(RExC_study_chunk_recursed + - (j * RExC_study_chunk_recursed_bytes), i) - ? 1 : 0 - ); - PerlIO_printf(Perl_debug_log,"]"); - } - } - PerlIO_printf(Perl_debug_log,"\n"); - } - ); DEBUG_STUDYDATA("Peep:", data, depth); DEBUG_PEEP("Peep", scan, depth); @@ -3773,17 +3843,47 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, NEXT_OFF(scan) = off; } - - /* The principal pseudo-switch. Cannot be a switch, since we look into several different things. */ - if (OP(scan) == BRANCH || OP(scan) == BRANCHJ - || OP(scan) == IFTHEN) { + if ( OP(scan) == DEFINEP ) { + SSize_t minlen = 0; + SSize_t deltanext = 0; + SSize_t fake_last_close = 0; + I32 f = SCF_IN_DEFINE; + + StructCopy(&zero_scan_data, &data_fake, scan_data_t); + scan = regnext(scan); + assert( OP(scan) == IFTHEN ); + DEBUG_PEEP("expect IFTHEN", scan, depth); + + data_fake.last_closep= &fake_last_close; + minlen = *minlenp; + next = regnext(scan); + scan = NEXTOPER(NEXTOPER(scan)); + DEBUG_PEEP("scan", scan, depth); + DEBUG_PEEP("next", next, depth); + + /* we suppose the run is continuous, last=next... + * NOTE we dont use the return here! */ + (void)study_chunk(pRExC_state, &scan, &minlen, + &deltanext, next, &data_fake, stopparen, + recursed_depth, NULL, f, depth+1); + + scan = next; + } else + if ( + OP(scan) == BRANCH || + OP(scan) == BRANCHJ || + OP(scan) == IFTHEN + ) { next = regnext(scan); code = OP(scan); - /* demq: the op(next)==code check is to see if we have - * "branch-branch" AFAICT */ + /* The op(next)==code check below is to see if we + * have "BRANCH-BRANCH", "BRANCHJ-BRANCHJ", "IFTHEN-IFTHEN" + * IFTHEN is special as it might not appear in pairs. + * Not sure whether BRANCH-BRANCHJ is possible, regardless + * we dont handle it cleanly. */ if (OP(next) == code || code == IFTHEN) { /* NOTE - There is similar code to this block below for * handling TRIE nodes on a re-study. If you change stuff here @@ -3805,8 +3905,10 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 f = 0; regnode_ssc this_class; + DEBUG_PEEP("Branch", scan, depth); + num++; - data_fake.flags = 0; + StructCopy(&zero_scan_data, &data_fake, scan_data_t); if (data) { data_fake.whilem_c = data->whilem_c; data_fake.last_closep = data->last_closep; @@ -3816,9 +3918,11 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, data_fake.pos_delta = delta; next = regnext(scan); - scan = NEXTOPER(scan); - if (code != BRANCH) + + scan = NEXTOPER(scan); /* everything */ + if (code != BRANCH) /* everything but BRANCH */ scan = NEXTOPER(scan); + if (flags & SCF_DO_STCLASS) { ssc_init(pRExC_state, &this_class); data_fake.start_class = &this_class; @@ -3831,6 +3935,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, minnext = study_chunk(pRExC_state, &scan, minlenp, &deltanext, next, &data_fake, stopparen, recursed_depth, NULL, f,depth+1); + if (min1 > minnext) min1 = minnext; if (deltanext == SSize_t_MAX) { @@ -3956,9 +4061,6 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, U8 trietype = 0; U32 count=0; -#ifdef DEBUGGING - SV * const mysv = sv_newmortal(); /* for dumping */ -#endif /* var tail is used because there may be a TAIL regop in the way. Ie, the exacts will point to the thing following the TAIL, but the last branch will @@ -3974,11 +4076,11 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, DEBUG_TRIE_COMPILE_r({ - regprop(RExC_rx, mysv, tail, NULL); + regprop(RExC_rx, RExC_mysv, tail, NULL, pRExC_state); PerlIO_printf( Perl_debug_log, "%*s%s%s\n", (int)depth * 2 + 2, "", "Looking for TRIE'able sequences. Tail node is: ", - SvPV_nolen_const( mysv ) + SvPV_nolen_const( RExC_mysv ) ); }); @@ -4055,18 +4157,18 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, #endif DEBUG_TRIE_COMPILE_r({ - regprop(RExC_rx, mysv, cur, NULL); + regprop(RExC_rx, RExC_mysv, cur, NULL, pRExC_state); PerlIO_printf( Perl_debug_log, "%*s- %s (%d)", - (int)depth * 2 + 2,"", SvPV_nolen_const( mysv ), REG_NODE_NUM(cur) ); + (int)depth * 2 + 2,"", SvPV_nolen_const( RExC_mysv ), REG_NODE_NUM(cur) ); - regprop(RExC_rx, mysv, noper, NULL); + regprop(RExC_rx, RExC_mysv, noper, NULL, pRExC_state); PerlIO_printf( Perl_debug_log, " -> %s", - SvPV_nolen_const(mysv)); + SvPV_nolen_const(RExC_mysv)); if ( noper_next ) { - regprop(RExC_rx, mysv, noper_next, NULL); + regprop(RExC_rx, RExC_mysv, noper_next, NULL, pRExC_state); PerlIO_printf( Perl_debug_log,"\t=> %s\t", - SvPV_nolen_const(mysv)); + SvPV_nolen_const(RExC_mysv)); } PerlIO_printf( Perl_debug_log, "(First==%d,Last==%d,Cur==%d,tt==%s,nt==%s,nnt==%s)\n", REG_NODE_NUM(first), REG_NODE_NUM(last), REG_NODE_NUM(cur), @@ -4163,11 +4265,11 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, } /* end handle unmergable node */ } /* loop over branches */ DEBUG_TRIE_COMPILE_r({ - regprop(RExC_rx, mysv, cur, NULL); + regprop(RExC_rx, RExC_mysv, cur, NULL, pRExC_state); PerlIO_printf( Perl_debug_log, "%*s- %s (%d) <SCAN FINISHED>\n", (int)depth * 2 + 2, - "", SvPV_nolen_const( mysv ),REG_NODE_NUM(cur)); + "", SvPV_nolen_const( RExC_mysv ),REG_NODE_NUM(cur)); }); if ( last && trietype ) { @@ -4203,10 +4305,10 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, * something like this: (?:|) So we can * turn it into a plain NOTHING op. */ DEBUG_TRIE_COMPILE_r({ - regprop(RExC_rx, mysv, cur, NULL); + regprop(RExC_rx, RExC_mysv, cur, NULL, pRExC_state); PerlIO_printf( Perl_debug_log, "%*s- %s (%d) <NOTHING BRANCH SEQUENCE>\n", (int)depth * 2 + 2, - "", SvPV_nolen_const( mysv ),REG_NODE_NUM(cur)); + "", SvPV_nolen_const( RExC_mysv ),REG_NODE_NUM(cur)); }); OP(startbranch)= NOTHING; @@ -4227,46 +4329,53 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, scan = NEXTOPER(scan); continue; } else if (OP(scan) == SUSPEND || OP(scan) == GOSUB || OP(scan) == GOSTART) { - scan_frame *newframe = NULL; - I32 paren; - regnode *start; - regnode *end; + I32 paren = 0; + regnode *start = NULL; + regnode *end = NULL; U32 my_recursed_depth= recursed_depth; + if (OP(scan) != SUSPEND) { /* GOSUB/GOSTART */ - /* set the pointer */ + /* Do setup, note this code has side effects beyond + * the rest of this block. Specifically setting + * RExC_recurse[] must happen at least once during + * study_chunk(). */ if (OP(scan) == GOSUB) { paren = ARG(scan); RExC_recurse[ARG2L(scan)] = scan; start = RExC_open_parens[paren-1]; end = RExC_close_parens[paren-1]; } else { - paren = 0; start = RExC_rxi->program + 1; end = RExC_opend; } - /* this code is intended to handle expanding regex "subs" so - * we can apply various optimizations. For instance with - * /(?(DEFINE)(?<foo>foo)(?<bar>bar))(?&foo)(?&bar)/ we - * want to recognize that the mandatory substr is going to be - * "foobar". - * However if we are not in SCF_DO_SUBSTR mode then there is - * no point in doing this, and it can cause a serious slowdown. - * See RT #122283. - * Note also that this was a workaround for the core problem - * which was that during compilation logic the excessive - * recursion resulted in slowly consuming all the memory on - * the box. Exactly what causes this is unclear. It does not - * appear to be directly related to allocating the "visited" - * bitmaps that is RExC_study_chunk_recursed. - * - * In reality study_chunk() does far far too much, and probably - * this an other issues would go away if we split it into - * multiple components. - * - * - Yves - * */ - if (flags & SCF_DO_SUBSTR) { + /* NOTE we MUST always execute the above code, even + * if we do nothing with a GOSUB/GOSTART */ + if ( + ( flags & SCF_IN_DEFINE ) + || + ( + (is_inf_internal || is_inf || data->flags & SF_IS_INF) + && + ( (flags & (SCF_DO_STCLASS | SCF_DO_SUBSTR)) == 0 ) + ) + ) { + /* no need to do anything here if we are in a define. */ + /* or we are after some kind of infinite construct + * so we can skip recursing into this item. + * Since it is infinite we will not change the maxlen + * or delta, and if we miss something that might raise + * the minlen it will merely pessimise a little. + * + * Iow /(?(DEFINE)(?<foo>foo|food))a+(?&foo)/ + * might result in a minlen of 1 and not of 4, + * but this doesn't make us mismatch, just try a bit + * harder than we should. + * */ + scan= regnext(scan); + continue; + } + if ( !recursed_depth || @@ -4293,7 +4402,6 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, DEBUG_STUDYDATA("set:", data,depth); PAREN_SET(RExC_study_chunk_recursed + (recursed_depth * RExC_study_chunk_recursed_bytes), paren); my_recursed_depth= recursed_depth + 1; - Newx(newframe,1,scan_frame); } else { DEBUG_STUDYDATA("inf:", data,depth); /* some form of infinite recursion, assume infinite length @@ -4306,23 +4414,37 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, if (flags & SCF_DO_STCLASS_OR) /* Allow everything */ ssc_anything(data->start_class); flags &= ~SCF_DO_STCLASS; + + start= NULL; /* reset start so we dont recurse later on. */ } - } } else { - Newx(newframe,1,scan_frame); paren = stopparen; - start = scan+2; + start = scan + 2; end = regnext(scan); } - if (newframe) { - assert(start); + if (start) { + scan_frame *newframe; assert(end); - SAVEFREEPV(newframe); - newframe->next = regnext(scan); - newframe->last = last; - newframe->stop = stopparen; - newframe->prev = frame; + if (!RExC_frame_last) { + Newxz(newframe, 1, scan_frame); + SAVEDESTRUCTOR_X(S_unwind_scan_frames, newframe); + RExC_frame_head= newframe; + RExC_frame_count++; + } else if (!RExC_frame_last->next_frame) { + Newxz(newframe,1,scan_frame); + RExC_frame_last->next_frame= newframe; + newframe->prev_frame= RExC_frame_last; + RExC_frame_count++; + } else { + newframe= RExC_frame_last->next_frame; + } + RExC_frame_last= newframe; + + newframe->next_regnode = regnext(scan); + newframe->last_regnode = last; + newframe->stopparen = stopparen; newframe->prev_recursed_depth = recursed_depth; + newframe->this_prev_frame= frame; DEBUG_STUDYDATA("frame-new:",data,depth); DEBUG_PEEP("fnew", scan, depth); @@ -4388,8 +4510,8 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, } flags &= ~SCF_DO_STCLASS; } - else if (PL_regkind[OP(scan)] == EXACT) { /* But OP != EXACT!, so is - EXACTFish */ + else if (PL_regkind[OP(scan)] == EXACT) { + /* But OP != EXACT!, so is EXACTFish */ SSize_t l = STR_LEN(scan); UV uc = *((U8*)STRING(scan)); SV* EXACTF_invlist = _new_invlist(4); /* Start out big enough for 2 @@ -5181,14 +5303,13 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVuf" RHS=%"UVuf"\n", regnode *opt; regnode *upto= regnext(scan); DEBUG_PARSE_r({ - SV * const mysv_val=sv_newmortal(); DEBUG_STUDYDATA("OPFAIL",data,depth); /*DEBUG_PARSE_MSG("opfail");*/ - regprop(RExC_rx, mysv_val, upto, NULL); + regprop(RExC_rx, RExC_mysv, upto, NULL, pRExC_state); PerlIO_printf(Perl_debug_log, "~ replace with OPFAIL pointed at %s (%"IVdf") offset %"IVdf"\n", - SvPV_nolen_const(mysv_val), + SvPV_nolen_const(RExC_mysv), (IV)REG_NODE_NUM(upto), (IV)(upto - scan) ); @@ -5212,7 +5333,7 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVuf" RHS=%"UVuf"\n", regnode_ssc intrnl; int f = 0; - data_fake.flags = 0; + StructCopy(&zero_scan_data, &data_fake, scan_data_t); if (data) { data_fake.whilem_c = data->whilem_c; data_fake.last_closep = data->last_closep; @@ -5456,7 +5577,7 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVuf" RHS=%"UVuf"\n", SSize_t deltanext=0, minnext=0, f = 0, fake; regnode_ssc this_class; - data_fake.flags = 0; + StructCopy(&zero_scan_data, &data_fake, scan_data_t); if (data) { data_fake.whilem_c = data->whilem_c; data_fake.last_closep = data->last_closep; @@ -5579,16 +5700,19 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVuf" RHS=%"UVuf"\n", } */ if (frame) { + depth = depth - 1; + DEBUG_STUDYDATA("frame-end:",data,depth); DEBUG_PEEP("fend", scan, depth); + /* restore previous context */ - last = frame->last; - scan = frame->next; - stopparen = frame->stop; + last = frame->last_regnode; + scan = frame->next_regnode; + stopparen = frame->stopparen; recursed_depth = frame->prev_recursed_depth; - depth = depth - 1; - frame = frame->prev; + RExC_frame_last = frame->prev_frame; + frame = frame->this_prev_frame; goto fake_study_recurse; } @@ -6535,7 +6659,14 @@ Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, RExC_contains_locale = 0; RExC_contains_i = 0; pRExC_state->runtime_code_qr = NULL; + RExC_frame_head= NULL; + RExC_frame_last= NULL; + RExC_frame_count= 0; + DEBUG_r({ + RExC_mysv1= sv_newmortal(); + RExC_mysv2= sv_newmortal(); + }); DEBUG_COMPILE_r({ SV *dsv= sv_newmortal(); RE_PV_QUOTED_DECL(s, RExC_utf8, dsv, exp, plen, 60); @@ -6873,9 +7004,11 @@ reStudy: RExC_study_chunk_recursed_count= 0; ); Zero(r->substrs, 1, struct reg_substr_data); - if (RExC_study_chunk_recursed) + if (RExC_study_chunk_recursed) { Zero(RExC_study_chunk_recursed, RExC_study_chunk_recursed_bytes * RExC_npar, U8); + } + #ifdef TRIE_STUDY_OPT if (!restudied) { @@ -7150,7 +7283,7 @@ reStudy: ri->regstclass = (regnode*)RExC_rxi->data->data[n]; r->intflags &= ~PREGf_SKIP; /* Used in find_byclass(). */ DEBUG_COMPILE_r({ SV *sv = sv_newmortal(); - regprop(r, sv, (regnode*)data.start_class, NULL); + regprop(r, sv, (regnode*)data.start_class, NULL, pRExC_state); PerlIO_printf(Perl_debug_log, "synthetic stclass \"%s\".\n", SvPVX_const(sv));}); @@ -7230,7 +7363,7 @@ reStudy: ri->regstclass = (regnode*)RExC_rxi->data->data[n]; r->intflags &= ~PREGf_SKIP; /* Used in find_byclass(). */ DEBUG_COMPILE_r({ SV* sv = sv_newmortal(); - regprop(r, sv, (regnode*)data.start_class, NULL); + regprop(r, sv, (regnode*)data.start_class, NULL, pRExC_state); PerlIO_printf(Perl_debug_log, "synthetic stclass \"%s\".\n", SvPVX_const(sv));}); @@ -7882,22 +8015,20 @@ S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags) } #define DEBUG_PARSE_MSG(funcname) DEBUG_PARSE_r({ \ - int rem=(int)(RExC_end - RExC_parse); \ - int cut; \ int num; \ - int iscut=0; \ - if (rem>10) { \ - rem=10; \ - iscut=1; \ - } \ - cut=10-rem; \ - if (RExC_lastparse!=RExC_parse) \ - PerlIO_printf(Perl_debug_log," >%.*s%-*s", \ - rem, RExC_parse, \ - cut + 4, \ - iscut ? "..." : "<" \ + if (RExC_lastparse!=RExC_parse) { \ + PerlIO_printf(Perl_debug_log, "%s", \ + Perl_pv_pretty(aTHX_ RExC_mysv1, RExC_parse, \ + RExC_end - RExC_parse, 16, \ + "", "", \ + PERL_PV_ESCAPE_UNI_DETECT | \ + PERL_PV_PRETTY_ELLIPSES | \ + PERL_PV_PRETTY_LTGT | \ + PERL_PV_ESCAPE_RE | \ + PERL_PV_PRETTY_EXACTSIZE \ + ) \ ); \ - else \ + } else \ PerlIO_printf(Perl_debug_log,"%16s",""); \ \ if (SIZE_ONLY) \ @@ -10015,7 +10146,8 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp,U32 depth) } RExC_recurse_count++; DEBUG_OPTIMISE_MORE_r(PerlIO_printf(Perl_debug_log, - "Recurse #%"UVuf" to %"IVdf"\n", + "%*s%*s Recurse #%"UVuf" to %"IVdf"\n", + 22, "| |", 1 + depth * 2, "", (UV)ARG(ret), (IV)ARG2L(ret))); } RExC_seen |= REG_RECURSE_SEEN; @@ -10287,7 +10419,8 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp,U32 depth) && !RExC_open_parens[parno-1]) { DEBUG_OPTIMISE_MORE_r(PerlIO_printf(Perl_debug_log, - "Setting open paren #%"IVdf" to %d\n", + "%*s%*s Setting open paren #%"IVdf" to %d\n", + 22, "| |", 1+2 * depth, "", (IV)parno, REG_NODE_NUM(ret))); RExC_open_parens[parno-1]= ret; } @@ -10376,8 +10509,8 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp,U32 depth) ender = reganode(pRExC_state, CLOSE, parno); if (!SIZE_ONLY && RExC_seen & REG_RECURSE_SEEN) { DEBUG_OPTIMISE_MORE_r(PerlIO_printf(Perl_debug_log, - "Setting close paren #%"IVdf" to %d\n", - (IV)parno, REG_NODE_NUM(ender))); + "%*s%*s Setting close paren #%"IVdf" to %d\n", + 22, "| |", 1+2 * depth, "", (IV)parno, REG_NODE_NUM(ender))); RExC_close_parens[parno-1]= ender; if (RExC_nestroot == parno) RExC_nestroot = 0; @@ -10403,15 +10536,13 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp,U32 depth) break; } DEBUG_PARSE_r(if (!SIZE_ONLY) { - SV * const mysv_val1=sv_newmortal(); - SV * const mysv_val2=sv_newmortal(); DEBUG_PARSE_MSG("lsbr"); - regprop(RExC_rx, mysv_val1, lastbr, NULL); - regprop(RExC_rx, mysv_val2, ender, NULL); + regprop(RExC_rx, RExC_mysv1, lastbr, NULL, pRExC_state); + regprop(RExC_rx, RExC_mysv2, ender, NULL, pRExC_state); PerlIO_printf(Perl_debug_log, "~ tying lastbr %s (%"IVdf") to ender %s (%"IVdf") offset %"IVdf"\n", - SvPV_nolen_const(mysv_val1), + SvPV_nolen_const(RExC_mysv1), (IV)REG_NODE_NUM(lastbr), - SvPV_nolen_const(mysv_val2), + SvPV_nolen_const(RExC_mysv2), (IV)REG_NODE_NUM(ender), (IV)(ender - lastbr) ); @@ -10444,15 +10575,13 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp,U32 depth) if (is_nothing) { br= PL_regkind[OP(ret)] != BRANCH ? regnext(ret) : ret; DEBUG_PARSE_r(if (!SIZE_ONLY) { - SV * const mysv_val1=sv_newmortal(); - SV * const mysv_val2=sv_newmortal(); DEBUG_PARSE_MSG("NADA"); - regprop(RExC_rx, mysv_val1, ret, NULL); - regprop(RExC_rx, mysv_val2, ender, NULL); + regprop(RExC_rx, RExC_mysv1, ret, NULL, pRExC_state); + regprop(RExC_rx, RExC_mysv2, ender, NULL, pRExC_state); PerlIO_printf(Perl_debug_log, "~ converting ret %s (%"IVdf") to ender %s (%"IVdf") offset %"IVdf"\n", - SvPV_nolen_const(mysv_val1), + SvPV_nolen_const(RExC_mysv1), (IV)REG_NODE_NUM(ret), - SvPV_nolen_const(mysv_val2), + SvPV_nolen_const(RExC_mysv2), (IV)REG_NODE_NUM(ender), (IV)(ender - ret) ); @@ -15724,11 +15853,10 @@ S_regtail(pTHX_ RExC_state_t *pRExC_state, regnode *p, for (;;) { regnode * const temp = regnext(scan); DEBUG_PARSE_r({ - SV * const mysv=sv_newmortal(); DEBUG_PARSE_MSG((scan==p ? "tail" : "")); - regprop(RExC_rx, mysv, scan, NULL); + regprop(RExC_rx, RExC_mysv, scan, NULL, pRExC_state); PerlIO_printf(Perl_debug_log, "~ %s (%d) %s %s\n", - SvPV_nolen_const(mysv), REG_NODE_NUM(scan), + SvPV_nolen_const(RExC_mysv), REG_NODE_NUM(scan), (temp == NULL ? "->" : ""), (temp == NULL ? PL_reg_name[OP(val)] : "") ); @@ -15813,11 +15941,10 @@ S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, } } DEBUG_PARSE_r({ - SV * const mysv=sv_newmortal(); DEBUG_PARSE_MSG((scan==p ? "tsdy" : "")); - regprop(RExC_rx, mysv, scan, NULL); + regprop(RExC_rx, RExC_mysv, scan, NULL, pRExC_state); PerlIO_printf(Perl_debug_log, "~ %s (%d) -> %s\n", - SvPV_nolen_const(mysv), + SvPV_nolen_const(RExC_mysv), REG_NODE_NUM(scan), PL_reg_name[exact]); }); @@ -15826,12 +15953,11 @@ S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, scan = temp; } DEBUG_PARSE_r({ - SV * const mysv_val=sv_newmortal(); DEBUG_PARSE_MSG(""); - regprop(RExC_rx, mysv_val, val, NULL); + regprop(RExC_rx, RExC_mysv, val, NULL, pRExC_state); PerlIO_printf(Perl_debug_log, "~ attach to %s (%"IVdf") offset to %"IVdf"\n", - SvPV_nolen_const(mysv_val), + SvPV_nolen_const(RExC_mysv), (IV)REG_NODE_NUM(val), (IV)(val - scan) ); @@ -15983,7 +16109,7 @@ Perl_regdump(pTHX_ const regexp *r) PerlIO_printf(Perl_debug_log, ") "); if (ri->regstclass) { - regprop(r, sv, ri->regstclass, NULL); + regprop(r, sv, ri->regstclass, NULL, NULL); PerlIO_printf(Perl_debug_log, "stclass %s ", SvPVX_const(sv)); } if (r->intflags & PREGf_ANCH) { @@ -16022,7 +16148,7 @@ Perl_regdump(pTHX_ const regexp *r) */ void -Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_info *reginfo) +Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state) { #ifdef DEBUGGING int k; @@ -16077,7 +16203,7 @@ Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_ PERL_ARGS_ASSERT_REGPROP; - sv_setpvs(sv, ""); + sv_setpvn(sv, "", 0); if (OP(o) > REGNODE_MAX) /* regnode.type is unsigned */ /* It would be nice to FAIL() here, but this may be called from @@ -16145,19 +16271,23 @@ Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_ else if (k == REF || k == OPEN || k == CLOSE || k == GROUPP || OP(o)==ACCEPT) { + AV *name_list= NULL; Perl_sv_catpvf(aTHX_ sv, "%d", (int)ARG(o)); /* Parenth number */ if ( RXp_PAREN_NAMES(prog) ) { + name_list= MUTABLE_AV(progi->data->data[progi->name_list_idx]); + } else if ( pRExC_state ) { + name_list= RExC_paren_name_list; + } + if (name_list) { if ( k != REF || (OP(o) < NREF)) { - AV *list= MUTABLE_AV(progi->data->data[progi->name_list_idx]); - SV **name= av_fetch(list, ARG(o), 0 ); + SV **name= av_fetch(name_list, ARG(o), 0 ); if (name) Perl_sv_catpvf(aTHX_ sv, " '%"SVf"'", SVfARG(*name)); } else { - AV *list= MUTABLE_AV(progi->data->data[ progi->name_list_idx ]); SV *sv_dat= MUTABLE_SV(progi->data->data[ ARG( o ) ]); I32 *nums=(I32*)SvPVX(sv_dat); - SV **name= av_fetch(list, nums[0], 0 ); + SV **name= av_fetch(name_list, nums[0], 0 ); I32 n; if (name) { for ( n=0; n<SvIVX(sv_dat); n++ ) { @@ -16182,9 +16312,22 @@ Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_ PERL_PV_ESCAPE_UNI_DETECT|PERL_PV_PRETTY_NOCLEAR|PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_QUOTE ); } } - } else if (k == GOSUB) + } else if (k == GOSUB) { + AV *name_list= NULL; + if ( RXp_PAREN_NAMES(prog) ) { + name_list= MUTABLE_AV(progi->data->data[progi->name_list_idx]); + } else if ( pRExC_state ) { + name_list= RExC_paren_name_list; + } + /* Paren and offset */ Perl_sv_catpvf(aTHX_ sv, "%d[%+d]", (int)ARG(o),(int)ARG2L(o)); + if (name_list) { + SV **name= av_fetch(name_list, ARG(o), 0 ); + if (name) + Perl_sv_catpvf(aTHX_ sv, " '%"SVf"'", SVfARG(*name)); + } + } else if (k == VERB) { if (!o->flags) Perl_sv_catpvf(aTHX_ sv, ":%"SVf, @@ -17265,7 +17408,7 @@ S_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, } else CLEAR_OPTSTART; - regprop(r, sv, node, NULL); + regprop(r, sv, node, NULL, NULL); PerlIO_printf(Perl_debug_log, "%4"IVdf":%*s%s", (IV)(node - start), (int)(2*indent + 1), "", SvPVX_const(sv)); diff --git a/regexec.c b/regexec.c index 9297d76..37018ac 100644 --- a/regexec.c +++ b/regexec.c @@ -2968,7 +2968,7 @@ Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend, } DEBUG_EXECUTE_r({ SV * const prop = sv_newmortal(); - regprop(prog, prop, c, reginfo); + regprop(prog, prop, c, reginfo, NULL); { RE_PV_QUOTED_DECL(quoted,utf8_target,PERL_DEBUG_PAD_ZERO(1), s,strend-s,60); @@ -3991,7 +3991,7 @@ S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog) SV * const prop = sv_newmortal(); regnode *rnext=regnext(scan); DUMP_EXEC_POS( locinput, scan, utf8_target ); - regprop(rex, prop, scan, reginfo); + regprop(rex, prop, scan, reginfo, NULL); PerlIO_printf(Perl_debug_log, "%3"IVdf":%*s%s(%"IVdf")\n", @@ -7598,7 +7598,7 @@ S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, GET_RE_DEBUG_FLAGS_DECL; DEBUG_EXECUTE_r({ SV * const prop = sv_newmortal(); - regprop(prog, prop, p, reginfo); + regprop(prog, prop, p, reginfo, NULL); PerlIO_printf(Perl_debug_log, "%*s %s can match %"IVdf" times out of %"IVdf"...\n", REPORT_CODE_OFF + depth*2, "", SvPVX_const(prop),(IV)c,(IV)max); -- Perl5 Master Repository
