Integrate with Sarathy.

p4raw-id: //depot/cfgperl@5043

13 files changed, 150 insertions, 168 deletions

diff --git a/pod/perlapi.pod b/pod/perlapi.pod
index 897fcdc9da..e6191c0a41 100644
--- a/pod/perlapi.pod
+++ b/pod/perlapi.pod
@@ -45,8 +45,8 @@ Returns the SV at the specified index in the array.  The C<key> is the
 index.  If C<lval> is set then the fetch will be part of a store.  Check
 that the return value is non-null before dereferencing it to a C<SV*>.
 
-See L<Understanding the Magic of Tied Hashes and Arrays> for more information
-on how to use this function on tied arrays. 
+See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
+more information on how to use this function on tied arrays. 
 
 	SV**	av_fetch(AV* ar, I32 key, I32 lval)
 
@@ -95,7 +95,7 @@ that the caller is responsible for suitably incrementing the reference
 count of C<val> before the call, and decrementing it if the function
 returned NULL.
 
-See L<Understanding the Magic of Tied Hashes and Arrays> for
+See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
 more information on how to use this function on tied arrays.
 
 	SV**	av_store(AV* ar, I32 key, SV* val)
@@ -349,7 +349,7 @@ obtained from the GV with the C<GvCV> macro.
 
 =item gv_fetchmethod
 
-See L<gv_fetchmethod_autoload.
+See L<gv_fetchmethod_autoload>.
 
 	GV*	gv_fetchmethod(HV* stash, const char* name)
 
@@ -548,7 +548,7 @@ C<klen> is the length of the key.  If C<lval> is set then the fetch will be
 part of a store.  Check that the return value is non-null before
 dereferencing it to a C<SV*>. 
 
-See L<Understanding the Magic of Tied Hashes and Arrays> for more
+See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
 information on how to use this function on tied hashes.
 
 	SV**	hv_fetch(HV* tb, const char* key, U32 klen, I32 lval)
@@ -563,7 +563,7 @@ accessing it.  The return value when C<tb> is a tied hash is a pointer to a
 static location, so be sure to make a copy of the structure if you need to
 store it somewhere. 
 
-See L<Understanding the Magic of Tied Hashes and Arrays> for more
+See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
 information on how to use this function on tied hashes.
 
 	HE*	hv_fetch_ent(HV* tb, SV* key, I32 lval, U32 hash)
@@ -632,7 +632,7 @@ be dereferenced to get the original C<SV*>.  Note that the caller is
 responsible for suitably incrementing the reference count of C<val> before
 the call, and decrementing it if the function returned NULL.  
 
-See L<Understanding the Magic of Tied Hashes and Arrays> for more
+See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
 information on how to use this function on tied hashes.
 
 	SV**	hv_store(HV* tb, const char* key, U32 klen, SV* val, U32 hash)
@@ -649,7 +649,7 @@ described here.  Note that the caller is responsible for suitably
 incrementing the reference count of C<val> before the call, and
 decrementing it if the function returned NULL. 
 
-See L<Understanding the Magic of Tied Hashes and Arrays> for more
+See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
 information on how to use this function on tied hashes.
 
 	HE*	hv_store_ent(HV* tb, SV* key, SV* val, U32 hash)
diff --git a/pod/perldebug.pod b/pod/perldebug.pod
index 1c94f5fda0..2431fc47f1 100644
--- a/pod/perldebug.pod
+++ b/pod/perldebug.pod
@@ -145,7 +145,7 @@ List C<incr+1> lines starting at C<min>.
 
 =item l min-max
 
-List lines C<min> through C<max>.  C<l -> is synonymous to C<->.
+List lines C<min> through C<max>.  C<l E<45>> is synonymous to C<E<45>>.
 
 =item l line
 
diff --git a/pod/perldelta.pod b/pod/perldelta.pod
index a22f75ba4f..33ab171746 100644
--- a/pod/perldelta.pod
+++ b/pod/perldelta.pod
@@ -477,6 +477,11 @@ C<require> and C<use> also support such literals:
     require v5.6.0;	# croak if $^V lt v5.6.0
     use v5.6.0;		# same, but croaks at compile-time
 
+C<sprintf> and C<printf> support the Perl-specific format type C<%v>
+to print arbitrary strings as dotted tuples.
+
+    printf "v%v", $^V;	# prints current version, such as "v5.5.650"
+
 =head2 Weak references
 
 WARNING: This is an experimental feature.
