This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Merge branch 'dual/Safe' into blead
authorRafael Garcia-Suarez <rgs@consttype.org>
Sat, 6 Mar 2010 21:44:12 +0000 (22:44 +0100)
committerRafael Garcia-Suarez <rgs@consttype.org>
Sat, 6 Mar 2010 21:44:12 +0000 (22:44 +0100)
29 files changed:
Porting/bump-perl-version
Porting/release_managers_guide.pod
cpan/Pod-Parser/t/pod/find.t
dist/ExtUtils-Install/t/lib/MakeMaker/Test/Utils.pm
ext/POSIX/POSIX.pod
lib/bytes.pm
lib/charnames.pm
lib/charnames.t
pod/perl5120delta.pod
pod/perldiag.pod
pod/perlfaq6.pod
pod/perlop.pod
pod/perlre.pod
pod/perlrebackslash.pod
pod/perlrecharclass.pod
pod/perlrepository.pod
pod/perlreref.pod
pod/perlretut.pod
pod/perltodo.pod
pod/perlunicode.pod
pp.c
sv.c
t/comp/colon.t
t/comp/hints.t
t/op/fork.t
t/op/threads.t
t/test.pl
toke.c
utf8.c

index b0e77a8..7951846 100755 (executable)
@@ -174,6 +174,14 @@ my @maps =  (
        undef,
     ],
 
+    # perl511, perl511.dll, perl511.lib, perl511s.lib
+    [
+       qr{\b perl (\d\d\d) (s?) \b }x,
+       sub {$1, "perl$newx$newy$2" },
+       "$oldx$oldy",
+       qr/makedef|win32/,      # makedef.pl, README.win32, win32/*
+    ],
+
 );
 
 
index 66a3bff..566171e 100644 (file)
@@ -808,12 +808,19 @@ high-reliability connection to the Internet, you should probably use the
 new release from wherever you put it for testers to find it.  This will
 eliminate anxious gnashing of teeth while you wait to see if your
 15 megabyte HTTP upload successfully completes across your slow, twitchy
-cable modem.  I<Remember>: if your upload is partially successful, you
-may need to contact a PAUSE administrator or even bump the version of
-perl.
+cable modem.  You can make use of your home directory on dromedary for
+this purpose: F<http://users.perl5.git.perl.org/~USERNAME> maps to
+F</home/USERNAME/public_html>, where F<USERNAME> is your login account
+on dromedary.  I<Remember>: if your upload is partially successful, you
+may need to contact a PAUSE administrator or even bump the version of perl.
 
 Upload both the .gz and .bz2 versions of the tarball.
 
+Wait until you receive notification emails from the PAUSE indexer
+confirming that your uploads have been successfully indexed.  Do not
+proceed any further until you are sure that the indexing of your uploads
+has been successful.
+
 =item *
 
 Now that you've shipped the new perl release to PAUSE, it's
index f6272d8..c4e8976 100644 (file)
@@ -3,6 +3,13 @@
 
 $| = 1;
 
+BEGIN {
+  if ($^O eq 'VMS') {
+    print "1..0 # needs upstream patch from https://rt.cpan.org/Ticket/Display.html?id=55121";
+    exit 0;
+  }
+}
+
 use Test::More tests => 4;
 
 BEGIN {
index c3c214c..453a8ed 100644 (file)
@@ -149,7 +149,7 @@ sub perl_lib {
        # $ENV{PERL5LIB} will be set with this, but (by default) it's a relative
        # path.
        $ENV{PERL5LIB} = join $Config{path_sep}, map {
-           File::Spec->rel2abs($_) } split $Config{path_sep}, $ENV{PERL5LIB};
+           File::Spec->rel2abs($_) } split quotemeta($Config{path_sep}), $ENV{PERL5LIB};
        @INC = map { File::Spec->rel2abs($_) } @INC;
     } else {
        my $lib = 'blib/lib';
index 5a2137c..64852e9 100644 (file)
@@ -1103,7 +1103,7 @@ Spanish. B<NOTE>: The naming and availability of locales depends on
 your operating system. Please consult L<perllocale> for how to find
 out which locales are available in your system.
 
-       $loc = setlocale( LC_ALL, "es_AR.ISO8859-1" );
+       $loc = setlocale( LC_COLLATE, "es_AR.ISO8859-1" );
 
 =item setpgid
 
index 97ba731..57916a5 100644 (file)
@@ -33,17 +33,17 @@ __END__
 
 bytes - Perl pragma to force byte semantics rather than character semantics
 
-=head1 DEPRECATED
+=head1 NOTICE
 
 This pragma reflects early attempts to incorporate Unicode into perl and
-has since been superceded. It breaks encapulation (i.e. it exposes the
-innards of how perl happens to be currently storing a string), and use of
-this module for anything other than debugging purposes is strongly
-discouraged. If you feel that the functions here within might be useful
-for your application, this possibly indicates a mismatch beteen your
-mental model of Perl Unicode and the current reality. In that case, you
-may wish to peruse some of the perl Unicode documentation: L<perluniintro>,
-L<perlunitut>, L<perlunifaq> and L<perlunicode>.
+has since been superseded. It breaks encapsulation (i.e. it exposes the
+innards of how the perl executable currently happens to store a string),
+and use of this module for anything other than debugging purposes is
+strongly discouraged. If you feel that the functions here within might be
+useful for your application, this possibly indicates a mismatch between
+your mental model of Perl Unicode and the current reality. In that case,
+you may wish to peruse some of the perl Unicode documentation:
+L<perluniintro>, L<perlunitut>, L<perlunifaq> and L<perlunicode>.
 
 =head1 SYNOPSIS
 
index 0acae61..ce0938b 100644 (file)
@@ -437,7 +437,15 @@ will also give a warning about being deprecated.
 =head1 CUSTOM ALIASES
 
 This version of charnames supports three mechanisms of adding local
-or customized aliases to standard Unicode naming conventions (:full)
+or customized aliases to standard Unicode naming conventions (:full).
+
+Note that an alias should not be something that is a legal curly
+brace-enclosed quantifier (see L<perlreref/QUANTIFIERS>).  For example
+C<\N{123}> means to match 123 non-newline characters, and is not treated as an
+alias.  Aliases are discouraged from beginning with anything other than an
+alphabetic character and from containing anything other than alphanumerics,
+spaces, dashes, colons, parentheses, and underscores.  Currently they must be
+ASCII.
 
 =head2 Anonymous hashes
 
@@ -530,23 +538,38 @@ state of C<bytes>-flag as in:
        }
     }
 
