develooper Front page | perl.perl5.changes | Postings from October 2019

[perl.git] branch blead updated. v5.31.4-324-g30659cfdea

Max Maischein
October 11, 2019 08:15
[perl.git] branch blead updated. v5.31.4-324-g30659cfdea
Message ID:
In perl.git, the branch blead has been updated


- Log -----------------------------------------------------------------
commit 30659cfdeafec7fc89eeb1ecb86d2f7d3ebdd638
Author: Max Maischein <>
Date:   Fri Oct 11 09:45:09 2019 +0200 is https, except for


Summary of changes:
 pod/perlebcdic.pod      |  6 +++---
 pod/perlfunc.pod        |  6 +++---
 pod/perllocale.pod      |  6 +++---
 pod/perlrebackslash.pod | 20 ++++++++++----------
 pod/perlrecharclass.pod |  2 +-
 pod/perlretut.pod       |  6 +++---
 pod/perluniintro.pod    | 14 +++++++-------
 7 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/pod/perlebcdic.pod b/pod/perlebcdic.pod
index d2e2d4e8ae..19c23e8c5e 100644
--- a/pod/perlebcdic.pod
+++ b/pod/perlebcdic.pod
@@ -254,7 +254,7 @@ extensions are constructed to allow encoding of any code point that fits
 in a 64-bit word.
 UTF-EBCDIC is defined by
-L<Unicode Technical Report #16|>
+L<Unicode Technical Report #16|>
 (often referred to as just TR16).
 It is defined based on CCSID 1047, not allowing for the differences for
 other code pages.  This allows for easy interchange of text between
@@ -1877,9 +1877,9 @@ L<perllocale>, L<perlfunc>, L<perlunicode>, L<utf8>.
 B<ASCII: American Standard Code for Information Infiltration> Tom Jennings,
diff --git a/pod/perlfunc.pod b/pod/perlfunc.pod
index 37046b8e68..3b92f0a2e3 100644
--- a/pod/perlfunc.pod
+++ b/pod/perlfunc.pod
@@ -2621,8 +2621,8 @@ L<Unicode::UCD/B<prop_invmap()>>.
 For further information on casefolding, refer to
 the Unicode Standard, specifically sections 3.13 C<Default Case Operations>,
 4.2 C<Case-Normative>, and 5.18 C<Case Mappings>,
-available at L<>, as well as the
-Case Charts available at L<>.
+available at L<>, as well as the
+Case Charts available at L<>.
 If EXPR is omitted, uses L<C<$_>|perlvar/$_>.
@@ -6037,7 +6037,7 @@ This protects against those locales where characters such as C<"|"> are
 considered to be word characters.
 Otherwise, Perl quotes non-ASCII characters using an adaptation from
-Unicode (see L<>).
+Unicode (see L<>).
 The only code points that are quoted are those that have any of the
 Unicode properties:  Pattern_Syntax, Pattern_White_Space, White_Space,
 Default_Ignorable_Code_Point, or General_Category=Control.
diff --git a/pod/perllocale.pod b/pod/perllocale.pod
index 905be3c195..28e546923f 100644
--- a/pod/perllocale.pod
+++ b/pod/perllocale.pod
@@ -1469,7 +1469,7 @@ system's implementation of the locale system than by Perl.
 The Unicode CLDR project extracts the POSIX portion of many of its
 locales, available at
 (Newer versions of CLDR require you to compute the POSIX data yourself.
 See L<>.)
@@ -1551,9 +1551,9 @@ multi-byte:
 The only multi-byte (or wide character) locale that Perl is ever likely
 to support is UTF-8.  This is due to the difficulty of implementation,
 the fact that high quality UTF-8 locales are now published for every