@@ -1535,93 +1540,66 @@ act as mutators (accessor $z->Re(), mutator $z->Re(3)).
 A little bit of radial trigonometry (cylindrical and spherical),
 radial coordinate conversions, and the great circle distance were added.
 
-=item Pod::Parser, Pod::InputObjects, Pod::ParseUtils, and Pod::Select
+=item Pod::Parser, Pod::InputObjects
 
-Pod::Parser is a new module that provides a base class for parsing and
-selecting sections of POD documentation from an input stream.  This
-module takes care of identifying POD paragraphs and commands in the
-input and hands off the parsed paragraphs and commands to user-defined
-methods which are free to interpret or translate them as they see fit.
+Pod::Parser is a base class for parsing and selecting sections of
+pod documentation from an input stream.  This module takes care of
+identifying pod paragraphs and commands in the input and hands off the
+parsed paragraphs and commands to user-defined methods which are free
+to interpret or translate them as they see fit.
 
 Pod::InputObjects defines some input objects needed by Pod::Parser, and
 for advanced users of Pod::Parser that need more about a command besides
-its name and text.  Pod::ParseUtils provides several object-oriented
-helpers for POD parsing and processing. Probably the most important is
-Pod::Hyperlink for parsing and expanding POD hyperlinks.  Pod::Select is
-a subclass of Pod::Parser which provides a function named "podselect()"
-to filter out user-specified sections of raw pod documentation from an
-input stream.
+its name and text.
 
 As of release 5.6 of Perl, Pod::Parser is now the officially sanctioned
 "base parser code" recommended for use by all pod2xxx translators.
 Pod::Text (pod2text) and Pod::Man (pod2man) have already been converted
-to use Pod::Parser and efforts to convert Pod::Html (pod2html) are
-already underway.  For any questions or comments about POD parsing and
-translating issues and utilities, please use the pod-people@perl.org
-mailing list.
-
-For further information, please see L<Pod::Parser>, L<Pod::InputObjects>,
-L<Pod::ParseUtils> and L<Pod::Select>.
-
-=item Pod::Usage
-
-Pod::Usage provides the function "pod2usage()" to print usage messages for
-a Perl script based on its embedded pod documentation.  The pod2usage()
-function is generally useful to all script authors since it lets them
-write and maintain a single source (the PODs) for documentation, thus
-removing the need to create and maintain redundant usage message text
-consisting of information already in the PODs.
-
-Script authors are encouraged to use Pod::Usage with their favorite Perl
-option-parser to provide both terse and verbose formatted usage messages
-for their users.  Here is a simple example using Getopt::Long that prints
-only a synopsis for syntax errors, a synopsis and description of arguments
-when C<-help> is used, and the full manual page when C<-man> is used.
-
-    use Getopt::Long;
-    use Pod::Usage;
-    my $man = 0;
-    my $help = 0;
-    GetOptions('help|?' => \$help, man => \$man) or pod2usage(2);
-    pod2usage(1) if $help;
-    pod2usage(-exitstatus => 0, -verbose => 2) if $man;
-
-    __END__
-
-    =head1 NAME
-
-    sample - Using GetOpt::Long and Pod::Usage
+to use Pod::Parser and efforts to convert Pod::HTML (pod2html) are already
+underway.  For any questions or comments about pod parsing and translating
+issues and utilities, please use the pod-people@perl.org mailing list.
 
-    =head1 SYNOPSIS
+For further information, please see L<Pod::Parser> and L<Pod::InputObjects>.
 
-    sample [options] [file ...]
+=item Pod::Checker, podchecker
 
-     Options:
-       -help            brief help message
-       -man             full documentation
+This utility checks pod files for correct syntax, according to
+L<perlpod>.  Obvious errors are flagged as such, while warnings are
+printed for mistakes that can be handled gracefully.  The checklist is
+not complete yet.  See L<Pod::Checker>.
 
-    =head1 OPTIONS
+=item Pod::ParseUtils, Pod::Find
 
-    =over 8
+These modules provide a set of gizmos that are useful mainly for pod
+translators.  L<Pod::Find|Pod::Find> traverses directory structures and
+returns found pod files, along with their canonical names (like
+C<File::Spec::Unix>).  L<Pod::ParseUtils|Pod::ParseUtils> contains
+B<Pod::List> (useful for storing pod list information), B<Pod::Hyperlink>
+(for parsing the contents of C<LE<gt>E<lt>> sequences) and B<Pod::Cache>
+(for caching information about pod files, e.g. link nodes).
 
