In perl.git, the branch blead has been updated

<https://perl5.git.perl.org/perl.git/commitdiff/8638266fb1a6a7f9b6ce2567347bfba94f8b2414?hp=a33a98cff0201570b461d59ea63f94a94f710e45>

- Log -----------------------------------------------------------------
commit 8638266fb1a6a7f9b6ce2567347bfba94f8b2414
Author: Karl Williamson <k...@cpan.org>
Date:   Mon Feb 19 20:28:19 2018 -0700

    Fix skipping char in (*sr:...) defn
    
    This was wrongly calling nextchar(), which skipped the next character
    wrongly

commit e54417e05d50aa46e805071583a78db0e3e557e9
Author: Karl Williamson <k...@cpan.org>
Date:   Mon Feb 19 20:15:21 2018 -0700

    t/re/script_run.t: White space only
    
    The previous commit created an outer block around these

commit 526c41635c97a91b5220919a2d5d1d38d7936e79
Author: Karl Williamson <k...@cpan.org>
Date:   Mon Feb 19 20:12:28 2018 -0700

    t/re/script_run.t: Tests for 'sr' form of (*script_run:...)

commit 3eb4defc9453e752f5aacd8d4934a502cc2d2138
Author: Karl Williamson <k...@cpan.org>
Date:   Mon Feb 19 12:14:06 2018 -0700

    regcomp.c: Silence uninit compiler warning
    
    This warning (only known on one compiler at the moment) is probably
    wrong, but by setting this to NULL, we avoid the warning, and should
    segfault if the warning were correct, instead of using uninitialized
    data.

commit 70bd58e99cf8c4f66531ed2261be494f9fe83a00
Author: Karl Williamson <k...@cpan.org>
Date:   Mon Feb 19 12:01:51 2018 -0700

    regcomp.c: Make sure no future ambiguity on new alpha assertions
    
    This change adds a colon when checking if a string is an alpha
    assertion.  This is defensive coding against an unlikely future change
    wherein some new (*... construct is added that has the same initial
    sequence as one of these assertions.  The colon acts as a terminator and
    would automatically prevent any ambiguity.  One of these had the colon,
    and hence was inconsistent with the rest.
    
    Spotted by ilmari.

commit 60861a1d0e9b98624c7721ba13b988c1d973232c
Author: Karl Williamson <k...@cpan.org>
Date:   Mon Feb 19 11:57:37 2018 -0700

    regcomp.c: White space only
    
    Fit in 80 columns, outdent because of removed enclosing block in a
    previous commit, consistent spacing around '+'.
    
    ilmari spotted the '+' spacing issues

commit 467d2991c8f76b1bea6e39aed49d8109d892827d
Author: Karl Williamson <k...@cpan.org>
Date:   Mon Feb 19 12:08:15 2018 -0700

    hints/hpux.sh: Note locale univ.utf8 may be defective
    
    A new check in 8b7358b96caf71db3213a7d72fc401e42ee0b2d0 is finding that
    this locale is defective.  It is fixed by 11.31

-----------------------------------------------------------------------

Summary of changes:
 hints/hpux.sh     |   5 +++
 regcomp.c         |  77 ++++++++++++++++++++---------------------
 t/re/script_run.t | 102 +++++++++++++++++++++++++++++-------------------------
 3 files changed, 98 insertions(+), 86 deletions(-)

diff --git a/hints/hpux.sh b/hints/hpux.sh
index 91a4d7d388..3eef0388a7 100644
--- a/hints/hpux.sh
+++ b/hints/hpux.sh
@@ -1,5 +1,10 @@
 #!/usr/bin/sh
 
+# The locale 'univ.utf8' is defective on some of these systems, as it doesn't
+# think that 
+#   $ + < = > ^ ` | ~
+# are punctuation.  This is fixed in 11.31
+
 ### SYSTEM ARCHITECTURE
 
 # Determine the architecture type of this system.
diff --git a/regcomp.c b/regcomp.c
index 90e93321b9..13c4154192 100644
--- a/regcomp.c
+++ b/regcomp.c
@@ -10689,7 +10689,7 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 
*flagp,U32 depth)
      * RExC_parse beyond the '('.  Things like '(?' are indivisible tokens, and
      * this flag alerts us to the need to check for that */
 {
-    regnode *ret;              /* Will be the head of the group. */
+    regnode *ret = NULL;    /* Will be the head of the group. */
     regnode *br;
     regnode *lastbr;
     regnode *ender = NULL;
@@ -10899,7 +10899,6 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 
*flagp,U32 depth)
 
                     if (RExC_in_script_run) {
                         paren = ':';
-                        nextchar(pRExC_state);
                         ret = NULL;
                         goto parse_rest;
                     }