-area of the world (L<> for
+area of the world (L<> for
 ones that are already set-up, but from an earlier version;
-L<> for the most up-to-date, but
+L<> for the most up-to-date, but
 you have to extract the POSIX information yourself), and that
 failing all that you can use the L<Encode> module to translate to/from
 your locale.  So, you'll have to do one of those things if you're using
diff --git a/pod/perlrebackslash.pod b/pod/perlrebackslash.pod
index 4a8717346d..1a812a8200 100644
--- a/pod/perlrebackslash.pod
+++ b/pod/perlrebackslash.pod
@@ -520,11 +520,11 @@ match to the true end of the string under all conditions.
 =item \G
 C<\G> is usually used only in combination with the C</g> modifier. If the
-C</g> modifier is used and the match is done in scalar context, Perl 
+C</g> modifier is used and the match is done in scalar context, Perl
 remembers where in the source string the last match ended, and the next time,
 it will start the match from where it ended the previous time.
-C<\G> matches the point where the previous match on that string ended, 
+C<\G> matches the point where the previous match on that string ended,
 or the beginning of that string if there was no previous match.
 =for later add link to perlremodifiers
@@ -550,11 +550,11 @@ C<\b>
 and C<\B> assume there's a non-word character before the beginning and after
 the end of the source string; so C<\b> will match at the beginning (or end)
 of the source string if the source string begins (or ends) with a word
-character. Otherwise, C<\B> will match.   
+character. Otherwise, C<\B> will match.
 Do not use something like C<\b=head\d\b> and expect it to match the
 beginning of a line.  It can't, because for there to be a boundary before
-the non-word "=", there must be a word character immediately previous.  
+the non-word "=", there must be a word character immediately previous.
 All plain C<\b> and C<\B> boundary determinations look for word
 characters alone, not for
 non-word characters nor for string ends.  It may help to understand how
@@ -566,8 +566,8 @@ C<\b> and C<\B> work by equating them as follows:
 In contrast, C<\b{...}> and C<\B{...}> may or may not match at the
 beginning and end of the line, depending on the boundary type.  These
 implement the Unicode default boundaries, specified in
-L<> and
+L<> and
 The boundary types are:
@@ -583,9 +583,9 @@ whichever is most convenient for your situation.
 =item C<\b{lb}>
 This matches according to the default Unicode Line Breaking Algorithm
-(L<>), as customized in that
+(L<>), as customized in that
-(L<Example 7 of revision 35|>)
+(L<Example 7 of revision 35|>)
 for better handling of numeric expressions.
 This is suitable for many purposes, but the L<Unicode::LineBreak> module
@@ -597,7 +597,7 @@ customization.
 This matches a Unicode "Sentence Boundary".  This is an aid to parsing
 natural language sentences.  It gives good, but imperfect results.  For
 example, it thinks that "Mr. Smith" is two sentences.  More details are
-at L<>.  Note also that it thinks
+at L<>.  Note also that it thinks
 that anything matching L</\R> (except form feed and vertical tab) is a
 sentence boundary.  C<\b{sb}> works with text designed for
 word-processors which wrap lines
@@ -617,7 +617,7 @@ expectations.  This gives better (though not
 perfect) results for natural language processing than plain C<\b>
 (without braces) does.  For example, it understands that apostrophes can
 be in the middle of words and that parentheses aren't (see the examples
-below).  More details are at L<>.
+below).  More details are at L<>.
 The current Unicode definition of a Word Boundary matches between every
 white space character.  Perl tailors this, starting in version 5.24, to
diff --git a/pod/perlrecharclass.pod b/pod/perlrecharclass.pod
index bda60cd49e..c355a73e40 100644
--- a/pod/perlrecharclass.pod
+++ b/pod/perlrecharclass.pod
@@ -140,7 +140,7 @@ C<\p{Numeric_Type=Digit}>, and so C<\d> doesn't match them.
 The Tamil digits (U+0BE6 - U+0BEF) can also legally be
 used in old-style Tamil numbers in which they would appear no more than
 one in a row, separated by characters that mean "times 10", "times 100",
-etc.  (See L<>.)
+etc.  (See L<>.)
 Any character not matched by C<\d> is matched by C<\D>.
diff --git a/pod/perlretut.pod b/pod/perlretut.pod
index 1e1cdd49b2..b7d3173753 100644
--- a/pod/perlretut.pod
+++ b/pod/perlretut.pod
@@ -2001,9 +2001,9 @@ L<charnames> pragma:
     print "\N{sigma} is Greek sigma\n";
 An index of character names is available on-line from the Unicode
-Consortium, L<>; explanatory
+Consortium, L<>; explanatory
 material with links to other resources at
 The answer to requirement 2) is that a regexp (mostly)
 uses Unicode characters.  The "mostly" is for messy backward
@@ -2070,7 +2070,7 @@ RING>" is a grapheme cluster with base character "A" and combining character
 as in the word E<Aring>ngstrom.
 For the full and latest information about Unicode see the latest
-Unicode standard, or the Unicode Consortium's website L<>
+Unicode standard, or the Unicode Consortium's website L<>
 As if all those classes weren't enough, Perl also defines POSIX-style
 character classes.  These have the form C<[:I<name>:]>, with I<name> the
diff --git a/pod/perluniintro.pod b/pod/perluniintro.pod
index 5e263b4e63..f7d892bc65 100644
--- a/pod/perluniintro.pod
+++ b/pod/perluniintro.pod
@@ -599,8 +599,8 @@ CAPITAL LETTER A's should be considered equal, or even A's of any case.
 The long answer is that you need to consider character normalization
 and casing issues: see L<Unicode::Normalize>, Unicode Technical Report #15,
-L<Unicode Normalization Forms|> and
-sections on case mapping in the L<Unicode Standard|>.
+L<Unicode Normalization Forms|> and
+sections on case mapping in the L<Unicode Standard|>.
 As of Perl 5.8.0, the "Full" case-folding of I<Case
 Mappings/SpecialCasing> is implemented, but bugs remain in C<qr//i> with them,
@@ -624,7 +624,7 @@ C<0x00C1> > C<0x00C0>.
 The long answer is that "it depends", and a good answer cannot be
 given without knowing (at the very least) the language context.
 See L<Unicode::Collate>, and I<Unicode Collation Algorithm>
@@ -911,19 +911,19 @@ show a decimal number in hexadecimal.  If you have just the
 Unicode Consortium
 =item *
 Unicode FAQ
 =item *
 Unicode Glossary
 =item *
@@ -937,7 +937,7 @@ L<>
 Unicode Useful Resources
 =item *

Perl5 Master Repository Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at | Group listing | About