-    =item B<-help>
+=item Pod::Select, podselect
 
-    Print a brief help message and exits.
+Pod::Select is a subclass of Pod::Parser which provides a function
+named "podselect()" to filter out user-specified sections of raw pod
+documentation from an input stream. podselect is a script that provides
+access to Pod::Select from other scripts to be used as a filter.
+See L<Pod::Select>.
 
-    =item B<-man>
+=item Pod::Usage, pod2usage
 
-    Prints the manual page and exits.
-
-    =back
-
-    =head1 DESCRIPTION
-
-    B<This program> will read the given input file(s) and do something
-    useful with the contents thereof.
+Pod::Usage provides the function "pod2usage()" to print usage messages for
+a Perl script based on its embedded pod documentation.  The pod2usage()
+function is generally useful to all script authors since it lets them
+write and maintain a single source (the pods) for documentation, thus
+removing the need to create and maintain redundant usage message text
+consisting of information already in the pods.
 
-    =cut
+There is also a pod2usage script which can be used from other kinds of
+scripts to print usage messages from pods (even for non-Perl scripts
+with pods embedded in comments).
 
-For details, please see L<Pod::Usage>.
+For details and examples, please see L<Pod::Usage>.
 
 =item Pod::Text and Pod::Man
 
@@ -2294,8 +2272,8 @@ L<perlvms>) so that the environ array isn't the target of the change to
 =item Unknown open() mode '%s'
 
 (F) The second argument of 3-argument open() is not among the list
-of valid modes: C<L<lt>>, C<L<gt>>, C<E<gt>E<gt>>, C<+L<lt>>,
-C<+L<gt>>, C<+E<gt>E<gt>>, C<-|>, C<|->.
+of valid modes: C<E<lt>>, C<E<gt>>, C<E<gt>E<gt>>, C<+E<lt>>,
+C<+E<gt>>, C<+E<gt>E<gt>>, C<-|>, C<|E<45>>.
 
 =item Unknown process %x sent message to prime_env_iter: %s
 
diff --git a/pod/perldiag.pod b/pod/perldiag.pod
index b7e115fb71..39112035fb 100644
--- a/pod/perldiag.pod
+++ b/pod/perldiag.pod
@@ -1584,22 +1584,11 @@ line was ignored.
 
 =item Illegal character %s (carriage return)
 
-(F) A carriage return character was found in the input.  This is an
-error, and not a warning, because carriage return characters can break
-multi-line strings, including here documents (e.g., C<print E<lt>E<lt>EOF;>).
-
-Under Unix, this error is usually caused by executing Perl code --
-either the main program, a module, or an eval'd string -- that was
-transferred over a network connection from a non-Unix system without
-properly converting the text file format.
-
-Under systems that use something other than '\n' to delimit lines of
-text, this error can also be caused by reading Perl code from a file
-handle that is in binary mode (as set by the C<binmode> operator).
-
-In either case, the Perl code in question will probably need to be
-converted with something like C<s/\x0D\x0A?/\n/g> before it can be
-executed.
+(F) Perl normally treats carriage returns in the program text as it
+would any other whitespace, which means you should never see this
+error when Perl was built using standard options.  For some reason,
+your version of Perl appears to have been built without this support.
+Talk to your Perl administrator.
 
 =item Illegal division by zero
 
@@ -2170,6 +2159,12 @@ on portability concerns.
 
 See also L<perlport> for writing portable code.
 
+=item Octal number in vector unsupported
+
+(F) Numbers with a leading C<0> are not currently allowed in vectors.  The
+octal number interpretation of such numbers may be supported in a future
+version.
+
 =item Odd number of elements in hash assignment
 
 (W) You specified an odd number of elements to initialize a hash, which
@@ -3137,8 +3132,8 @@ representative, who probably put it there in the first place.
 =item Unknown open() mode '%s'
 
 (F) The second argument of 3-argument open() is not among the list