+See L</CUSTOM ALIASES> above for restrictions on C<CHARNAME>.
+
 =head1 ILLEGAL CHARACTERS
 
-If you ask by name for a character that does not exist, a warning is
-given and the Unicode I<replacement character> "\x{FFFD}" is returned.
+If you ask by name for a character that does not exist, a warning is given and
+the Unicode I<replacement character> "\x{FFFD}" is returned.
 
-If you ask by code for a character that does not exist, no warning is
+If you ask by code for a character that is unassigned, no warning is
 given and C<undef> is returned.  (Though if you ask for a code point
-past U+10FFFF you do get a warning.)
+past U+10FFFF you do get a warning.)  See L</BUGS> below.
 
 =head1 BUGS
 
+viacode should return an empty string for unassigned in-range Unicode code
+points, as that is their correct current name.
+
+viacode(0) doesn't return C<NULL>, but C<undef>
+
+vianame returns a chr if the input name is of the form C<U+...>, and an ord
+otherwise.  It is planned to change this to always return an ord.
+
+None of the functions work on almost all the Hangul syllable and CJK Unicode
+characters that have their code points as part of their names.
+
+Names must be ASCII characters only.
+
 Unicode standard named sequences are not recognized, such as
 C<LATIN CAPITAL LETTER A WITH MACRON AND GRAVE>
 (which should mean C<LATIN CAPITAL LETTER A WITH MACRON> with an additional
 C<COMBINING GRAVE ACCENT>).
 
-Since evaluation of the translation function happens in a middle of
+Since evaluation of the translation function happens in the middle of
 compilation (of a string literal), the translation function should not
 do any C<eval>s or C<require>s.  This restriction should be lifted in
 a future version of Perl.
index f74453d..50c23f3 100644 (file)
@@ -15,7 +15,7 @@ require File::Spec;
 
 $| = 1;
 
-print "1..79\n";
+print "1..80\n";
 
 use charnames ':full';
 