@@ -11363,43 +11362,43 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 
*flagp,U32 depth)
                                 || RExC_parse[1] == '<'
                                 || RExC_parse[1] == '{'))
                        || (       RExC_parse[0] == '*'        /* (?(*...)) */
-                            && (   memBEGINs(RExC_parse +1,
-                                             (Size_t) (RExC_end - (RExC_parse 
+ 1)),
-                                             "pla:")
-                                || memBEGINs(RExC_parse +1,
-                                             (Size_t) (RExC_end - (RExC_parse 
+ 1)),
-                                             "plb")
-                                || memBEGINs(RExC_parse +1,
-                                             (Size_t) (RExC_end - (RExC_parse 
+ 1)),
-                                             "nla")
-                                || memBEGINs(RExC_parse +1,
-                                             (Size_t) (RExC_end - (RExC_parse 
+ 1)),
-                                             "nlb")
-                                || memBEGINs(RExC_parse +1,
-                                             (Size_t) (RExC_end - (RExC_parse 
+ 1)),
-                                             "positive_lookahead")
-                                || memBEGINs(RExC_parse +1,
-                                             (Size_t) (RExC_end - (RExC_parse 
+ 1)),
-                                             "positive_lookbehind")
-                                || memBEGINs(RExC_parse +1,
-                                             (Size_t) (RExC_end - (RExC_parse 
+ 1)),
-                                             "negative_lookahead")
-                                || memBEGINs(RExC_parse +1,
-                                             (Size_t) (RExC_end - (RExC_parse 
+ 1)),
-                                             "negative_lookbehind"))))
-                    ) { /* Lookahead or eval. */
-                       I32 flag;
-                        regnode *tail;
-
-                       ret = reg_node(pRExC_state, LOGICAL);
-                       if (!SIZE_ONLY)
-                           ret->flags = 1;
-
-                        tail = reg(pRExC_state, 1, &flag, depth+1);
-                        RETURN_NULL_ON_RESTART(flag,flagp);
-                        REGTAIL(pRExC_state, ret, tail);
-                       goto insert_if;
-                   }
+                            && (   memBEGINs(RExC_parse + 1,
+                                         (Size_t) (RExC_end - (RExC_parse + 
1)),
+                                         "pla:")
+                                || memBEGINs(RExC_parse + 1,
+                                         (Size_t) (RExC_end - (RExC_parse + 
1)),
+                                         "plb:")
+                                || memBEGINs(RExC_parse + 1,
+                                         (Size_t) (RExC_end - (RExC_parse + 
1)),
+                                         "nla:")
+                                || memBEGINs(RExC_parse + 1,
+                                         (Size_t) (RExC_end - (RExC_parse + 
1)),
+                                         "nlb:")
+                                || memBEGINs(RExC_parse + 1,
+                                         (Size_t) (RExC_end - (RExC_parse + 
1)),
+                                         "positive_lookahead:")
+                                || memBEGINs(RExC_parse + 1,
+                                         (Size_t) (RExC_end - (RExC_parse + 
1)),
+                                         "positive_lookbehind:")
+                                || memBEGINs(RExC_parse + 1,
+                                         (Size_t) (RExC_end - (RExC_parse + 
1)),
+                                         "negative_lookahead:")
+                                || memBEGINs(RExC_parse + 1,
+                                         (Size_t) (RExC_end - (RExC_parse + 
1)),
+                                         "negative_lookbehind:"))))
+                ) { /* Lookahead or eval. */
+                    I32 flag;
+                    regnode *tail;
+
+                    ret = reg_node(pRExC_state, LOGICAL);
+                    if (!SIZE_ONLY)
+                        ret->flags = 1;
+
+                    tail = reg(pRExC_state, 1, &flag, depth+1);
+                    RETURN_NULL_ON_RESTART(flag,flagp);
+                    REGTAIL(pRExC_state, ret, tail);
+                    goto insert_if;
+                }
                else if (   RExC_parse[0] == '<'     /* (?(<NAME>)...) */
                         || RExC_parse[0] == '\'' ) /* (?('NAME')...) */
                {
diff --git a/t/re/script_run.t b/t/re/script_run.t
index 8c91602259..5005d637a4 100644
--- a/t/re/script_run.t
+++ b/t/re/script_run.t
@@ -17,68 +17,76 @@ $|=1;
 
 no warnings "experimental::script_run";
 
-my $script_run = qr/ ^ (*script_run: .* ) $ /x;
+# Since there's so few tests currently, we can afford to try each syntax on
+# all of them
+foreach my $type ('script_run', 'sr') {
+    my $script_run;
+    eval '$script_run = qr/ ^ (*$type: .* ) $ /x;';
 
-unlike("\N{CYRILLIC SMALL LETTER ER}\N{CYRILLIC SMALL LETTER A}\N{CYRILLIC 
SMALL LETTER U}}\N{CYRILLIC SMALL LETTER ER}\N{CYRILLIC SMALL LETTER A}l", 
$script_run, "Cyrillic 'paypal' with a Latin 'l' is not a script run");
-unlike("A\N{GREEK CAPITAL LETTER GAMMA}", $script_run, "Latin followed by 
Greek isn't a script run");
+    unlike("\N{CYRILLIC SMALL LETTER ER}\N{CYRILLIC SMALL LETTER A}\N{CYRILLIC 
SMALL LETTER U}}\N{CYRILLIC SMALL LETTER ER}\N{CYRILLIC SMALL LETTER A}l", 
$script_run, "Cyrillic 'paypal' with a Latin 'l' is not a script run");
+    unlike("A\N{GREEK CAPITAL LETTER GAMMA}", $script_run, "Latin followed by 
Greek isn't a script run");
 
-like("\N{CYRILLIC THOUSANDS SIGN}\N{COMBINING CYRILLIC TITLO}", $script_run, 
"Cyrillic followed by Permic-Arabic is Arabic");
-like("\N{OLD PERMIC LETTER AN}\N{COMBINING CYRILLIC TITLO}", $script_run, 
"Permic followed by Permic-Arabic is Permic");
-unlike("\N{GLAGOLITIC CAPITAL LETTER AZU}\N{COMBINING CYRILLIC TITLO}", 
$script_run, "Glagolithic followed by Permic-Arabic isn't a script run");
+    like("\N{CYRILLIC THOUSANDS SIGN}\N{COMBINING CYRILLIC TITLO}", 
$script_run, "Cyrillic followed by Permic-Arabic is Arabic");
+    like("\N{OLD PERMIC LETTER AN}\N{COMBINING CYRILLIC TITLO}", $script_run, 
"Permic followed by Permic-Arabic is Permic");
+    unlike("\N{GLAGOLITIC CAPITAL LETTER AZU}\N{COMBINING CYRILLIC TITLO}", 
$script_run, "Glagolithic followed by Permic-Arabic isn't a script run");
 
-like("\N{CYRILLIC THOUSANDS SIGN}\N{COMBINING CYRILLIC PALATALIZATION}", 
$script_run, "Cyrillic followed by Glagolithic-Arabic is Arabic");
-like("\N{GLAGOLITIC CAPITAL LETTER AZU}\N{COMBINING CYRILLIC PALATALIZATION}", 
$script_run, "Glagolithic followed by Glagolithic-Arabic is Glagolithic");
-unlike("\N{OLD PERMIC LETTER AN}\N{COMBINING CYRILLIC PALATALIZATION}", 
$script_run, "Permic followed by Glagolithic-Arabic isn't a script run");
+    like("\N{CYRILLIC THOUSANDS SIGN}\N{COMBINING CYRILLIC PALATALIZATION}", 
$script_run, "Cyrillic followed by Glagolithic-Arabic is Arabic");
+    like("\N{GLAGOLITIC CAPITAL LETTER AZU}\N{COMBINING CYRILLIC 
PALATALIZATION}", $script_run, "Glagolithic followed by Glagolithic-Arabic is 
Glagolithic");
+    unlike("\N{OLD PERMIC LETTER AN}\N{COMBINING CYRILLIC PALATALIZATION}", 
$script_run, "Permic followed by Glagolithic-Arabic isn't a script run");
 
-like("\N{ARABIC-INDIC DIGIT ZERO}\N{ARABIC-INDIC DIGIT ONE}\N{ARABIC-INDIC 
DIGIT TWO}\N{ARABIC-INDIC DIGIT THREE}\N{ARABIC COMMA}\N{ARABIC-INDIC DIGIT 
FOUR}\N{THAANA LETTER HAA}", $script_run, "Arabic-Thaana chars followed by 
Thaana is Thaana");
-unlike("\N{ARABIC-INDIC DIGIT ZERO}\N{ARABIC-INDIC DIGIT ONE}A", $script_run, 
"Arabic-Thaana chars followed by Latin isn't a script run");
-like("\N{ARABIC-INDIC DIGIT ZERO}\N{ARABIC-INDIC DIGIT ONE}\N{ARABIC-INDIC 
DIGIT TWO}\N{ARABIC-INDIC DIGIT THREE}\N{ARABIC COMMA}\N{ARABIC-INDIC DIGIT 
FOUR}\N{ARABIC NUMBER SIGN}", $script_run, "Arabic-Thaana chars followed by 
Arabic is Arabic");
-unlike("\N{ARABIC-INDIC DIGIT ZERO}\N{ARABIC-INDIC DIGIT ONE}\N{ARABIC-INDIC 
DIGIT TWO}\N{ARABIC-INDIC DIGIT THREE}\N{EXTENDED ARABIC-INDIC DIGIT NINE}", 
$script_run, "Arabic-Thaana digits followed by an Arabic digit from a different 
sequence isn't a script run");
-like("\N{ARABIC-INDIC DIGIT ZERO}\N{ARABIC-INDIC DIGIT ONE}\N{ARABIC-INDIC 
DIGIT TWO}\N{ARABIC-INDIC DIGIT THREE}\N{THAANA LETTER HAA}", $script_run, 
"Arabic-Thaana digits followed by a Thaana leter is a script run");
+    like("\N{ARABIC-INDIC DIGIT ZERO}\N{ARABIC-INDIC DIGIT ONE}\N{ARABIC-INDIC 
DIGIT TWO}\N{ARABIC-INDIC DIGIT THREE}\N{ARABIC COMMA}\N{ARABIC-INDIC DIGIT 
FOUR}\N{THAANA LETTER HAA}", $script_run, "Arabic-Thaana chars followed by 
Thaana is Thaana");
+    unlike("\N{ARABIC-INDIC DIGIT ZERO}\N{ARABIC-INDIC DIGIT ONE}A", 
$script_run, "Arabic-Thaana chars followed by Latin isn't a script run");
+    like("\N{ARABIC-INDIC DIGIT ZERO}\N{ARABIC-INDIC DIGIT ONE}\N{ARABIC-INDIC 
DIGIT TWO}\N{ARABIC-INDIC DIGIT THREE}\N{ARABIC COMMA}\N{ARABIC-INDIC DIGIT 
FOUR}\N{ARABIC NUMBER SIGN}", $script_run, "Arabic-Thaana chars followed by 
Arabic is Arabic");
+    unlike("\N{ARABIC-INDIC DIGIT ZERO}\N{ARABIC-INDIC DIGIT 
ONE}\N{ARABIC-INDIC DIGIT TWO}\N{ARABIC-INDIC DIGIT THREE}\N{EXTENDED 
ARABIC-INDIC DIGIT NINE}", $script_run, "Arabic-Thaana digits followed by an 
Arabic digit from a different sequence isn't a script run");
+    like("\N{ARABIC-INDIC DIGIT ZERO}\N{ARABIC-INDIC DIGIT ONE}\N{ARABIC-INDIC 
DIGIT TWO}\N{ARABIC-INDIC DIGIT THREE}\N{THAANA LETTER HAA}", $script_run, 
"Arabic-Thaana digits followed by a Thaana leter is a script run");
 