-of valid modes: C<L<lt>>, C<L<gt>>, C<E<gt>E<gt>>, C<+L<lt>>,
-C<+L<gt>>, C<+E<gt>E<gt>>, C<-|>, C<|->.
+of valid modes: C<E<lt>>, C<E<gt>>, C<E<gt>E<gt>>, C<+E<lt>>,
+C<+E<gt>>, C<+E<gt>E<gt>>, C<-|>, C<|E<45>>.
 
 =item Unknown process %x sent message to prime_env_iter: %s
 
diff --git a/pod/perlfunc.pod b/pod/perlfunc.pod
index fa8504ed38..88cbb0a6e5 100644
--- a/pod/perlfunc.pod
+++ b/pod/perlfunc.pod
@@ -4310,6 +4310,10 @@ In addition, Perl permits the following widely-supported conversions:
    %n	special: *stores* the number of characters output so far
         into the next variable in the parameter list 
 
+And the following Perl-specific conversion:
+
+   %v   a string, output as a tuple of integers ("Perl" is 80.101.114.108)
+
 Finally, for backward (and we do mean "backward") compatibility, Perl
 permits these unnecessary but widely-supported conversions:
 
@@ -5269,9 +5273,13 @@ to give the expression the correct precedence as in
 
     vec($image, $max_x * $x + $y, 8) = 3;
 
-Vectors created with C<vec> can also be manipulated with the logical
-operators C<|>, C<&>, and C<^>, which will assume a bit vector
-operation is desired when both operands are strings.
+If the selected element is off the end of the string, the value 0 is
+returned.  If an element off the end of the string is written to,
+Perl will first extend the string with sufficiently many zero bytes.
+
+Strings created with C<vec> can also be manipulated with the logical
+operators C<|>, C<&>, C<^>, and C<~>.  These operators will assume a bit
+vector operation is desired when both operands are strings.
 See L<perlop/"Bitwise String Operators">.
 
 The following code will build up an ASCII string saying C<'PerlPerlPerl'>.
diff --git a/pod/perlhist.pod b/pod/perlhist.pod
index 288d8229cc..7a8d1e5879 100644
--- a/pod/perlhist.pod
+++ b/pod/perlhist.pod
@@ -332,8 +332,8 @@ the strings?).
 	  5.005_61	1999-Aug-20
 	  5.005_62	1999-Oct-15
 	  5.005_63	1999-Dec-09
-	  5.005_64	2000-***-**
-	  5.6 beta	2000-***-**
+	  5.5.640	2000-Feb-02
+	  5.5.650	2000-Feb-08	5.6 beta1
 
 =head2 SELECTED RELEASE SIZES
 
diff --git a/pod/perlop.pod b/pod/perlop.pod
index 150813e711..d932704666 100644
--- a/pod/perlop.pod
+++ b/pod/perlop.pod
@@ -1804,14 +1804,15 @@ in a bit vector.
 
 =head2 Version tuples
 
-A version number of the form C<v1.2.3.4> is parsed as a dual-valued literal.
-It has the string value of C<"\x{1}\x{2}\x{3}\x{4}"> (i.e., a utf8 string)
-and a numeric value of C<1 + 2/1000 + 3/1000000 + 4/1000000000>.  This is
-useful for representing and comparing version numbers.
-
-Version tuples are accepted by both C<require> and C<use>.  The C<$^V> variable
-contains the running Perl interpreter's version in this format.
-See L<perlvar/$^V>.
+A literal of the form C<v1.20.300.4000> is parsed as a dual-valued quantity.
+It has the string value of C<"\x{1}\x{14}\x{12c}\x{fa0}"> (i.e., a UTF-8
+string) and a numeric value of C<1 + 20/1000 + 300/1000000 + 4000/1000000000>.
+This is useful for representing Unicode strings, and for comparing version
+numbers using the string comparison operators, C<cmp>, C<gt>, C<lt> etc.
+
+Such "version tuples" or "vectors" are accepted by both C<require> and
+C<use>.  The C<$^V> variable contains the running Perl interpreter's
+version in this format.  See L<perlvar/$^V>.
 
 =head2 Integer Arithmetic
 
diff --git a/pod/perlopentut.pod b/pod/perlopentut.pod
index 5d2be3039e..fd32bd9f49 100644
--- a/pod/perlopentut.pod
+++ b/pod/perlopentut.pod
@@ -494,7 +494,7 @@ to mean standard input, per the standard convention.
 You've probably noticed how Perl's C<warn> and C<die> functions can
 produce messages like:
 