@@ -342,6 +342,23 @@ if ($@) {
 print "not " unless "\N{U+1D0C5}" eq "\N{BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON CHROMA VASIS}";
 print "ok 79\n";
 
+# [perl #73174] use of \N{FOO} used to reset %^H
+
+{
+    use charnames ":full";
+    my $res;
+    BEGIN { $^H{73174} = "foo" }
+    BEGIN { $res = ($^H{73174} // "") }
+    # forces loading of utf8.pm, which used to reset %^H
+    $res .= '-1' if ":" =~ /\N{COLON}/i;
+    BEGIN { $res .= '-' . ($^H{73174} // "") }
+    $res .= '-' . ($^H{73174} // "");
+    $res .= '-2' if ":" =~ /\N{COLON}/;
+    $res .= '-3' if ":" =~ /\N{COLON}/i;
+    print $res eq "foo-foo-1--2-3" ? "" : "not ",
+       "ok 80 - \$^H{foo} correct after /\\N{bar}/i (res=$res)\n";
+}
+
 __END__
 # unsupported pragma
 use charnames ":scoobydoo";
index 47304ff..1519850 100644 (file)
@@ -233,20 +233,34 @@ more information.
 This pragma allows you to lexically disable or enable overloading
 for some or all operations. (Yuval Kogman)
 
-=head2 C<\N> regex escape
+=head2 C<\N> experimental regex escape
 
 A new regex escape has been added, C<\N>. It will match any character that
 is not a newline, independently from the presence or absence of the single
 line match modifier C</s>.  It is not usable within a character class.
-(If C<\N> is followed by an opening brace and
-by a letter, perl will still assume that a Unicode character name is
-coming, so compatibility is preserved.) (Rafael Garcia-Suarez).
+C<\N{3}> means to match 3 non-newlines; C<\N{5,}> means to match at least 5.
+C<\N{NAME}> still means the character or sequence named C<NAME>, but C<NAME> no
+longer can be things like C<3>, or C<5,>.
+Compatibility with Unicode names is preserved, as none look like these, but it
+has been possible to create custom names that do look like them, and those will
+no longer work. (Rafael Garcia-Suarez)
 
 This will break a L<custom charnames translator|charnames/CUSTOM TRANSLATORS>
 which allows numbers for character names, as C<\N{3}> will now mean to match 3
 non-newline characters, and not the character whose name is C<3>.  (No standard
 name is a number, so only a custom translator would be affected.)
 
+This escape is experimental, subject to change, because there is some concern
+about possible confusion with the previous meaning of C<\N{...}>
+
+=head2 \N{...} now compiles better, always forces UTF-8 internal representation.
+
+There were several problems that have been fixed with recognizing C<\N{...}>
+constructs.   As part of this, any scalar or regex that has either a
+C<\N{I<name>}> or C<\N{U+I<wide hex char>}> in its definition will be stored in
+UTF-8 format.  (This was true previously for all occurences of C<\N{I<name>}>
+that did not use a custom translator, but now it's always true.)
+
 =head2 Implicit strictures
 
 Using the C<use VERSION> syntax with a version number greater or equal
@@ -701,6 +715,18 @@ Using C<goto> to jump from an outer scope into an inner scope is now
 deprecated. This rare use case was causing problems in the
 implementation of scopes.
 
+=item Custom character names in \N{name} should look like names
+
+In C<\N{I<name>}>, I<name> can be just about anything.  The standard Unicode
+names have a very limited domain, but a custom name translator could create
+names that are, for example, made up entirely of punctuation symbols.  It is
+now deprecated to make names that don't begin with an alphabetic character, and
+aren't alphanumeric or contain other than a very few other characters,
+namely spaces, dashes, parentheses and colons.  Because of the added meaning of
+C<\N> (See L</C<\N> experimental regex escape>), names that look like curly
+brace -enclosed quantifiers won't work.  For example, C<\N{3,4}> now means to
+match 3 to 4 non-newlines; before a custom name C<3,4> could have been created.
+
 =item Deprecated Modules
 
 The following modules will be removed from the core distribution in a future
@@ -1060,6 +1086,10 @@ C<use>.
 
 The documentation for C<$1> in perlvar.pod has been clarified.
 
+=item *
+
+C<\N{U+I<wide hex char>}> is now documented.
+
 =back
 
 =head1 Performance Enhancements
@@ -2470,6 +2500,11 @@ with the thread the pattern was compiled into [RT #55600].
 
 =item *
 
+Things like C<"\N{LATIN SMALL LIGATURE FF}" =~ /\N{LATIN SMALL LETTER F}+/>
+will appear to hang as they get into a very long running loop [RT #72998].
+
+=item *
+
 Untriaged test crashes on Windows 2000
 
 Several porters have reported mysterious crashes when Perl's entire test suite is run after a build on certain Windows 2000 systems.  When run by hand, the individual tests reportedly work fine.
index e1f02db..f0695ea 100644 (file)
@@ -1159,11 +1159,6 @@ that is already inside a group with a byte-order modifier.
 For example you cannot force little-endianness on a type that
 is inside a big-endian group.
 
-=item Can't use keyword '%s' as a label
-
-(F) You attempted to use a reserved keyword, such as C<print> or C<BEGIN>,
-as a statement label. This is disallowed since Perl 5.11.0.
-
 =item Can't use "my %s" in sort comparison
 
 (F) The global variables $a and $b are reserved for sort comparisons.
@@ -2645,12 +2640,13 @@ specialness: it matches almost everything, which is probably not what you want.
 
 (F) When compiling a regex pattern, an unresolved named character or sequence
 was encountered.  This can happen in any of several ways that bypass the lexer,
-such as using single-quotish context:
+such as using single-quotish context, or an extra backslash in double quotish:
 
     $re = '\N{SPACE}'; # Wrong!
+    $re = "\\N{SPACE}";        # Wrong!
     /$re/;
 
-Instead, use double-quotes:
+Instead, use double-quotes with a single backslash:
 
     $re = "\N{SPACE}"; # ok
     /$re/;
index 4074526..40965d0 100644 (file)
@@ -33,9 +33,9 @@ comments.
 =item Comments Inside the Regex
 
 The C</x> modifier causes whitespace to be ignored in a regex pattern
-(except in a character class), and also allows you to use normal
-comments there, too.  As you can imagine, whitespace and comments help
-a lot.
+(except in a character class and a few other places), and also allows you to
+use normal comments there, too.  As you can imagine, whitespace and comments
+help a lot.
 
 C</x> lets you turn this:
 
index a6514bb..ea0b07f 100644 (file)
@@ -1025,6 +1025,7 @@ X<\t> X<\n> X<\r> X<\f> X<\b> X<\a> X<\e> X<\x> X<\0> X<\c> X<\N>
     \x{263a}   wide hex char   (example: SMILEY)
     \c[                control char    (example: ESC)
     \N{name}   named Unicode character
+    \N{U+263D} Unicode character (example: FIRST QUARTER MOON)
 
 The character following C<\c> is mapped to some other character by
 converting letters to upper case and then (on ASCII systems) by inverting
@@ -1034,10 +1035,15 @@ through 0x1F. A '?' maps to the DEL character. On EBCDIC systems only
 '@', the letters, '[', '\', ']', '^', '_' and '?' will work, resulting
 in 0x00 through 0x1F and 0x7F.
 
-B<NOTE>: Unlike C and other languages, Perl has no \v escape sequence for
-the vertical tab (VT - ASCII 11), but you may use C<\ck> or C<\x0b>.
+C<\N{U+I<wide hex char>}> means the Unicode character whose Unicode ordinal
+number is I<wide hex char>.
+For documentation of C<\N{name}>, see L<charnames>.
 
-The following escape sequences are available in constructs that interpolate
+B<NOTE>: Unlike C and other languages, Perl has no C<\v> escape sequence for
+the vertical tab (VT - ASCII 11), but you may use C<\ck> or C<\x0b>.  (C<\v>
+does have meaning in regular expression patterns in Perl, see L<perlre>.)
+
+The following escape sequences are available in constructs that interpolate,
 but not in transliterations.
 X<\l> X<\u> X<\L> X<\U> X<\E> X<\Q>
 
@@ -1052,8 +1058,7 @@ If C<use locale> is in effect, the case map used by C<\l>, C<\L>,
 C<\u> and C<\U> is taken from the current locale.  See L<perllocale>.
 If Unicode (for example, C<\N{}> or wide hex characters of 0x100 or
 beyond) is being used, the case map used by C<\l>, C<\L>, C<\u> and
-C<\U> is as defined by Unicode.  For documentation of C<\N{name}>,
-see L<charnames>.
+C<\U> is as defined by Unicode.
 
 All systems use the virtual C<"\n"> to represent a line terminator,
 called a "newline".  There is no such thing as an unvarying, physical
@@ -2068,6 +2073,11 @@ is emitted if the C<use warnings> pragma or the B<-w> command-line flag
 Processing of C<\Q>, C<\U>, C<\u>, C<\L>, C<\l>, C<\E>,
 and interpolation happens (almost) as with C<qq//> constructs.
 
+Processing of C<\N{...}> is also done here, and compiled into an intermediate
+form for the regex compiler.  (This is because, as mentioned below, the regex
+compilation may be done at execution time, and C<\N{...}> is a compile-time
+construct.)
+
 However any other combinations of C<\> followed by a character
 are not substituted but only skipped, in order to parse them
 as regular expressions at the following step.
index 8189b29..b6a73c0 100644 (file)
@@ -41,7 +41,7 @@ X<regular expression, single-line>
 Treat string as single line.  That is, change "." to match any character
 whatsoever, even a newline, which normally it would not match.
 
-Used together, as /ms, they let the "." match any character whatsoever,
+Used together, as C</ms>, they let the "." match any character whatsoever,
 while still allowing "^" and "$" to match, respectively, just after
 and just before newlines within the string.
 
@@ -82,20 +82,30 @@ modifiers may also be embedded within the regular expression itself using
 the C<(?...)> construct.  See below.
 
 The C</x> modifier itself needs a little more explanation.  It tells
-the regular expression parser to ignore whitespace that is neither
+the regular expression parser to ignore most whitespace that is neither
 backslashed nor within a character class.  You can use this to break up
 your regular expression into (slightly) more readable parts.  The C<#>
 character is also treated as a metacharacter introducing a comment,
 just as in ordinary Perl code.  This also means that if you want real
 whitespace or C<#> characters in the pattern (outside a character
 class, where they are unaffected by C</x>), then you'll either have to
-escape them (using backslashes or C<\Q...\E>) or encode them using octal
-or hex escapes.  Taken together, these features go a long way towards
+escape them (using backslashes or C<\Q...\E>) or encode them using octal,
+hex, or C<\N{}> escapes.  Taken together, these features go a long way towards
 making Perl's regular expressions more readable.  Note that you have to
 be careful not to include the pattern delimiter in the comment--perl has
 no way of knowing you did not intend to close the pattern early.  See
 the C-comment deletion code in L<perlop>.  Also note that anything inside
-a C<\Q...\E> stays unaffected by C</x>.
+a C<\Q...\E> stays unaffected by C</x>.  And note that C</x> doesn't affect
+whether space interpretation within a single multi-character construct.  For
+example in C<\x{...}>, regardless of the C</x> modifier, there can be no
+spaces.  Same for a L<quantifier|Quantifiers> such as C<{3}> or
+C<{5,}>.  Similarly, C<(?:...)> can't have a space between the C<?> and C<:>,
+but can between the C<(> and C<?>.  Within any delimiters for such a
+construct, allowed spaces are not affected by C</x>, and depend on the
+construct.  For example, C<\x{...}> can't have spaces because hexadecimal
+numbers don't have spaces in them.  But, Unicode properties can have spaces, so
+in C<\p{...}>  there can be spaces that follow the Unicode rules, for which see
+L<perluniprops.pod/Properties accessible through \p{} and \P{}>.
 X</x>
 
 =head2 Regular Expressions
@@ -226,6 +236,7 @@ X<\0> X<\c> X<\N> X<\x>
     \x{263a}   long hex char         (example: Unicode SMILEY)
     \cK                control char          (example: VT)
     \N{name}   named Unicode character
+    \N{U+263D} Unicode character     (example: FIRST QUARTER MOON)
     \l         lowercase next char (think vi)
     \u         uppercase next char (think vi)
     \L         lowercase till \E (think vi)
@@ -270,7 +281,7 @@ X<word> X<whitespace> X<character class> X<backreference>
     \g{name} Named backreference
     \k<name> Named backreference
     \K       Keep the stuff left of the \K, don't include it in $&
-    \N       Any character but \n
+    \N       Any character but \n (experimental)
     \v       Vertical whitespace
     \V       Not vertical whitespace
     \h       Horizontal whitespace
@@ -301,6 +312,11 @@ B<Note:> C<\R> has no special meaning inside of a character class;
 use C<\v> instead (vertical whitespace).
 X<\R>
 
+Note that C<\N> has two meanings.  When of the form C<\N{NAME}>, it matches the
+character whose name is C<NAME>; and similarly when of the form
+C<\N{U+I<wide hex char>}>, it matches the character whose Unicode ordinal is
+I<wide hex char>.  Otherwise it matches any character but C<\n>.
+
 The POSIX character class syntax
 X<character class>
 
@@ -2138,6 +2154,15 @@ Subroutine call to a named capture buffer. Equivalent to C<< (?&NAME) >>.
 
 =head1 BUGS
 
+There are numerous problems with case insensitive matching of characters
+outside the ASCII range, especially with those whose folds are multiple
+characters, such as ligatures like C<LATIN SMALL LIGATURE FF>.
+
+In a bracketed character class with case insensitive matching, ranges only work
+for ASCII characters.  For example,
+C<m/[\N{CYRILLIC CAPITAL LETTER A}-\N{CYRILLIC CAPITAL LETTER YA}]/i>
+doesn't match all the Russian upper and lower case letters.
+
 This document varies from difficult to understand to completely
 and utterly opaque.  The wandering prose riddled with jargon is
 hard to fathom in several places.
index 3d3a76f..6b60684 100644 (file)
@@ -25,14 +25,13 @@ it either takes away the special meaning of the character following it
 or it is the start of a backslash or escape sequence.
 
 The rules determining what it is are quite simple: if the character
-following the backslash is a punctuation (non-word) character (that is,
-anything that is not a letter, digit or underscore), then the backslash
-just takes away the special meaning (if any) of the character following
-it.
-
-If the character following the backslash is a letter or a digit, then the
-sequence may be special; if so, it's listed below. A few letters have not
-been used yet, and escaping them with a backslash is safe for now, but a
+following the backslash is an ASCII punctuation (non-word) character (that is,
+anything that is not a letter, digit or underscore), then the backslash just
+takes away the special meaning (if any) of the character following it.
+
+If the character following the backslash is an ASCII letter or an ASCII digit,
+then the sequence may be special; if so, it's listed below. A few letters have
+not been used yet, and escaping them with a backslash is safe for now, but a
 future version of Perl may assign a special meaning to it. However, if you
 have warnings turned on, Perl will issue a warning if you use such a sequence.
 [1].
@@ -61,48 +60,51 @@ quoted constructs>.
 
 =head2 All the sequences and escapes
 
+Those not usable within a bracketed character class (like C<[\da-z]>) are marked
+as C<Not in [].>
+
  \000              Octal escape sequence.
- \1                Absolute backreference.
+ \1                Absolute backreference.  Not in [].
  \a                Alarm or bell.
- \A                Beginning of string.
- \b                Word/non-word boundary. (Backspace in a char class).
- \B                Not a word/non-word boundary.
+ \A                Beginning of string.  Not in [].
+ \b                Word/non-word boundary. (Backspace in []).
+ \B                Not a word/non-word boundary.  Not in [].
  \cX               Control-X (X can be any ASCII character).
- \C                Single octet, even under UTF-8.
+ \C                Single octet, even under UTF-8.  Not in [].
  \d                Character class for digits.
  \D                Character class for non-digits.
  \e                Escape character.
- \E                Turn off \Q, \L and \U processing.
+ \E                Turn off \Q, \L and \U processing.  Not in [].
  \f                Form feed.
- \g{}, \g1         Named, absolute or relative backreference.
- \G                Pos assertion.
+ \g{}, \g1         Named, absolute or relative backreference.  Not in [].
+ \G                Pos assertion.  Not in [].
  \h                Character class for horizontal white space.
  \H                Character class for non horizontal white space.
- \k{}, \k<>, \k''  Named backreference.
- \K                Keep the stuff left of \K.
- \l                Lowercase next character.
- \L                Lowercase till \E.
+ \k{}, \k<>, \k''  Named backreference.  Not in [].
+ \K                Keep the stuff left of \K.  Not in [].
+ \l                Lowercase next character.  Not in [].
+ \L                Lowercase till \E.  Not in [].
  \n                (Logical) newline character.
- \N                Any character but newline.
- \N{}              Named (Unicode) character.
+ \N                Any character but newline.  Experimental.  Not in [].
+ \N{}              Named or numbered (Unicode) character.
  \p{}, \pP         Character with the given Unicode property.
  \P{}, \PP         Character without the given Unicode property.
- \Q                Quotemeta till \E.
+ \Q                Quotemeta till \E.  Not in [].
  \r                Return character.
- \R                Generic new line.
+ \R                Generic new line.  Not in [].
  \s                Character class for white space.
  \S                Character class for non white space.
  \t                Tab character.
- \u                Titlecase next character.
- \U                Uppercase till \E.
+ \u                Titlecase next character.  Not in [].
+ \U                Uppercase till \E.  Not in [].
  \v                Character class for vertical white space.
  \V                Character class for non vertical white space.
  \w                Character class for word characters.
  \W                Character class for non-word characters.
  \x{}, \x00        Hexadecimal escape sequence.
- \X                Unicode "extended grapheme cluster".
- \z                End of string.
- \Z                End of string.
+ \X                Unicode "extended grapheme cluster".  Not in [].
+ \z                End of string.  Not in [].
+ \Z                End of string.  Not in [].
 
 =head2 Character Escapes
 
@@ -154,17 +156,39 @@ Mnemonic: I<c>ontrol character.
 
  $str =~ /\cK/;  # Matches if $str contains a vertical tab (control-K).
 
-=head3 Named characters
+=head3 Named or numbered characters
+
+All Unicode characters have a Unicode name and numeric ordinal value.  Use the
+C<\N{}> construct to specify a character by either of these values.
+
+To specify by name, the name of the character goes between the curly braces.
+In this case, you have to C<use charnames> to load the Unicode names of the
+characters, otherwise Perl will complain.
+
+To specify by Unicode ordinal number, use the form
+C<\N{U+I<wide hex character>}>, where I<wide hex character> is a number in
+hexadecimal that gives the ordinal number that Unicode has assigned to the
+desired character.  It is customary (but not required) to use leading zeros to
+pad the number to 4 digits.  Thus C<\N{U+0041}> means
+C<Latin Capital Letter A>, and you will rarely see it written without the two
+leading zeros.  C<\N{U+0041}> means C<A> even on EBCDIC machines (where the
+ordinal value of C<A> is not 0x41).
+
+It is even possible to give your own names to characters, and even to short
+sequences of characters.  For details, see L<charnames>.
 
-All Unicode characters have a Unicode name, and characters in various scripts
-have names as well. It is even possible to give your own names to characters.
-You can use a character by name by using the C<\N{}> construct; the name of
-the character goes between the curly braces. You do have to C<use charnames>
-to load the names of the characters, otherwise Perl will complain you use
-a name it doesn't know about. For more details, see L<charnames>.
+(There is an expanded internal form that you may see in debug output:
+C<\N{U+I<wide hex character>.I<wide hex character>...}>.
+The C<...> means any number of these I<wide hex character>s separated by dots.
+This represents the sequence formed by the characters.  This is an internal
+form only, subject to change, and you should not try to use it yourself.)
 
 Mnemonic: I<N>amed character.
 
+Note that a character that is expressed as a named or numbered character is
+considered as a character without special meaning by the regex engine, and will
+match "as is".
+
 =head4 Example
 
  use charnames ':full';               # Loads the Unicode names.
@@ -177,7 +201,8 @@ Mnemonic: I<N>amed character.
 
 Octal escapes consist of a backslash followed by two or three octal digits
 matching the code point of the character you want to use. This allows for
-512 characters (C<\00> up to C<\777>) that can be expressed this way.
+512 characters (C<\00> up to C<\777>) that can be expressed this way (but
+anything above C<\377> is deprecated).
 Enough in pre-Unicode days, but most Unicode characters cannot be escaped
 this way.
 
@@ -329,7 +354,7 @@ absolutely, relatively, and by name.
 
 A backslash sequence that starts with a backslash and is followed by a
 number is an absolute reference (but be aware of the caveat mentioned above).
-If the number is I<N>, it refers to the Nth set of parenthesis - whatever
+If the number is I<N>, it refers to the Nth set of parentheses - whatever
 has been matched by that set of parenthesis has to be matched by the C<\N>
 as well.
 
@@ -379,7 +404,7 @@ written as C<\k{name}>, C<< \k<name> >> or C<\k'name'>.
 
 Note that C<\g{}> has the potential to be ambiguous, as it could be a named
 reference, or an absolute or relative reference (if its argument is numeric).
-However, names are not allowed to start with digits, nor are allowed to
+However, names are not allowed to start with digits, nor are they allowed to
 contain a hyphen, so there is no ambiguity.
 
 =head4 Examples
@@ -490,6 +515,18 @@ instead of C<s/(PAT1) PAT2/${1}REPL/x> or C<s/(?<=PAT1) PAT2/REPL/x>.
 
 Mnemonic: I<K>eep.
 
+=item \N
+
+This is a new experimental feature in perl 5.12.0.  It matches any character
+that is not a newline.  It is a short-hand for writing C<[^\n]>, and is
+identical to the C<.> metasymbol, except under the C</s> flag, which changes
+the meaning of C<.>, but not C<\N>.
+
+Note that C<\N{...}> can mean a
+L<named or numbered character|/Named or numbered characters>.
+
+Mnemonic: Complement of I<\n>.
+
 =item \R
 
 C<\R> matches a I<generic newline>, that is, anything that is considered
@@ -512,7 +549,7 @@ This matches a Unicode I<extended grapheme cluster>.
 C<\X> matches quite well what normal (non-Unicode-programmer) usage
 would consider a single character.  As an example, consider a G with some sort
 of diacritic mark, such as an arrow.  There is no such single character in
-Unicode, but one can be composed using a G followed by a Unicode "COMBINING
+Unicode, but one can be composed by using a G followed by a Unicode "COMBINING
 UPWARDS ARROW BELOW", and would be displayed by Unicode-aware software as if it
 were a single character.
 
index 0b5b89a..140d8ea 100644 (file)
@@ -45,7 +45,7 @@ constitute a character class. That is, they will match a single
 character, if that character belongs to a specific set of characters
 (defined by the sequence). A backslashed sequence is a sequence of
 characters starting with a backslash. Not all backslashed sequences
-are character class; for a full list, see L<perlrebackslash>.
+are character classes; for a full list, see L<perlrebackslash>.
 
 Here's a list of the backslashed sequences, which are discussed in
 more detail below.
@@ -58,7 +58,7 @@ more detail below.
  \S             Match a non-white space character.
  \h             Match a horizontal white space character.
  \H             Match a character that isn't horizontal white space.
- \N             Match a character that isn't newline.
+ \N             Match a character that isn't newline.  Experimental.
  \v             Match a vertical white space character.
  \V             Match a character that isn't vertical white space.
  \pP, \p{Prop}  Match a character matching a Unicode property.
@@ -113,11 +113,15 @@ C<\h> will match any character that is considered horizontal white space;
 this includes the space and the tab characters. C<\H> will match any character
 that is not considered horizontal white space.
 
-C<\N>, like the dot, will match any character that is not a newline. The
-difference is that C<\N> will not be influenced by the single line C</s>
-regular expression modifier. (Note that, since C<\N{}> is also used for
-Unicode named characters, if C<\N> is followed by an opening brace and
-by a letter, perl will assume that a Unicode character name is coming.)
+C<\N> is an experimental feature.  It, like the dot, will match any character
+that is not a newline. The difference is that C<\N> will not be influenced by
+the single line C</s> regular expression modifier. (Note that, since C<\N{}> is
+also used for named characters, if C<\N> is followed by an opening brace and
+something that is not a quantifier, perl will assume that a character name is
+coming.  For example, C<\N{3}> means to match 3 non-newlines; C<\N{5,}> means
+to match 5 or more non-newlines, but C<\N{4F}> is not a legal quantifier, and
+will cause perl to look for a character named C<4F> (and won't find one unless
+custom names have been defined that include it.)
 
 C<\v> will match any character that is considered vertical white space;
 this includes the carriage return and line feed characters (newline).
@@ -265,7 +269,7 @@ Examples:
 =head3 Special Characters Inside a Bracketed Character Class
 
 Most characters that are meta characters in regular expressions (that
-is, characters that carry a special meaning like C<*> or C<(>) lose
+is, characters that carry a special meaning like C<.>, C<*>, or C<(>) lose
 their special meaning and can be used inside a character class without
 the need to escape them. For instance, C<[()]> matches either an opening
 parenthesis, or a closing parenthesis, and the parens inside the character
@@ -282,6 +286,23 @@ that does not have either two word characters or two non-word characters
 on either side, inside a bracketed character class, C<\b> matches a
 backspace character.
 
+The sequences
+C<\a>,
+C<\c>,
+C<\e>,
+C<\f>,
+C<\n>,
+C<\N{I<NAME>}>,
+C<\N{U+I<wide hex char>}>,
+C<\r>,
+C<\t>,
+and
+C<\x>
+are also special and have the same meanings as they do outside a bracketed character
+class.
+
+Also, a backslash followed by digits is considered an octal number.
+
 A C<[> is not special inside a character class, unless it's the start
 of a POSIX character class (see below). It normally does not need escaping.
 
@@ -362,11 +383,16 @@ Examples:
 
 =head3 Backslash Sequences
 
-You can put a backslash sequence character class inside a bracketed character
-class, and it will act just as if you put all the characters matched by
-the backslash sequence inside the character class. For instance,
-C<[a-f\d]> will match any digit, or any of the lowercase letters between
-'a' and 'f' inclusive.
+You can put any backslash sequence character class (with one exception listed
+in the next paragraph) inside a bracketed character class, and it will act just
+as if you put all the characters matched by the backslash sequence inside the
+character class. For instance, C<[a-f\d]> will match any digit, or any of the
+lowercase letters between 'a' and 'f' inclusive.
+
+C<\N> within a bracketed character class must be of the forms C<\N{I<name>}>  or
+C<\N{U+I<wide hex char>}> for the same reason that a dot C<.> inside a
+bracketed character class loses its special meaning: it matches nearly
+anything, which generally isn't what you want to happen.
 
 Examples:
 
index 2f29aef..29d53cc 100644 (file)
@@ -745,7 +745,7 @@ If someone has provided a branch via GitHub and you are a committer,
 you should use the following in your perl-ssh directory:
 
   % git remote add dandv git://github.com/dandv/perl.git
-  % git fetch
+  % git fetch dandv
 
 Now you can see the differences between the branch and blead:
 
index f7d01b8..c6cbe75 100644 (file)
@@ -92,6 +92,7 @@ These work as in normal strings.
    \x{263a} A wide hexadecimal value
    \cx      Control-x
    \N{name} A named character
+   \N{U+263D} A Unicode character by hex ordinal
 
    \l  Lowercase next character
    \u  Titlecase next character
@@ -113,7 +114,7 @@ This one works differently from normal strings:
    [f-j-]   Dash escaped or at start or end means 'dash'
    [^f-j]   Caret indicates "match any character _except_ these"
 
-The following sequences work within or without a character class.
+The following sequences (except C<\N>) work within or without a character class.
 The first six are locale aware, all are Unicode aware. See L<perllocale>
 and L<perlunicode> for details.
 
@@ -125,7 +126,9 @@ and L<perlunicode> for details.
    \S      A non-whitespace character
    \h      An horizontal white space
    \H      A non horizontal white space
-   \N      A non newline (when not followed by a '{'; it's like . without /s)
+   \N      A non newline (when not followed by '{NAME}'; experimental; not
+          valid in a character class; equivalent to [^\n]; it's like '.'
+          without /s modifier)
    \v      A vertical white space
    \V      A non vertical white space
    \R      A generic newline           (?>\v|\x0D\x0A)
index f9a4351..2798f68 100644 (file)
@@ -1866,8 +1866,8 @@ Unicode and encoded in UTF-8, then an explicit C<use utf8> is needed.)
 Figuring out the hexadecimal sequence of a Unicode character you want
 or deciphering someone else's hexadecimal Unicode regexp is about as
 much fun as programming in machine code.  So another way to specify
-Unicode characters is to use the I<named character>> escape
-sequence C<\N{name}>.  C<name> is a name for the Unicode character, as
+Unicode characters is to use the I<named character> escape
+sequence C<\N{I<name>}>.  I<name> is a name for the Unicode character, as
 specified in the Unicode standard.  For instance, if we wanted to
 represent or match the astrological sign for the planet Mercury, we
 could use
index 56d5045..d9d0807 100644 (file)
@@ -920,6 +920,15 @@ also the warning messages (see L<perllexwarn>, C<warnings.pl>).
 These tasks would need C knowledge, and knowledge of how the interpreter works,
 or a willingness to learn.
 
+=head2 forbid labels with keyword names
+
+Currently C<goto keyword> "computes" the label value:
+
+    $ perl -e 'goto print'
+    Can't find label 1 at -e line 1.
+
+It would be nice to forbid labels with keyword names, to avoid confusion.
+
 =head2 truncate() prototype
 
 The prototype of truncate() is currently C<$$>. It should probably
index 042e421..ae13a33 100644 (file)
@@ -146,12 +146,16 @@ If you use a Unicode editor to edit your program, Unicode characters may
 occur directly within the literal strings in UTF-8 encoding, or UTF-16.
 (The former requires a BOM or C<use utf8>, the latter requires a BOM.)
 
-Unicode characters can also be added to a string by using the C<\x{...}>
+Unicode characters can also be added to a string by using the C<\N{U+...}>
 notation.  The Unicode code for the desired character, in hexadecimal,
-should be placed in the braces. For instance, a smiley face is
-C<\x{263A}>.  This encoding scheme works for all characters, but
-for characters under 0x100, note that Perl may use an 8 bit encoding
-internally, for optimization and/or backward compatibility.
+should be placed in the braces, after the C<U>. For instance, a smiley face is
+C<\N{U+263A}>.
+
+Alternatively, you can use the C<\x{...}> notation for characters 0x100 and
+above.  For characters below 0x100 you may get byte semantics instead of
+character semantics;  see L</The "Unicode Bug">.  On EBCDIC machines there is
+the additional problem that the value for such characters gives the EBCDIC
+character rather than the Unicode one.
 
 Additionally, if you
 
@@ -159,6 +163,7 @@ Additionally, if you
 
 you can use the C<\N{...}> notation and put the official Unicode
 character name within the braces, such as C<\N{WHITE SMILING FACE}>.
+See L<charnames>.
 
 =item *
 
@@ -1296,7 +1301,7 @@ readdir, readlink
 =head2 The "Unicode Bug"
 
 The term, the "Unicode bug" has been applied to an inconsistency with the
-Unicode characters whose code points are in the Latin-1 Supplement block, that
+Unicode characters whose ordinals are in the Latin-1 Supplement block, that
 is, between 128 and 255.  Without a locale specified, unlike all other
 characters or code points, these characters have very different semantics in
 byte semantics versus character semantics.
@@ -1374,7 +1379,9 @@ operations in the 5.12 release, it is planned to have it affect all the
 problematic behaviors in later releases: you can't have one without them all.
 
 In the meantime, a workaround is to always call utf8::upgrade($string), or to
-use the standard modules L<Encode> or L<charnames>.
+use the standard module L<Encode>.   Also, a scalar that has any characters
+whose ordinal is above 0x100, or which were specified using either of the
+C<\N{...}> notations will automatically have character semantics.
 
 =head2 Forcing Unicode in Perl (Or Unforcing Unicode in Perl)
 
diff --git a/pp.c b/pp.c
index 3e2ed48..5876cfd 100644 (file)
--- a/pp.c
+++ b/pp.c
@@ -132,7 +132,7 @@ PP(pp_padhv)
 
 /* Translations. */
 
-const char S_no_symref_sv[] =
+static const char S_no_symref_sv[] =
     "Can't use string (\"%" SVf32 "\"%s) as %s ref while \"strict refs\" in use";
 
 PP(pp_rv2gv)
diff --git a/sv.c b/sv.c
index 2f429cc..b6c03ed 100644 (file)
--- a/sv.c
+++ b/sv.c
@@ -7674,7 +7674,8 @@ string.  You are responsible for ensuring that the source string is at least
 C<len> bytes long.  If the C<s> argument is NULL the new SV will be undefined.
 Currently the only flag bits accepted are C<SVf_UTF8> and C<SVs_TEMP>.
 If C<SVs_TEMP> is set, then C<sv2mortal()> is called on the result before
-returning. If C<SVf_UTF8> is set, then it will be set on the new SV.
+returning. If C<SVf_UTF8> is set, C<s> is considered to be in UTF-8 and the
+C<SVf_UTF8> flag will be set on the new SV.
 C<newSVpvn_utf8()> is a convenience wrapper for this function, defined as
 
     #define newSVpvn_utf8(s, len, u)                   \
@@ -12008,9 +12009,8 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     SvNV_set(&PL_sv_yes, 1);
     ptr_table_store(PL_ptr_table, &proto_perl->Isv_yes, &PL_sv_yes);
 
-    /* dbargs array probably holds garbage; give the child a clean array */
-    PL_dbargs          = newAV();
-    ptr_table_store(PL_ptr_table, proto_perl->Idbargs, PL_dbargs);
+    /* dbargs array probably holds garbage */
+    PL_dbargs          = NULL;
 
     /* create (a non-shared!) shared string table */
     PL_strtab          = newHV();
index 91b2e36..e43af3b 100644 (file)
@@ -122,14 +122,14 @@ ok 22, (not eval "y:1" and
        not eval "y:echo: eq y|echo|" and
        eval "y:echo:ohce: >= 0");
 
-ok 23, (not eval "AUTOLOAD:1" and
+ok 23, (eval "AUTOLOAD:1" and
        not eval "AUTOLOAD:echo: eq AUTOLOAD|echo|" and
        not eval "AUTOLOAD:echo:ohce: >= 0");
 
-ok 24, (not eval "and:1" and
+ok 24, (eval "and:1" and
        not eval "and:echo: eq and|echo|" and
        not eval "and:echo:ohce: >= 0");
 
-ok 25, (not eval "alarm:1" and
+ok 25, (eval "alarm:1" and
        not eval "alarm:echo: eq alarm|echo|" and
        not eval "alarm:echo:ohce: >= 0");
index f8c6dca..b81028a 100644 (file)
@@ -2,9 +2,11 @@
 
 # Tests the scoping of $^H and %^H
 
-@INC = '../lib';
+BEGIN {
+    @INC = qw(. ../lib);
+}
 
-BEGIN { print "1..23\n"; }
+BEGIN { print "1..24\n"; }
 BEGIN {
     print "not " if exists $^H{foo};
     print "ok 1 - \$^H{foo} doesn't exist initially\n";
@@ -109,6 +111,21 @@ BEGIN {
     print +($rf2 eq "z" ? "" : "not "), "ok 22 - \$^H{foo} correct after require\n";
 }
 
+# [perl #73174]
+
+{
+    my $res;
+    BEGIN { $^H{73174} = "foo" }
+    BEGIN { $res = ($^H{73174} // "") }
+    "" =~ /\x{100}/i;  # forces loading of utf8.pm, which used to reset %^H
+    BEGIN { $res .= '-' . ($^H{73174} // "")}
+    $res .= '-' . ($^H{73174} // "");
+    print $res eq "foo-foo-" ? "" : "not ",
+       "ok 23 - \$^H{foo} correct after /unicode/i (res=$res)\n";
+}
+
+
+
 # Add new tests above this require, in case it fails.
 require './test.pl';
 
@@ -118,7 +135,7 @@ my $result = runperl(
     stderr => 1
 );
 print "not " if length $result;
-print "ok 23 - double-freeing hints hash\n";
+print "ok 24 - double-freeing hints hash\n";
 print "# got: $result\n" if length $result;
 
 __END__
index 9fe8107..fc9c58f 100644 (file)
@@ -462,3 +462,21 @@ sub { @_ = 3; fork ? die "1\n" : die "1\n" }->(2);
 EXPECT
 1
 1
+########
+# [perl #72604] @DB::args stops working across Win32 fork
+$|=1;
+sub f {
+    if ($pid = fork()) {
+       print "waitpid() returned ok\n" if waitpid($pid,0) == $pid;
+    }
+    else {
+       package DB;
+       my @c = caller(0);
+       print "child: called as [$c[3](", join(',',@DB::args), ")]\n";
+       exit(0);
+    }
+}
+f("foo", "bar");
+EXPECT
+child: called as [main::f(foo,bar)]
+waitpid() returned ok
index 588b969..956102a 100644 (file)
@@ -16,7 +16,7 @@ BEGIN {
        exit 0;
      }
 
-     plan(17);
+     plan(18);
 }
 
 use strict;
@@ -225,4 +225,16 @@ print create threads sub {
  //"undef"
 EOJ
 
+# At the point of thread creation, $h{1} is on the temps stack.
+# The weak reference $a, however, is visible from the symbol table.
+fresh_perl_is(<<'EOI', 'ok', { }, 'Test for 34394ecd06e704e9');
+    use threads;
+    %h = (1, 2);
+    use Scalar::Util 'weaken';
+    $a = \$h{1};
+    weaken($a);
+    delete $h{1} && threads->create(sub {}, shift)->join();
+    print 'ok';
+EOI
+
 # EOF
index c0406b0..d39c010 100644 (file)
--- a/t/test.pl
+++ b/t/test.pl
@@ -525,7 +525,7 @@ sub runperl {
        my @keys = grep {exists $ENV{$_}} qw(CDPATH IFS ENV BASH_ENV);
        local @ENV{@keys} = ();
        # Untaint, plus take out . and empty string:
-       local $ENV{'DCL$PATH'} = $1 if $is_vms && ($ENV{'DCL$PATH'} =~ /(.*)/s);
+       local $ENV{'DCL$PATH'} = $1 if $is_vms && exists($ENV{'DCL$PATH'}) && ($ENV{'DCL$PATH'} =~ /(.*)/s);
        $ENV{PATH} =~ /(.*)/s;
        local $ENV{PATH} =
            join $sep, grep { $_ ne "" and $_ ne "." and -d $_ and
diff --git a/toke.c b/toke.c
index 7167004..a7a71a4 100644 (file)
--- a/toke.c
+++ b/toke.c
@@ -6143,8 +6143,6 @@ Perl_yylex(pTHX)
        /* Is this a label? */
        if (!anydelim && PL_expect == XSTATE
              && d < PL_bufend && *d == ':' && *(d + 1) != ':') {
-           if (tmp)
-               Perl_croak(aTHX_ "Can't use keyword '%s' as a label", PL_tokenbuf);
            s = d + 1;
            pl_yylval.pval = CopLABEL_alloc(PL_tokenbuf);
            CLINE;
diff --git a/utf8.c b/utf8.c
index 040b273..9ed0663 100644 (file)
--- a/utf8.c
+++ b/utf8.c
@@ -1842,8 +1842,7 @@ Perl_swash_init(pTHX_ const char* pkg, const char* name, SV *listsv, I32 minbits
 
     PUSHSTACKi(PERLSI_MAGIC);
     ENTER;
-    SAVEI32(PL_hints);
-    PL_hints = 0;
+    SAVEHINTS();
     save_re_context();
     if (!gv_fetchmeth(stash, "SWASHNEW", 8, -1)) {     /* demand load utf8 */
        ENTER;