-# The next tests are at a hard-coded boundary in regexec.c at the time of this
-# writing (U+02B9/02BA).
-like("abc\N{MODIFIER LETTER SMALL Y}", $script_run, "All Latin is a script 
run");
-like("abc\N{MODIFIER LETTER PRIME}", $script_run, "Latin then Common is a 
script run");
-like(":a", $script_run, "Common then Latin is a script run");
-like("-\N{SINHALA LETTER RAYANNA}", $script_run, "Common then Sinhala (which 
has its own 0) is a script run");
+    # The next tests are at a hard-coded boundary in regexec.c at the time of 
this
+    # writing (U+02B9/02BA).
+    like("abc\N{MODIFIER LETTER SMALL Y}", $script_run, "All Latin is a script 
run");
+    like("abc\N{MODIFIER LETTER PRIME}", $script_run, "Latin then Common is a 
script run");
+    like(":a", $script_run, "Common then Latin is a script run");
+    like("-\N{SINHALA LETTER RAYANNA}", $script_run, "Common then Sinhala 
(which has its own 0) is a script run");
 
-like("\N{HEBREW LETTER ALEF}\N{HEBREW LETTER TAV}\N{MODIFIER LETTER PRIME}", 
$script_run, "Hebrew then Common is a script run");
-unlike("\N{HEBREW LETTER ALEF}\N{HEBREW LETTER TAV}\N{MODIFIER LETTER SMALL 
Y}", $script_run, "Hebrew then Latin isn't a script run");
-like("9876543210\N{DESERET SMALL LETTER WU}", $script_run, "0-9 are the digits 
for Deseret");
-like("\N{DESERET SMALL LETTER WU}9876543210", $script_run, "Also when they 
aren't in the initial position");
-unlike("\N{DESERET SMALL LETTER WU}\N{FULLWIDTH DIGIT FIVE}", $script_run, 
"Fullwidth digits aren't the digits for Deseret");
-unlike("\N{FULLWIDTH DIGIT SIX}\N{DESERET SMALL LETTER LONG I}", $script_run, 
"... likewise if the digits come first");
+    like("\N{HEBREW LETTER ALEF}\N{HEBREW LETTER TAV}\N{MODIFIER LETTER 
PRIME}", $script_run, "Hebrew then Common is a script run");
+    unlike("\N{HEBREW LETTER ALEF}\N{HEBREW LETTER TAV}\N{MODIFIER LETTER 
SMALL Y}", $script_run, "Hebrew then Latin isn't a script run");
+    like("9876543210\N{DESERET SMALL LETTER WU}", $script_run, "0-9 are the 
digits for Deseret");
+    like("\N{DESERET SMALL LETTER WU}9876543210", $script_run, "Also when they 
aren't in the initial position");
+    unlike("\N{DESERET SMALL LETTER WU}\N{FULLWIDTH DIGIT FIVE}", $script_run, 
"Fullwidth digits aren't the digits for Deseret");
+    unlike("\N{FULLWIDTH DIGIT SIX}\N{DESERET SMALL LETTER LONG I}", 
$script_run, "... likewise if the digits come first");
 
-like("1234567890\N{ARABIC LETTER ALEF}", $script_run, "[0-9] work for Arabic");
-unlike("1234567890\N{ARABIC LETTER ALEF}\N{ARABIC-INDIC DIGIT 
FOUR}\N{ARABIC-INDIC DIGIT FIVE}", $script_run, "... but not in combination 
with real ARABIC digits");
-unlike("\N{ARABIC LETTER ALEF}\N{ARABIC-INDIC DIGIT SIX}\N{ARABIC-INDIC DIGIT 
SEVEN}1", $script_run, "... nor when the ARABIC digits come before them");
+    like("1234567890\N{ARABIC LETTER ALEF}", $script_run, "[0-9] work for 
Arabic");
+    unlike("1234567890\N{ARABIC LETTER ALEF}\N{ARABIC-INDIC DIGIT 
FOUR}\N{ARABIC-INDIC DIGIT FIVE}", $script_run, "... but not in combination 
with real ARABIC digits");
+    unlike("\N{ARABIC LETTER ALEF}\N{ARABIC-INDIC DIGIT SIX}\N{ARABIC-INDIC 
DIGIT SEVEN}1", $script_run, "... nor when the ARABIC digits come before them");
 
-# This exercises the case where the script zero but not the script is
-# ambiguous until a non-ambiguous digit is found.
-like("\N{ARABIC LETTER ALEF}\N{EXTENDED ARABIC-INDIC DIGIT EIGHT}", 
$script_run, "ARABIC with a Shia digit is a script run");
+    # This exercises the case where the script zero but not the script is
+    # ambiguous until a non-ambiguous digit is found.
+    like("\N{ARABIC LETTER ALEF}\N{EXTENDED ARABIC-INDIC DIGIT EIGHT}", 
$script_run, "ARABIC with a Shia digit is a script run");
 
-like("\N{U+03A2}", $script_run, "A single unassigned code point is a script 
run");
-unlike("\N{U+03A2}\N{U+03A2}", $script_run, "But not more than one");
-unlike("A\N{U+03A2}", $script_run, "... and not in combination with an 
assigned one");
-unlike("\N{U+03A2}A", $script_run, "... in either order");
-unlike("\N{U+03A2}0", $script_run, "... nor with a digit following");
+    like("\N{U+03A2}", $script_run, "A single unassigned code point is a 
script run");
+    unlike("\N{U+03A2}\N{U+03A2}", $script_run, "But not more than one");
+    unlike("A\N{U+03A2}", $script_run, "... and not in combination with an 
assigned one");
+    unlike("\N{U+03A2}A", $script_run, "... in either order");
+    unlike("\N{U+03A2}0", $script_run, "... nor with a digit following");
 
-like("A\N{COMBINING GRAVE ACCENT}", $script_run, "An inherited script matches 
others");
-like("\N{COMBINING GRAVE ACCENT}A", $script_run, "... even if first in the 
sequence");
+    like("A\N{COMBINING GRAVE ACCENT}", $script_run, "An inherited script 
matches others");
+    like("\N{COMBINING GRAVE ACCENT}A", $script_run, "... even if first in the 
sequence");
 
-like("\N{COMBINING TILDE}\N{COMBINING GRAVE ACCENT}", $script_run, "A script 
containing only inherited characters matches");
+    like("\N{COMBINING TILDE}\N{COMBINING GRAVE ACCENT}", $script_run, "A 
script containing only inherited characters matches");
 
-like("\N{DEVANAGARI DOUBLE DANDA}\N{DEVANAGARI DANDA}\N{DEVANAGARI STRESS SIGN 
UDATTA}\N{DEVANAGARI STRESS SIGN ANUDATTA}\N{NORTH INDIC FRACTION ONE 
QUARTER}\N{NORTH INDIC QUANTITY MARK}", $script_run, "A bunch of narrowing down 
of multiple possible scripts");
+    like("\N{DEVANAGARI DOUBLE DANDA}\N{DEVANAGARI DANDA}\N{DEVANAGARI STRESS 
SIGN UDATTA}\N{DEVANAGARI STRESS SIGN ANUDATTA}\N{NORTH INDIC FRACTION ONE 
QUARTER}\N{NORTH INDIC QUANTITY MARK}", $script_run, "A bunch of narrowing down 
of multiple possible scripts");
 
-unlike("\N{JAVANESE PANGRANGKEP}\N{GEORGIAN PARAGRAPH SEPARATOR}", 
$script_run, "Two code points each in multiple scripts that don't intersect 
aren't a script run");
-like("\N{DEVANAGARI SIGN CANDRABINDU VIRAMA}\N{VEDIC TONE YAJURVEDIC KATHAKA 
INDEPENDENT SVARITA}", $script_run, "Two code points each in multiple scripts 
that 't intersect singly are a script run");
+    unlike("\N{JAVANESE PANGRANGKEP}\N{GEORGIAN PARAGRAPH SEPARATOR}", 
$script_run, "Two code points each in multiple scripts that don't intersect 
aren't a script run");
+    like("\N{DEVANAGARI SIGN CANDRABINDU VIRAMA}\N{VEDIC TONE YAJURVEDIC 
KATHAKA INDEPENDENT SVARITA}", $script_run, "Two code points each in multiple 
scripts that 't intersect singly are a script run");
 
-like("", $script_run, "An empty string is a script run");
+    like("", $script_run, "An empty string is a script run");
 
-use utf8;
+    use utf8;
 
-# From UTS 39
-like("写真だけの結婚式", $script_run, "Mixed Hiragana and Han");
+    # From UTS 39
+    like("写真だけの結婚式", $script_run, "Mixed Hiragana and Han");
+}
+
+    # Until fixed, this was skipping the '['
+    unlike("abc]c", qr/^ (*sr:a(*sr:[bc]*)c) $/x, "Doesn't skip parts of exact 
matches");
 
 done_testing();

-- 
Perl5 Master Repository

Reply via email to