-    Some warning at scriptname line 29, <FH> chunk 7.
+    Some warning at scriptname line 29, <FH> line 7.
 
 That's because you opened a filehandle FH, and had read in seven records
 from it.  But what was the name of the file, not the handle?
@@ -510,7 +510,7 @@ temporarily, then all you have to do is this:
 Since you're using the pathname of the file as its handle,
 you'll get warnings more like
 
-    Some warning at scriptname line 29, </etc/motd> chunk 7.
+    Some warning at scriptname line 29, </etc/motd> line 7.
 
 =head2 Single Argument Open
 
diff --git a/pod/perlport.pod b/pod/perlport.pod
index 21f144c237..7a500f8838 100644
--- a/pod/perlport.pod
+++ b/pod/perlport.pod
@@ -870,7 +870,8 @@ Even though VOS allows the slash character to appear in object
 names, because the VOS port of Perl interprets it as a pathname
 delimiting character, VOS files, directories, or links whose names
 contain a slash character cannot be processed.  Such files must be
-renamed before they can be processed by Perl.
+renamed before they can be processed by Perl.  Note that VOS limits
+file names to 32 or fewer characters.
 
 The following C functions are unimplemented on VOS, and any attempt by
 Perl to use them will result in a fatal error message and an immediate
@@ -883,7 +884,7 @@ The value of C<$^O> on VOS is "VOS".  To determine the architecture that
 you are running on without resorting to loading all of C<%Config> you
 can examine the content of the C<@INC> array like so:
 
-    if (grep(/VOS/, @INC)) {
+    if ($^O =~ /VOS/) {
         print "I'm on a Stratus box!\n";
     } else {
         print "I'm not on a Stratus box!\n";
@@ -894,13 +895,13 @@ can examine the content of the C<@INC> array like so:
         print "This box is a Stratus XA/R!\n";
 
     } elsif (grep(/7100/, @INC)) {
-        print "This box is a Stratus HP 7100 or 8000!\n";
+        print "This box is a Stratus HP 7100 or 8xxx!\n";
 
     } elsif (grep(/8000/, @INC)) {
-        print "This box is a Stratus HP 8000!\n";
+        print "This box is a Stratus HP 8xxx!\n";
 
     } else {
-        print "This box is a Stratus 68K...\n";
+        print "This box is a Stratus 68K!\n";
     }
 
 Also see:
@@ -1401,11 +1402,11 @@ Not implemented. (Plan9, Win32, S<RISC OS>)
 
 =item endpwent
 
-Not implemented. (S<Mac OS>, Win32, VM/ESA)
+Not implemented. (S<Mac OS>, MPE/iX, VM/ESA, Win32)
 
 =item endgrent
 
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VM/ESA)
+Not implemented. (S<Mac OS>, MPE/iX, S<RISC OS>, VM/ESA, VMS, Win32)
 
 =item endhostent
 
@@ -1462,11 +1463,14 @@ the process.  (Win32)
 
 =item link OLDFILE,NEWFILE
 
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
+Not implemented. (S<Mac OS>, MPE/iX, VMS, S<RISC OS>)
 
 Link count not updated because hard links are not quite that hard
 (They are sort of half-way between hard and soft links). (AmigaOS)
 
+Hard links are implemented on Win32 (Windows NT and Windows 2000)
+under NTFS only.
+
 =item lstat FILEHANDLE
 
 =item lstat EXPR
@@ -1494,7 +1498,7 @@ Not implemented. (S<Mac OS>, Win32, VMS, Plan9, S<RISC OS>, VOS)
 The C<|> variants are supported only if ToolServer is installed.
 (S<Mac OS>)
 
-open to C<|-> and C<-|> are unsupported. (S<Mac OS>, Win32, S<RISC OS>)
+open to C<|E<45>> and C<-|> are unsupported. (S<Mac OS>, Win32, S<RISC OS>)
 
 =item pipe READHANDLE,WRITEHANDLE
 
@@ -1522,6 +1526,10 @@ Only reliable on sockets. (S<RISC OS>)
 
 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
 
+=item setgrent
+
+Not implemented. (MPE/iX, Win32)
+
 =item setpgrp PID,PGRP
 
 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
@@ -1530,6 +1538,10 @@ Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
 
 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
 
+=item setpwent
+
+Not implemented. (MPE/iX, Win32)
+
 =item setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL
 
 Not implemented. (S<Mac OS>, Plan9)
