integrate cfgperl contents into mainline

p4raw-id: //depot/perl@4106

3 files changed, 32 insertions, 36 deletions

diff --git a/pod/perldelta.pod b/pod/perldelta.pod
index cf975594bb..94b4635e7b 100644
--- a/pod/perldelta.pod
+++ b/pod/perldelta.pod
@@ -150,37 +150,31 @@ use "quads" (64-integers) as follows:
 
 =over 4
 
-=item literal numeric constants in the code
+=item constants in the code 
 
 =item arguments to oct() and hex()
 
 =item arguments to print(), printf() and sprintf()
 
-=item pack() and unpack() "q" and "Q" formats
+=item pack() and unpack() "q" format
 
-=item in basic arithmetics: +, -, *, /, %
+=item in basic arithmetics
 
-=item in bit arithmetics: &, |, ^, ~, <<, >>, vec()
+=item vec() (but see the below note about bit arithmetics)
     
 =back
 
 Note that unless you have the case (a) you will have to configure
 and compile Perl using the -Duse64bits Configure flag.
 
+Unfortunately bit arithmetics (&, |, ^, ~, <<, >>) are not 64-bit clean.
+
 Last but not least: note that due to Perl's habit of always using
-floating point numbers (inherently inexact) the quads are still not
-true integers (exact).  When the quads overflow their limits
-(0...18_446_744_073_709_551_615 unsigned, -9_223_372_036_854_775_808...
-9_223_372_036_854_775_807 signed), they are silently promoted to
-floating point numbers, after which they will start losing precision
-(their lower digits).  What this means, among other things, is that
-adding/subtracting small numbers doesn't change the large number,
-and that == may return equalness for numbers that are not equal.
-One particular cause of grief is using the ~ operator which when
-used on small numbers produces large numbers.  These large numbers
-stay (internally) integers for only as long as bit arithmetics are
-used, but for example + will turn the results into floating point
-numbers.
+floating point numbers the quads are still not true integers.
+When quads overflow their limits (0...18_446_744_073_709_551_615 unsigned,
+-9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they
+are silently promoted to floating point numbers, after which they will
+start losing precision (their lower digits).
 
 =head2 Large file support
 
@@ -188,10 +182,9 @@ If you have filesystems that support "large files" (files larger than
 2 gigabytes), you may now also be able to create and access them from Perl.
 
 Note that in addition to requiring a proper file system to do this you
-may also need to adjust your per-process (or even your per-system, or
-per-user group) maximum filesize limits before running Perl scripts
-that try to handle large files, especially if you intend to write such
-files (reading may work even without adjustments).
+may also need to adjust your per-process (or even your per-system)
+maximum filesize limits before running Perl scripts that try to handle
+large files, especially if you intend to write such files.
 
 Adjusting your file system/system limits is outside the scope of Perl.
 For process limits, you may try to increase the limits using your
@@ -732,6 +725,13 @@ like in the first argument to C<join>.  Perl will treat the true
 or false result of matching the pattern against $_ as the string,
 which is probably not what you had in mind.
 
+=item /%s/ should probably be written as "%s"
+
+(W) You have used a pattern where Perl expected to find a string,
+like in the first argument to C<join>.  Perl will treat the true
+or false result of matching the pattern against $_ as the string,
+which is probably not what you had in mind.
+
 =head1 Obsolete Diagnostics
 
 Todo.
diff --git a/pod/perlop.pod b/pod/perlop.pod
index 6c2cb3393a..14ca6b5ec0 100644
--- a/pod/perlop.pod
+++ b/pod/perlop.pod
@@ -220,15 +220,11 @@ Binary "." concatenates two strings.
 
 Binary "<<" returns the value of its left argument shifted left by the
 number of bits specified by the right argument.  Arguments should be
-integers.  (See also L<Integer Arithmetic>.)  Shifting more than the
-width of an integer in bits (usually 32 or 64) produces undefined
-(platform dependent) results.
+integers.  (See also L<Integer Arithmetic>.)
 
 Binary ">>" returns the value of its left argument shifted right by
 the number of bits specified by the right argument.  Arguments should
-be integers.  (See also L<Integer Arithmetic>.)  Shifting more than
-the width of an integer in bits (usually 32 or 64) produces undefined
-(platform dependent) results.
+be integers.  (See also L<Integer Arithmetic>.)
 
 =head2 Named Unary Operators
 
diff --git a/pod/perlre.pod b/pod/perlre.pod
index 76f345de35..468bf9f820 100644
--- a/pod/perlre.pod
+++ b/pod/perlre.pod
@@ -192,8 +192,8 @@ The POSIX character class syntax
 
 	[:class:]
 
-is also available.  The available classes and their \-equivalents
-(if any) are as follows:
+is also available.  The available classes and their backslash
+equivalents (if available) are as follows:
 
     alpha
     alnum
@@ -209,15 +209,15 @@ is also available.  The available classes and their \-equivalents
     word        \w
     xdigit
 
-Note that the [] are part of the [::] construct, not part of the whole
+For example use C<[:upper:]> to match all the uppercase characters.
+Note that the C<[]> are part of the C<[::]> construct, not part of the whole
 character class.  For example:
 
 	[01[:alpha:]%]
 
 matches one, zero, any alphabetic character, and the percentage sign.
 
-The exact meanings of the above classes depend from many things:
-if the C<utf8> pragma is used, the following equivalences to Unicode
+If the C<utf8> pragma is used, the following equivalences to Unicode
 \p{} constructs hold:
 
     alpha       IsAlpha
@@ -234,11 +234,11 @@ if the C<utf8> pragma is used, the following equivalences to Unicode
     word        IsWord
     xdigit      IsXDigit
 
-For example, [:lower:] and \p{IsLower} are equivalent.
+For example C<[:lower:]> and C<\p{IsLower}> are equivalent.
 
 If the C<utf8> pragma is not used but the C<locale> pragma is, the
 classes correlate with the isalpha(3) interface (except for `word',
-which is a Perl extension, mirroring \w).
+which is a Perl extension, mirroring C<\w>).
 
 The assumedly non-obviously named classes are:
 
@@ -283,8 +283,8 @@ with a '^'. This is a Perl extension.  For example:
     [:^space:]	    \S	    \P{IsSpace}
     [:^word:]	    \W	    \P{IsWord}
 
-The POSIX character classes [.cc.] and [=cc=] are B<not> supported
-and trying to use them will cause an error.
+The POSIX character classes [.cc.] and [=cc=] are recognized but
+B<not> supported and trying to use them will cause an error.
 
 Perl defines the following zero-width assertions: