propagate /msix and (?msix) etc flags into (??{})

In  /.........(??{ some_string_value; }).../flags
and /(?flags).(??{ some_string_value; }).../,

use flags when compiling the inner /some_string_value/ pattern.

Achieve this by storing the compile-time modifier flags in the
(apparently) unused 'flags' field of the EVAL node in the (??{})
case.

diff --git a/ext/re/t/reflags.t b/ext/re/t/reflags.t
index 56763fd..b2cbf80 100644 (file)
--- a/ext/re/t/reflags.t
+++ b/ext/re/t/reflags.t
@@ -10,26 +10,35 @@ BEGIN {
 
 use strict;
 
-use Test::More tests => 53;
+use Test::More tests => 62;
 
 my @flags = qw( a d l u );
 
 use re '/i';
 ok "Foo" =~ /foo/, 'use re "/i"';
+ok "Foo" =~ /(??{'foo'})/, 'use re "/i" (??{})';
 no re '/i';
 ok "Foo" !~ /foo/, 'no re "/i"';
+ok "Foo" !~ /(??{'foo'})/, 'no re "/i" (??{})';
 use re '/x';
 ok "foo" =~ / foo /, 'use re "/x"';
+ok "foo" =~ / (??{' foo '}) /, 'use re "/x" (??{})';
 no re '/x';
 ok "foo" !~ / foo /, 'no re "/x"';
+ok "foo" !~ /(??{' foo '})/, 'no re "/x" (??{})';
+ok "foo" !~ / (??{'foo'}) /, 'no re "/x" (??{})';
 use re '/s';
 ok "\n" =~ /./, 'use re "/s"';
+ok "\n" =~ /(??{'.'})/, 'use re "/s" (??{})';
 no re '/s';
 ok "\n" !~ /./, 'no re "/s"';
+ok "\n" !~ /(??{'.'})/, 'no re "/s" (??{})';
 use re '/m';
 ok "\nfoo" =~ /^foo/, 'use re "/m"';
+ok "\nfoo" =~ /(??{'^'})foo/, 'use re "/m" (??{})';
 no re '/m';
 ok "\nfoo" !~ /^foo/, 'no re "/m"';
+ok "\nfoo" !~ /(??{'^'})foo/, 'no re "/m" (??{})';
 
 use re '/xism';
 ok qr// =~ /(?=.*x)(?=.*i)(?=.*s)(?=.*m)/, 'use re "/multiple"';

diff --git a/regcomp.c b/regcomp.c
index a81dc58..cb98e62 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -8607,10 +8607,15 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp,U32 depth)
                nextchar(pRExC_state);
 
                if (is_logical) {
+                    regnode *eval;
                    ret = reg_node(pRExC_state, LOGICAL);
-                   if (!SIZE_ONLY)
+                    eval = reganode(pRExC_state, EVAL, n);
+                   if (!SIZE_ONLY) {
                        ret->flags = 2;
-                    REGTAIL(pRExC_state, ret, reganode(pRExC_state, EVAL, n));
+                        /* for later propagation into (??{}) return value */
+                        eval->flags = (RExC_flags & RXf_PMf_COMPILETIME);
+                    }
+                    REGTAIL(pRExC_state, ret, eval);
                     /* deal with the length of this later - MJD */
                    return ret;
                }

diff --git a/regexec.c b/regexec.c
index 878cdfc..41331e7 100644 (file)
--- a/regexec.c
+++ b/regexec.c
@@ -4483,8 +4483,12 @@ S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog)
                        /* if we got here, it should be an engine which
                         * supports compiling code blocks and stuff */
                        assert(rex->engine && rex->engine->op_comp);
+                        assert(!(scan->flags & ~RXf_PMf_COMPILETIME));
                        re_sv = rex->engine->op_comp(aTHX_ &ret, 1, NULL,
-                                   rex->engine, NULL, NULL, 0, pm_flags);
+                                   rex->engine, NULL, NULL,
+                                    /* copy /msix etc to inner pattern */
+                                    scan->flags,
+                                    pm_flags);
 
                        if (!(SvFLAGS(ret)
                              & (SVs_TEMP | SVs_PADTMP | SVf_READONLY

diff --git a/t/re/re_tests b/t/re/re_tests
index b636707..ca40bc1 100644 (file)
--- a/t/re/re_tests
+++ b/t/re/re_tests
@@ -1652,4 +1652,17 @@ ab[c\\\](??{"x"})]{3}d   ab\\](d y       -       -
 ^(A)((?(?{return 1})abc|xyz))$ Aabc    y       $1-$2   A-abc   -
 ^(A)((?(?{return 0})abc|xyz))$ Axyz    y       $1-$2   A-xyz   -
 
+# pattern modifier flags should propagate into returned (??{}) pattern
+# p,d,l not tested
+
+/^(a)((??{"b"}))$/i    AB      y       $1-$2   A-B     -
+/^(A)((??{'B$'}))(\nC)$/m      AB\nC   y       $1-$2-$3        A-B-\nC -
+/^(A)((??{'.'}))(B)$/s A\nB    y       $1-$2-$3        A-\n-B  -
+/^(A) ((??{' .'}))(B)$/x       A B     y       $1-$2-$3        A- -B   -
+/^((??{'\d'}))$/a      \x{660} n       -       -
+/^(??{"s"})$/i \x{17F} y       -       -
+/^(??{"s"})$/ia        \x{17F} y       -       -
+/^(??{"s"})$/iaa       \x{17F} n       -       -
+/^(??{'\w'})$/u        \x{AA}  y       -       -
+
 # vim: softtabstop=0 noexpandtab