diff --git a/pod/perlrun.pod b/pod/perlrun.pod
index f668d53178..8aa06fb2bf 100644
--- a/pod/perlrun.pod
+++ b/pod/perlrun.pod
@@ -4,7 +4,7 @@ perlrun - how to execute the Perl interpreter
 
 =head1 SYNOPSIS
 
-B<perl>	S<[ B<-sTuUWX> ]>
+B<perl>	S<[ B<-CsTuUWX> ]>
 	S<[ B<-hv> ] [ B<-V>[:I<configvar>] ]>
 	S<[ B<-cw> ] [ B<-d>[:I<debugger>] ] [ B<-D>[I<number/list>] ]>
 	S<[ B<-pna> ] [ B<-F>I<pattern> ] [ B<-l>[I<octal>] ] [ B<-0>[I<octal>] ]>
@@ -265,6 +265,14 @@ is equivalent to
 
 An alternate delimiter may be specified using B<-F>.
 
+=item B<-C>
+
+enables Perl to use the native wide character APIs on the target system.
+The magic variable C<${^WIDE_SYSTEM_CALLS}> reflects the state of
+this switch.  See L<perlvar/"${^WIDE_SYSTEM_CALLS}">.
+
+This feature is currently only implemented on the Win32 platform.
+
 =item B<-c>
 
 causes Perl to check the syntax of the program and then exit without
diff --git a/pod/perltoc.pod b/pod/perltoc.pod
index 96ec7f0e75..2f8f3a27af 100644
--- a/pod/perltoc.pod
+++ b/pod/perltoc.pod
@@ -1826,7 +1826,7 @@ $EFFECTIVE_USER_ID, $EUID, $>, $REAL_GROUP_ID, $GID, $(,
 $EFFECTIVE_GROUP_ID, $EGID, $), $PROGRAM_NAME, $0, $[, $PERL_VERSION, $],
 $COMPILING, $^C, $DEBUGGING, $^D, $SYSTEM_FD_MAX, $^F, $^H, %^H,
 $INPLACE_EDIT, $^I, $^M, $OSNAME, $^O, $PERLDB, $^P, 0x01, 0x02, 0x04,
-0x08, 0x10, 0x20, $^R, $^S, $BASETIME, $^T, $WARNING, $^W, ${^Warnings},
+0x08, 0x10, 0x20, $^R, $^S, $BASETIME, $^T, $WARNING, $^W, ${^WARNING_BITS},
 $EXECUTABLE_NAME, $^X, $ARGV, @ARGV, @INC, @_, %INC, %ENV, $ENV{expr},
 %SIG, $SIG{expr}
 
diff --git a/pod/perlunicode.pod b/pod/perlunicode.pod
index 5a73d4e959..bc880364d3 100644
--- a/pod/perlunicode.pod
+++ b/pod/perlunicode.pod
@@ -31,12 +31,10 @@ or from literals and constants in the source text.  Later, in
 L</Character encodings for input and output>, we'll see how such
 inputs may be marked as being Unicode character data sources.
 
-One particular condition will enable character semantics on the entire
-program, bypassing the compatibility mode: if the C<$^U> global flag is
-set to C<1>, nearly all operations will use character semantics by
-default.  As an added convenience, if the C<utf8> pragma is used in the
-C<main> package, C<$^U> is enabled automatically.  [XXX: Should there
-be a -C switch to enable $^U?]
+If the C<-C> command line switch is used, (or the ${^WIDE_SYSTEM_CALLS}
+global flag is set to C<1>), all system calls will use the
+corresponding wide character APIs.  This is currently only implemented
+on Windows.
 
 Regardless of the above, the C<byte> pragma can always be used to force
 byte semantics in a particular lexical scope.  See L<byte>.
@@ -229,6 +227,6 @@ tend to run slower.  Avoidance of locales is strongly encouraged.
 
 =head1 SEE ALSO
 
-L<byte>, L<utf8>, L<perlvar/"$^U">
+L<byte>, L<utf8>, L<perlvar/"${^WIDE_SYSTEM_CALLS}">
 
 =cut
