This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Deprecate /\C/
authorDavid Mitchell <davem@iabyn.com>
Thu, 3 Jul 2014 15:08:56 +0000 (16:08 +0100)
committerDavid Mitchell <davem@iabyn.com>
Thu, 3 Jul 2014 15:16:07 +0000 (16:16 +0100)
This character class matches a single byte within a multi-byte utf8 char,
and so breaks encapsulation. It is buggy, and can corrupt utf8 strings.

This deprecation was agreed in the thread starting

http://nntp.perl.org/group/perl.perl5.porters/210621

dist/Filter-Simple/lib/Filter/Simple.pm
ext/XS-APItest/t/callregexec.t
pod/perldiag.pod
regcomp.c
t/lib/Cname.pm
t/op/bop.t
t/re/pat_advanced.t
t/re/pat_rt_report.t

index 4b15e55..069482a 100644 (file)
@@ -4,7 +4,7 @@ use Text::Balanced ':ALL';
 
 use vars qw{ $VERSION @EXPORT };
 
-$VERSION = '0.91';
+$VERSION = '0.92';
 
 use Filter::Util::Call;
 use Carp;
@@ -119,6 +119,7 @@ sub gen_std_filter_for {
         }
         if ($type =~ /^code/) {
             my $count = 0;
+            no warnings 'deprecated';
             local $placeholder = qr/\Q$;\E(\C{4})\Q$;\E/;
             my $extractor =      qr/\Q$;\E(\C{4})\Q$;\E/;
             $_ = join "",
index 3111390..74e1e20 100644 (file)
@@ -42,7 +42,10 @@ sub try {
     try "ax",          qr/a$/m,           1, 'MEOL';
     try "ax",          qr/a$/s,           1, 'SEOL';
     try "abx",         qr/^(ab|X)./s,     0, 'SANY';
-    try "abx",         qr/^(ab|X)\C/,     0, 'CANY';
+    {
+        no warnings 'deprecated';
+        try "abx",         qr/^(ab|X)\C/,     0, 'CANY';
+    }
     try "abx",         qr/^(ab|X)./,      0, 'REG_ANY';
     try "abx",         qr/^ab(c|d|e|x)/,  0, 'TRIE/TRIEC';
     try "abx",         qr/^abx/,          0, 'EXACT';
index db7b1b4..be29485 100644 (file)
@@ -536,6 +536,16 @@ encountered an invalid data type.
 iterate over %ENV, it encountered a logical name or symbol definition
 which was too long, so it was truncated to the string shown.
 
+=item \C is deprecated in regex; marked by <-- HERE in m/%s/
+
+(D deprecated, regexp) The \C character class is deprecated, and will
+become a compile-time error in a future release of perl (tentatively
+v5.24). This construct allows you to match a single byte of what makes up
+a multi-byte single UTF8 character, and breaks encapsulation. It is
+currently also very buggy. If you really need to process the individual
+bytes, you probably want to convert your string to one where each
+underlying byte is stored as a character, with utf8::encode().
+
 =item Callback called exit
 
 (F) A subroutine invoked from an external package via call_sv()
index 37a2177..c673274 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -11388,6 +11388,9 @@ tryagain:
            ret = reg_node(pRExC_state, CANY);
             RExC_seen |= REG_CANY_SEEN;
            *flagp |= HASWIDTH|SIMPLE;
+            if (SIZE_ONLY) {
+                ckWARNdep(RExC_parse+1, "\\C is deprecated");
+            }
            goto finish_meta_pat;
        case 'X':
            ret = reg_node(pRExC_state, CLUMP);
index 562f59a..4a1bc16 100644 (file)
@@ -28,6 +28,8 @@ sub translator {
         $str = "\xDF\xDFabc";
         utf8::upgrade($str);
          
+        no warnings 'deprecated';
+
         # Create a malformed in first and second characters.
         $str =~ s/^\C/A/;
         $str =~ s/^(\C\C)\C/$1A/;
index 09ae479..f946d8b 100644 (file)
@@ -448,7 +448,11 @@ SKIP: {
   # U+0800 is three bytes in UTF-8/UTF-EBCDIC.
 
   no warnings "utf8";
-  { use bytes; $str =~ s/\C\C\z//; }
+  {
+    use bytes;
+    no warnings 'deprecated';
+    $str =~ s/\C\C\z//;
+  }
 
   # it's really bogus that (~~malformed) is \0.
   my $ref = "\x{10000}\0";
@@ -458,7 +462,11 @@ SKIP: {
   # exercises a different branch in pp_subsr()
 
   $str = "\x{10000}\x{800}";
-  { use bytes; $str =~ s/\C\C\z/\0\0\0/; }
+  {
+    use bytes;
+    no warnings 'deprecated';
+    $str =~ s/\C\C\z/\0\0\0/;
+  }
 
   # it's also bogus that (~~malformed) is \0\0\0\0.
   my $ref = "\x{10000}\0\0\0\0";
index e39e36c..82f0917 100644 (file)
@@ -29,6 +29,8 @@ run_tests() unless caller;
 sub run_tests {
 
     {
+        no warnings 'deprecated';
+
         my $message = '\C matches octet';
         $_ = "a\x{100}b";
         ok(/(.)(\C)(\C)(.)/, $message);
@@ -51,6 +53,8 @@ sub run_tests {
     }
 
     {
+        no warnings 'deprecated';
+
         my $message = '\C matches octet';
         $_ = "\x{100}";
         ok(/(\C)/g, $message);
@@ -280,6 +284,8 @@ sub run_tests {
     }
 
     {
+        no warnings 'deprecated';
+
         my $message = '. matches \n with /s';
         my $str1 = "foo\nbar";
         my $str2 = "foo\n\x{100}bar";
@@ -486,6 +492,8 @@ sub run_tests {
                                          =~ /^(\X)!/ &&
                $1 eq "\N{LATIN CAPITAL LETTER E}\N{COMBINING GRAVE ACCENT}", $message);
 
+        no warnings 'deprecated';
+
         $message = '\C and \X';
         like("!abc!", qr/a\Cc/, $message);
         like("!abc!", qr/a\Xc/, $message);
@@ -544,10 +552,13 @@ sub run_tests {
             $& eq "Francais", $message);
         ok("Fran\N{LATIN SMALL LETTER C WITH CEDILLA}ais" =~ /Fran.ais/ &&
             $& eq "Fran\N{LATIN SMALL LETTER C WITH CEDILLA}ais", $message);
-        ok("Fran\N{LATIN SMALL LETTER C}ais" =~ /Fran\Cais/ &&
-            $& eq "Francais", $message);
-        # COMBINING CEDILLA is two bytes when encoded
-        like("Franc\N{COMBINING CEDILLA}ais", qr/Franc\C\Cais/, $message);
+        {
+            no warnings 'deprecated';
+            ok("Fran\N{LATIN SMALL LETTER C}ais" =~ /Fran\Cais/ &&
+                $& eq "Francais", $message);
+            # COMBINING CEDILLA is two bytes when encoded
+            like("Franc\N{COMBINING CEDILLA}ais", qr/Franc\C\Cais/, $message);
+        }
         ok("Fran\N{LATIN SMALL LETTER C}ais" =~ /Fran\Xais/ &&
             $& eq "Francais", $message);
         ok("Fran\N{LATIN SMALL LETTER C WITH CEDILLA}ais" =~ /Fran\Xais/  &&
index 94100d1..ea9a306 100644 (file)
@@ -91,6 +91,7 @@ sub run_tests {
     }
 
     {
+        no warnings 'deprecated';
         my $message = '\C and É; Bug 20001230.002';
         ok("École" =~ /^\C\C(.)/ && $1 eq 'c', $message);
         like("École", qr/^\C\C(c)/, $message);
@@ -238,6 +239,8 @@ sub run_tests {
         chop $a;    # Leaves the UTF-8 flag
         $a .= "y";  # 1 byte before 'y'.
 
+        no warnings 'deprecated';
+
         like($a, qr/^\C/,        'match one \C on 1-byte UTF-8; Bug 15763');
         like($a, qr/^\C{1}/,     'match \C{1}; Bug 15763');
 
@@ -1172,7 +1175,10 @@ EOP
 
        # this one segfaulted under the conditions above
        # of course, CANY is evil, maybe it should crash
-       ok($s =~ /.\C+/, "CANY pointer wrap");
+        {
+            no warnings 'deprecated';
+            ok($s =~ /.\C+/, "CANY pointer wrap");
+        }
     }
 } # End of sub run_tests