diff --git a/pod/perlvar.pod b/pod/perlvar.pod
index dca9cc092f..f0cb109005 100644
--- a/pod/perlvar.pod
+++ b/pod/perlvar.pod
@@ -185,7 +185,7 @@ $+[0] - $-[0]>.  Similarly, C<$>I<n> coincides with C<substr $_, $-[>I<n>C<],
 $+[>I<n>C<] - $-[>I<n>C<]> if C<$-[>I<n>C<]> is defined, and $+ coincides with
 C<substr $_, $-[$#-], $+[$#-]>.  One can use C<$#+> to find the number
 of subgroups in the last successful match.  Contrast with
-C<$#->, the last I<matched> subgroup.  Compare with C<@->.
+C<$#E<45>>, the last I<matched> subgroup.  Compare with C<@E<45>>.
 
 =item $MULTILINE_MATCHING
 
@@ -421,7 +421,7 @@ I<n>-th subpattern, or undef if the subpattern did not match.
 Thus after a match against $_, $& coincides with C<substr $_, $-[0],
 $+[0] - $-[0]>.  Similarly, C<$>I<n> coincides with C<substr $_, $-[>I<n>C<],
 $+[>I<n>C<] - $-[>I<n>C<]> if C<$-[>I<n>C<]> is defined, and $+ coincides with
-C<substr $_, $-[$#-], $+[$#-]>.  One can use C<$#-> to find the last
+C<substr $_, $-[$#-], $+[$#-]>.  One can use C<$#E<45>> to find the last
 matched subgroup in the last successful match.  Contrast with
 C<$#+>, the number of subgroups in the regular expression.  Compare
 with C<@+>.
@@ -873,40 +873,7 @@ The time at which the program began running, in seconds since the
 epoch (beginning of 1970).  The values returned by the B<-M>, B<-A>,
 and B<-C> filetests are based on this value.
 
-=item $^U
-
-Global flag that switches on Unicode character support in the Perl
-interpreter.  The initial value is usually C<0> for compatibility
-with Perl versions earlier than 5.6, but may be automatically set
-to C<1> by Perl if the system provides a user-settable default
-(e.g., C<$ENV{LC_CTYPE}>).  It is also implicitly set to C<1>
-whenever the utf8 pragma is loaded.
-
-Setting it to C<1> has the following effects:
-
-=over
-
-=item *
-
-C<chr> produces UTF-8 encoded Unicode characters.  These are the same
-as the corresponding ASCII characters if the argument is less than 128.
-
-=item *
-
-The C<%c> format in C<sprintf> generates a UTF-8 encoded Unicode
-character.  This is the same as the corresponding ASCII character
-if the argument is less than 128.
-
-=item *
-
-Any system calls made by Perl will use wide character APIs native to
-the system, if available.  This is currently only implemented on the
-Windows platform.
-
-=back
-
-The C<byte> pragma overrides the value of this flag in the current
-lexical scope.  See L<byte>.
+=item $PERL_VERSION_TUPLE
 
 =item $^V
 
@@ -914,7 +881,7 @@ The revision, version, and subversion of the Perl interpreter, represented
 as a "version tuple".  Version tuples have both a numeric value and a
 string value.  The numeric value is a floating point number that amounts
 to revision + version/1000 + subversion/1000000, and the string value
-is made of utf8 characters:
+is made of characters possibly in the UTF-8 range:
 C<chr($revision) . chr($version) . chr($subversion)>.
 
 This can be used to determine whether the Perl interpreter executing a
@@ -936,11 +903,26 @@ The current value of the warning switch, initially true if B<-w>
 was used, false otherwise, but directly modifiable.  (Mnemonic:
 related to the B<-w> switch.)  See also L<warnings>.
 
-=item ${^Warnings}
+=item ${^WARNING_BITS}
 
 The current set of warning checks enabled by the C<use warnings> pragma.
 See the documentation of C<warnings> for more details.
 
+=item ${^WIDE_SYSTEM_CALLS}
+
+Global flag that enables system calls made by Perl to use wide character
+APIs native to the system, if available.  This is currently only implemented
+on the Windows platform.
+
+This can also be enabled from the command line using the C<-C> switch.
+
+The initial value is typically C<0> for compatibility with Perl versions
+earlier than 5.6, but may be automatically set to C<1> by Perl if the system
+provides a user-settable default (e.g., C<$ENV{LC_CTYPE}>).
+
+The C<byte> pragma always overrides the effect of this flag in the current
+lexical scope.  See L<byte>.
+
 =item $EXECUTABLE_NAME
 
 =item $^X