Integrate mainline - a few Devel::Peak fails.

p4raw-id: //depot/perlio@13066

52 files changed, 4870 insertions, 850 deletions

diff --git a/pod/buildtoc.PL b/pod/buildtoc.PL
index bb6d0d3ad0..f486f834b7 100644
--- a/pod/buildtoc.PL
+++ b/pod/buildtoc.PL
@@ -145,6 +145,7 @@ if (-d "pod") {
 
     perlport
     perllocale
+    perluniintro
     perlunicode
     perlebcdic
 
@@ -288,6 +289,8 @@ sub getpods {
 	my $file = $File::Find::name;
 	return if $file eq '../lib/Pod/Functions.pm'; # Used only by pod itself
         return if $file =~ m!lib/Attribute/Handlers/demo/!;
+	return if $file =~ m!lib/Net/FTP/.+\.pm!; # Hi, Graham! :-)
+        return if $file =~ m!lib/Math/BigInt/t/!;
 
 	die "tut $name" if $file =~ /TUT/;
 	unless (open (F, "< $_\0")) {
diff --git a/pod/perl.pod b/pod/perl.pod
index 8495648083..081e1dfa78 100644
--- a/pod/perl.pod
+++ b/pod/perl.pod
@@ -53,7 +53,7 @@ For ease of access, the Perl manual has been split up into several sections.
       perlfaq7		Perl Language Issues
       perlfaq8		System Interaction
       perlfaq9		Networking
-  
+
 =head2 Reference Manual
 
     perlsyn		Perl syntax
@@ -81,11 +81,12 @@ For ease of access, the Perl manual has been split up into several sections.
     perlnumber		Perl number semantics
 
     perlthrtut		Perl threads tutorial
-      perlothrtut		Perl threads tutorial
+      perlothrtut		Old Perl threads tutorial
 
     perlport		Perl portability guide
     perllocale		Perl locale support
-    perlunicode		Perl unicode support
+    perluniintro	Perl Unicode introduction
+    perlunicode		Perl Unicode support
     perlebcdic		Considerations for running Perl on EBCDIC platforms
 
     perlsec		Perl security
@@ -270,7 +271,8 @@ Described in L<perlreftut>, L<perlref>, L<perldsc>, and L<perllol>.
 
 object-oriented programming
 
-Described in L<perlobj>, L<perltoot>, and L<perlbot>.
+Described in L<perlobj>, L<perlboot>, L<perltoot>, L<perltooc>,
+and L<perlbot>.
 
 =item *
 
@@ -307,7 +309,7 @@ Described in L<perlre>, with additional examples in L<perlop>.
 enhanced debugger and interactive Perl environment,
 with integrated editor support
 
-Described in L<perldebug>.
+Described in L<perldebtut>, L<perldebug> and L<perldebguts>.
 
 =item *
 
@@ -347,8 +349,9 @@ Perl developers, please write to perl-thanks@perl.org .
  a2p	awk to perl translator
  s2p	sed to perl translator
 
- http://www.perl.com/	    the Perl Home Page
- http://www.perl.com/CPAN   the Comprehensive Perl Archive
+ http://www.perl.com/       the Perl Home Page
+ http://www.cpan.org/       the Comprehensive Perl Archive
+ http://www.perl.org/       Perl Mongers (Perl user groups)
 
 =head1 DIAGNOSTICS
 
diff --git a/pod/perl571delta.pod b/pod/perl571delta.pod
index df132ccf77..80478716ec 100644
--- a/pod/perl571delta.pod
+++ b/pod/perl571delta.pod
@@ -420,7 +420,7 @@ parsing algorithms.  See L<Text::Balanced> for more information.
 =item *
 
 Tie::RefHash::Nestable, by Edward Avis, allows storing hash references
-(unlike the standard Tie::Refhash)  The module is contained within
+(unlike the standard Tie::RefHash)  The module is contained within
 Tie::RefHash.
 
 =item *
diff --git a/pod/perl572delta.pod b/pod/perl572delta.pod
index bfe44c46e9..1e7251e33d 100644
--- a/pod/perl572delta.pod
+++ b/pod/perl572delta.pod
@@ -599,7 +599,7 @@ Don't panic.  Read INSTALL 'make test' section instead.
 
 The subtests 11 and 12 sometimes fail and sometimes work.
 
-=head2 HP-UX lib/io_multihomed Fails When LP64-Configur
+=head2 HP-UX lib/io_multihomed Fails When LP64-Configured
 
 The lib/io_multihomed test may hang in HP-UX if Perl has been
 configured to be 64-bit. Because other 64-bit platforms do not hang in
@@ -726,7 +726,7 @@ Compaq C V6.2-008 on OpenVMS Alpha V7.1
   [.lib]vmsish............................FAILED on test 13
   Failed 4/399 tests, 92.48% okay.
 
-Compac C V6.4-005 on OpenVMS Alpha 7.2.1
+Compaq C V6.4-005 on OpenVMS Alpha 7.2.1
 
   [-.ext.b]showlex........................FAILED on test 1
   [-.ext.list.util.t]tainted..............FAILED on test 3
diff --git a/pod/perlapi.pod b/pod/perlapi.pod
index e01489ab49..79fbc932a2 100644
--- a/pod/perlapi.pod
+++ b/pod/perlapi.pod
@@ -575,7 +575,7 @@ returns UV_MAX, sets C<PERL_SCAN_GREATER_THAN_UV_MAX> in the output flags,
 and writes the value to I<*result> (or the value is discarded if I<result>
 is NULL).
 
-The hex number may optinally be prefixed with "0b" or "b" unless
+The hex number may optionally be prefixed with "0b" or "b" unless
 C<PERL_SCAN_DISALLOW_PREFIX> is set in I<*flags> on entry. If
 C<PERL_SCAN_ALLOW_UNDERSCORES> is set in I<*flags> then the binary
 number may use '_' characters to separate digits.
@@ -601,7 +601,7 @@ returns UV_MAX, sets C<PERL_SCAN_GREATER_THAN_UV_MAX> in the output flags,
 and writes the value to I<*result> (or the value is discarded if I<result>
 is NULL).
 
-The hex number may optinally be prefixed with "0x" or "x" unless
+The hex number may optionally be prefixed with "0x" or "x" unless
 C<PERL_SCAN_DISALLOW_PREFIX> is set in I<*flags> on entry. If
 C<PERL_SCAN_ALLOW_UNDERSCORES> is set in I<*flags> then the hex
 number may use '_' characters to separate digits.
@@ -794,7 +794,7 @@ Found in file cop.h
 =item HEf_SVKEY
 
 This flag, used in the length slot of hash entries and magic structures,
-specifies the structure contains a C<SV*> pointer where a C<char*> pointer
+specifies the structure contains an C<SV*> pointer where a C<char*> pointer
 is to be expected. (For information only--not to be used).
 
 =for hackers
@@ -958,7 +958,7 @@ Found in file hv.c
 Returns the SV which corresponds to the specified key in the hash.  The
 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*>.
+dereferencing it to an C<SV*>.
 
 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for more
 information on how to use this function on tied hashes.
@@ -1553,6 +1553,24 @@ memory is zeroed with C<memzero>.
 =for hackers
 Found in file handy.h
 
+=item new_vstring
+
+Returns a pointer to the next character after the parsed
+vstring, as well as updating the passed in sv.
+ * 
+Function must be called like 
+ 	
+        sv = NEWSV(92,5);
+	s = new_vstring(s,sv);
+
+The sv must already be large enough to store the vstring
+passed in.
+
+	char*	new_vstring(char *vstr, SV *sv)
+
+=for hackers
+Found in file util.c
+
 =item Nullav
 
 Null AV pointer.
@@ -1980,7 +1998,7 @@ Found in file sharedsv.c
 =item sharedsv_lock
 
 Recursive locks on a sharedsv.
-Locks are dynamicly scoped at the level of the first lock.
+Locks are dynamically scoped at the level of the first lock.
 	void	sharedsv_lock(shared_sv* ssv)
 
 =for hackers
@@ -2023,7 +2041,6 @@ Found in file sharedsv.c
 
 =item sortsv
 
-   
 Sort an array. Here is an example:
 
     sortsv(AvARRAY(av), av_len(av)+1, Perl_sv_cmp_locale); 
@@ -2220,7 +2237,7 @@ Found in file sv.h
 
 =item SvIOK_notUV
 
-Returns a boolean indicating whether the SV contains an signed integer.
+Returns a boolean indicating whether the SV contains a signed integer.
 
 	void	SvIOK_notUV(SV* sv)
 
@@ -2282,22 +2299,22 @@ version which guarantees to evaluate sv only once.
 =for hackers
 Found in file sv.h
 
-=item SvIVx
+=item SvIVX
 
-Coerces the given SV to an integer and returns it. Guarantees to evaluate
-sv only once. Use the more efficent C<SvIV> otherwise.
+Returns the raw value in the SV's IV slot, without checks or conversions.
+Only use when you are sure SvIOK is true. See also C<SvIV()>.
 
-	IV	SvIVx(SV* sv)
+	IV	SvIVX(SV* sv)
 
 =for hackers
 Found in file sv.h
 
-=item SvIVX
+=item SvIVx
 
-Returns the raw value in the SV's IV slot, without checks or conversions.
-Only use when you are sure SvIOK is true. See also C<SvIV()>.
+Coerces the given SV to an integer and returns it. Guarantees to evaluate
+sv only once. Use the more efficient C<SvIV> otherwise.
 
-	IV	SvIVX(SV* sv)
+	IV	SvIVx(SV* sv)
 
 =for hackers
 Found in file sv.h
@@ -2397,22 +2414,22 @@ which guarantees to evaluate sv only once.
 =for hackers
 Found in file sv.h
 
-=item SvNVX
+=item SvNVx
 
-Returns the raw value in the SV's NV slot, without checks or conversions.
-Only use when you are sure SvNOK is true. See also C<SvNV()>.
+Coerces the given SV to a double and returns it. Guarantees to evaluate
+sv only once. Use the more efficient C<SvNV> otherwise.
 
-	NV	SvNVX(SV* sv)
+	NV	SvNVx(SV* sv)
 
 =for hackers
 Found in file sv.h
 
-=item SvNVx
+=item SvNVX
 
-Coerces the given SV to a double and returns it. Guarantees to evaluate
-sv only once. Use the more efficent C<SvNV> otherwise.
+Returns the raw value in the SV's NV slot, without checks or conversions.
+Only use when you are sure SvNOK is true. See also C<SvNV()>.
 
-	NV	SvNVx(SV* sv)
+	NV	SvNVX(SV* sv)
 
 =for hackers
 Found in file sv.h
@@ -2519,7 +2536,7 @@ Found in file sv.h
 =item SvPVbytex
 
 Like C<SvPV>, but converts sv to byte representation first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVbyte>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte>
 otherwise.
 
 
@@ -2531,7 +2548,7 @@ Found in file sv.h
 =item SvPVbytex_force
 
 Like C<SvPV_force>, but converts sv to byte representation first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVbyte_force>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte_force>
 otherwise.
 
 	char*	SvPVbytex_force(SV* sv, STRLEN len)
@@ -2569,7 +2586,7 @@ Found in file sv.h
 =item SvPVutf8x
 
 Like C<SvPV>, but converts sv to utf8 first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVutf8>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8>
 otherwise.
 
 	char*	SvPVutf8x(SV* sv, STRLEN len)
@@ -2580,7 +2597,7 @@ Found in file sv.h
 =item SvPVutf8x_force
 
 Like C<SvPV_force>, but converts sv to utf8 first if necessary.
-Guarantees to evalute sv only once; use the more efficient C<SvPVutf8_force>
+Guarantees to evaluate sv only once; use the more efficient C<SvPVutf8_force>
 otherwise.
 
 	char*	SvPVutf8x_force(SV* sv, STRLEN len)
@@ -2953,7 +2970,7 @@ Found in file sv.h
 =item SvUVx
 
 Coerces the given SV to an unsigned integer and returns it. Guarantees to
-evaluate sv only once. Use the more efficent C<SvUV> otherwise.
+evaluate sv only once. Use the more efficient C<SvUV> otherwise.
 
 	UV	SvUVx(SV* sv)
 
@@ -4245,7 +4262,7 @@ $utf8::ToLower, which is stored in lib/unicore/To/Lower.pl,
 and loaded by SWASHGET, using lib/utf8_heavy.pl.
 
 The "special" is a string like "utf8::ToSpecLower", which means
-the hash %utf8::ToSpecLower, which is stored in in the same file,
+the hash %utf8::ToSpecLower, which is stored in the same file,
 lib/unicore/To/Lower.pl, and also loaded by SWASHGET.  The access
 to the hash is by Perl_to_utf8_case().
 
@@ -4521,7 +4538,7 @@ Found in file XSUB.h
 
 =item XSRETURN_NV
 
-Return an double from an XSUB immediately.  Uses C<XST_mNV>.
+Return a double from an XSUB immediately.  Uses C<XST_mNV>.
 
 	void	XSRETURN_NV(NV nv)
 
diff --git a/pod/perlapio.pod b/pod/perlapio.pod
index 06e3d14e62..d378e6e12e 100644
--- a/pod/perlapio.pod
+++ b/pod/perlapio.pod
@@ -67,15 +67,17 @@ perlapio - perl's IO abstraction interface.
 
 =head1 DESCRIPTION
 
-Perl's source code, and extensions that want maximum portability, should use the above
-functions instead of those defined in ANSI C's I<stdio.h>.  The perl headers (in
-particular "perlio.h") will C<#define> them to the I/O mechanism selected at Configure time.
+Perl's source code, and extensions that want maximum portability,
+should use the above functions instead of those defined in ANSI C's
+I<stdio.h>.  The perl headers (in particular "perlio.h") will
+C<#define> them to the I/O mechanism selected at Configure time.
 
 The functions are modeled on those in I<stdio.h>, but parameter order
 has been "tidied up a little".
 
-C<PerlIO *> takes the place of FILE *. Like FILE * it should be treated as
-opaque (it is probably safe to assume it is a pointer to something).
+C<PerlIO *> takes the place of FILE *. Like FILE * it should be
+treated as opaque (it is probably safe to assume it is a pointer to
+something).
 
 There are currently three implementations:
 
@@ -83,40 +85,42 @@ There are currently three implementations:
 
 =item 1. USE_STDIO
 
-All above are #define'd to stdio functions or are trivial wrapper functions which
-call stdio. In this case I<only> PerlIO * is a FILE *.
-This has been the default implementation since the abstraction was introduced
-in perl5.003_02.
+All above are #define'd to stdio functions or are trivial wrapper
+functions which call stdio. In this case I<only> PerlIO * is a FILE *.
+This has been the default implementation since the abstraction was
+introduced in perl5.003_02.
 
 =item 2. USE_SFIO
 
-A "legacy" implementation in terms of the "sfio" library. Used for some specialist
-applications on Unix machines ("sfio" is not widely ported away from Unix).
-Most of above are #define'd to the sfio functions. PerlIO * is in this case Sfio_t *.
+A "legacy" implementation in terms of the "sfio" library. Used for
+some specialist applications on Unix machines ("sfio" is not widely
+ported away from Unix).  Most of above are #define'd to the sfio
+functions. PerlIO * is in this case Sfio_t *.
 
 =item 3. USE_PERLIO
 
-Introduced just after perl5.7.0 this is a re-implementation of the above abstraction
-which allows perl more control over how IO is done as it decouples IO from the
-way the operating system and C library choose to do things. For USE_PERLIO
-PerlIO * has an extra layer of indirection - it is a pointer-to-a-pointer.
-This allows the PerlIO * to remain with a known value while swapping the
-implementation arround underneath I<at run time>. In this case all the
-above are true (but very simple) functions which call the underlying implementation.
+Introduced just after perl5.7.0, this is a re-implementation of the
+above abstraction which allows perl more control over how IO is done
+as it decouples IO from the way the operating system and C library
+choose to do things. For USE_PERLIO PerlIO * has an extra layer of
+indirection - it is a pointer-to-a-pointer.  This allows the PerlIO *
+to remain with a known value while swapping the implementation around
+underneath I<at run time>. In this case all the above are true (but
+very simple) functions which call the underlying implementation.
 
-This is the only implementation for which C<PerlIO_apply_layers()> does anything
-"interesting".
+This is the only implementation for which C<PerlIO_apply_layers()>
+does anything "interesting".
 
 The USE_PERLIO implementation is described in L<perliol>.
 
 =back
 
-Because "perlio.h" is a thing layer (for efficiency) the semantics of these functions are
-somewhat dependent on the the underlying implementation. Where these variations are
-understood they are noted below.
+Because "perlio.h" is a thin layer (for efficiency) the semantics of
+these functions are somewhat dependent on the underlying implementation.
+Where these variations are understood they are noted below.
 
-Unless otherwise noted, functions return 0 on success, or a negative value (usually
-C<EOF> which is usually -1) and set C<errno> on error.
+Unless otherwise noted, functions return 0 on success, or a negative
+value (usually C<EOF> which is usually -1) and set C<errno> on error.
 
 =over 4
 
@@ -131,19 +135,19 @@ values.
 =item B<PerlIO_open(path, mode)>, B<PerlIO_fdopen(fd,mode)>
 
 These correspond to fopen()/fdopen() and the arguments are the same.
-Return C<NULL> and set C<errno> if there is an error.
-There may be an implementation limit on the number of open handles, which may
-be lower than the limit on the number of open files - C<errno> may
-not be set when C<NULL> is returned if this limnit is exceeded.
+Return C<NULL> and set C<errno> if there is an error.  There may be an
+implementation limit on the number of open handles, which may be lower
+than the limit on the number of open files - C<errno> may not be set
+when C<NULL> is returned if this limit is exceeded.
 
 =item B<PerlIO_reopen(path,mode,f)>
 
 While this currently exists in all three implementations perl itself
 does not use it. I<As perl does not use it, it is not well tested.>
 
-Perl prefers to C<dup> the new low-level descriptor to the descriptor used
-by the existing PerlIO. This may become the behaviour of this function
-in the future.
+Perl prefers to C<dup> the new low-level descriptor to the descriptor
+used by the existing PerlIO. This may become the behaviour of this
+function in the future.
 
 =item B<PerlIO_printf(f,fmt,...)>, B<PerlIO_vprintf(f,fmt,a)>
 
@@ -156,17 +160,17 @@ so it is (currently) legal to use C<printf(fmt,...)> in perl sources.
 
 =item B<PerlIO_read(f,buf,count)>, B<PerlIO_write(f,buf,count)>
 
-These correspond to fread() and fwrite(). Note that arguments
-are different, there is only one "count" and order has
-"file" first. Returns a byte count if successful (which may be zero),
-returns negative value and sets C<errno> on error.
-Depending on implementation C<errno> may be C<EINTR> if operation
-was interrupted by a signal.
+These correspond to fread() and fwrite(). Note that arguments are
+different, there is only one "count" and order has "file"
+first. Returns a byte count if successful (which may be zero), returns
+negative value and sets C<errno> on error.  Depending on
+implementation C<errno> may be C<EINTR> if operation was interrupted
+by a signal.
 
 =item B<PerlIO_close(f)>
 
-Depending on implementation C<errno> may be C<EINTR> if operation
-was interrupted by a signal.
+Depending on implementation C<errno> may be C<EINTR> if operation was
+interrupted by a signal.
 
 =item B<PerlIO_puts(f,s)>, B<PerlIO_putc(f,c)>
 
@@ -175,13 +179,13 @@ Note that arguments have been revised to have "file" first.
 
 =item B<PerlIO_ungetc(f,c)>
 
-This corresponds to ungetc().
-Note that arguments have been revised to have "file" first.
-Arranges that next read operation will return the byte B<c>.
-Despite the implied "character" in the name only values in the
-range 0..0xFF are defined. Returns the byte B<c> on success or -1 (C<EOF>) on error.
-The number of bytes that can be "pushed back" may vary, only 1 character is
-certain, and then only if it is the last character that was read from the handle.
+This corresponds to ungetc().  Note that arguments have been revised
+to have "file" first.  Arranges that next read operation will return
+the byte B<c>.  Despite the implied "character" in the name only
+values in the range 0..0xFF are defined. Returns the byte B<c> on
+success or -1 (C<EOF>) on error.  The number of bytes that can be
+"pushed back" may vary, only 1 character is certain, and then only if
+it is the last character that was read from the handle.
 
 =item B<PerlIO_getc(f)>
 
@@ -191,61 +195,62 @@ Returns the character read or -1 (C<EOF>) on error.
 
 =item B<PerlIO_eof(f)>
 
-This corresponds to feof().
-Returns a true/false indication of whether the handle is at end of file.
-For terminal devices this may or may not be "sticky" depending on the implementation.
-The flag is cleared by PerlIO_seek(), or PerlIO_rewind().
+This corresponds to feof().  Returns a true/false indication of
+whether the handle is at end of file.  For terminal devices this may
+or may not be "sticky" depending on the implementation.  The flag is
+cleared by PerlIO_seek(), or PerlIO_rewind().
 
 =item B<PerlIO_error(f)>
 
-This corresponds to ferror().
-Returns a true/false indication of whether there has been an IO error on the handle.
+This corresponds to ferror().  Returns a true/false indication of
+whether there has been an IO error on the handle.
 
 =item B<PerlIO_fileno(f)>
 
-This corresponds to fileno(), note that on some platforms,
-the meaning of "fileno" may not match Unix. Returns -1 if the handle has no
-open descriptor associated with it.
+This corresponds to fileno(), note that on some platforms, the meaning
+of "fileno" may not match Unix. Returns -1 if the handle has no open
+descriptor associated with it.
 
 =item B<PerlIO_clearerr(f)>
 
-This corresponds to clearerr(), i.e., clears 'error' and (usually) 'eof'
-flags for the "stream". Does not return a value.
+This corresponds to clearerr(), i.e., clears 'error' and (usually)
+'eof' flags for the "stream". Does not return a value.
 
 =item B<PerlIO_flush(f)>
 
-This corresponds to fflush().
-Sends any buffered write data to the underlying file.
-If called with C<NULL> this may flush all open streams (or core dump).
-Calling on a handle open for read only, or on which last operation was a read of some kind
-may lead to undefined behaviour.
+This corresponds to fflush().  Sends any buffered write data to the
+underlying file.  If called with C<NULL> this may flush all open
+streams (or core dump).  Calling on a handle open for read only, or on
+which last operation was a read of some kind may lead to undefined
+behaviour.
 
 =item B<PerlIO_seek(f,offset,whence)>
 
-This corresponds to fseek().
-Sends buffered write data to the underlying file, or discards any buffered
-read data, then positions the file desciptor as specified by B<offset> and B<whence> (sic).
-This is the correct thing to do when switching between read and write on the same
-handle (see issues with PerlIO_flush() above).
-Offset is of type C<Off_t> which is a perl Configure value which may not be same
+This corresponds to fseek().  Sends buffered write data to the
+underlying file, or discards any buffered read data, then positions
+the file desciptor as specified by B<offset> and B<whence> (sic).
+This is the correct thing to do when switching between read and write
+on the same handle (see issues with PerlIO_flush() above).  Offset is
+of type C<Off_t> which is a perl Configure value which may not be same
 as stdio's C<off_t>.
 
 =item B<PerlIO_tell(f)>
 
-This corresponds to ftell().
-Returns the current file position, or (Off_t) -1 on error.
-May just return value system "knows" without making a system call or checking
-the underlying file descriptor (so use on shared file descriptors is not
-safe without a PerlIO_seek()). Return value is of type C<Off_t> which is a perl Configure
-value which may not be same  as stdio's C<off_t>.
+This corresponds to ftell().  Returns the current file position, or
+(Off_t) -1 on error.  May just return value system "knows" without
+making a system call or checking the underlying file descriptor (so
+use on shared file descriptors is not safe without a
+PerlIO_seek()). Return value is of type C<Off_t> which is a perl
+Configure value which may not be same as stdio's C<off_t>.
 
 =item B<PerlIO_getpos(f,p)>, B<PerlIO_setpos(f,p)>
 
-These correspond (loosely) to fgetpos() and fsetpos(). Rather than stdio's Fpos_t
-they expect a "Perl Scalar Value" to be passed. What is stored there should
-be considered opaque. The layout of the data may vary from handle to handle.
-When not using stdio or if platform does not have the stdio calls then they are
-implemented in terms of PerlIO_tell() and PerlIO_seek().
+These correspond (loosely) to fgetpos() and fsetpos(). Rather than
+stdio's Fpos_t they expect a "Perl Scalar Value" to be passed. What is
+stored there should be considered opaque. The layout of the data may
+vary from handle to handle.  When not using stdio or if platform does
+not have the stdio calls then they are implemented in terms of
+PerlIO_tell() and PerlIO_seek().
 
 =item B<PerlIO_rewind(f)>
 
@@ -254,93 +259,92 @@ This corresponds to rewind(). It is usually defined as being
     PerlIO_seek(f,(Off_t)0L, SEEK_SET);
     PerlIO_clearerr(f);
 
-
 =item B<PerlIO_tmpfile()>
 
-This corresponds to tmpfile(), i.e., returns an anonymous
-PerlIO  or NULL on error.
-The system will attempt to automatically delete the file when closed.
-On Unix the file is usually C<unlink>-ed just after
-it is created so it does not matter how it gets closed. On other systems the file may
-only be deleted if closed via PerlIO_close() and/or the program exits via C<exit>.
-Depending on the implementation there may be "race conditions" which allow other
-processes access to the file, though in general it will be safer in this regard
-than ad. hoc. schemes.
+This corresponds to tmpfile(), i.e., returns an anonymous PerlIO or
+NULL on error.  The system will attempt to automatically delete the
+file when closed.  On Unix the file is usually C<unlink>-ed just after
+it is created so it does not matter how it gets closed. On other
+systems the file may only be deleted if closed via PerlIO_close()
+and/or the program exits via C<exit>.  Depending on the implementation
+there may be "race conditions" which allow other processes access to
+the file, though in general it will be safer in this regard than
+ad. hoc. schemes.
 
 =item B<PerlIO_setlinebuf(f)>
 
-This corresponds to setlinebuf().
-Does not return a value. What constitutes a "line" is implementation
-dependent but usually means that writing "\n" flushes the buffer.
-What happens with things like "this\nthat" is uncertain.
-(Perl core uses it I<only> when "dumping"; it has nothing to do with $| auto-flush.)
+This corresponds to setlinebuf().  Does not return a value. What
+constitutes a "line" is implementation dependent but usually means
+that writing "\n" flushes the buffer.  What happens with things like
+"this\nthat" is uncertain.  (Perl core uses it I<only> when "dumping";
+it has nothing to do with $| auto-flush.)
 
 =back
 
 =head2 Co-existence with stdio
 
 There is outline support for co-existence of PerlIO with stdio.
-Obviously if PerlIO is implemented in terms of stdio there is
-no problem. However in other cases then mechanisms must exist to create a FILE *
-which can be passed to library code which is going to use stdio calls.
+Obviously if PerlIO is implemented in terms of stdio there is no
+problem. However in other cases then mechanisms must exist to create a
+FILE * which can be passed to library code which is going to use stdio
+calls.
 
-The fisrt step is to add this line:
+The first step is to add this line:
 
    #define PERLIO_NOT_STDIO 0
 
-I<before> including any perl header files. (This will probably become the
-default at some point).  That prevents "perlio.h" from attempting to
-#define stdio functions onto PerlIO functions.
+I<before> including any perl header files. (This will probably become
+the default at some point).  That prevents "perlio.h" from attempting
+to #define stdio functions onto PerlIO functions.
 
-XS code is probably better using "typemap" if it expects FILE * arguments.
-The standard typemap will be adjusted to comprehend any changes in this area.
+XS code is probably better using "typemap" if it expects FILE *
+arguments.  The standard typemap will be adjusted to comprehend any
+changes in this area.
 
 =over 4
 
 =item B<PerlIO_importFILE(f,flags)>
 
-Used to get a PerlIO * from a FILE *.
-May need additional arguments, interface under review.
+Used to get a PerlIO * from a FILE *.  May need additional arguments,
+interface under review.
 
-The flags argument was meant to be used for read vs write vs read/write
-information. In hindsight it would have been better to make it a char *mode
-as in fopen/freopen.
+The flags argument was meant to be used for read vs write vs
+read/write information. In hindsight it would have been better to make
+it a char *mode as in fopen/freopen.
 
 =item B<PerlIO_exportFILE(f,flags)>
 
-Given a PerlIO * return a 'native' FILE * suitable for
-passing to code expecting to be compiled and linked with
-ANSI C I<stdio.h>.
+Given a PerlIO * return a 'native' FILE * suitable for passing to code
+expecting to be compiled and linked with ANSI C I<stdio.h>.
 
-The fact that such a FILE * has been 'exported' is recorded,
-and may affect future PerlIO operations on the original
-PerlIO *.
+The fact that such a FILE * has been 'exported' is recorded, and may
+affect future PerlIO operations on the original PerlIO *.
 
 =item B<PerlIO_findFILE(f)>
 
-Returns previously 'exported' FILE * (if any).
-Place holder until interface is fully defined.
+Returns previously 'exported' FILE * (if any).  Placeholder until
+interface is fully defined.
 
 =item B<PerlIO_releaseFILE(p,f)>
 
-Calling PerlIO_releaseFILE informs PerlIO that all use
-of FILE * is complete. It is removed from list of 'exported'
-FILE *s, and associated PerlIO * should revert to original
-behaviour.
+Calling PerlIO_releaseFILE informs PerlIO that all use of FILE * is
+complete. It is removed from list of 'exported' FILE *s, and
+associated PerlIO * should revert to original behaviour.
 
 =back
 
 =head2 "Fast gets" Functions
 
-In addition to standard-like API defined so far above there is an "implementation" interface
-which allows perl to get at internals of PerlIO.
-The following calls correspond to the various FILE_xxx macros determined
-by Configure - or their equivalent in other implementations. This section is really of
-interest to only those concerned with detailed perl-core behaviour, implementing a
-PerlIO mapping or writing code which can make use of the "read ahead" that has been done by
-the IO system in the same way perl does. Note that any code that uses these interfaces
-must be prepared to do things the traditional way if a handle does not support
-them.
+In addition to standard-like API defined so far above there is an
+"implementation" interface which allows perl to get at internals of
+PerlIO.  The following calls correspond to the various FILE_xxx macros
+determined by Configure - or their equivalent in other
+implementations. This section is really of interest to only those
+concerned with detailed perl-core behaviour, implementing a PerlIO
+mapping or writing code which can make use of the "read ahead" that
+has been done by the IO system in the same way perl does. Note that
+any code that uses these interfaces must be prepared to do things the
+traditional way if a handle does not support them.
 
 =over 4
 
@@ -357,28 +361,29 @@ This can vary from handle to handle.
 
 =item B<PerlIO_has_cntptr(f)>
 
-Implementation can return pointer to current position in the "buffer" and
-a count of bytes available in the buffer.
-Do not use this - use PerlIO_fast_gets.
+Implementation can return pointer to current position in the "buffer"
+and a count of bytes available in the buffer.  Do not use this - use
+PerlIO_fast_gets.
 
 =item B<PerlIO_get_cnt(f)>
 
-Return count of readable bytes in the buffer. Zero or negative return means
-no more bytes available.
+Return count of readable bytes in the buffer. Zero or negative return
+means no more bytes available.
 
 =item B<PerlIO_get_ptr(f)>
 
-Return pointer to next readable byte in buffer, accessing via the pointer
-(dereferencing) is only safe if PerlIO_get_cnt() has returned a positive value.
-Only positive offsets up to value returned by PerlIO_get_cnt() are allowed.
+Return pointer to next readable byte in buffer, accessing via the
+pointer (dereferencing) is only safe if PerlIO_get_cnt() has returned
+a positive value.  Only positive offsets up to value returned by
+PerlIO_get_cnt() are allowed.
 
 =item B<PerlIO_set_ptrcnt(f,p,c)>
 
 Set pointer into buffer, and a count of bytes still in the
-buffer. Should be used only to set
-pointer to within range implied by previous calls
-to C<PerlIO_get_ptr> and C<PerlIO_get_cnt>. The two values I<must> be consistent
-with each other (implementation may only use one or the other or may require both).
+buffer. Should be used only to set pointer to within range implied by
+previous calls to C<PerlIO_get_ptr> and C<PerlIO_get_cnt>. The two
+values I<must> be consistent with each other (implementation may only
+use one or the other or may require both).
 
 =item B<PerlIO_canset_cnt(f)>
 
@@ -387,13 +392,11 @@ Do not use this - use PerlIO_fast_gets.
 
 =item B<PerlIO_set_cnt(f,c)>
 
-Obscure - set count of bytes in the buffer. Deprecated.
-Only usable if PerlIO_canset_cnt() returns true.
-Currently used in only doio.c to force count less than -1 to -1.
-Perhaps should be PerlIO_set_empty or similar.
-This call may actually do nothing if "count" is deduced from pointer
-and a "limit".
-Do not use this - use PerlIO_set_ptrcnt().
+Obscure - set count of bytes in the buffer. Deprecated.  Only usable
+if PerlIO_canset_cnt() returns true.  Currently used in only doio.c to
+force count less than -1 to -1.  Perhaps should be PerlIO_set_empty or
+similar.  This call may actually do nothing if "count" is deduced from
+pointer and a "limit".  Do not use this - use PerlIO_set_ptrcnt().
 
 =item B<PerlIO_has_base(f)>
 
@@ -408,10 +411,10 @@ up to the value returned by PerlIO_get_bufsiz().
 
 =item B<PerlIO_get_bufsiz(f)>
 
-Return the I<total number of bytes> in the buffer, this is neither the number
-that can be read, nor the amount of memory allocated to the buffer. Rather
-it is what the operating system and/or implementation happened to C<read()>
-(or whatever) last time IO was requested.
+Return the I<total number of bytes> in the buffer, this is neither the
+number that can be read, nor the amount of memory allocated to the
+buffer. Rather it is what the operating system and/or implementation
+happened to C<read()> (or whatever) last time IO was requested.
 
 =back
 
@@ -429,7 +432,7 @@ case.
 =item PerlIO_binmode(f,ptype,imode,layers)
 
 The hook used by perl's C<binmode> operator.
-B<ptype> is perl's charcter for the kind of IO:
+B<ptype> is perl's character for the kind of IO:
 
 =over 8
 
@@ -452,21 +455,22 @@ Portable cases are:
 and
     PerlIO_binmode(f,ptype,O_TEXT,":crlf");
 
-On Unix these calls probably have no effect whatsoever.
-Elsewhere they alter "\n" to CR,LF translation and possibly cause a special
-text "end of file" indicator to be written or honoured on read. The effect of
-making the call after doing any IO to the handle depends on the implementation. (It may be
-ignored, affect any data which is already buffered as well, or only apply
-to subsequent data.)
+On Unix these calls probably have no effect whatsoever.  Elsewhere
+they alter "\n" to CR,LF translation and possibly cause a special text
+"end of file" indicator to be written or honoured on read. The effect
+of making the call after doing any IO to the handle depends on the
+implementation. (It may be ignored, affect any data which is already
+buffered as well, or only apply to subsequent data.)
 
 =item PerlIO_debug(fmt,...)
 
-PerlIO_debug is a printf()-like function which can be used for debugging.
-No return value. Its main use is inside PerlIO where using real printf, warn() etc. would
-recursively call PerlIO and be a problem.
+PerlIO_debug is a printf()-like function which can be used for
+debugging.  No return value. Its main use is inside PerlIO where using
+real printf, warn() etc. would recursively call PerlIO and be a
+problem.
 
-PerlIO_debug writes to the file named by $ENV{'PERLIO_DEBUG'} typical use
-might be
+PerlIO_debug writes to the file named by $ENV{'PERLIO_DEBUG'} typical
+use might be
 
   Bourne shells:
    PERLIO_DEBUG=/dev/tty ./perl somescript some args
diff --git a/pod/perlcompile.pod b/pod/perlcompile.pod
index 282592e9fb..07c4202bc1 100644
--- a/pod/perlcompile.pod
+++ b/pod/perlcompile.pod
@@ -9,7 +9,7 @@ internal form (a parse tree) which is then optimized before being
 run.  Since version 5.005, Perl has shipped with a module
 capable of inspecting the optimized parse tree (C<B>), and this has
 been used to write many useful utilities, including a module that lets
-you turn your Perl into C source code that can be compiled into an
+you turn your Perl into C source code that can be compiled into a
 native executable.
 
 The C<B> module provides access to the parse tree, and other modules
diff --git a/pod/perldata.pod b/pod/perldata.pod
index 3e2482e784..f2484dbc7e 100644
--- a/pod/perldata.pod
+++ b/pod/perldata.pod
@@ -219,7 +219,7 @@ an array that was previously shortened does not recover values
 that were in those elements.  (It used to do so in Perl 4, but we
 had to break this to make sure destructors were called when expected.)
 
-You can also gain some miniscule measure of efficiency by pre-extending
+You can also gain some minuscule measure of efficiency by pre-extending
 an array that is going to get big.  You can also extend an array
 by assigning to an element that is off the end of the array.  You
 can truncate an array down to nothing by assigning the null list
@@ -416,8 +416,8 @@ plain paranoid, you can force the correct interpretation with curly
 braces as above.
 
 If you're looking for the information on how to use here-documents,
-which used to be here, that's been moved to L<perlop> in the section on
-L<Quote and Quote-like Operators>.
+which used to be here, that's been moved to
+L<perlop/Quote and Quote-like Operators>.
 
 =head2 List value constructors
 
diff --git a/pod/perldebguts.pod b/pod/perldebguts.pod
index efc979861f..ff2b074ec4 100644
--- a/pod/perldebguts.pod
+++ b/pod/perldebguts.pod
@@ -774,7 +774,7 @@ were
 	   4     12    24    48    80
 
 With non-C<DEBUGGING> perl, the buckets starting from C<128> have
-a 4-byte overhead, and thus a 8192-long bucket may take up to
+a 4-byte overhead, and thus an 8192-long bucket may take up to
 8188-byte allocations.
 
 =item C<Total sbrk(): SBRKed/SBRKs:CONTINUOUS>
diff --git a/pod/perldebug.pod b/pod/perldebug.pod
index 7997a3890a..bb01bd3e94 100644
--- a/pod/perldebug.pod
+++ b/pod/perldebug.pod
@@ -6,6 +6,10 @@ perldebug - Perl debugging
 
 First of all, have you tried using the B<-w> switch?
 
+
+If you're new to the Perl debugger, you may prefer to read
+L<perldebtut>, which is a tutorial introduction to the debugger .
+
 =head1 The Perl Debugger
 
 If you invoke Perl with the B<-d> switch, your script runs under the
@@ -940,6 +944,7 @@ See L<perldebguts/"Debugging Perl memory usage"> for the details.
 
 You did try the B<-w> switch, didn't you?
 
+L<perldebtut>,
 L<perldebguts>,
 L<re>,
 L<DB>,
diff --git a/pod/perldelta.pod b/pod/perldelta.pod
index 7d15597e19..689f4bc4c9 100644
--- a/pod/perldelta.pod
+++ b/pod/perldelta.pod
@@ -1,13 +1,2689 @@
 =head1 NAME
 
-perldelta - what will be new for perl v5.8.0
+perldelta - what is new for perl v5.8.0
 
 =head1 DESCRIPTION
 
-This document does not exist yet.  When the Perl 5.8.0 is released
-this document will describe the changes since Perl 5.6.0, the previous
-major release.  In the meanwhile, see L<perl570delta> and
-L<perl571delta>.
+This document describes differences between the 5.6.0 release and the
+5.8.0 release.
+
+=head1 Security Vulnerability Closed
+
+A potential security vulnerability in the optional suidperl component
+of Perl has been identified.  suidperl is neither built nor installed
+by default.  As of September the 2nd, 2000, the only known vulnerable
+platform is Linux, most likely all Linux distributions.  CERT and
+various vendors have been alerted about the vulnerability.
+
+The problem was caused by Perl trying to report a suspected security
+exploit attempt using an external program, /bin/mail.  On Linux
+platforms the /bin/mail program had an undocumented feature which
+when combined with suidperl gave access to a root shell, resulting in
+a serious compromise instead of reporting the exploit attempt.  If you
+don't have /bin/mail, or if you have 'safe setuid scripts', or if
+suidperl is not installed, you are safe.
+
+The exploit attempt reporting feature has been completely removed from
+the Perl 5.7.0 release, so that particular vulnerability isn't there
+anymore.  However, further security vulnerabilities are,
+unfortunately, always possible.  The suidperl code is being reviewed
+and if deemed too risky to continue to be supported, it may be
+completely removed from future releases.  In any case, suidperl should
+only be used by security experts who know exactly what they are doing
+and why they are using suidperl instead of some other solution such as
+sudo (see http://www.courtesan.com/sudo/).
+
+=head1 Incompatible Changes
+
+=over 4
+
+=item *
+
+Arrays now always interpolate into double-quoted strings:
+constructs like "foo@bar" now always assume C<@bar> is an array,
+whether or not the compiler has seen use of C<@bar>.
+
+=item *
+
+The semantics of bless(REF, REF) were unclear and until someone proves
+it to make some sense, it is forbidden.
+
+=item *
+
+A reference to a reference now stringify as "REF(0x81485ec)" instead
+of "SCALAR(0x81485ec)" in order to be more consistent with the return
+value of ref().
+
+=item *
+
+The very dusty examples in the eg/ directory have been removed.
+Suggestions for new shiny examples welcome but the main issue is that
+the examples need to be documented, tested and (most importantly)
+maintained.
+
+=item *
+
+The obsolete chat2 library that should never have been allowed
+to escape the laboratory has been decommissioned.
+
+=item *
+
+The unimplemented POSIX regex features [[.cc.]] and [[=c=]] are still
+recognised but now cause fatal errors.  The previous behaviour of
+ignoring them by default and warning if requested was unacceptable
+since it, in a way, falsely promised that the features could be used.
+
+=item *
+
+The (bogus) escape sequences \8 and \9 now give an optional warning
+("Unrecognized escape passed through").  There is no need to \-escape
+any C<\w> character.
+
+=item *
+
+lstat(FILEHANDLE) now gives a warning because the operation makes no sense.
+In future releases this may become a fatal error.
+
+=item *
+
+The long deprecated uppercase aliases for the string comparison
+operators (EQ, NE, LT, LE, GE, GT) have now been removed.
+
+=item *
+
+The regular expression captured submatches ($1, $2, ...) are now
+more consistently unset if the match fails, instead of leaving false
+data lying around in them.
+
+=item *
+
+The tr///C and tr///U features have been removed and will not return;
+the interface was a mistake.  Sorry about that.  For similar
+functionality, see pack('U0', ...) and pack('C0', ...).
+
+=back
+
+=head1 Core Enhancements
+
+=over 4
+
+=item *
+
+C<perl -d:Module=arg,arg,arg> now works (previously one couldn't pass
+in multiple arguments.)
+
+=item *
+
+my __PACKAGE__ $obj now works.
+
+=item *
+
+C<no Module;> now works even if there is no "sub unimport" in the Module.
+
+=item *
+
+The numerical comparison operators return C<undef> if either operand
+is a NaN.  Previously the behaviour was unspecified.
+
+=item *
+
+C<pack('U0a*', ...)> can now be used to force a string to UTF8.
+
+=item *
+
+prototype(\&) is now available.
+
+=item *
+
+There is now an UNTIE method.
+
+=back
+
+=head1 Modules and Pragmata
+
+=head2 New Modules
+
+=over 4
+
+=item *
+
+File::Temp allows one to create temporary files and directories in an
+easy, portable, and secure way.
+
+=item *
+
+Storable gives persistence to Perl data structures by allowing the
+storage and retrieval of Perl data to and from files in a fast and
+compact binary format.
+
+=back
+
+=head2 Updated And Improved Modules and Pragmata
+
+=over 4
+
+=item *
+
+The following independently supported modules have been updated to
+newer versions from CPAN: CGI, CPAN, DB_File, File::Spec, Getopt::Long,
+the podlators bundle, Pod::LaTeX, Pod::Parser, Term::ANSIColor, Test.
+
+=item *
+
+Bug fixes and minor enhancements have been applied to B::Deparse,
+Data::Dumper, IO::Poll, IO::Socket::INET, Math::BigFloat,
+Math::Complex, Math::Trig, Net::protoent, the re pragma, SelfLoader,
+Sys::SysLog, Test::Harness, Text::Wrap, UNIVERSAL, and the warnings
+pragma.
+
+=item *
+
+The attributes::reftype() now works on tied arguments.
+
+=item *
+
+AutoLoader can now be disabled with C<no AutoLoader;>,
+
+=item *
+
+The English module can now be used without the infamous performance
+hit by saying
+
+	use English '-no_performance_hit';
+
+(Assuming, of course, that one doesn't need the troublesome variables
+C<$`>, C<$&>, or C<$'>.)  Also, introduced C<@LAST_MATCH_START> and
+C<@LAST_MATCH_END> English aliases for C<@-> and C<@+>.
+
+=item *
+
+File::Find now has pre- and post-processing callbacks.  It also
+correctly changes directories when chasing symbolic links.  Callbacks
+(naughtily) exiting with "next;" instead of "return;" now work.
+
+=item *
+
+File::Glob::glob() renamed to File::Glob::bsd_glob() to avoid
+prototype mismatch with CORE::glob().
+
+=item *
+
+IPC::Open3 now allows the use of numeric file descriptors.
+
+=item *
+
+use lib now works identically to @INC.  Removing directories
+with 'no lib' now works.
+
+=item *
+
+C<%INC> now localised in a Safe compartment so that use/require work.
+
+=item *
+
+The Shell module now has an OO interface.
+
+=back
+
+=head1 Utility Changes
+
+=over 4
+
+=item *
+
+The Emacs perl mode (emacs/cperl-mode.el) has been updated to version
+4.31.
+
+=item *
+
+Perlbug is now much more robust.  It also sends the bug report to
+perl.org, not perl.com.
+
+=item *
+
+The perlcc utility has been rewritten and its user interface (that is,
+command line) is much more like that of the UNIX C compiler, cc.
+
+=item *
+
+The xsubpp utility for extension writers now understands POD
+documentation embedded in the *.xs files.
+
+=back
+
+=head1 New Documentation
+
+=over 4
+
+=item *
+
+perl56delta details the changes between the 5.005 release and the
+5.6.0 release.
+
+=item *
+
+perldebtut is a Perl debugging tutorial.
+
+=item *
+
+perlebcdic contains considerations for running Perl on EBCDIC platforms.
+Note that unfortunately EBCDIC platforms that used to supported back in
+Perl 5.005 are still unsupported by Perl 5.7.0; the plan, however, is to
+bring them back to the fold.  
+
+=item *
+
+perlnewmod tells about writing and submitting a new module.
+
+=item *
+
+perlposix-bc explains using Perl on the POSIX-BC platform
+(an EBCDIC mainframe platform).
+
+=item *
+
+perlretut is a regular expression tutorial.
+
+=item *
+
+perlrequick is a regular expressions quick-start guide.
+Yes, much quicker than perlretut.
+
+=item *
+
+perlutil explains the command line utilities packaged with the Perl
+distribution.
+
+=back
+
+=head1 Performance Enhancements
+
+=over 4
+
+=item *
+
+map() that changes the size of the list should now work faster.
+
+=item *
+
+sort() has been changed to use mergesort internally as opposed to the
+earlier quicksort.  For very small lists this may result in slightly
+slower sorting times, but in general the speedup should be at least
+20%.  Additional bonuses are that the worst case behaviour of sort()
+is now better (in computer science terms it now runs in time O(N log N),
+as opposed to quicksort's Theta(N**2) worst-case run time behaviour),
+and that sort() is now stable (meaning that elements with identical
+keys will stay ordered as they were before the sort).
+
+=back
+
+=head1 Installation and Configuration Improvements
+
+=head2 Generic Improvements
+
+=over 4
+
+=item *
+
+INSTALL now explains how you can configure Perl to use 64-bit
+integers even on non-64-bit platforms.
+
+=item *
+
+Policy.sh policy change: if you are reusing a Policy.sh file
+(see INSTALL) and you use Configure -Dprefix=/foo/bar and in the old
+Policy $prefix eq $siteprefix and $prefix eq $vendorprefix, all of
+them will now be changed to the new prefix, /foo/bar.  (Previously
+only $prefix changed.)  If you do not like this new behaviour,
+specify prefix, siteprefix, and vendorprefix explicitly.
+
+=item *
+
+A new optional location for Perl libraries, otherlibdirs, is available.
+It can be used for example for vendor add-ons without disturbing Perl's
+own library directories.
+
+=item *
+
+In many platforms the vendor-supplied 'cc' is too stripped-down to
+build Perl (basically, 'cc' doesn't do ANSI C).  If this seems
+to be the case and 'cc' does not seem to be the GNU C compiler
+'gcc', an automatic attempt is made to find and use 'gcc' instead.
+
+=item *
+
+gcc needs to closely track the operating system release to avoid
+build problems. If Configure finds that gcc was built for a different
+operating system release than is running, it now gives a clearly visible
+warning that there may be trouble ahead.
+
+=item *
+
+If binary compatibility with the 5.005 release is not wanted, Configure
+no longer suggests including the 5.005 modules in @INC.
+
+=item *
+
+Configure C<-S> can now run non-interactively.
+
+=item *
+
+configure.gnu now works with options with whitespace in them.
+
+=item *
+
+installperl now outputs everything to STDERR.
+
+=item *
+
+$Config{byteorder} is now computed dynamically (this is more robust
+with "fat binaries" where an executable image contains binaries for
+more than one binary platform.)
+
+=back
+
+=head1 Selected Bug Fixes
+
+=over 4
+
+=item *
+
+Several debugger fixes: exit code now reflects the script exit code,
+condition C<"0"> now treated correctly, the C<d> command now checks
+line number, the C<$.> no longer gets corrupted, all debugger output now
+goes correctly to the socket if RemotePort is set.
+
+=item *
+
+C<*foo{FORMAT}> now works.
+
+=item *
+
+Lexical warnings now propagating correctly between scopes.
+
+=item *
+
+Line renumbering with eval and C<#line> now works.
+
+=item *
+
+Fixed numerous memory leaks, especially in eval "".
+
+=item *
+
+Modulus of unsigned numbers now works (4063328477 % 65535 used to
+return 27406, instead of 27047).
+
+=item *
+
+Some "not a number" warnings introduced in 5.6.0 eliminated to be
+more compatible with 5.005.  Infinity is now recognised as a number.
+
+=item *
+
+our() variables will not cause "will not stay shared" warnings.
+
+=item *
+
+pack "Z" now correctly terminates the string with "\0".
+
+=item *
+
+Fix password routines which in some shadow password platforms
+(e.g. HP-UX) caused getpwent() to return every other entry.
+
+=item *
+
+printf() no longer resets the numeric locale to "C".
+
+=item *
+
+C<q(a\\b)> now parses correctly as C<'a\\b'>.
+
+=item *
+
+Printing quads (64-bit integers) with printf/sprintf now works
+without the q L ll prefixes (assuming you are on a quad-capable platform).
+
+=item *
+
+Regular expressions on references and overloaded scalars now work.
+
+=item *
+
+scalar() now forces scalar context even when used in void context.
+
+=item *
+
+sort() arguments are now compiled in the right wantarray context
+(they were accidentally using the context of the sort() itself).
+
+=item *
+
+Changed the POSIX character class C<[[:space:]]> to include the (very
+rare) vertical tab character.  Added a new POSIX-ish character class
+C<[[:blank:]]> which stands for horizontal whitespace (currently,
+the space and the tab).
+
+=item *
+
+$AUTOLOAD, sort(), lock(), and spawning subprocesses
+in multiple threads simultaneously are now thread-safe.
+
+=item *
+
+Allow read-only string on left hand side of non-modifying tr///.
+
+=item *
+
+Several Unicode fixes (but still not perfect).
+
+=over 8
+
+=item *
+
+BOMs (byte order marks) in the beginning of Perl files
+(scripts, modules) should now be transparently skipped.
+UTF-16 (UCS-2) encoded Perl files should now be read correctly.
+
+=item *
+
+The character tables have been updated to Unicode 3.0.1.
+
+=item *
+
+chr() for values greater than 127 now create utf8 when under use
+utf8.
+
+=item *
+
+Comparing with utf8 data does not magically upgrade non-utf8 data into
+utf8.
+
+=item *
+
+C<IsAlnum>, C<IsAlpha>, and C<IsWord> now match titlecase.
+
+=item *
+
+Concatenation with the C<.> operator or via variable interpolation,
+C<eq>, C<substr>, C<reverse>, C<quotemeta>, the C<x> operator,
+substitution with C<s///>, single-quoted UTF8, should now work--in
+theory.
+
+=item *
+
+The C<tr///> operator now works I<slightly> better but is still rather
+broken.  Note that the C<tr///CU> functionality has been removed (but
+see pack('U0', ...)).
+
+=item *
+
+vec() now refuses to deal with characters >255.
+
+=item *
+
+Zero entries were missing from the Unicode classes like C<IsDigit>.
+
+=back
+
+=item *
+
+UNIVERSAL::isa no longer caches methods incorrectly.  (This broke
+the Tk extension with 5.6.0.)
+
+=back
+
+=head2 Platform Specific Changes and Fixes
+
+=over 4
+
+=item *
+
+BSDI 4.*
+
+Perl now works on post-4.0 BSD/OSes.
+
+=item *
+
+All BSDs
+
+Setting C<$0> now works (as much as possible; see perlvar for details).
+
+=item *
+
+Cygwin
+
+Numerous updates; currently synchronised with Cygwin 1.1.4.
+
+=item *
+
+EPOC
+
+EPOC update after Perl 5.6.0.  See README.epoc.
+
+=item *
+
+FreeBSD 3.*
+
+Perl now works on post-3.0 FreeBSDs.
+
+=item *
+
+HP-UX
+
+README.hpux updated; C<Configure -Duse64bitall> now almost works.
+
+=item *
+
+IRIX
+
+Numerous compilation flag and hint enhancements; accidental mixing
+of 32-bit and 64-bit libraries (a doomed attempt) made much harder.
+
+=item *
+
+Linux
+
+Long doubles should now work (see INSTALL).
+
+=item *
+
+MacOS Classic
+
+Compilation of the standard Perl distribution in MacOS Classic should
+now work if you have the Metrowerks development environment and
+the missing Mac-specific toolkit bits.  Contact the macperl mailing
+list for details.
+
+=item *
+
+MPE/iX
+
+MPE/iX update after Perl 5.6.0.  See README.mpeix.
+
+=item *
+
+NetBSD/sparc
+
+Perl now works on NetBSD/sparc.
+
+=item *
+
+OS/2
+
+Now works with usethreads (see INSTALL).
+
+=item *
+
+Solaris
+
+64-bitness using the Sun Workshop compiler now works.
+
+=item *
+
+Tru64 (aka Digital UNIX, aka DEC OSF/1)
+
+The operating system version letter now recorded in $Config{osvers}.
+Allow compiling with gcc (previously explicitly forbidden).  Compiling
+with gcc still not recommended because buggy code results, even with
+gcc 2.95.2.
+
+=item *
+
+Unicos
+
+Fixed various alignment problems that lead into core dumps either
+during build or later; no longer dies on math errors at runtime;
+now using full quad integers (64 bits), previously was using 
+only 46 bit integers for speed.
+
+=item *
+
+VMS
+
+chdir() now works better despite a CRT bug; now works with MULTIPLICITY
+(see INSTALL); now works with Perl's malloc.
+
+=item *
+
+Windows
+
+=over 8
+
+=item *
+
+accept() no longer leaks memory.
+
+=item *
+
+Better chdir() return value for a non-existent directory.
+
+=item *
+
+New %ENV entries now propagate to subprocesses.
+
+=item *
+
+$ENV{LIB} now used to search for libs under Visual C.
+
+=item *
+
+A failed (pseudo)fork now returns undef and sets errno to EAGAIN.
+
+=item *
+
+Allow REG_EXPAND_SZ keys in the registry.
+
+=item *
+
+Can now send() from all threads, not just the first one.
+
+=item *
+
+Fake signal handling reenabled, bugs and all.
+
+=item *
+
+Less stack reserved per thread so that more threads can run
+concurrently. (Still 16M per thread.)
+
+=item *
+
+C<File::Spec->tmpdir()> now prefers C:/temp over /tmp
+(works better when perl is running as service).
+
+=item *
+
+Better UNC path handling under ithreads.
+
+=item *
+
+wait() and waitpid() now work much better.
+
+=item *
+
+winsock handle leak fixed.
+
+=back
+
+=back
+
+=head1 New or Changed Diagnostics
+
+All regular expression compilation error messages are now hopefully
+easier to understand both because the error message now comes before
+the failed regex and because the point of failure is now clearly
+marked.
+
+The various "opened only for", "on closed", "never opened" warnings
+drop the C<main::> prefix for filehandles in the C<main> package,
+for example C<STDIN> instead of <main::STDIN>. 
+
+The "Unrecognized escape" warning has been extended to include C<\8>,
+C<\9>, and C<\_>.  There is no need to escape any of the C<\w> characters.
+
+=head1 Changed Internals
+
+=over 4
+
+=item *
+
+perlapi.pod (a companion to perlguts) now attempts to document the
+internal API.
+
+=item *
+
+You can now build a really minimal perl called microperl.
+Building microperl does not require even running Configure;
+C<make -f Makefile.micro> should be enough.  Beware: microperl makes
+many assumptions, some of which may be too bold; the resulting
+executable may crash or otherwise misbehave in wondrous ways.
+For careful hackers only.
+
+=item *
+
+Added rsignal(), whichsig(), do_join() to the publicised API.
+
+=item *
+
+Made possible to propagate customised exceptions via croak()ing.
+
+=item *
+
+Added is_utf8_char(), is_utf8_string(), bytes_to_utf8(), and utf8_to_bytes().
+
+=item *
+
+Now xsubs can have attributes just like subs.
+
+=back
+
+=head1 Known Problems
+
+=head2 Unicode Support Still Far From Perfect
+
+We're working on it.  Stay tuned.
+
+=head2 EBCDIC Still A Lost Platform
+
+The plan is to bring them back.
+
+=head2 Building Extensions Can Fail Because Of Largefiles
+
+Certain extensions like mod_perl and BSD::Resource are known to have
+issues with `largefiles', a change brought by Perl 5.6.0 in which file
+offsets default to 64 bits wide, where supported.  Modules may fail to
+compile at all or compile and work incorrectly.  Currently there is no
+good solution for the problem, but Configure now provides appropriate
+non-largefile ccflags, ldflags, libswanted, and libs in the %Config
+hash (e.g., $Config{ccflags_nolargefiles}) so the extensions that are
+having problems can try configuring themselves without the
+largefileness.  This is admittedly not a clean solution, and the
+solution may not even work at all.  One potential failure is whether
+one can (or, if one can, whether it's a good idea) link together at
+all binaries with different ideas about file offsets, all this is
+platform-dependent.
+
+=head2 ftmp-security tests warn 'system possibly insecure'
+
+Don't panic.  Read INSTALL 'make test' section instead. 
+
+=head2 Test lib/posix Subtest 9 Fails In LP64-Configured HP-UX
+
+If perl is configured with -Duse64bitall, the successful result of the
+subtest 10 of lib/posix may arrive before the successful result of the
+subtest 9, which confuses the test harness so much that it thinks the
+subtest 9 failed.
+
+=head2 Long Doubles Still Don't Work In Solaris
+
+The experimental long double support is still very much so in Solaris.
+(Other platforms like Linux and Tru64 are beginning to solidify in
+this area.)
+
+=head2 Linux With Sfio Fails op/misc Test 48
+
+No known fix.
+
+=head2 Storable tests fail in some platforms
+
+If any Storable tests fail the use of Storable is not advisable.
+
+=over 4
+
+=item *
+
+Many Storable tests fail on AIX configured with 64 bit integers.
+
+So far unidentified problems break Storable in AIX if Perl is
+configured to use 64 bit integers.  AIX in 32-bit mode works and
+other 64-bit platforms work with Storable.
+
+=item *
+
+DOS DJGPP may hang when testing Storable.
+
+=item *
+
+st-06compat fails in UNICOS and UNICOS/mk.
+
+This means that you cannot read old (pre-Storable-0.7) Storable images
+made in other platforms.
+
+=item *
+
+st-store.t and st-retrieve may fail with Compaq C 6.2 on OpenVMS Alpha 7.2.
+
+=back
+
+=head2 Threads Are Still Experimental
+
+Multithreading is still an experimental feature.  Some platforms
+emit the following message for lib/thr5005
+
+    #
+    # This is a KNOWN FAILURE, and one of the reasons why threading
+    # is still an experimental feature.  It is here to stop people
+    # from deploying threads in production. ;-)
+    #
+
+and another known thread-related warning is
+
+   pragma/overload......Unbalanced saves: 3 more saves than restores
+   panic: magic_mutexfree during global destruction.
+   ok
+   lib/selfloader.......Unbalanced saves: 3 more saves than restores
+   panic: magic_mutexfree during global destruction.
+   ok
+   lib/st-dclone........Unbalanced saves: 3 more saves than restores
+   panic: magic_mutexfree during global destruction.
+   ok
+
+=head2 The Compiler Suite Is Still Experimental
+
+The compiler suite is slowly getting better but is nowhere near
+working order yet.  The backend part that has seen perhaps the most
+progress is the bytecode compiler.
+
+=head1 Security Vulnerability Closed
+
+(This change was already made in 5.7.0 but bears repeating here.)
+
+A potential security vulnerability in the optional suidperl component
+of Perl was identified in August 2000.  suidperl is neither built nor
+installed by default.  As of April 2001 the only known vulnerable
+platform is Linux, most likely all Linux distributions.  CERT and
+various vendors and distributors have been alerted about the vulnerability.
+See http://www.cpan.org/src/5.0/sperl-2000-08-05/sperl-2000-08-05.txt
+for more information.
+
+The problem was caused by Perl trying to report a suspected security
+exploit attempt using an external program, /bin/mail.  On Linux
+platforms the /bin/mail program had an undocumented feature which
+when combined with suidperl gave access to a root shell, resulting in
+a serious compromise instead of reporting the exploit attempt.  If you
+don't have /bin/mail, or if you have 'safe setuid scripts', or if
+suidperl is not installed, you are safe.
+
+The exploit attempt reporting feature has been completely removed from
+all the Perl 5.7 releases (and will be gone also from the maintenance
+release 5.6.1), so that particular vulnerability isn't there anymore.
+However, further security vulnerabilities are, unfortunately, always
+possible.  The suidperl code is being reviewed and if deemed too risky
+to continue to be supported, it may be completely removed from future
+releases.  In any case, suidperl should only be used by security
+experts who know exactly what they are doing and why they are using
+suidperl instead of some other solution such as sudo (see
+http://www.courtesan.com/sudo/).
+
+=head1 Incompatible Changes
+
+=over 4
+
+=item *
+
+Although "you shouldn't do that", it was possible to write code that
+depends on Perl's hashed key order (Data::Dumper does this).  The new
+algorithm "One-at-a-Time" produces a different hashed key order.
+More details are in L</"Performance Enhancements">.
+
+=item *
+
+The list of filenames from glob() (or <...>) is now by default sorted
+alphabetically to be csh-compliant.  (bsd_glob() does still sort platform
+natively, ASCII or EBCDIC, unless GLOB_ALPHASORT is specified.)
+
+=back
+
+=head1 Core Enhancements
+
+=head2 AUTOLOAD Is Now Lvaluable
+
+AUTOLOAD is now lvaluable, meaning that you can add the :lvalue attribute
+to AUTOLOAD subroutines and you can assign to the AUTOLOAD return value.
+
+=head2 PerlIO is Now The Default
+
+=over 4
+
+=item *
+
+IO is now by default done via PerlIO rather than system's "stdio".
+PerlIO allows "layers" to be "pushed" onto a file handle to alter the
+handle's behaviour.  Layers can be specified at open time via 3-arg
+form of open:
+
+   open($fh,'>:crlf :utf8', $path) || ...
+
+or on already opened handles via extended C<binmode>:
+
+   binmode($fh,':encoding(iso-8859-7)');
+
+The built-in layers are: unix (low level read/write), stdio (as in
+previous Perls), perlio (re-implementation of stdio buffering in a
+portable manner), crlf (does CRLF <=> "\n" translation as on Win32,
+but available on any platform).  A mmap layer may be available if
+platform supports it (mostly UNIXes).
+
+Layers to be applied by default may be specified via the 'open' pragma.
+
+See L</"Installation and Configuration Improvements"> for the effects
+of PerlIO on your architecture name.
+
+=item *
+
+File handles can be marked as accepting Perl's internal encoding of Unicode
+(UTF-8 or UTF-EBCDIC depending on platform) by a pseudo layer ":utf8" :
+
+   open($fh,">:utf8","Uni.txt");
+
+Note for EBCDIC users: the pseudo layer ":utf8" is erroneously named
+for you since it's not UTF-8 what you will be getting but instead
+UTF-EBCDIC.  See L<perlunicode>, L<utf8>, and
+http://www.unicode.org/unicode/reports/tr16/ for more information.
+In future releases this naming may change.
+
+=item *
+
+File handles can translate character encodings from/to Perl's internal
+Unicode form on read/write via the ":encoding()" layer.
+
+=item *
+
+File handles can be opened to "in memory" files held in Perl scalars via:
+
+   open($fh,'>', \$variable) || ...
+
+=item *
+
+Anonymous temporary files are available without need to
+'use FileHandle' or other module via
+
+   open($fh,"+>", undef) || ...
+
+That is a literal undef, not an undefined value.
+
+=item *
+
+The list form of C<open> is now implemented for pipes (at least on UNIX):
+
+   open($fh,"-|", 'cat', '/etc/motd')
+
+creates a pipe, and runs the equivalent of exec('cat', '/etc/motd') in
+the child process.
+
+=item *
+
+The following builtin functions are now overridable: chop(), chomp(),
+each(), keys(), pop(), push(), shift(), splice(), unshift().
+
+=item *
+
+Formats now support zero-padded decimal fields.
+
+=item *
+
+Perl now tries internally to use integer values in numeric conversions
+and basic arithmetics (+ - * /) if the arguments are integers, and
+tries also to keep the results stored internally as integers.
+This change leads into often slightly faster and always less lossy
+arithmetics. (Previously Perl always preferred floating point numbers
+in its math.)
+
+=item *
+
+The printf() and sprintf() now support parameter reordering using the
+C<%\d+\$> and C<*\d+\$> syntaxes.  For example
+
+    print "%2\$s %1\$s\n", "foo", "bar";
+
+will print "bar foo\n"; This feature helps in writing
+internationalised software.
+
+=item *
+
+Unicode in general should be now much more usable.  Unicode can be
+used in hash keys, Unicode in regular expressions should work now,
+Unicode in tr/// should work now (though tr/// seems to be a
+particularly tricky to get right, so you have been warned)
+
+=item *
+
+The Unicode Character Database coming with Perl has been upgraded
+to Unicode 3.1.  For more information, see http://www.unicode.org/,
+and http://www.unicode.org/unicode/reports/tr27/
+
+For developers interested in enhancing Perl's Unicode capabilities:
+almost all the UCD files are included with the Perl distribution in
+the lib/unicode subdirectory.  The most notable omission, for space
+considerations, is the Unihan database.
+
+=item *
+
+The Unicode character classes \p{Blank} and \p{SpacePerl} have been
+added.  "Blank" is like C isblank(), that is, it contains only
+"horizontal whitespace" (the space character is, the newline isn't),
+and the "SpacePerl" is the Unicode equivalent of C<\s> (\p{Space}
+isn't, since that includes the vertical tabulator character, whereas
+C<\s> doesn't.)
+
+=back
+
+=head2 Signals Are Now Safe
+
+Perl used to be fragile in that signals arriving at inopportune moments
+could corrupt Perl's internal state.
+
+=head1 Modules and Pragmata
+
+=head2 New Modules
+
+=over 4
+
+=item *
+
+B::Concise, by Stephen McCamant, is a new compiler backend for
+walking the Perl syntax tree, printing concise info about ops.
+The output is highly customisable.
+
+See L<B::Concise> for more information.
+
+=item *
+
+Class::ISA, by Sean Burke, for reporting the search path for a
+class's ISA tree, has been added.
+
+See L<Class::ISA> for more information.
+
+=item *
+
+Cwd has now a split personality: if possible, an extension is used,
+(this will hopefully be both faster and more secure and robust) but
+if not possible, the familiar Perl library implementation is used.
+
+=item *
+
+Digest, a frontend module for calculating digests (checksums),
+from Gisle Aas, has been added.
+
+See L<Digest> for more information.
+
+=item *
+
+Digest::MD5 for calculating MD5 digests (checksums), by Gisle Aas,
+has been added.
+
+    use Digest::MD5 'md5_hex';
+
+    $digest = md5_hex("Thirsty Camel");
+
+    print $digest, "\n"; # 01d19d9d2045e005c3f1b80e8b164de1
+
+NOTE: the MD5 backward compatibility module is deliberately not
+included since its use is discouraged.
+
+See L<Digest::MD5> for more information.
+
+=item *
+
+Encode, by Nick Ing-Simmons, provides a mechanism to translate
+between different character encodings.  Support for Unicode,
+ISO-8859-*, ASCII, CP*, KOI8-R, and three variants of EBCDIC are
+compiled in to the module.  Several other encodings (like Japanese,
+Chinese, and MacIntosh encodings) are included and will be loaded at
+runtime.
+
+Any encoding supported by Encode module is also available to the
+":encoding()" layer if PerlIO is used.
+
+See L<Encode> for more information.
+
+=item *
+
+Filter::Simple is an easy-to-use frontend to Filter::Util::Call,
+from Damian Conway.
+
+    # in MyFilter.pm:
+
+    package MyFilter;
+
+    use Filter::Simple sub {
+        while (my ($from, $to) = splice @_, 0, 2) {
+                s/$from/$to/g;
+        }
+    };
+
+    1;
+
+    # in user's code:
+
+    use MyFilter qr/red/ => 'green';
+
+    print "red\n";   # this code is filtered, will print "green\n"
+    print "bored\n"; # this code is filtered, will print "bogreen\n"
+
+    no MyFilter;
+
+    print "red\n";   # this code is not filtered, will print "red\n"
+
+See L<Filter::Simple> for more information.
+
+=item *
+
+Filter::Util::Call, by Paul Marquess, provides you with the
+framework to write I<Source Filters> in Perl.  For most uses
+the frontend Filter::Simple is to be preferred.
+See L<Filter::Util::Call> for more information.
+
+=item *
+
+Locale::Constants, Locale::Country, Locale::Currency, and Locale::Language,
+from Neil Bowers, have been added.  They provide the codes for various
+locale standards, such as "fr" for France, "usd" for US Dollar, and
+"jp" for Japanese.
+
+    use Locale::Country;
+
+    $country = code2country('jp');               # $country gets 'Japan'
+    $code    = country2code('Norway');           # $code gets 'no'
+
+See L<Locale::Constants>, L<Locale::Country>, L<Locale::Currency>,
+and L<Locale::Language> for more information.
+
+=item *
+
+MIME::Base64, by Gisle Aas, allows you to encode data in base64.
+
+    use MIME::Base64;
+
+    $encoded = encode_base64('Aladdin:open sesame');
+    $decoded = decode_base64($encoded);
+
+    print $encoded, "\n"; # "QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
+
+See L<MIME::Base64> for more information.
+
+=item *
+
+MIME::QuotedPrint, by Gisle Aas, allows you to encode data in
+quoted-printable encoding.
+
+    use MIME::QuotedPrint;
+
+    $encoded = encode_qp("Smiley in Unicode: \x{263a}");
+    $decoded = decode_qp($encoded);
+
+    print $encoded, "\n"; # "Smiley in Unicode: =263A"
+
+MIME::QuotedPrint has been enhanced to provide the basic methods
+necessary to use it with PerlIO::Via as in :
+
+    use MIME::QuotedPrint;
+    open($fh,">Via(MIME::QuotedPrint)",$path)
+
+See L<MIME::QuotedPrint> for more information.
+
+=item *
+
+PerlIO::Scalar, by Nick Ing-Simmons, provides the implementation of
+IO to "in memory" Perl scalars as discussed above.  It also serves as
+an example of a loadable layer.  Other future possibilities include
+PerlIO::Array and PerlIO::Code.  See L<PerlIO::Scalar> for more
+information.
+
+=item *
+
+PerlIO::Via, by Nick Ing-Simmons, acts as a PerlIO layer and wraps
+PerlIO layer functionality provided by a class (typically implemented
+in perl code).
+
+    use MIME::QuotedPrint;
+    open($fh,">Via(MIME::QuotedPrint)",$path)
+
+This will automatically convert everything output to C<$fh>
+to Quoted-Printable.  See L<PerlIO::Via> for more information.
+
+=item *
+
+Pod::Text::Overstrike, by Joe Smith, has been added.
+It converts POD data to formatted overstrike text.
+See L<Pod::Text::Overstrike> for more information.
+
+=item *
+
+Switch from Damian Conway has been added.  Just by saying
+
+    use Switch;
+
+you have C<switch> and C<case> available in Perl.
+
+    use Switch;
+
+    switch ($val) {
+
+		case 1		{ print "number 1" }
+		case "a"	{ print "string a" }
+		case [1..10,42]	{ print "number in list" }
+		case (@array)	{ print "number in list" }
+		case /\w+/	{ print "pattern" }
+		case qr/\w+/	{ print "pattern" }
+		case (%hash)	{ print "entry in hash" }
+		case (\%hash)	{ print "entry in hash" }
+		case (\&sub)	{ print "arg to subroutine" }
+		else		{ print "previous case not true" }
+    }
+
+See L<Switch> for more information.
+
+=item *
+
+Text::Balanced from Damian Conway has been added, for
+extracting delimited text sequences from strings.
+
+    use Text::Balanced 'extract_delimited';
+
+    ($a, $b) = extract_delimited("'never say never', he never said", "'", '');
+
+$a will be "'never say never'", $b will be ', he never said'.
+
+In addition to extract_delimited() there are also extract_bracketed(),
+extract_quotelike(), extract_codeblock(), extract_variable(),
+extract_tagged(), extract_multiple(), gen_delimited_pat(), and
+gen_extract_tagged().  With these you can implement rather advanced
+parsing algorithms.  See L<Text::Balanced> for more information.
+
+=item *
+
+Tie::RefHash::Nestable, by Edward Avis, allows storing hash references
+(unlike the standard Tie::RefHash)  The module is contained within
+Tie::RefHash.
+
+=item *
+
+XS::Typemap, by Tim Jenness, is a test extension that exercises XS
+typemaps.  Nothing gets installed but for extension writers the code
+is worth studying.
+
+=back
+
+=head2 Updated And Improved Modules and Pragmata
+
+=over 4
+
+=item *
+
+B::Deparse should be now more robust.  It still far from providing a full
+round trip for any random piece of Perl code, though, and is under active
+development: expect more robustness in 5.7.2.
+
+=item *
+
+Class::Struct can now define the classes in compile time.
+
+=item *
+
+Math::BigFloat has undergone much fixing, and in addition the fmod()
+function now supports modulus operations.
+
+(The fixed Math::BigFloat module is also available in CPAN for those
+who can't upgrade their Perl: http://www.cpan.org/authors/id/J/JP/JPEACOCK/)
+
+=item *
+
+Devel::Peek now has an interface for the Perl memory statistics
+(this works only if you are using perl's malloc, and if you have
+compiled with debugging).
+
+=item *
+
+IO::Socket has now atmark() method, which returns true if the socket
+is positioned at the out-of-band mark.  The method is also exportable
+as a sockatmark() function.
+
+=item *
+
+IO::Socket::INET has support for ReusePort option (if your platform
+supports it).  The Reuse option now has an alias, ReuseAddr.  For clarity
+you may want to prefer ReuseAddr.
+
+=item *
+
+Net::Ping has been enhanced.  There is now "external" protocol which
+uses Net::Ping::External module which runs external ping(1) and parses
+the output.  An alpha version of Net::Ping::External is available in
+CPAN and in 5.7.2 the Net::Ping::External may be integrated to Perl.
+
+=item *
+
+The C<open> pragma allows layers other than ":raw" and ":crlf" when
+using PerlIO.
+
+=item *
+
+POSIX::sigaction() is now much more flexible and robust.
+You can now install coderef handlers, 'DEFAULT', and 'IGNORE'
+handlers, installing new handlers was not atomic.
+
+=item *
+
+The Test module has been significantly enhanced.  Its use is
+greatly recommended for module writers.
+
+=item *
+
+The utf8:: name space (as in the pragma) provides various
+Perl-callable functions to provide low level access to Perl's
+internal Unicode representation.  At the moment only length()
+has been implemented.
+
+=back
+
+The following modules have been upgraded from the versions at CPAN:
+CPAN, CGI, DB_File, File::Temp, Getopt::Long, Pod::Man, Pod::Text,
+Storable, Text-Tabs+Wrap.
+
+=head1 Performance Enhancements
+
+=over 4
+
+=item *
+
+Hashes now use Bob Jenkins "One-at-a-Time" hashing key algorithm
+(http://burtleburtle.net/bob/hash/doobs.html).  This algorithm is
+reasonably fast while producing a much better spread of values than
+the old hashing algorithm (originally by Chris Torek, later tweaked by
+Ilya Zakharevich).  Hash values output from the algorithm on a hash of
+all 3-char printable ASCII keys comes much closer to passing the
+DIEHARD random number generation tests.  According to perlbench, this
+change has not affected the overall speed of Perl.
+
+=item *
+
+unshift() should now be noticeably faster.
+
+=back
+
+=head1 Utility Changes
+
+=over 4
+
+=item *
+
+h2xs now produces template README.
+
+=item *
+
+s2p has been completely rewritten in Perl.  (It is in fact a full
+implementation of sed in Perl.)
+
+=item *
+
+xsubpp now supports OUT keyword.
+
+=back
+
+=head1 New Documentation
+
+=head2 perlclib
+
+Internal replacements for standard C library functions.
+(Interesting only for extension writers and Perl core hackers.)
+
+=head2 perliol
+
+Internals of PerlIO with layers.
+
+=head2 README.aix
+
+Documentation on compiling Perl on AIX has been added.  AIX has
+several different C compilers and getting the right patch level
+is essential.  On install README.aix will be installed as L<perlaix>.
+
+=head2 README.bs2000
+
+Documentation on compiling Perl on the POSIX-BC platform (an EBCDIC
+mainframe environment) has been added.
+
+This was formerly known as README.posix-bc but the name was considered
+to be too confusing (it has nothing to do with the POSIX module or the
+POSIX standard).  On install README.bs2000 will be installed as L<perlbs2000>.
+
+=head2 README.macos
+
+In perl 5.7.1 (and in the 5.6.1) the MacPerl sources have been
+synchronised with the standard Perl sources.  To compile MacPerl
+some additional steps are required, and this file documents those
+steps.  On install README.macos will be installed as L<perlmacos>.
+
+=head2 README.mpeix
+
+The README.mpeix has been podified, which means that this information
+about compiling and using Perl on the MPE/iX miniframe platform will
+be installed as L<perlmpeix>.
+
+=head2 README.solaris
+
+README.solaris has been created and Solaris wisdom from elsewhere
+in the Perl documentation has been collected there.  On install
+README.solaris will be installed as L<perlsolaris>.
+
+=head2 README.vos
+
+The README.vos has been podified, which means that this information
+about compiling and using Perl on the Stratus VOS miniframe platform
+will be installed as L<perlvos>.
+
+=head2 Porting/repository.pod
+
+Documentation on how to use the Perl source repository has been added.
+
+=head1 Installation and Configuration Improvements
+
+=over 4
+
+=item *
+
+Because PerlIO is now the default on most platforms, "-perlio" doesn't
+get appended to the $Config{archname} (also known as $^O) anymore.
+Instead, if you explicitly choose not to use perlio (Configure command
+line option -Uuseperlio), you will get "-stdio" appended.
+
+=item *
+
+Another change related to the architecture name is that "-64all"
+(-Duse64bitall, or "maximally 64-bit") is appended only if your
+pointers are 64 bits wide.  (To be exact, the use64bitall is ignored.)
+
+=item *
+
+APPLLIB_EXP, a less-know configuration-time definition, has been
+documented.  It can be used to prepend site-specific directories
+to Perl's default search path (@INC), see INSTALL for information.
+
+=item *
+
+Building Berkeley DB3 for compatibility modes for DB, NDBM, and ODBM
+has been documented in INSTALL.
+
+=item *
+
+If you are on IRIX or Tru64 platforms, new profiling/debugging options
+have been added, see L<perlhack> for more information about pixie and
+Third Degree.
+
+=back
+
+=head2 New Or Improved Platforms
+
+For the list of platforms known to support Perl,
+see L<perlport/"Supported Platforms">.
+
+=over 4
+
+=item *
+
+AIX dynamic loading should be now better supported.
+
+=item *
+
+After a long pause, AmigaOS has been verified to be happy with Perl.
+
+=item *
+
+EBCDIC platforms (z/OS, also known as OS/390, POSIX-BC, and VM/ESA)
+have been regained.  Many test suite tests still fail and the
+co-existence of Unicode and EBCDIC isn't quite settled, but the
+situation is much better than with Perl 5.6.  See L<perlos390>,
+L<perlbs2000> (for POSIX-BC), and L<perlvmesa> for more information.
+
+=item *
+
+Building perl with -Duseithreads or -Duse5005threads now works under
+HP-UX 10.20 (previously it only worked under 10.30 or later). You will
+need a thread library package installed. See README.hpux.
+
+=item *
+
+MacOS Classic (MacPerl has of course been available since
+perl 5.004 but now the source code bases of standard Perl
+and MacPerl have been synchronised)
+
+=item *
+
+NCR MP-RAS is now supported.
+
+=item *
+
+NonStop-UX is now supported.
+
+=item *
+
+Amdahl UTS is now supported.
+
+=item *
+
+z/OS (formerly known as OS/390, formerly known as MVS OE) has now
+support for dynamic loading.  This is not selected by default,
+however, you must specify -Dusedl in the arguments of Configure.
+
+=back
+
+=head2 Generic Improvements
+
+=over 4
+
+=item *
+
+Configure no longer includes the DBM libraries (dbm, gdbm, db, ndbm)
+when building the Perl binary.  The only exception to this is SunOS 4.x,
+which needs them.
+
+=item *
+
+Some new Configure symbols, useful for extension writers:
+
+=over 8
+
+=item d_cmsghdr
+
+For struct cmsghdr.
+
+=item d_fcntl_can_lock
+
+Whether fcntl() can be used for file locking.
+
+=item d_fsync
+
+=item d_getitimer
+
+=item d_getpagsz
+
+For getpagesize(), though you should prefer POSIX::sysconf(_SC_PAGE_SIZE))
+
+=item d_msghdr_s
+
+For struct msghdr.
+
+=item need_va_copy
+
+Whether one needs to use Perl_va_copy() to copy varargs.
+
+=item d_readv
+
+=item d_recvmsg
+
+=item d_sendmsg
+
+=item sig_size
+
+The number of elements in an array needed to hold all the available signals.
+
+=item d_sockatmark
+
+=item d_strtoq
+
+=item d_u32align
+
+Whether one needs to access character data aligned by U32 sized pointers.
+
+=item d_ualarm
+
+=item d_usleep
+
+=back
+
+=item *
+
+Removed Configure symbols: the PDP-11 memory model settings: huge,
+large, medium, models.
+
+=item *
+
+SOCKS support is now much more robust.
+
+=item *
+
+If your file system supports symbolic links you can build Perl outside
+of the source directory by
+
+	mkdir /tmp/perl/build/directory
+	cd /tmp/perl/build/directory
+	sh /path/to/perl/source/Configure -Dmksymlinks ...
+
+This will create in /tmp/perl/build/directory a tree of symbolic links
+pointing to files in /path/to/perl/source.  The original files are left
+unaffected.  After Configure has finished you can just say
+
+	make all test
+
+and Perl will be built and tested, all in /tmp/perl/build/directory.
+
+=back
+
+=head1 Selected Bug Fixes
+
+Numerous memory leaks and uninitialized memory accesses have been hunted down.
+Most importantly anonymous subs used to leak quite a bit.
+
+=over 4
+
+=item *
+
+chop(@list) in list context returned the characters chopped in
+reverse order.  This has been reversed to be in the right order.
+
+=item *
+
+The order of DESTROYs has been made more predictable.
+
+=item *
+
+mkdir() now ignores trailing slashes in the directory name,
+as mandated by POSIX.
+
+=item *
+
+Attributes (like :shared) didn't work with our().
+
+=item *
+
+The PERL5OPT environment variable (for passing command line arguments
+to Perl) didn't work for more than a single group of options.
+
+=item *
+
+The tainting behaviour of sprintf() has been rationalized.  It does
+not taint the result of floating point formats anymore, making the
+behaviour consistent with that of string interpolation.
+
+=item *
+
+All but the first argument of the IO syswrite() method are now optional.
+
+=item *
+
+Tie::ARRAY SPLICE method was broken.
+
+=item *
+
+vec() now tries to work with characters <= 255 when possible, but it leaves
+higher character values in place.  In that case, if vec() was used to modify
+the string, it is no longer considered to be utf8-encoded.
+
+=back
+
+=head2 Platform Specific Changes and Fixes
+
+=over 4
+
+=item *
+
+Linux previously had problems related to sockaddrlen when using
+accept(), revcfrom() (in Perl: recv()), getpeername(), and getsockname().
+
+=item *
+
+Previously DYNIX/ptx had problems in its Configure probe for non-blocking I/O.
+
+=item *
+
+Windows
+
+=over 8
+
+=item *
+
+Borland C++ v5.5 is now a supported compiler that can build Perl.
+However, the generated binaries continue to be incompatible with those
+generated by the other supported compilers (GCC and Visual C++).
+
+=item *
+
+Win32::GetCwd() correctly returns C:\ instead of C: when at the drive root.
+Other bugs in chdir() and Cwd::cwd() have also been fixed.
+
+=item *
+
+Duping socket handles with open(F, ">&MYSOCK") now works under Windows 9x.
+
+=item *
+
+HTML files will be installed in c:\perl\html instead of c:\perl\lib\pod\html
+
+=item *
+
+The makefiles now provide a single switch to bulk-enable all the features
+enabled in ActiveState ActivePerl (a popular binary distribution).
+
+=back
+
+=back
+
+=head1 New or Changed Diagnostics
+
+Two new debugging options have been added: if you have compiled your
+Perl with debugging, you can use the -DT and -DR options to trace
+tokenising and to add reference counts to displaying variables,
+respectively.
+
+=over 4
+
+=item *
+
+If an attempt to use a (non-blessed) reference as an array index
+is made, a warning is given.
+
+=item *
+
+C<push @a;> and C<unshift @a;> (with no values to push or unshift)
+now give a warning.  This may be a problem for generated and evaled
+code.
+
+=back
+
+=head1 Changed Internals
+
+=over 4
+
+=item *
+
+Some new APIs: ptr_table_clear(), ptr_table_free(), sv_setref_uv().
+For the full list of the available APIs see L<perlapi>.
+
+=item *
+
+dTHR and djSP have been obsoleted; the former removed (because it's
+a no-op) and the latter replaced with dSP.
+
+=item *
+
+Perl now uses system malloc instead of Perl malloc on all 64-bit
+platforms, and even in some not-always-64-bit platforms like AIX,
+IRIX, and Solaris.  This change breaks backward compatibility but
+Perl's malloc has problems with large address spaces and also the
+speed of vendors' malloc is generally better in large address space
+machines (Perl's malloc is mostly tuned for space).
+
+=back
+
+=head1 New Tests
+
+Many new tests have been added.  The most notable is probably the
+lib/1_compile: it is very notable because running it takes quite a
+long time -- it test compiles all the Perl modules in the distribution.
+Please be patient.
+
+=head1 Known Problems
+
+Note that unlike other sections in this document (which describe
+changes since 5.7.0) this section is cumulative containing known
+problems for all the 5.7 releases.
+
+=head2 AIX vac 5.0.0.0 May Produce Buggy Code For Perl
+
+The AIX C compiler vac version 5.0.0.0 may produce buggy code,
+resulting in few random tests failing, but when the failing tests
+are run by hand, they succeed.  We suggest upgrading to at least
+vac version 5.0.1.0, that has been known to compile Perl correctly.
+"lslpp -L|grep vac.C" will tell you the vac version.
+
+=head2 lib/ftmp-security tests warn 'system possibly insecure'
+
+Don't panic.  Read INSTALL 'make test' section instead.
+
+=head2 lib/io_multihomed Fails In LP64-Configured HP-UX
+
+The lib/io_multihomed test may hang in HP-UX if Perl has been
+configured to be 64-bit. Because other 64-bit platforms do not hang in
+this test, HP-UX is suspect. All other tests pass in 64-bit HP-UX. The
+test attempts to create and connect to "multihomed" sockets (sockets
+which have multiple IP addresses).
+
+=head2 Test lib/posix Subtest 9 Fails In LP64-Configured HP-UX
+
+If perl is configured with -Duse64bitall, the successful result of the
+subtest 10 of lib/posix may arrive before the successful result of the
+subtest 9, which confuses the test harness so much that it thinks the
+subtest 9 failed.
+
+=head2 lib/b test 19
+
+The test fails on various platforms (PA64 and IA64 are known), but the
+exact cause is still being investigated.
+
+=head2 Linux With Sfio Fails op/misc Test 48
+
+No known fix.
+
+=head2 sigaction test 13 in VMS
+
+The test is known to fail; whether it's because of VMS of because
+of faulty test is not known.
+
+=head2 sprintf tests 129 and 130
+
+The op/sprintf tests 129 and 130 are known to fail on some platforms.
+Examples include any platform using sfio, and Compaq/Tandem's NonStop-UX.
+The failing platforms do not comply with the ANSI C Standard, line
+19ff on page 134 of ANSI X3.159 1989 to be exact.  (They produce
+something else than "1" and "-1" when formatting 0.6 and -0.6 using
+the printf format "%.0f", most often they produce "0" and "-0".)
+
+=head2  Failure of Thread tests
+
+The subtests 19 and 20 of lib/thr5005.t test are known to fail due to
+fundamental problems in the 5.005 threading implementation. These are
+not new failures--Perl 5.005_0x has the same bugs, but didn't have
+these tests. (Note that support for 5.005-style threading remains
+experimental.)
+
+=head2 Localising a Tied Variable Leaks Memory
+
+    use Tie::Hash;
+    tie my %tie_hash => 'Tie::StdHash';
+
+    ...
+
+    local($tie_hash{Foo}) = 1; # leaks
+
+Code like the above is known to leak memory every time the local()
+is executed.
+
+=head2 Self-tying of Arrays and Hashes Is Forbidden
+
+Self-tying of arrays and hashes is broken in rather deep and
+hard-to-fix ways.  As a stop-gap measure to avoid people from getting
+frustrated at the mysterious results (core dumps, most often) it is
+for now forbidden (you will get a fatal error even from an attempt).
+
+=head2 Building Extensions Can Fail Because Of Largefiles
+
+Some extensions like mod_perl are known to have issues with
+`largefiles', a change brought by Perl 5.6.0 in which file offsets
+default to 64 bits wide, where supported.  Modules may fail to compile
+at all or compile and work incorrectly.  Currently there is no good
+solution for the problem, but Configure now provides appropriate
+non-largefile ccflags, ldflags, libswanted, and libs in the %Config
+hash (e.g., $Config{ccflags_nolargefiles}) so the extensions that are
+having problems can try configuring themselves without the
+largefileness.  This is admittedly not a clean solution, and the
+solution may not even work at all.  One potential failure is whether
+one can (or, if one can, whether it's a good idea) link together at
+all binaries with different ideas about file offsets, all this is
+platform-dependent.
+
+=head2 The Compiler Suite Is Still Experimental
+
+The compiler suite is slowly getting better but is nowhere near
+working order yet.
+
+=head1 Security Vulnerability Closed
+
+(This change was already made in 5.7.0 but bears repeating here.)
+
+A security vulnerability affecting all Perl versions prior to 5.6.1
+was found in August 2000.  The vulnerability does not affect default
+installations and as far as is known affects only the Linux platform.
+
+You should upgrade your Perl to 5.6.1 as soon as possible.  Patches
+for earlier releases exist but using the patches require full
+recompilation from the source code anyway, so 5.6.1 is your best
+choice.
+
+See http://www.cpan.org/src/5.0/sperl-2000-08-05/sperl-2000-08-05.txt
+for more information.
+
+=head1 Incompatible Changes
+
+=head2 64-bit platforms and malloc
+
+If your pointers are 64 bits wide, the Perl malloc is no more being
+used because it simply does not work with 8-byte pointers.  Also,
+usually the system malloc on such platforms are much better optimized
+for such large memory models than the Perl malloc.
+
+=head2 AIX Dynaloading
+
+The AIX dynaloading now uses in AIX releases 4.3 and newer the native
+dlopen interface of AIX instead of the old emulated interface.  This
+change will probably break backward compatibility with compiled
+modules.  The change was made to make Perl more compliant with other
+applications like modperl which are using the AIX native interface.
+
+=head2 Socket Extension Dynamic in VMS
+
+The Socket extension is now dynamically loaded instead of being
+statically built in.  This may or may not be a problem with ancient
+TCP/IP stacks of VMS: we do not know since we weren't able to test
+Perl in such configurations.
+
+=head2 Different Definition of the Unicode Character Classes \p{In...}
+
+As suggested by the Unicode consortium, the Unicode character classes
+now prefer I<scripts> as opposed to I<blocks> (as defined by Unicode);
+in Perl, when the C<\p{In....}> and the C<\p{In....}> regular expression
+constructs are used.  This has changed the definition of some of those
+character classes.
+
+The difference between scripts and blocks is that scripts are the
+glyphs used by a language or a group of languages, while the blocks
+are more artificial groupings of 256 characters based on the Unicode
+numbering.
+
+In general this change results in more inclusive Unicode character
+classes, but changes to the other direction also do take place:
+for example while the script C<Latin> includes all the Latin
+characters and their various diacritic-adorned versions, it
+does not include the various punctuation or digits (since they
+are not solely C<Latin>).
+
+Changes in the character class semantics may have happened if a script
+and a block happen to have the same name, for example C<Hebrew>.
+In such cases the script wins and C<\p{InHebrew}> now means the script
+definition of Hebrew.  The block definition in still available,
+though, by appending C<Block> to the name: C<\p{InHebrewBlock}> means
+what C<\p{InHebrew}> meant in perl 5.6.0.  For the full list
+of affected character classes, see L<perlunicode/Blocks>.
+
+=head2 Deprecations
+
+The current user-visible implementation of pseudo-hashes (the weird
+use of the first array element) is deprecated starting from Perl 5.8.0
+and will be removed in Perl 5.10.0, and the feature will be
+implemented differently.  Not only is the current interface rather
+ugly, but the current implementation slows down normal array and hash
+use quite noticeably. The C<fields> pragma interface will remain
+available.
+
+The syntaxes C<@a->[...]> and  C<@h->{...}> have now been deprecated.
+
+The suidperl is also considered to be too much a risk to continue
+maintaining and the suidperl code is likely to be removed in a future
+release.
+
+The C<package;> syntax (C<package> without an argument has been
+deprecated.  Its semantics were never that clear and its
+implementation even less so.  If you have used that feature to
+disallow all but fully qualified variables, C<use strict;> instead.
+
+The chdir(undef) and chdir('') behaviors to match chdir() has been
+deprecated.  In future versions, chdir(undef) and chdir('') will
+simply fail.
+
+=head1 Core Enhancements
+
+In general a lot of fixing has happened in the area of Perl's
+understanding of numbers, both integer and floating point.  Since in
+many systems the standard number parsing functions like C<strtoul()>
+and C<atof()> seem to have bugs, Perl tries to work around their
+deficiencies.  This results hopefully in more accurate numbers.
+
+=over 4
+
+=item *
+
+The rules for allowing underscores (underbars) in numeric constants
+have been relaxed and simplified: now you can have an underscore
+B<between digits>.
+
+=item *
+
+GMAGIC (right-hand side magic) could in many cases such as string
+concatenation be invoked too many times.
+
+=item *
+
+Lexicals I: lexicals outside an eval "" weren't resolved
+correctly inside a subroutine definition inside the eval "" if they
+were not already referenced in the top level of the eval""ed code.
+
+=item *
+
+Lexicals II: lexicals leaked at file scope into subroutines that
+were declared before the lexicals.
+
+=item *
+
+Lvalue subroutines can now return C<undef> in list context.
+
+=item *
+
+The C<op_clear> and C<op_null> are now exported.
+
+=item *
+
+A new special regular expression variable has been introduced:
+C<$^N>, which contains the most-recently closed group (submatch).
+
+=item *
+
+L<utime> now supports C<utime undef, undef, @files> to change the
+file timestamps to the current time.
+
+=item *
+
+The Perl parser has been stress tested using both random input and
+Markov chain input.
+
+=item *
+
+C<eval "v200"> now works.
+
+=item *
+
+VMS now works under PerlIO.
+
+=item *
+
+END blocks are now run even if you exit/die in a BEGIN block.
+The execution of END blocks is now controlled by 
+PL_exit_flags & PERL_EXIT_DESTRUCT_END. This enables the new
+behaviour for perl embedders. This will default in 5.10. See
+L<perlembed>.
+
+=back
+
+=head1 Modules and Pragmata
+
+=head2 New Modules and Distributions
+
+=over 4
+
+=item *
+
+L<Attribute::Handlers> - Simpler definition of attribute handlers
+
+=item *
+
+L<ExtUtils::Constant> - generate XS code to import C header constants
+
+=item *
+
+L<I18N::Langinfo> - query locale information
+
+=item *
+
+L<I18N::LangTags> - functions for dealing with RFC3066-style language tags
+
+=item *
+
+L<libnet> - a collection of perl5 modules related to network programming
+
+Perl installation leaves libnet unconfigured, use F<libnetcfg> to configure.
+
+=item *
+
+L<List::Util> - selection of general-utility list subroutines
+
+=item *
+
+L<Locale::Maketext> - framework for localization
+
+=item *
+
+L<Memoize> - Make your functions faster by trading space for time
+
+=item *
+
+L<NEXT> - pseudo-class for method redispatch
+
+=item *
+
+L<Scalar::Util> - selection of general-utility scalar subroutines
+
+=item *
+
+L<Test::More> - yet another framework for writing test scripts
+
+=item *
+
+L<Test::Simple> - Basic utilities for writing tests
+
+=item *
+
+L<Time::HiRes> - high resolution ualarm, usleep, and gettimeofday
+
+=item *
+
+L<Time::Piece> - Object Oriented time objects
+
+(Previously known as L<Time::Object>.)
+
+=item *
+
+L<Time::Seconds> - a simple API to convert seconds to other date values
+
+=item *
+
+L<UnicodeCD> - Unicode Character Database
+
+=back
+
+=head2 Updated And Improved Modules and Pragmata
+
+=over 4
+
+=item *
+
+L<B::Deparse> module has been significantly enhanced.  It now
+can deparse almost all of the standard test suite (so that the
+tests still succeed).  There is a make target "test.deparse"
+for trying this out.
+
+=item *
+
+L<Class::Struct> now assigns the array/hash element if the accessor
+is called with an array/hash element as the B<sole> argument.
+
+=item *
+
+L<Cwd> extension is now (even) faster.
+
+=item *
+
+L<DB_File> extension has been updated to version 1.77.
+
+=item *
+
+L<Fcntl>, L<Socket>, and L<Sys::Syslog> have been rewritten to use the
+new-style constant dispatch section (see L<ExtUtils::Constant>).
+
+=item *
+
+L<File::Find> is now (again) reentrant.  It also has been made
+more portable.
+
+=item *
+
+L<File::Glob> now supports C<GLOB_LIMIT> constant to limit the
+size of the returned list of filenames.
+
+=item *
+
+L<IO::Socket::INET> now supports C<LocalPort> of zero (usually meaning
+that the operating system will make one up.)
+
+=item *
+
+The L<vars> pragma now supports declaring fully qualified variables.
+(Something that C<our()> does not and will not support.)
+
+=back
+
+=head1 Utility Changes
+
+=over 4
+
+=item *
+
+The F<emacs/e2ctags.pl> is now much faster.
+
+=item *
+
+L<h2ph> now supports C trigraphs.
+
+=item *
+
+L<h2xs> uses the new L<ExtUtils::Constant> module which will affect
+newly created extensions that define constants.  Since the new code is
+more correct (if you have two constants where the first one is a
+prefix of the second one, the first constant B<never> gets defined),
+less lossy (it uses integers for integer constant, as opposed to the
+old code that used floating point numbers even for integer constants),
+and slightly faster, you might want to consider regenerating your
+extension code (the new scheme makes regenerating easy).
+L<h2xs> now also supports C trigraphs.
+
+=item *
+
+L<libnetcfg> has been added to configure the libnet.
+
+=item *
+
+The F<Pod::Html> (and thusly L<pod2html>) now allows specifying
+a cache directory.
+
+=back
+
+=head1 New Documentation
+
+=over 4
+
+=item *
+
+L<Locale::Maketext::TPJ13> is an article about software localization,
+originally published in The Perl Journal #13, republished here with
+kind permission.
+
+=item *
+
+More README.$PLATFORM files have been converted into pod, which also
+means that they also be installed as perl$PLATFORM documentation
+files.  The new files are L<perlapollo>, L<perlbeos>, L<perldgux>,
+L<perlhurd>, L<perlmint>, L<perlnetware>, L<perlplan9>, L<perlqnx>,
+and L<perltru64>.
+
+=item *
+
+The F<Todo> and F<Todo-5.6> files have been merged into L<perltodo>.
+
+=item *
+
+Use of the F<gprof> tool to profile Perl has been documented in
+L<perlhack>.  There is a make target "perl.gprof" for generating a
+gprofiled Perl executable.
+
+=back
+
+=head1 Installation and Configuration Improvements
+
+=head2 New Or Improved Platforms
+
+=over 4
+
+=item *
+
+AIX should now work better with gcc, threads, and 64-bitness.  Also the
+long doubles support in AIX should be better now.  See L<perlaix>.
+
+=item *
+
+AtheOS (http://www.atheos.cx/) is a new platform.
+
+=item *
+
+DG/UX platform now supports the 5.005-style threads.  See L<perldgux>.
+
+=item *
+
+DYNIX/ptx platform (a.k.a. dynixptx) is supported at or near osvers 4.5.2.
+
+=item *
+
+Several MacOS (Classic) portability patches have been applied.  We
+hope to get a fully working port by 5.8.0.  (The remaining problems
+relate to the changed IO model of Perl.)  See L<perlmacos>.
+
+=item *
+
+MacOS X (or Darwin) should now be able to build Perl even on HFS+
+filesystems.  (The case-insensitivity confused the Perl build process.)
+
+=item *
+
+NetWare from Novell is now supported.  See L<perlnetware>.
+
+=item *
+
+The Amdahl UTS UNIX mainframe platform is now supported.
+
+=back
+
+=head2 Generic Improvements
+
+=over 4
+
+=item *
+
+In AFS installations one can configure the root of the AFS to be
+somewhere else than the default F</afs> by using the Configure
+parameter C<-Dafsroot=/some/where/else>.
+
+=item *
+
+The version of Berkeley DB used when the Perl (and, presumably, the
+DB_File extension) was built is now available as
+C<@Config{qw(db_version_major db_version_minor db_version_patch)}>
+from Perl and as C<DB_VERSION_MAJOR_CFG DB_VERSION_MINOR_CFG
+DB_VERSION_PATCH_CFG> from C.
+
+=item *
+
+The Thread extension is now not built at all under ithreads
+(C<Configure -Duseithreads>) because it wouldn't work anyway (the
+Thread extension requires being Configured with C<-Duse5005threads>).
+
+=item *
+
+The C<B::Deparse> compiler backend has been so significantly improved
+that almost the whole Perl test suite passes after being deparsed.  A
+make target has been added to help in further testing: C<make test.deparse>.
+
+=back
+
+=head1 Selected Bug Fixes
+
+=over 5
+
+=item *
+
+The autouse pragma didn't work for Multi::Part::Function::Names.
+
+=item *
+
+The behaviour of non-decimal but numeric string constants such as
+"0x23" was platform-dependent: in some platforms that was seen as 35,
+in some as 0, in some as a floating point number (don't ask).  This
+was caused by Perl using the operating system libraries in a situation
+where the result of the string to number conversion is undefined: now
+Perl consistently handles such strings as zero in numeric contexts.
+
+=item *
+
+L<dprofpp> -R didn't work.
+
+=item *
+
+PERL5OPT with embedded spaces didn't work.
+
+=item *
+
+L<Sys::Syslog> ignored the C<LOG_AUTH> constant.
+
+=back
+
+=head2 Platform Specific Changes and Fixes
+
+=over 4
+
+=item *
+
+Some versions of glibc have a broken modfl().  This affects builds
+with C<-Duselongdouble>.  This version of Perl detects this brokenness
+and has a workaround for it.  The glibc release 2.2.2 is known to have
+fixed the modfl() bug.
+
+=back
+
+=head1 New or Changed Diagnostics
+
+=over 4
+
+=item *
+
+In the regular expression diagnostics the C<E<lt>E<lt> HERE> marker
+introduced in 5.7.0 has been changed to be C<E<lt>-- HERE> since too
+many people found the C<E<lt>E<lt>> to be too similar to here-document
+starters.
+
+=item *
+
+If you try to L<perlfunc/pack> a number less than 0 or larger than 255
+using the C<"C"> format you will get an optional warning.  Similarly
+for the C<"c"> format and a number less than -128 or more than 127.
+
+=item *
+
+Certain regex modifiers such as C<(?o)> make sense only if applied to
+the entire regex.  You will an optional warning if you try to do otherwise.
+
+=item *
+
+Using arrays or hashes as references (e.g. C<%foo->{bar}> has been
+deprecated for a while.  Now you will get an optional warning.
+
+=back
+
+=head1 Source Code Enhancements
+
+=head2 MAGIC constants
+
+The MAGIC constants (e.g. C<'P'>) have been macrofied
+(e.g. C<PERL_MAGIC_TIED>) for better source code readability
+and maintainability.
+
+=head2 Better commented code
+
+F<perly.c>, F<sv.c>, and F<sv.h> have now been extensively commented.
+
+=head2 Regex pre-/post-compilation items matched up
+
+The regex compiler now maintains a structure that identifies nodes in
+the compiled bytecode with the corresponding syntactic features of the
+original regex expression.  The information is attached to the new
+C<offsets> member of the C<struct regexp>. See L<perldebguts> for more
+complete information.
+
+=head2 gcc -Wall
+
+The C code has been made much more C<gcc -Wall> clean.  Some warning
+messages still remain, though, so if you are compiling with gcc you
+will see some warnings about dubious practices.  The warnings are
+being worked on.
+
+=head1 New Tests
+
+Several new tests have been added, especially for the F<lib> subsection.
+
+The tests are now reported in a different order than in earlier Perls.
+(This happens because the test scripts from under t/lib have been moved
+to be closer to the library/extension they are testing.)
+
+=head1 Known Problems
+
+Note that unlike other sections in this document (which describe
+changes since 5.7.0) this section is cumulative containing known
+problems for all the 5.7 releases.
+
+=head2 AIX
+
+=over 4
+
+=item *
+
+In AIX 4.2 Perl extensions that use C++ functions that use statics
+may have problems in that the statics are not getting initialized.
+In newer AIX releases this has been solved by linking Perl with
+the libC_r library, but unfortunately in AIX 4.2 the said library
+has an obscure bug where the various functions related to time
+(such as time() and gettimeofday()) return broken values, and
+therefore in AIX 4.2 Perl is not linked against the libC_r.
+
+=item *
+
+vac 5.0.0.0 May Produce Buggy Code For Perl
+
+The AIX C compiler vac version 5.0.0.0 may produce buggy code,
+resulting in few random tests failing, but when the failing tests
+are run by hand, they succeed.  We suggest upgrading to at least
+vac version 5.0.1.0, that has been known to compile Perl correctly.
+"lslpp -L|grep vac.C" will tell you the vac version.
+
+=back
+
+=head2 Amiga Perl Invoking Mystery
+
+One cannot call Perl using the C<volume:> syntax, that is, C<perl -v>
+works, but for example C<bin:perl -v> doesn't.  The exact reason is
+known but the current suspect is the F<ixemul> library.
+
+=head2 lib/ftmp-security tests warn 'system possibly insecure'
+
+Don't panic.  Read INSTALL 'make test' section instead.
+
+=head2 Cygwin intermittent failures of lib/Memoize/t/expire_file 11 and 12
+
+The subtests 11 and 12 sometimes fail and sometimes work.
+
+=head2 HP-UX lib/io_multihomed Fails When LP64-Configured
+
+The lib/io_multihomed test may hang in HP-UX if Perl has been
+configured to be 64-bit. Because other 64-bit platforms do not hang in
+this test, HP-UX is suspect. All other tests pass in 64-bit HP-UX. The
+test attempts to create and connect to "multihomed" sockets (sockets
+which have multiple IP addresses).
+
+=head2  HP-UX lib/posix Subtest 9 Fails When LP64-Configured
+
+If perl is configured with -Duse64bitall, the successful result of the
+subtest 10 of lib/posix may arrive before the successful result of the
+subtest 9, which confuses the test harness so much that it thinks the
+subtest 9 failed.
+
+=head2 Linux With Sfio Fails op/misc Test 48
+
+No known fix.
+
+=head2 OS/390
+
+OS/390 has rather many test failures but the situation is actually
+better than it was in 5.6.0, it's just that so many new modules and
+tests have been added.
+
+ Failed Test                     Stat Wstat Total Fail  Failed  List of Failed
+ -----------------------------------------------------------------------------
+ ../ext/B/Deparse.t                            14    1   7.14%  14
+ ../ext/B/Showlex.t                             1    1 100.00%  1
+ ../ext/Encode/Encode/Tcl.t                   610   13   2.13%  592 594 596 598
+                                                                600 602 604-610
+ ../ext/IO/lib/IO/t/io_unix.t     113 28928     5    3  60.00%  3-5
+ ../ext/POSIX/POSIX.t                          29    1   3.45%  14
+ ../ext/Storable/t/lock.t         255 65280     5    3  60.00%  3-5
+ ../lib/locale.t                  129 33024   117   19  16.24%  99-117
+ ../lib/warnings.t                            434    1   0.23%  75
+ ../lib/ExtUtils.t                             27    1   3.70%  25
+ ../lib/Math/BigInt/t/bigintpm.t             1190    1   0.08%  1145
+ ../lib/Unicode/UCD.t                          81   48  59.26%  1-16 49-64 66-81
+ ../lib/User/pwent.t                            9    1  11.11%  4
+ op/pat.t                                     660    6   0.91%  242-243 424-425
+                                                                626-627
+ op/split.t                         0     9    ??   ??       %  ??
+ op/taint.t                                   174    3   1.72%  156 162 168
+ op/tr.t                                       70    3   4.29%  50 58-59
+ Failed 16/422 test scripts, 96.21% okay. 105/23251 subtests failed, 99.55% okay.
+
+=head2 op/sprintf tests 129 and 130
+
+The op/sprintf tests 129 and 130 are known to fail on some platforms.
+Examples include any platform using sfio, and Compaq/Tandem's NonStop-UX.
+The failing platforms do not comply with the ANSI C Standard, line
+19ff on page 134 of ANSI X3.159 1989 to be exact.  (They produce
+something other than "1" and "-1" when formatting 0.6 and -0.6 using
+the printf format "%.0f", most often they produce "0" and "-0".)
+
+=head2  Failure of Thread tests
+
+B<Note that support for 5.005-style threading remains experimental.>
+
+The following tests are known to fail due to fundamental problems in
+the 5.005 threading implementation. These are not new failures--Perl
+5.005_0x has the same bugs, but didn't have these tests.
+
+  lib/autouse.t                 4
+  t/lib/thr5005.t               19-20
+
+=head2 UNICOS
+
+=over 4
+
+=item *
+
+ext/POSIX/sigaction subtests 6 and 13 may fail.
+
+=item *
+
+lib/ExtUtils may spuriously claim that subtest 28 failed,
+which is interesting since the test only has 27 tests.
+
+=item *
+
+Numerous numerical test failures
+
+  op/numconvert                 209,210,217,218
+  op/override                   7
+  ext/Time/HiRes/HiRes          9
+  lib/Math/BigInt/t/bigintpm    1145
+  lib/Math/Trig                 25
+
+These tests fail because of yet unresolved floating point inaccuracies.
+
+=back
+
+=head2 UTS
+
+There are a few known test failures, see L<perluts>.
+
+=head2 VMS
+
+Rather many tests are failing in VMS but that actually more tests
+succeed in VMS than they used to, it's just that there are many,
+many more tests than there used to be.
+
+Here are the known failures from some compiler/platform combinations.
+
+DEC C V5.3-006 on OpenVMS VAX V6.2
+ 
+  [-.ext.list.util.t]tainted..............FAILED on test 3
+  [-.ext.posix]sigaction..................FAILED on test 7
+  [-.ext.time.hires]hires.................FAILED on test 14
+  [-.lib.file.find]taint..................FAILED on test 17
+  [-.lib.math.bigint.t]bigintpm...........FAILED on test 1183
+  [-.lib.test.simple.t]exit...............FAILED on test 1
+  [.lib]vmsish............................FAILED on test 13
+  [.op]sprintf............................FAILED on test 12
+  Failed 8/399 tests, 91.23% okay.
+
+DEC C V6.0-001 on OpenVMS Alpha V7.2-1 and
+Compaq C V6.2-008 on OpenVMS Alpha V7.1
+
+  [-.ext.list.util.t]tainted..............FAILED on test 3 
+  [-.lib.file.find]taint..................FAILED on test 17
+  [-.lib.test.simple.t]exit...............FAILED on test 1
+  [.lib]vmsish............................FAILED on test 13
+  Failed 4/399 tests, 92.48% okay.
+
+Compaq C V6.4-005 on OpenVMS Alpha 7.2.1
+
+  [-.ext.b]showlex........................FAILED on test 1
+  [-.ext.list.util.t]tainted..............FAILED on test 3
+  [-.lib.file.find]taint..................FAILED on test 17 
+  [-.lib.test.simple.t]exit...............FAILED on test 1
+  [.lib]vmsish............................FAILED on test 13
+  [.op]misc...............................FAILED on test 49
+  Failed 6/401 tests, 92.77% okay.
+
+=head2 Win32
+
+In multi-CPU boxes there are some problems with the I/O buffering:
+some output may appear twice.
+
+=head2 Localising a Tied Variable Leaks Memory
+
+    use Tie::Hash;
+    tie my %tie_hash => 'Tie::StdHash';
+
+    ...
+
+    local($tie_hash{Foo}) = 1; # leaks
+
+Code like the above is known to leak memory every time the local()
+is executed.
+
+=head2 Self-tying of Arrays and Hashes Is Forbidden
+
+Self-tying of arrays and hashes is broken in rather deep and
+hard-to-fix ways.  As a stop-gap measure to avoid people from getting
+frustrated at the mysterious results (core dumps, most often) it is
+for now forbidden (you will get a fatal error even from an attempt).
+
+=head2 Variable Attributes are not Currently Usable for Tieing
+
+This limitation will hopefully be fixed in future.  (Subroutine
+attributes work fine for tieing, see L<Attribute::Handlers>).
+
+=head2 Building Extensions Can Fail Because Of Largefiles
+
+Some extensions like mod_perl are known to have issues with
+`largefiles', a change brought by Perl 5.6.0 in which file offsets
+default to 64 bits wide, where supported.  Modules may fail to compile
+at all or compile and work incorrectly.  Currently there is no good
+solution for the problem, but Configure now provides appropriate
+non-largefile ccflags, ldflags, libswanted, and libs in the %Config
+hash (e.g., $Config{ccflags_nolargefiles}) so the extensions that are
+having problems can try configuring themselves without the
+largefileness.  This is admittedly not a clean solution, and the
+solution may not even work at all.  One potential failure is whether
+one can (or, if one can, whether it's a good idea) link together at
+all binaries with different ideas about file offsets, all this is
+platform-dependent.
+
+=head2 The Compiler Suite Is Still Experimental
+
+The compiler suite is slowly getting better but is nowhere near
+working order yet.
+
+=head2 The Long Double Support is Still Experimental
+
+The ability to configure Perl's numbers to use "long doubles",
+floating point numbers of hopefully better accuracy, is still
+experimental.  The implementations of long doubles are not yet
+widespread and the existing implementations are not quite mature
+or standardised, therefore trying to support them is a rare
+and moving target.  The gain of more precision may also be offset
+by slowdown in computations (more bits to move around, and the
+operations are more likely to be executed by less optimised
+libraries).
 
 =head1 Reporting Bugs
 
diff --git a/pod/perldiag.pod b/pod/perldiag.pod
index 6c6655c2da..a4c6543bd2 100644
--- a/pod/perldiag.pod
+++ b/pod/perldiag.pod
@@ -611,7 +611,7 @@ line.
 
 =item Can't exec "%s": %s
 
-(W exec) An system(), exec(), or piped open call could not execute the
+(W exec) A system(), exec(), or piped open call could not execute the
 named program for the indicated reason.  Typical reasons include: the
 permissions were wrong on the file, the file wasn't found in
 C<$ENV{PATH}>, the executable in question was compiled for another
@@ -1629,11 +1629,11 @@ two from 1 to 32 (or 64, if your platform supports that).
 
 =item Illegal octal digit %s
 
-(F) You used an 8 or 9 in a octal number.
+(F) You used an 8 or 9 in an octal number.
 
 =item Illegal octal digit %s ignored
 
-(W digit) You may have tried to use an 8 or 9 in a octal number.
+(W digit) You may have tried to use an 8 or 9 in an octal number.
 Interpretation of the octal number stopped before the 8 or 9.
 
 =item Illegal switch in PERL5OPT: %s
@@ -1837,7 +1837,7 @@ L<perlfunc/listen>.
 
 =item lstat() on filehandle %s
 
-(W io) You tried to do a lstat on a filehandle.  What did you mean
+(W io) You tried to do an lstat on a filehandle.  What did you mean
 by that?  lstat() makes sense only on filenames.  (Perl did a fstat()
 instead on the filehandle.)
 
@@ -2688,7 +2688,7 @@ the result of the value of the environment variable PERLIO.
 =item perlio: invalid separator character %s in attribute list
 
 (S) When pushing layers onto the Perl I/O system, something other than a
-colon or whitespace was seen between the elements of an layer list.
+colon or whitespace was seen between the elements of a layer list.
 If the previous attribute had a parenthesised parameter list, perhaps that
 list was terminated too soon.
 
@@ -3150,8 +3150,8 @@ account you tested it under), does not rely on any environment variables
 location where the CGI server can't find it, basically, more or less.
 Please see the following for more information:
 
-	http://www.perl.com/CPAN/doc/FAQs/cgi/idiots-guide.html
-	http://www.perl.com/CPAN/doc/FAQs/cgi/perl-cgi-faq.html
+	http://www.cpan.org/doc/FAQs/cgi/idiots-guide.html
+	http://www.cpan.org/doc/FAQs/cgi/perl-cgi-faq.html
 	ftp://rtfm.mit.edu/pub/usenet/news.answers/www/cgi-faq
 	http://hoohoo.ncsa.uiuc.edu/cgi/interface.html
 	http://www-genome.wi.mit.edu/WWW/faqs/www-security-faq.html
@@ -3284,13 +3284,13 @@ L<perlop/"Quote and Quote-like Operators">.
 
 =item Substitution pattern not terminated
 
-(F) The lexer couldn't find the interior delimiter of a s/// or s{}{}
+(F) The lexer couldn't find the interior delimiter of an s/// or s{}{}
 construct.  Remember that bracketing delimiters count nesting level.
 Missing the leading C<$> from variable C<$s> may cause this error.
 
 =item Substitution replacement not terminated
 
-(F) The lexer couldn't find the final delimiter of a s/// or s{}{}
+(F) The lexer couldn't find the final delimiter of an s/// or s{}{}
 construct.  Remember that bracketing delimiters count nesting level.
 Missing the leading C<$> from variable C<$s> may cause this error.
 
diff --git a/pod/perldsc.pod b/pod/perldsc.pod
index 5ab97e1795..11304a67ac 100644
--- a/pod/perldsc.pod
+++ b/pod/perldsc.pod
@@ -15,7 +15,7 @@ hacked Perl's internal symbol table directly, a strategy that proved hard
 to develop and maintain--to put it mildly.
 
 The 5.0 release of Perl let us have complex data structures.  You
-may now write something like this and all of a sudden, you'd have a array
+may now write something like this and all of a sudden, you'd have an array
 with three dimensions!
 
     for $x (1 .. 10) {
@@ -32,7 +32,7 @@ elaborate construct than meets the eye!
 
 How do you print it out?  Why can't you say just C<print @AoA>?  How do
 you sort it?  How can you pass it to a function or get one of these back
-from a function?  Is is an object?  Can you save it to disk to read
+from a function?  Is it an object?  Can you save it to disk to read
 back later?  How do you access whole rows or columns of that matrix?  Do
 all the values have to be numeric?
 
@@ -76,7 +76,7 @@ one-dimensional.  They can hold only scalar values (meaning a string,
 number, or a reference).  They cannot directly contain other arrays or
 hashes, but instead contain I<references> to other arrays or hashes.
 
-You can't use a reference to a array or hash in quite the same way that you
+You can't use a reference to an array or hash in quite the same way that you
 would a real array or hash.  For C or C++ programmers unused to
 distinguishing between arrays and pointers to the same, this can be
 confusing.  If so, just think of it as the difference between a structure
@@ -332,7 +332,7 @@ types of data structures.
 
 =head1 ARRAYS OF ARRAYS
 
-=head2 Declaration of a ARRAY OF ARRAYS
+=head2 Declaration of an ARRAY OF ARRAYS
 
  @AoA = (
         [ "fred", "barney" ],
@@ -340,7 +340,7 @@ types of data structures.
         [ "homer", "marge", "bart" ],
       );
 
-=head2 Generation of a ARRAY OF ARRAYS
+=head2 Generation of an ARRAY OF ARRAYS
 
  # reading from file
  while ( <> ) {
@@ -361,7 +361,7 @@ types of data structures.
  # add to an existing row
  push @{ $AoA[0] }, "wilma", "betty";
 
-=head2 Access and Printing of a ARRAY OF ARRAYS
+=head2 Access and Printing of an ARRAY OF ARRAYS
 
  # one element
  $AoA[0][0] = "Fred";
@@ -466,7 +466,7 @@ types of data structures.
 
 =head1 ARRAYS OF HASHES
 
-=head2 Declaration of a ARRAY OF HASHES
+=head2 Declaration of an ARRAY OF HASHES
 
  @AoH = (
         {
@@ -485,7 +485,7 @@ types of data structures.
         }
   );
 
-=head2 Generation of a ARRAY OF HASHES
+=head2 Generation of an ARRAY OF HASHES
 
  # reading from file
  # format: LEAD=fred FRIEND=barney
@@ -521,7 +521,7 @@ types of data structures.
  $AoH[0]{pet} = "dino";
  $AoH[2]{pet} = "santa's little helper";
 
-=head2 Access and Printing of a ARRAY OF HASHES
+=head2 Access and Printing of an ARRAY OF HASHES
 
  # one element
  $AoH[0]{lead} = "fred";
diff --git a/pod/perlebcdic.pod b/pod/perlebcdic.pod
index c98b46c6e7..86dcba29a5 100644
--- a/pod/perlebcdic.pod
+++ b/pod/perlebcdic.pod
@@ -1054,7 +1054,7 @@ following will print "Yes indeed\n" on either an ASCII or EBCDIC computer:
     $all_byte_chrs = '';
     for (0..255) { $all_byte_chrs .= chr($_); }
     $uuencode_byte_chrs = pack('u', $all_byte_chrs);
-    ($uu = <<'    ENDOFHEREDOC') =~ s/^\s*//gm;
+    ($uu = <<'ENDOFHEREDOC') =~ s/^\s*//gm;
     M``$"`P0%!@<("0H+#`T.#Q`1$A,4%187&!D:&QP='A\@(2(C)"4F)R@I*BLL
     M+2XO,#$R,S0U-C<X.3H[/#T^/T!!0D-$149'2$E*2TQ-3D]045)35%565UA9
     M6EM<75Y?8&%B8V1E9F=H:6IK;&UN;W!Q<G-T=79W>'EZ>WQ]?G^`@8*#A(6&
diff --git a/pod/perlembed.pod b/pod/perlembed.pod
index 1a08a77390..e8634577b0 100644
--- a/pod/perlembed.pod
+++ b/pod/perlembed.pod
@@ -792,7 +792,7 @@ Now compile:
 
  % cc -o persistent persistent.c `perl -MExtUtils::Embed -e ccopts -e ldopts`
 
-Here's a example script file:
+Here's an example script file:
 
  #test.pl
  my $string = "hello";
diff --git a/pod/perlfaq1.pod b/pod/perlfaq1.pod
index 3e50a576f1..e9b1ef7184 100644
--- a/pod/perlfaq1.pod
+++ b/pod/perlfaq1.pod
@@ -1,6 +1,6 @@
 =head1 NAME
 
-perlfaq1 - General Questions About Perl ($Revision: 1.1 $, $Date: 2001/09/20 03:03:00 $)
+perlfaq1 - General Questions About Perl ($Revision: 1.2 $, $Date: 2001/11/09 08:06:04 $)
 
 =head1 DESCRIPTION
 
@@ -252,12 +252,12 @@ programmers prefer to avoid them altogether.
 These are the "just another perl hacker" signatures that some people
 sign their postings with.  Randal Schwartz made these famous.  About
 100 of the earlier ones are available from
-http://www.perl.com/CPAN/misc/japh .
+http://www.cpan.org/misc/japh .
 
 =head2 Where can I get a list of Larry Wall witticisms?
 
 Over a hundred quips by Larry, from postings of his or source code,
-can be found at http://www.perl.com/CPAN/misc/lwall-quotes.txt.gz .
+can be found at http://www.cpan.org/misc/lwall-quotes.txt.gz .
 
 =head2 How can I convince my sysadmin/supervisor/employees to use version 5/5.005/Perl instead of some other language?
 
diff --git a/pod/perlfaq2.pod b/pod/perlfaq2.pod
index 52dc457c8e..71be980e10 100644
--- a/pod/perlfaq2.pod
+++ b/pod/perlfaq2.pod
@@ -1,6 +1,6 @@
 =head1 NAME
 
-perlfaq2 - Obtaining and Learning about Perl ($Revision: 1.2 $, $Date: 2001/10/16 13:27:22 $)
+perlfaq2 - Obtaining and Learning about Perl ($Revision: 1.3 $, $Date: 2001/11/09 08:06:04 $)
 
 =head1 DESCRIPTION
 
@@ -97,7 +97,7 @@ third-party modules and extensions, designed for everything from
 commercial database interfaces to keyboard/screen control to web
 walking and CGI scripts.  The master web site for CPAN is
 http://www.cpan.org/ and there is the CPAN Multiplexer at
-http://www.perl.com/CPAN/CPAN.html which will choose a mirror near you
+http://www.cpan.org/CPAN.html which will choose a mirror near you
 via DNS.  See http://www.perl.com/CPAN (without a slash at the
 end) for how this process works. Also, http://mirror.cpan.org/
 has a nice interface to the http://www.cpan.org/MIRRORED.BY
diff --git a/pod/perlfaq3.pod b/pod/perlfaq3.pod
index c0ca0ec0ba..8bd3d45399 100644
--- a/pod/perlfaq3.pod
+++ b/pod/perlfaq3.pod
@@ -1,6 +1,6 @@
 =head1 NAME
 
-perlfaq3 - Programming Tools ($Revision: 1.8 $, $Date: 2001/10/17 14:14:20 $)
+perlfaq3 - Programming Tools ($Revision: 1.9 $, $Date: 2001/11/09 08:06:04 $)
 
 =head1 DESCRIPTION
 
@@ -22,7 +22,7 @@ Have you read the appropriate manpages?  Here's a brief index:
 	Regexes		perlre, perlfunc, perlop, perllocale
 	Moving to perl5	perltrap, perl
 	Linking w/C	perlxstut, perlxs, perlcall, perlguts, perlembed
-	Various 	http://www.perl.com/CPAN/doc/FMTEYEWTK/index.html
+	Various 	http://www.cpan.org/doc/FMTEYEWTK/index.html
 			(not a man-page but still useful)
 
 A crude table of contents for the Perl manpage set is found in L<perltoc>.
@@ -152,11 +152,11 @@ Put that in your F<.exrc> file (replacing the caret characters
 with control characters) and away you go.  In insert mode, ^T is
 for indenting, ^D is for undenting, and ^O is for blockdenting--
 as it were.  A more complete example, with comments, can be found at
-http://www.perl.com/CPAN-local/authors/id/TOMC/scripts/toms.exrc.gz
+http://www.cpan.org/authors/id/TOMC/scripts/toms.exrc.gz
 
 If you are used to using the I<vgrind> program for printing out nice code
 to a laser printer, you can take a stab at this using
-http://www.perl.com/CPAN/doc/misc/tips/working.vgrind.entry, but the
+http://www.cpan.org/doc/misc/tips/working.vgrind.entry, but the
 results are not particularly satisfying for sophisticated code.
 
 The a2ps at http://www.infres.enst.fr/%7Edemaille/a2ps/ does lots of things
@@ -169,7 +169,7 @@ EXUBERANT CTAGS is available from http://ctags.sourceforge.net/
 and does a good job of making tags files for perl code.
 
 There is also a simple one at
-http://www.perl.com/CPAN/authors/id/TOMC/scripts/ptags.gz which may do
+http://www.cpan.org/authors/id/TOMC/scripts/ptags.gz which may do
 the trick.  It can be easy to hack this into what you want.
 
 =head2 Is there an IDE or Windows Perl Editor?
@@ -385,10 +385,10 @@ OS X and BeOS respectively (http://www.hekkelman.com/).
 =head2 Where can I get Perl macros for vi?
 
 For a complete version of Tom Christiansen's vi configuration file,
-see http://www.perl.com/CPAN/authors/Tom_Christiansen/scripts/toms.exrc.gz ,
+see http://www.cpan.org/authors/Tom_Christiansen/scripts/toms.exrc.gz ,
 the standard benchmark file for vi emulators.  The file runs best with nvi,
 the current version of vi out of Berkeley, which incidentally can be built
-with an embedded Perl interpreter--see http://www.perl.com/CPAN/src/misc.
+with an embedded Perl interpreter--see http://www.cpan.org/src/misc.
 
 =head2 Where can I get perl-mode for emacs?
 
@@ -409,7 +409,7 @@ shouldn't be an issue.
 
 The Curses module from CPAN provides a dynamically loadable object
 module interface to a curses library.  A small demo can be found at the
-directory http://www.perl.com/CPAN/authors/Tom_Christiansen/scripts/rep;
+directory http://www.cpan.org/authors/Tom_Christiansen/scripts/rep;
 this program repeats a command and updates the screen as needed, rendering
 B<rep ps axu> similar to B<top>.
 
@@ -418,18 +418,18 @@ B<rep ps axu> similar to B<top>.
 Tk is a completely Perl-based, object-oriented interface to the Tk toolkit
 that doesn't force you to use Tcl just to get at Tk.  Sx is an interface
 to the Athena Widget set.  Both are available from CPAN.  See the
-directory http://www.perl.com/CPAN/modules/by-category/08_User_Interfaces/
+directory http://www.cpan.org/modules/by-category/08_User_Interfaces/
 
 Invaluable for Perl/Tk programming are the Perl/Tk FAQ at
 http://w4.lns.cornell.edu/%7Epvhp/ptk/ptkTOC.html , the Perl/Tk Reference
 Guide available at
-http://www.perl.com/CPAN-local/authors/Stephen_O_Lidie/ , and the
+http://www.cpan.org/authors/Stephen_O_Lidie/ , and the
 online manpages at
 http://www-users.cs.umn.edu/%7Eamundson/perl/perltk/toc.html .
 
 =head2 How can I generate simple menus without using CGI or Tk?
 
-The http://www.perl.com/CPAN/authors/id/SKUNZ/perlmenu.v4.0.tar.gz
+The http://www.cpan.org/authors/id/SKUNZ/perlmenu.v4.0.tar.gz
 module, which is curses-based, can help with this.
 
 =head2 What is undump?
@@ -670,7 +670,7 @@ Both of these solutions can have far-reaching effects on your system
 and on the way you write your CGI programs, so investigate them with
 care.
 
-See http://www.perl.com/CPAN/modules/by-category/15_World_Wide_Web_HTML_HTTP_CGI/ .
+See http://www.cpan.org/modules/by-category/15_World_Wide_Web_HTML_HTTP_CGI/ .
 
 A non-free, commercial product, ``The Velocity Engine for Perl'',
 (http://www.binevolve.com/ or http://www.binevolve.com/velocigen/ )
@@ -873,13 +873,13 @@ when it runs fine on the command line'', see the troubleshooting
 guides and references in L<perlfaq9> or in the CGI MetaFAQ:
 
 	http://www.perl.org/CGI_MetaFAQ.html
-	
+
 =head2 Where can I learn about object-oriented Perl programming?
 
 A good place to start is L<perltoot>, and you can use L<perlobj>,
 L<perlboot>, and L<perlbot> for reference.  Perltoot didn't come out
 until the 5.004 release; you can get a copy (in pod, html, or
-postscript) from http://www.perl.com/CPAN/doc/FMTEYEWTK/ .
+postscript) from http://www.cpan.org/doc/FMTEYEWTK/ .
 
 =head2 Where can I learn about linking C with Perl? [h2xs, xsubpp]
 
diff --git a/pod/perlfaq4.pod b/pod/perlfaq4.pod
index faccc22d29..0196407871 100644
--- a/pod/perlfaq4.pod
+++ b/pod/perlfaq4.pod
@@ -1,6 +1,6 @@
 =head1 NAME
 
-perlfaq4 - Data Manipulation ($Revision: 1.7 $, $Date: 2001/10/26 19:46:03 $)
+perlfaq4 - Data Manipulation ($Revision: 1.8 $, $Date: 2001/11/09 08:06:04 $)
 
 =head1 DESCRIPTION
 
@@ -136,13 +136,15 @@ functions is that it works with numbers of ANY size, that it is
 optimized for speed on some operations, and for at least some
 programmers the notation might be familiar.
 
+=over 4
+
 =item B<How do I convert Hexadecimal into decimal:>
 
 Using perl's built in conversion of 0x notation:
 
     $int = 0xDEADBEEF;
     $dec = sprintf("%d", $int);
- 
+
 Using the hex function:
 
     $int = hex("DEADBEEF");
@@ -247,6 +249,7 @@ Using Bit::Vector:
 The remaining transformations (e.g. hex -> oct, bin -> hex, etc.)
 are left as an exercise to the inclined reader.
 
+=back
 
 =head2 Why doesn't & work the way I want it to?
 
@@ -322,7 +325,7 @@ will not create a list of 500,000 integers.
 
 =head2 How can I output Roman numerals?
 
-Get the http://www.perl.com/CPAN/modules/by-module/Roman module.
+Get the http://www.cpan.org/modules/by-module/Roman module.
 
 =head2 Why aren't my random numbers random?
 
@@ -334,7 +337,7 @@ than more.
 
 Computers are good at being predictable and bad at being random
 (despite appearances caused by bugs in your programs :-).
-http://www.perl.com/CPAN/doc/FMTEYEWTK/random , courtesy of Tom
+http://www.cpan.org/doc/FMTEYEWTK/random , courtesy of Tom
 Phoenix, talks more about this.  John von Neumann said, ``Anyone who
 attempts to generate random numbers by deterministic means is, of
 course, living in a state of sin.''
@@ -1473,7 +1476,7 @@ If you need to sort on several fields, the following paradigm is useful.
 This can be conveniently combined with precalculation of keys as given
 above.
 
-See http://www.perl.com/CPAN/doc/FMTEYEWTK/sort.html for more about
+See http://www.cpan.org/doc/FMTEYEWTK/sort.html for more about
 this approach.
 
 See also the question below on sorting hashes.
@@ -1849,7 +1852,7 @@ in L<perltoot>.
 
 =head2 How can I use a reference as a hash key?
 
-You can't do this directly, but you could use the standard Tie::Refhash
+You can't do this directly, but you could use the standard Tie::RefHash
 module distributed with Perl.
 
 =head1 Data: Misc
diff --git a/pod/perlfaq5.pod b/pod/perlfaq5.pod
index 95957eb204..28888f6f6c 100644
--- a/pod/perlfaq5.pod
+++ b/pod/perlfaq5.pod
@@ -1,6 +1,6 @@
 =head1 NAME
 
-perlfaq5 - Files and Formats ($Revision: 1.3 $, $Date: 2001/10/16 13:27:22 $)
+perlfaq5 - Files and Formats ($Revision: 1.4 $, $Date: 2001/11/09 08:06:04 $)
 
 =head1 DESCRIPTION
 
@@ -838,7 +838,7 @@ Or even:
 
 Otherwise you'll have to write your own multiplexing print
 function--or your own tee program--or use Tom Christiansen's,
-at http://www.perl.com/CPAN/authors/id/TOMC/scripts/tct.gz , which is
+at http://www.cpan.org/authors/id/TOMC/scripts/tct.gz , which is
 written in Perl and offers much greater functionality
 than the stock version.
 
@@ -1130,7 +1130,7 @@ documentation for details.
 
 This is elaborately and painstakingly described in the "Far More Than
 You Ever Wanted To Know" in
-http://www.perl.com/CPAN/doc/FMTEYEWTK/file-dir-perms .
+http://www.cpan.org/doc/FMTEYEWTK/file-dir-perms .
 
 The executive summary: learn how your filesystem works.  The
 permissions on a file say what can happen to the data in that file.
diff --git a/pod/perlfaq6.pod b/pod/perlfaq6.pod
index 4a52259800..be7e8ecc73 100644
--- a/pod/perlfaq6.pod
+++ b/pod/perlfaq6.pod
@@ -1,6 +1,6 @@
 =head1 NAME
 
-perlfaq6 - Regexes ($Revision: 1.3 $, $Date: 2001/10/16 13:27:22 $)
+perlfaq6 - Regexes ($Revision: 1.4 $, $Date: 2001/11/09 08:06:04 $)
 
 =head1 DESCRIPTION
 
@@ -404,7 +404,7 @@ are many others.
 An elaborate subroutine (for 7-bit ASCII only) to pull out balanced
 and possibly nested single chars, like C<`> and C<'>, C<{> and C<}>,
 or C<(> and C<)> can be found in
-http://www.perl.com/CPAN/authors/id/TOMC/scripts/pull_quotes.gz .
+http://www.cpan.org/authors/id/TOMC/scripts/pull_quotes.gz .
 
 The C::Scan module from CPAN also contains such subs for internal use,
 but they are undocumented.
diff --git a/pod/perlfaq7.pod b/pod/perlfaq7.pod
index cabfca134b..e0b2e8e0fb 100644
--- a/pod/perlfaq7.pod
+++ b/pod/perlfaq7.pod
@@ -1,6 +1,6 @@
 =head1 NAME
 
-perlfaq7 - Perl Language Issues ($Revision: 1.3 $, $Date: 2001/10/19 14:39:24 $)
+perlfaq7 - Perl Language Issues ($Revision: 1.4 $, $Date: 2001/11/07 02:27:50 $)
 
 =head1 DESCRIPTION
 
@@ -183,17 +183,9 @@ L<perlobj> and L<perlbot>.
 
 =head2 How can I tell if a variable is tainted?
 
-See L<perlsec/"Laundering and Detecting Tainted Data">.  Here's an
-example (which doesn't use any system calls, because the kill()
-is given no processes to signal):
-
-    sub is_tainted {
-	return ! eval { join('',@_), kill 0; 1; };
-    }
-
-This is not C<-w> clean, however.  There is no C<-w> clean way to
-detect taintedness--take this as a hint that you should untaint
-all possibly-tainted data.
+You can use the tainted() function of the Scalar::Util module, available
+from CPAN (or included with Perl since release 5.8.0).
+See also L<perlsec/"Laundering and Detecting Tainted Data">.
 
 =head2 What's a closure?
 
diff --git a/pod/perlfaq8.pod b/pod/perlfaq8.pod
index 19be3be74f..bf5d7a6a6f 100644
--- a/pod/perlfaq8.pod
+++ b/pod/perlfaq8.pod
@@ -1,6 +1,6 @@
 =head1 NAME
 
-perlfaq8 - System Interaction ($Revision: 1.2 $, $Date: 2001/10/16 13:27:22 $)
+perlfaq8 - System Interaction ($Revision: 1.4 $, $Date: 2001/11/09 08:06:04 $)
 
 =head1 DESCRIPTION
 
@@ -635,7 +635,7 @@ STDOUT).
 Note that you I<must> use Bourne shell (sh(1)) redirection syntax in
 backticks, not csh(1)!  Details on why Perl's system() and backtick
 and pipe opens all use the Bourne shell are in
-http://www.perl.com/CPAN/doc/FMTEYEWTK/versus/csh.whynot .
+http://www.cpan.org/doc/FMTEYEWTK/versus/csh.whynot .
 To capture a command's STDERR and STDOUT together:
 
     $output = `cmd 2>&1`;                       # either with backticks
@@ -811,7 +811,7 @@ causes many inefficiencies.
 =head2 Can I use perl to run a telnet or ftp session?
 
 Try the Net::FTP, TCP::Client, and Net::Telnet modules (available from
-CPAN).  http://www.perl.com/CPAN/scripts/netstuff/telnet.emul.shar
+CPAN).  http://www.cpan.org/scripts/netstuff/telnet.emul.shar
 will also help for emulating the telnet protocol, but Net::Telnet is
 quite probably easier to use..
 
@@ -953,9 +953,8 @@ in L<perlfunc/fork>.
 =head2 How do I use an SQL database?
 
 There are a number of excellent interfaces to SQL databases.  See the
-DBD::* modules available from http://www.perl.com/CPAN/modules/DBD .
-A lot of information on this can be found at 
-http://www.symbolstone.org/technology/perl/DBI/
+DBD::* modules available from http://www.cpan.org/modules/DBD .
+A lot of information on this can be found at http://dbi.perl.org/
 
 =head2 How do I make a system() exit on control-C?
 
diff --git a/pod/perlfaq9.pod b/pod/perlfaq9.pod
index 62e3069c41..cdc00d6755 100644
--- a/pod/perlfaq9.pod
+++ b/pod/perlfaq9.pod
@@ -1,6 +1,6 @@
 =head1 NAME
 
-perlfaq9 - Networking ($Revision: 1.4 $, $Date: 2001/10/31 23:54:56 $)
+perlfaq9 - Networking ($Revision: 1.5 $, $Date: 2001/11/09 08:06:04 $)
 
 =head1 DESCRIPTION
 
@@ -115,7 +115,7 @@ Here's one "simple-minded" approach, that works for most files:
 
 If you want a more complete solution, see the 3-stage striphtml
 program in
-http://www.perl.com/CPAN/authors/Tom_Christiansen/scripts/striphtml.gz
+http://www.cpan.org/authors/Tom_Christiansen/scripts/striphtml.gz
 .
 
 Here are some tricky cases that you should think about when picking
@@ -272,7 +272,7 @@ with a complete URL. This redirection is handled by the web browser.
 
       use CGI qw/:standard/;
 
-      my $url = 'http://www.perl.com/CPAN/';
+      my $url = 'http://www.cpan.org/';
       print redirect($url);
 
 
@@ -377,7 +377,7 @@ mail addresses with a simple regex, such as
 C</^[\w.-]+\@(?:[\w-]+\.)+\w+$/>.  It's a very bad idea.  However,
 this also throws out many valid ones, and says nothing about
 potential deliverability, so it is not suggested.  Instead, see
-http://www.perl.com/CPAN/authors/Tom_Christiansen/scripts/ckaddr.gz,
+http://www.cpan.org/authors/Tom_Christiansen/scripts/ckaddr.gz,
 which actually checks against the full RFC spec (except for nested
 comments), looks for addresses you may not wish to accept mail to
 (say, Bill Clinton or your postmaster), and then makes sure that the
diff --git a/pod/perlfilter.pod b/pod/perlfilter.pod
index 4221371a05..0103f8cfa3 100644
--- a/pod/perlfilter.pod
+++ b/pod/perlfilter.pod
@@ -527,7 +527,7 @@ blocks get included.
 Once you can identify individual blocks, try allowing them to be
 nested. That isn't difficult either.
 
-Here is a interesting idea that doesn't involve the Debug filter.
+Here is an interesting idea that doesn't involve the Debug filter.
 Currently Perl subroutines have fairly limited support for formal
 parameter lists. You can specify the number of parameters and their
 type, but you still have to manually take them out of the C<@_> array
diff --git a/pod/perlfunc.pod b/pod/perlfunc.pod
index 8722105c2b..679fe3734f 100644
--- a/pod/perlfunc.pod
+++ b/pod/perlfunc.pod
@@ -69,7 +69,7 @@ last value in the list.  Some operators return a count of successful
 operations.  In general, they do what you want, unless you want
 consistency.
 
-An named array in scalar context is quite different from what would at
+A named array in scalar context is quite different from what would at
 first glance appear to be a list in scalar context.  You can't get a list
 like C<(1,2,3)> into being in scalar context, because the compiler knows
 the context at compile time.  It would generate the scalar comma operator
@@ -448,13 +448,22 @@ L<perlipc/"Sockets: Client/Server Communication">.
 Arranges for FILEHANDLE to be read or written in "binary" or "text" mode
 on systems where the run-time libraries distinguish between binary and
 text files.  If FILEHANDLE is an expression, the value is taken as the
-name of the filehandle.  DISCIPLINE can be either of C<":raw"> for
-binary mode or C<":crlf"> for "text" mode.  If the DISCIPLINE is
-omitted, it defaults to C<":raw">.  Returns true on success, C<undef> on
-failure.
+name of the filehandle.  DISCIPLINE can be either of C<:raw> for
+binary mode or C<:crlf> for "text" mode.  If the DISCIPLINE is
+omitted, it defaults to C<:raw>.  Returns true on success, C<undef> on
+failure.  The C<:raw> are C<:clrf>, and any other directives of the
+form C<:...>, are called I/O I<disciplines>.
 
-binmode() should be called after open() but before any I/O is done on
-the filehandle.
+The C<open> pragma can be used to establish default I/O disciplines.
+See L<open>.
+
+In general, binmode() should be called after open() but before any I/O
+is done on the filehandle.  Calling binmode() will flush any possibly
+pending buffered input or output data on the handle.  The only
+exception to this is the C<:encoding> discipline that changes
+the default character encoding of the handle, see L<open>.
+The C<:encoding> discipline sometimes needs to be called in
+mid-stream, and it doesn't flush the stream.
 
 On some systems binmode() is necessary when you're not working with a
 text file.  For the sake of portability it is a good idea to always use
@@ -463,9 +472,6 @@ it when appropriate, and to never use it when it isn't appropriate.
 In other words:  Regardless of platform, use binmode() on binary
 files, and do not use binmode() on text files.
 
-The C<open> pragma can be used to establish default disciplines.
-See L<open>.
-
 The operating system, device drivers, C libraries, and Perl run-time
 system all work together to let the programmer treat a single
 character (C<\n>) as the line terminator, irrespective of the external
@@ -592,7 +598,7 @@ module:
 
 =item chomp VARIABLE
 
-=item chomp LIST
+=item chomp( LIST )
 
 =item chomp
 
@@ -626,7 +632,7 @@ characters removed is returned.
 
 =item chop VARIABLE
 
-=item chop LIST
+=item chop( LIST )
 
 =item chop
 
@@ -857,7 +863,7 @@ back.  Look at the F<by-module/Crypt> and F<by-module/PGP> directories
 on your favorite CPAN mirror for a slew of potentially useful
 modules.
 
-If using crypt() on an Unicode string (which potentially has
+If using crypt() on a Unicode string (which potentially has
 characters with codepoints above 255), Perl tries to make sense of
 the situation by using only the low eight bits of the characters when
 calling crypt().
@@ -1195,7 +1201,7 @@ C code have superseded it.
 If you're looking to use L<dump> to speed up your program, consider
 generating bytecode or native C code as described in L<perlcc>.  If
 you're just trying to accelerate a CGI script, consider using the
-C<mod_perl> extension to B<Apache>, or the CPAN module, Fast::CGI.
+C<mod_perl> extension to B<Apache>, or the CPAN module, CGI::Fast.
 You might also consider autoloading or selfloading, which at least
 make your program I<appear> to run faster.
 
@@ -2004,7 +2010,7 @@ C<File::Glob> extension.  See L<File::Glob> for details.
 
 =item gmtime EXPR
 
-Converts a time as returned by the time function to a 8-element list
+Converts a time as returned by the time function to an 8-element list
 with the time localized for the standard Greenwich time zone.
 Typically used as follows:
 
@@ -2327,7 +2333,7 @@ C<redo> work.
 
 =item lc
 
-Returns an lowercased version of EXPR.  This is the internal function
+Returns a lowercased version of EXPR.  This is the internal function
 implementing the C<\L> escape in double-quoted strings.  Respects
 current LC_CTYPE locale if C<use locale> in force.  See L<perllocale>
 and L<perlunicode> for more details about locale and Unicode support.
@@ -2438,9 +2444,9 @@ and the month of the year, may not necessarily be three characters wide.
 This function places an advisory lock on a variable, subroutine,
 or referenced object contained in I<THING> until the lock goes out
 of scope.  This is a built-in function only if your version of Perl
-was built with threading enabled, and if you've said C<use Threads>.
-Otherwise a user-defined function by this name will be called.  See
-L<Thread>.
+was built with threading enabled, and if you've said C<use Thread>.
+Otherwise a user-defined function by this name will be called.
+See L<Thread>.
 
 =item log EXPR
 
@@ -2659,33 +2665,39 @@ conversion assumes base 10.)
 =item open FILEHANDLE
 
 Opens the file whose filename is given by EXPR, and associates it with
-FILEHANDLE.  If FILEHANDLE is an undefined lexical (C<my>) variable the variable is
-assigned a reference to a new anonymous filehandle, otherwise if FILEHANDLE is an expression,
-its value is used as the name of the real filehandle wanted.  (This is considered a symbolic
-reference, so C<use strict 'refs'> should I<not> be in effect.)
-
-If EXPR is omitted, the scalar
-variable of the same name as the FILEHANDLE contains the filename.
-(Note that lexical variables--those declared with C<my>--will not work
-for this purpose; so if you're using C<my>, specify EXPR in your call
-to open.)  See L<perlopentut> for a kinder, gentler explanation of opening
-files.
-
-If three or more arguments are specified then the mode of opening and the file name
-are separate. If MODE is C<< '<' >> or nothing, the file is opened for input.
-If MODE is C<< '>' >>, the file is truncated and opened for
-output, being created if necessary.  If MODE is C<<< '>>' >>>,
+FILEHANDLE.
+
+(The following is a comprehensive reference to open(): for a gentler
+introduction you may consider L<perlopentut>.)
+
+If FILEHANDLE is an undefined lexical (C<my>) variable the variable is
+assigned a reference to a new anonymous filehandle, otherwise if
+FILEHANDLE is an expression, its value is used as the name of the real
+filehandle wanted.  (This is considered a symbolic reference, so C<use
+strict 'refs'> should I<not> be in effect.)
+
+If EXPR is omitted, the scalar variable of the same name as the
+FILEHANDLE contains the filename.  (Note that lexical variables--those
+declared with C<my>--will not work for this purpose; so if you're
+using C<my>, specify EXPR in your call to open.) 
+
+If three or more arguments are specified then the mode of opening and
+the file name are separate. If MODE is C<< '<' >> or nothing, the file
+is opened for input.  If MODE is C<< '>' >>, the file is truncated and
+opened for output, being created if necessary.  If MODE is C<<< '>>' >>>,
 the file is opened for appending, again being created if necessary.
-You can put a C<'+'> in front of the C<< '>' >> or C<< '<' >> to indicate that
-you want both read and write access to the file; thus C<< '+<' >> is almost
-always preferred for read/write updates--the C<< '+>' >> mode would clobber the
-file first.  You can't usually use either read-write mode for updating
-textfiles, since they have variable length records.  See the B<-i>
-switch in L<perlrun> for a better approach.  The file is created with
-permissions of C<0666> modified by the process' C<umask> value.
 
-These various prefixes correspond to the fopen(3) modes of C<'r'>, C<'r+'>,
-C<'w'>, C<'w+'>, C<'a'>, and C<'a+'>.
+You can put a C<'+'> in front of the C<< '>' >> or C<< '<' >> to
+indicate that you want both read and write access to the file; thus
+C<< '+<' >> is almost always preferred for read/write updates--the C<<
+'+>' >> mode would clobber the file first.  You can't usually use
+either read-write mode for updating textfiles, since they have
+variable length records.  See the B<-i> switch in L<perlrun> for a
+better approach.  The file is created with permissions of C<0666>
+modified by the process' C<umask> value.
+
+These various prefixes correspond to the fopen(3) modes of C<'r'>,
+C<'r+'>, C<'w'>, C<'w+'>, C<'a'>, and C<'a+'>.
 
 In the 2-arguments (and 1-argument) form of the call the mode and
 filename should be concatenated (in this order), possibly separated by
@@ -2701,38 +2713,46 @@ that pipes both in I<and> out, but see L<IPC::Open2>, L<IPC::Open3>,
 and L<perlipc/"Bidirectional Communication with Another Process">
 for alternatives.)
 
-For three or more arguments if MODE is C<'|-'>, the filename is interpreted as a
-command to which output is to be piped, and if MODE is
-C<'-|'>, the filename is interpreted as a command which pipes output to
-us.  In the 2-arguments (and 1-argument) form one should replace dash
-(C<'-'>) with the command.  See L<perlipc/"Using open() for IPC">
-for more examples of this.  (You are not allowed to C<open> to a command
-that pipes both in I<and> out, but see L<IPC::Open2>, L<IPC::Open3>,
-and L<perlipc/"Bidirectional Communication"> for alternatives.) In 3+ arg form of
-pipe opens then if LIST is specified (extra arguments after the command name) then
-LIST becomes arguments to the command invoked if the platform supports it.
-The meaning of C<open> with more than three arguments for non-pipe modes
-is not yet specified. Experimental "layers" may give extra LIST arguments meaning.
+For three or more arguments if MODE is C<'|-'>, the filename is
+interpreted as a command to which output is to be piped, and if MODE
+is C<'-|'>, the filename is interpreted as a command which pipes
+output to us.  In the 2-arguments (and 1-argument) form one should
+replace dash (C<'-'>) with the command.
+See L<perlipc/"Using open() for IPC"> for more examples of this.
+(You are not allowed to C<open> to a command that pipes both in I<and>
+out, but see L<IPC::Open2>, L<IPC::Open3>, and
+L<perlipc/"Bidirectional Communication"> for alternatives.)
+
+In the three-or-more argument form of pipe opens, if LIST is specified
+(extra arguments after the command name) then LIST becomes arguments
+to the command invoked if the platform supports it.  The meaning of
+C<open> with more than three arguments for non-pipe modes is not yet
+specified. Experimental "layers" may give extra LIST arguments
+meaning.
 
 In the 2-arguments (and 1-argument) form opening C<'-'> opens STDIN
 and opening C<< '>-' >> opens STDOUT.
 
-Open returns
-nonzero upon success, the undefined value otherwise.  If the C<open>
-involved a pipe, the return value happens to be the pid of the
-subprocess.
+You may use the three-argument form of open to specify
+I<I/O disciplines> that affect how the input and output
+are processed: see L</binmode> and L<open>.
+
+Open returns nonzero upon success, the undefined value otherwise.  If
+the C<open> involved a pipe, the return value happens to be the pid of
+the subprocess.
 
-If you're unfortunate enough to be running Perl on a system that
-distinguishes between text files and binary files (modern operating
-systems don't care), then you should check out L</binmode> for tips for
-dealing with this.  The key distinction between systems that need C<binmode>
-and those that don't is their text file formats.  Systems like Unix, MacOS, and
-Plan9, which delimit lines with a single character, and which encode that
-character in C as C<"\n">, do not need C<binmode>.  The rest need it.
+If you're running Perl on a system that distinguishes between text
+files and binary files, then you should check out L</binmode> for tips
+for dealing with this.  The key distinction between systems that need
+C<binmode> and those that don't is their text file formats.  Systems
+like Unix, MacOS, and Plan9, which delimit lines with a single
+character, and which encode that character in C as C<"\n">, do not
+need C<binmode>.  The rest need it.
 
-In the three argument form MODE may also contain a list of IO "layers" (see L<open> and
-L<PerlIO> for more details) to be applied to the handle. This can be used to achieve the
-effect of C<binmode> as well as more complex behaviours.
+In the three argument form MODE may also contain a list of IO "layers"
+(see L<open> and L<PerlIO> for more details) to be applied to the
+handle. This can be used to achieve the effect of C<binmode> as well
+as more complex behaviours.
 
 When opening a file, it's usually a bad idea to continue normal execution
 if the request failed, so C<open> is frequently used in connection with
@@ -2742,14 +2762,13 @@ modules that can help with that problem)) you should always check
 the return value from opening a file.  The infrequent exception is when
 working with an unopened filehandle is actually what you want to do.
 
-As a special case the 3 arg form with a read/write mode and the third argument
-being C<undef>:
+As a special case the 3 arg form with a read/write mode and the third
+argument being C<undef>:
 
     open(TMP, "+>", undef) or die ...
 
 opens a filehandle to an anonymous temporary file.
 
-
 Examples:
 
     $ARTICLE = 100;
@@ -2887,17 +2906,16 @@ supported on some platforms (see L<perlport>).  To be safe, you may need
 to set C<$|> ($AUTOFLUSH in English) or call the C<autoflush()> method
 of C<IO::Handle> on any open handles.
 
-On systems that support a
-close-on-exec flag on files, the flag will be set for the newly opened
-file descriptor as determined by the value of $^F.  See L<perlvar/$^F>.
+On systems that support a close-on-exec flag on files, the flag will
+be set for the newly opened file descriptor as determined by the value
+of $^F.  See L<perlvar/$^F>.
 
 Closing any piped filehandle causes the parent process to wait for the
 child to finish, and returns the status value in C<$?>.
 
-The filename passed to 2-argument (or 1-argument) form of open()
-will have leading and trailing
-whitespace deleted, and the normal redirection characters
-honored.  This property, known as "magic open",
+The filename passed to 2-argument (or 1-argument) form of open() will
+have leading and trailing whitespace deleted, and the normal
+redirection characters honored.  This property, known as "magic open",
 can often be used to good effect.  A user could specify a filename of
 F<"rsh cat file |">, or you could change certain filenames as needed:
 
@@ -3925,7 +3943,7 @@ may vary from one execution to the next (see C<wantarray>).  If no EXPR
 is given, returns an empty list in list context, the undefined value in
 scalar context, and (of course) nothing at all in a void context.
 
-(Note that in the absence of a explicit C<return>, a subroutine, eval,
+(Note that in the absence of an explicit C<return>, a subroutine, eval,
 or do FILE will automatically return the value of the last expression
 evaluated.)
 
diff --git a/pod/perlguts.pod b/pod/perlguts.pod
index 8ccdde8fa8..8a1d511cde 100644
--- a/pod/perlguts.pod
+++ b/pod/perlguts.pod
@@ -405,7 +405,7 @@ specified below.
             /* Get the key from an HE structure and also return
                the length of the key string */
     SV*    hv_iterval(HV*, HE* entry);
-            /* Return a SV pointer to the value of the HE
+            /* Return an SV pointer to the value of the HE
                structure */
     SV*    hv_iternextsv(HV*, char** key, I32* retlen);
             /* This convenience routine combines hv_iternext,
@@ -609,7 +609,7 @@ package.
 
 =head2 Reference Counts and Mortality
 
-Perl uses an reference count-driven garbage collection mechanism. SVs,
+Perl uses a reference count-driven garbage collection mechanism. SVs,
 AVs, or HVs (xV for short in the following) start their life with a
 reference count of 1.  If the reference count of an xV ever drops to 0,
 then it will be destroyed and its memory made available for reuse.
@@ -866,7 +866,7 @@ was initially made magical.
 
 =head2 Magic Virtual Tables
 
-The C<mg_virtual> field in the C<MAGIC> structure is a pointer to a
+The C<mg_virtual> field in the C<MAGIC> structure is a pointer to an
 C<MGVTBL>, which is a structure of function pointers and stands for
 "Magic Virtual Table" to handle the various operations that might be
 applied to that variable.
@@ -1255,7 +1255,7 @@ C<sarg> of C<SV*> of length C<maxsarg>.
 
 =item C<SV* save_svref(SV **sptr)>
 
-Similar to C<save_scalar>, but will reinstate a C<SV *>.
+Similar to C<save_scalar>, but will reinstate an C<SV *>.
 
 =item C<void save_aptr(AV **aptr)>
 
@@ -1695,7 +1695,7 @@ C<sv_dump> to produce debugging output from Perl-space, so users of that
 module should already be familiar with its format.
 
 C<Perl_op_dump> can be used to dump an C<OP> structure or any of its
-derivatives, and produces output similiar to C<perl -Dx>; in fact,
+derivatives, and produces output similar to C<perl -Dx>; in fact,
 C<Perl_dump_eval> will dump the main root of the code being evaluated,
 exactly like C<-Dx>.
 
diff --git a/pod/perlhack.pod b/pod/perlhack.pod
index 6f11044a80..49d7625ab0 100644
--- a/pod/perlhack.pod
+++ b/pod/perlhack.pod
@@ -1531,47 +1531,42 @@ tests to the end. First, we'll test that the C<U> does indeed create
 Unicode strings.  
 
 t/op/pack.t has a sensible ok() function, but if it didn't we could
-write one easily.
+use the one from t/test.pl.
 
-    my $test = 1;
-    sub ok {
-        my($ok, $name) = @_;
-
-        # You have to do it this way or VMS will get confused.
-        print $ok ? "ok $test - $name\n" : "not ok $test - $name\n";
-
-        printf "# Failed test at line %d\n", (caller)[2] unless $ok;
-
-        $test++;
-        return $ok;
-    }
+ require './test.pl';
+ plan( tests => 159 );
 
 so instead of this:
 
  print 'not ' unless "1.20.300.4000" eq sprintf "%vd", pack("U*",1,20,300,4000);
  print "ok $test\n"; $test++;
 
-we can write the (somewhat) more sensible:
+we can write the more sensible (see L<Test::More> for a full
+explanation of is() and other testing functions).
 
- ok( "1.20.300.4000" eq sprintf "%vd", pack("U*",1,20,300,4000), 
+ is( "1.20.300.4000", sprintf "%vd", pack("U*",1,20,300,4000), 
                                        "U* produces unicode" );
 
 Now we'll test that we got that space-at-the-beginning business right:
 
- ok( "1.20.300.4000" eq sprintf "%vd", pack("  U*",1,20,300,4000),
+ is( "1.20.300.4000", sprintf "%vd", pack("  U*",1,20,300,4000),
                                        "  with spaces at the beginning" );
 
 And finally we'll test that we don't make Unicode strings if C<U> is B<not>
 the first active format:
 
- ok( v1.20.300.4000 ne  sprintf "%vd", pack("C0U*",1,20,300,4000),
+ isnt( v1.20.300.4000, sprintf "%vd", pack("C0U*",1,20,300,4000),
                                        "U* not first isn't unicode" );
 
-Mustn't forget to change the number of tests which appears at the top, or
-else the automated tester will get confused:
+Mustn't forget to change the number of tests which appears at the top,
+or else the automated tester will get confused.  This will either look
+like this:
 
- -print "1..156\n";
- +print "1..159\n";
+ print "1..156\n";
+
+or this:
+
+ plan( tests => 156 );
 
 We now compile up Perl, and run it through the test suite. Our new
 tests pass, hooray!
@@ -1643,7 +1638,7 @@ extremely important to test any addition thoroughly and add new tests
 to explore all boundary conditions that your new function is expected
 to handle.  If your new function is used only by one module (e.g. toke),
 then it should probably be named S_your_function (for static); on the
-other hand, if you expect it to accessable from other functions in
+other hand, if you expect it to accessible from other functions in
 Perl, you should name it Perl_your_function.  See L<perlguts/Internal Functions>
 for more details.
 
@@ -1684,7 +1679,7 @@ Lastly, TEST TEST TEST TEST TEST any code before posting to p5p.
 Test on as many platforms as you can find.  Test as many perl
 Configure options as you can (e.g. MULTIPLICITY).  If you have
 profiling or memory tools, see L<EXTERNAL TOOLS FOR DEBUGGING PERL>
-below for how to use them to futher test your code.  Remember that
+below for how to use them to further test your code.  Remember that
 most of the people on P5P are doing this on their own time and
 don't have the time to debug your code.
 
@@ -1717,7 +1712,7 @@ I<really> broken.
 =item F<t/cmd/>
 
 These test the basic control structures, C<if/else>, C<while>,
-subroutines, etc... 
+subroutines, etc.
 
 =item F<t/comp/>
 
@@ -1754,11 +1749,35 @@ The core uses the same testing style as the rest of Perl, a simple
 "ok/not ok" run through Test::Harness, but there are a few special
 considerations.
 
-For most libraries and extensions, you'll want to use the Test::More
-library rather than rolling your own test functions.  If a module test
-doesn't use Test::More, consider rewriting it so it does.  For the
-rest it's best to use a simple C<print "ok $test_num\n"> style to avoid
-broken core functionality from causing the whole test to collapse.
+There are three ways to write a test in the core.  Test::More,
+t/test.pl and ad hoc C<print $test ? "ok 42\n" : "not ok 42\n">.  The
+decision of which to use depends on what part of the test suite you're
+working on.  This is a measure to prevent a high-level failure (such
+as Config.pm breaking) from causing basic functionality tests to fail.
+
+=over 4 
+
+=item t/base t/comp
+
+Since we don't know if require works, or even subroutines, use ad hoc
+tests for these two.  Step carefully to avoid using the feature being
+tested.
+
+=item t/cmd t/run t/io t/op
+
+Now that basic require() and subroutines are tested, you can use the
+t/test.pl library which emulates the important features of Test::More
+while using a minimum of core features.
+
+You can also conditionally use certain libraries like Config, but be
+sure to skip the test gracefully if it's not there.
+
+=item t/lib ext lib
+
+Now that the core of Perl is tested, Test::More can be used.  You can
+also use the full suite of core modules in the tests.
+
+=back
 
 When you say "make test" Perl uses the F<t/TEST> program to run the
 test suite.  All tests are run from the F<t/> directory, B<not> the
diff --git a/pod/perlintern.pod b/pod/perlintern.pod
index 6ca016cfcc..544b87887f 100644
--- a/pod/perlintern.pod
+++ b/pod/perlintern.pod
@@ -131,7 +131,7 @@ Found in file sv.c
 
 Function called by C<do_readline> to spawn a glob (or do the glob inside
 perl on VMS). This code used to be inline, but now perl uses C<File::Glob>
-this glob starter is only used by miniperl during the build proccess.
+this glob starter is only used by miniperl during the build process.
 Moving it away shrinks pp_hot.c; shrinking pp_hot.c helps speed perl up.
 
 	PerlIO*	start_glob(SV* pattern, IO *io)
diff --git a/pod/perlintro.pod b/pod/perlintro.pod
index ee4a0118c8..cde6742746 100644
--- a/pod/perlintro.pod
+++ b/pod/perlintro.pod
@@ -169,7 +169,7 @@ The elements we're getting from the array start with a C<$> because
 we're getting just a single value out of the array -- you ask for a scalar, 
 you get a scalar.
 
-To get multiple values from a array:
+To get multiple values from an array:
 
     @animals[0,1];                  # gives ("camel", "llama");
     @animals[0..2];                 # gives ("camel", "llama", "owl");
diff --git a/pod/perliol.pod b/pod/perliol.pod
index 037c9f4a8f..e51f309106 100644
--- a/pod/perliol.pod
+++ b/pod/perliol.pod
@@ -19,7 +19,7 @@ C<USE_SFIO> is not).
 
 The PerlIO abstraction was introduced in perl5.003_02 but languished as
 just an abstraction until perl5.7.0. However during that time a number
-of perl extentions switched to using it, so the API is mostly fixed to
+of perl extensions switched to using it, so the API is mostly fixed to
 maintain (source) compatibility.
 
 The aim of the implementation is to provide the PerlIO API in a flexible
@@ -53,7 +53,7 @@ The basic data structure is a PerlIOl:
 	 IV		flags;      /* Various flags for state */
 	};
 
-A C<PerlIOl *> is a pointer to to the struct, and the I<application> level
+A C<PerlIOl *> is a pointer to the struct, and the I<application> level
 C<PerlIO *> is a pointer to a C<PerlIOl *> - i.e. a pointer to a pointer to
 the struct. This allows the application level C<PerlIO *> to remain
 constant while the actual C<PerlIOl *> underneath changes. (Compare perl's
@@ -69,9 +69,13 @@ A "layer" is composed of two parts:
 
 =over 4
 
-=item 1. The functions and attributes of the "layer class".
+=item 1.
+
+The functions and attributes of the "layer class".
+
+=item 2.
 
-=item 2. The per-instance data for a particular handle.
+The per-instance data for a particular handle.
 
 =back
 
@@ -214,7 +218,7 @@ not having a buffer layer.
 
 Extra layers can be inserted to process the data as it flows through.
 This was the driving need for including the scheme in perl 5.7.0+ - we
-needed a mechanism to allow data to be translated bewteen perl's
+needed a mechanism to allow data to be translated between perl's
 internal encoding (conceptually at least Unicode as UTF-8), and the
 "native" format used by the system. This is provided by the
 ":encoding(xxxx)" layer which typically sits above the buffering layer.
@@ -248,7 +252,7 @@ Reads are permitted i.e. opened "r" or "w+" (or even "a+" - ick).
 
 =item PERLIO_F_ERROR
 
-An error has occured (for C<PerlIO_error()>)
+An error has occurred (for C<PerlIO_error()>)
 
 =item PERLIO_F_TRUNCATE
 
@@ -305,10 +309,10 @@ Handle is open.
 
 This instance of this layer supports the "fast C<gets>" interface.
 Normally set based on C<PERLIO_K_FASTGETS> for the class and by the
-existance of the function(s) in the table. However a class that
+existence of the function(s) in the table. However a class that
 normally provides that interface may need to avoid it on a
 particular instance. The "pending" layer needs to do this when
-it is pushed above an layer which does not support the interface.
+it is pushed above a layer which does not support the interface.
 (Perl's C<sv_gets()> does not expect the streams fast C<gets> behaviour
 to change during one "get".)
 
@@ -320,7 +324,7 @@ to change during one "get".)
 
 =item  IV		(*Pushed)(PerlIO *f,const char *mode, SV *arg);
 
-The only absoultely mandatory method. Called when the layer is pushed onto the stack.
+The only absolutely mandatory method. Called when the layer is pushed onto the stack.
 The C<mode> argument may  be NULL if this occurs post-open. The C<arg> will be non-C<NULL>
 if an argument string was passed. In most cases this should call
 C<PerlIOBase_pushed()> to convert C<mode> into the appropriate
@@ -366,15 +370,15 @@ The C<'I'> prefix is used during creation of C<stdin>..C<stderr> via special
 C<PerlIO_fdopen> calls; the C<'#'> prefix means that this is C<sysopen> and that I<imode> and
 I<perm> should be passed to C<PerlLIO_open3>; C<'r'> means B<r>ead, C<'w'> means B<w>rite
 and C<'a'> means B<a>ppend. The C<'+'> suffix means that both reading and writing/appending
-are permited. The C<'b'> suffix means file should be binary, and C<'t'> means it
+are permitted. The C<'b'> suffix means file should be binary, and C<'t'> means it
 is text. (Binary/Text should be ignored by almost all layers and binary IO done,
 with PerlIO. The C<:crlf> layer should be pushed to handle the distinction.)
 
-If I<old> is not C<NULL> then this is a C<PerlIO_reopen>. Perl iteself does not use
+If I<old> is not C<NULL> then this is a C<PerlIO_reopen>. Perl itself does not use
 this (yet?) and semantics are a little vague.
 
 If I<fd> not negative then it is the numeric file descriptor I<fd>, which will
-be open in an manner compatible with the supplied mode string, the call is
+be open in a manner compatible with the supplied mode string, the call is
 thus equivalent to C<PerlIO_fdopen>. In this case I<nargs> will be zero.
 
 If I<nargs> is greater than zero then it gives the number of arguments passed
@@ -383,7 +387,7 @@ In simple cases SvPV(*args) is the pathname to open.
 
 Having said all that translation-only layers do not need to provide C<Open()> at all,
 but rather leave the opening to a lower level layer and wait to be "pushed".
-If a layer does provide C<Open()> it should normaly call the C<Open()> method
+If a layer does provide C<Open()> it should normally call the C<Open()> method
 of next layer down (if any) and then push itself on top if that succeeds.
 
 =item SV *		(*Getarg)(PerlIO *f);
@@ -394,7 +398,7 @@ return an SvPV with value "ascii".
 
 =item IV	(*Fileno)(PerlIO *f);
 
-Returns the Unix/Posix numeric file decriptor for the handle. Normally
+Returns the Unix/Posix numeric file descriptor for the handle. Normally
 C<PerlIOBase_fileno()> (which just asks next layer down) will suffice
 for this.
 
@@ -437,7 +441,7 @@ structure.
 
 Should make stream's state consistent with layers below. That is, any
 buffered write data should be written, and file position of lower layers
-adjusted for data read fron below but not actually consumed.
+adjusted for data read from below but not actually consumed.
 (Should perhaps C<Unread()> such data to the lower layer.)
 
 =item  IV		(*Fill)(PerlIO *f);
diff --git a/pod/perlipc.pod b/pod/perlipc.pod
index 56816b15d6..e591f54bf8 100644
--- a/pod/perlipc.pod
+++ b/pod/perlipc.pod
@@ -1218,8 +1218,8 @@ clear out.
 
 Once the generic server socket has been created using the parameters
 listed above, the server then waits for a new client to connect
-to it.  The server blocks in the C<accept> method, which eventually an
-bidirectional connection to the remote client.  (Make sure to autoflush
+to it.  The server blocks in the C<accept> method, which eventually accepts a
+bidirectional connection from the remote client.  (Make sure to autoflush
 this handle to circumvent buffering.)
 
 To add to user-friendliness, our server prompts the user for commands.
diff --git a/pod/perlmodinstall.pod b/pod/perlmodinstall.pod
index 0fc359e913..ea28725620 100644
--- a/pod/perlmodinstall.pod
+++ b/pod/perlmodinstall.pod
@@ -8,9 +8,9 @@ You can think of a module as the fundamental unit of reusable Perl
 code; See L<perlmod> for details.  Whenever anyone creates a chunk
 of Perl code that they think will be useful to the world, they
 register as a Perl developer at
-http://www.perl.com/CPAN/modules/04pause.html so that they can then
+http://www.cpan.org/modules/04pause.html so that they can then
 upload their code to CPAN.  CPAN is the Comprehensive Perl Archive
-Network and can be accessed at http://www.perl.com/CPAN/, or searched
+Network and can be accessed at http://www.cpan.org/, or searched
 via http://cpan.perl.com/ and
 http://theory.uwinnipeg.ca/mod_perl/cpan-search.pl .
 
@@ -57,7 +57,7 @@ B<If you're on Unix,>
 
 You can use Andreas Koenig's CPAN module
 (which comes standard with Perl, or can itself be downloaded
-from http://www.perl.com/CPAN/modules/by-module/CPAN)
+from http://www.cpan.org/modules/by-module/CPAN)
 to automate the following steps, from DECOMPRESS through INSTALL.
 
 A. DECOMPRESS
diff --git a/pod/perlmodlib.pod b/pod/perlmodlib.pod
index 53e491c8a2..80ad7c1de5 100644
--- a/pod/perlmodlib.pod
+++ b/pod/perlmodlib.pod
@@ -990,7 +990,7 @@ system B<man> command, you might try the B<perldoc> program.
 
 Extension modules are written in C (or a mix of Perl and C).  They
 are usually dynamically loaded into Perl if and when you need them,
-but may also be be linked in statically.  Supported extension modules
+but may also be linked in statically.  Supported extension modules
 include Socket, Fcntl, and POSIX.
 
 Many popular C extension modules do not come bundled (at least, not
diff --git a/pod/perlopentut.pod b/pod/perlopentut.pod
index a1d3955930..b158480935 100644
--- a/pod/perlopentut.pod
+++ b/pod/perlopentut.pod
@@ -765,7 +765,7 @@ uses locking and another doesn't, all bets are off.
 
 By default, the C<flock> call will block until a lock is granted.
 A request for a shared lock will be granted as soon as there is no
-exclusive locker.  A request for a exclusive lock will be granted as
+exclusive locker.  A request for an exclusive lock will be granted as
 soon as there is no locker of any kind.  Locks are on file descriptors,
 not file names.  You can't lock a file until you open it, and you can't
 hold on to a lock once the file has been closed.
diff --git a/pod/perlpod.pod b/pod/perlpod.pod
index 91cc81ac84..80c9ba134a 100644
--- a/pod/perlpod.pod
+++ b/pod/perlpod.pod
@@ -173,21 +173,21 @@ usually used just when you want to start a Pod block with an ordinary
 paragraph or a verbatim paragraph.  For example:
 
   =item stuff()
-  
+
   This function does stuff.
-  
+
   =cut
-  
+
   sub stuff {
     ...
   }
-  
+
   =pod
-  
+
   Remember to check its return value, as in:
-  
-    stuff() || die "Couldn't do stufF!";
-  
+
+    stuff() || die "Couldn't do stuff!";
+
   =cut
 
 =item C<=begin I<formatname>>
@@ -208,10 +208,10 @@ is meant for formatters that understand the special format
 called I<formatname>.  For example,
 
   =begin html
-  
+
   <hr> <img src="thang.png">
   <p> This is a raw HTML paragraph </p>
-  
+
   =end html
 
 The command "=for I<formatname> I<text...>"
@@ -613,7 +613,7 @@ wish to work around.
 =item *
 
 If you're more familiar with writing in HTML than with writing in Pod, you
-can try your hand at writing documentation in simple HTML, and coverting
+can try your hand at writing documentation in simple HTML, and converting
 it to Pod with the experimental L<Pod::HTML2Pod|Pod::HTML2Pod> module,
 (available in CPAN), and looking at the resulting code.  The experimental
 L<Pod::PXML|Pod::PXML> module in CPAN might also be useful.
@@ -626,7 +626,7 @@ line.  Having something like this:
 
  # - - - - - - - - - - - -
  =item $firecracker->boom()
- 
+
  This noisily detonates the firecracker object.
  =cut
  sub boom {
@@ -638,13 +638,13 @@ at all.
 Instead, have it like this:
 
  # - - - - - - - - - - - -
- 
+
  =item $firecracker->boom()
- 
+
  This noisily detonates the firecracker object.
- 
+
  =cut
- 
+
  sub boom {
  ...
 
diff --git a/pod/perlpodspec.pod b/pod/perlpodspec.pod
index 6b6e08d3a4..145309c58f 100644
--- a/pod/perlpodspec.pod
+++ b/pod/perlpodspec.pod
@@ -121,7 +121,7 @@ But they may span several (non-blank) lines:
   =for comment
   Hm, I wonder what it would look like if
   you tried to write a BNF for Pod from this.
-  
+
   =head3 Dr. Strangelove, or: How I Learned to
   Stop Worrying and Love the Bomb
 
@@ -176,11 +176,11 @@ For example: consider the following paragraphs:
   # <- that's the 0th column
 
   =head1 Foo
-  
+
   Stuff
-  
+
     $foo->bar
-  
+
   =cut
 
 Here, "=head1 Foo" and "=cut" are command paragraphs because the first
@@ -208,7 +208,7 @@ This command indicates that the text in the remainder of the paragraph
 is a heading.  That text may contain formatting codes.  Examples:
 
   =head1 Object Attributes
-  
+
   =head3 What B<Not> to Do!
 
 =item "=pod"
@@ -219,9 +219,9 @@ all.)  If there is any text in this command paragraph after "=pod",
 it must be ignored.  Examples:
 
   =pod
-  
+
   This is a plain Pod paragraph.
-  
+
   =pod This text is ignored.
 
 =item "=cut"
@@ -251,9 +251,9 @@ explained in the L</"About =over...=back Regions"> section, further
 below.  Formatting codes are not expanded.  Examples:
 
   =over 3
-  
+
   =over 3.5
-  
+
   =over
 
 =item "=item"
@@ -265,20 +265,20 @@ explained in the L</"About =over...=back Regions"> section, further
 below.  Examples:
 
   =item
-  
+
   =item *
-  
+
   =item      *    
-  
+
   =item 14
-  
+
   =item   3.
-  
+
   =item C<< $thing->stuff(I<dodad>) >>
-  
+
   =item For transporting us beyond seas to be tried for pretended
   offenses
-  
+
   =item He is at this time transporting large armies of foreign
   mercenaries to complete the works of death, desolation and
   tyranny, already begun with circumstances of cruelty and perfidy
@@ -320,9 +320,9 @@ L</About Data Paragraphs and "=beginE<sol>=end" Regions>.
 This is synonymous with:
 
      =begin formatname
-     
+
      text...
-     
+
      =end formatname
 
 That is, it creates a region consisting of a single paragraph; that
@@ -517,7 +517,7 @@ starting at line 123: 'Time objects are not...'").  So these
 two paragraphs:
 
   I<I told you not to do this!
-  
+
   Don't make me say it again!>
 
 ...must I<not> be parsed as two paragraphs in italics (with the I
@@ -526,7 +526,7 @@ the first paragraph should generate a warning, but that aside, the
 above code must parse as if it were:
 
   I<I told you not to do this!>
-  
+
   Don't make me say it again!E<gt>
 
 (In SGMLish jargon, all Pod commands are like block-level
@@ -645,11 +645,11 @@ version numbers of any modules it might be using to process the Pod.
 Minimal examples:
 
   %% POD::Pod2PS v3.14159, using POD::Parser v1.92
-  
+
   <!-- Pod::HTML v3.14159, using POD::Parser v1.92 -->
-  
+
   {\doccomm generated by Pod::Tree::RTF 3.14159 using Pod::Tree 1.08}
-  
+
   .\" Pod::Man version 3.14159, using POD::Parser version 1.92
 
 Formatters may also insert additional comments, including: the
@@ -758,7 +758,7 @@ the CE<lt>interest rate> attribute...'").
 Pod parsers, when processing a series of verbatim paragraphs one
 after another, should consider them to be one large verbatim
 paragraph that happens to contain blank lines.  I.e., these two
-lines, which have an blank line between them:
+lines, which have a blank line between them:
 
 	use Foo;
 
@@ -802,7 +802,7 @@ characters (also defined there by Unicode, with the same meaning),
 which all Pod formatters must render faithfully.  Characters
 in the ranges 0-31 and 127-159 should not be used (neither as
 literals, nor as EE<lt>number> codes), except for the
-literal byte-sequences for newline (13, 13 10, or 13), and tab (9).
+literal byte-sequences for newline (13, 13 10, or 10), and tab (9).
 
 Characters in the range 160-255 refer to Latin-1 characters (also
 defined there by Unicode, with the same meaning).  Characters above
@@ -861,7 +861,7 @@ it contains spaces, which aren't alphanumeric characters.  This
 presumably does not I<need> special treatment by a Pod processor;
 " 0 1 2 3 " doesn't look like a number in any base, so it would
 presumably be looked up in the table of HTML-like names.  Since
-there is (and cannot be) an HTML-like entity called " 0 1 2 3 ",
+there isn't (and cannot be) an HTML-like entity called " 0 1 2 3 ",
 this will be treated as an error.  However, Pod processors may
 treat "EE<lt> 0 1 2 3 >" or "EE<lt>e-acute>" as I<syntactically>
 invalid, potentially earning a different error message than the
@@ -942,7 +942,7 @@ unknown EE<lt>thing> sequence that the parser couldn't resolve to
 anything, renderable or not).  It is good practice to map Latin letters
 with diacritics (like "EE<lt>eacute>"/"EE<lt>233>") to the corresponding
 unaccented US-ASCII letters (like a simple character 101, "e"), but
-clearly this is often not feasable, and an unrenderable character may
+clearly this is often not feasible, and an unrenderable character may
 be represented as "?", or the like.  In attempting a sane fallback
 (as from EE<lt>233> to "e"), Pod formatters may use the
 %Latin1Code_to_fallback table in L<Pod::Escapes|Pod::Escapes>, or
@@ -987,7 +987,7 @@ representation that maps best to what the output format demands.
 
 =item *
 
-Some processors may find it the C<SE<lt>...E<gt>> code easiest to
+Some processors may find that the C<SE<lt>...E<gt>> code is easiest to
 implement by replacing each space in the parse tree under the content
 of the S, with an NBSP.  But note: the replacement should apply I<not> to
 spaces in I<all> text, but I<only> to spaces in I<printable> text.  (This
@@ -1018,7 +1018,7 @@ character/code and no code for "don't break this stuff across lines".
 
 Besides the NBSP character discussed above, implementors are reminded
 of the existence of the other "special" character in Latin-1, the
-"soft hyphen" chararacter, also known as "discretionary hyphen",
+"soft hyphen" character, also known as "discretionary hyphen",
 i.e. C<EE<lt>173E<gt>> = C<EE<lt>0xADE<gt>> =
 C<EE<lt>shyE<gt>>).  This character expresses an optional hyphenation
 point.  That is, it normally renders as nothing, but may render as a
@@ -1225,9 +1225,9 @@ as in:
 
   <h1><a name="About_the_-M_Operator">About the <code>-M</code>
   Operator</h1>
-  
+
   ...
-  
+
   <a href="somedoc#About_the_-M_Operator">About the <code>-M</code>
   Operator" in somedoc</a>
 
@@ -1434,17 +1434,17 @@ Pod processors should tolerate "=item *" / "=item I<number>" commands
 with no accompanying paragraph.  The middle item is an example:
 
   =over
-  
+
   =item 1
-  
+
   Pick up dry cleaning.
-  
+
   =item 2
-  
+
   =item 3
-  
+
   Stop by the store.  Get Abba Zabas, Stoli, and cheap lawn chairs.
-  
+
   =back
 
 =item *
@@ -1458,7 +1458,7 @@ Note that an "=over" ... "=back" region should have some
 content.  That is, authors should not have an empty region like this:
 
   =over
-  
+
   =back
 
 Pod processors seeing such a contentless "=over" ... "=back" region,
@@ -1479,7 +1479,7 @@ Authors of Pod formatters should note that this construct:
   =item Porro
 
   =item Quisquam Est
-  
+
   Qui dolorem ipsum quia dolor sit amet, consectetur, adipisci 
   velit, sed quia non numquam eius modi tempora incidunt ut
   labore et dolore magnam aliquam quaerat voluptatem.
@@ -1494,9 +1494,9 @@ paragraph "Qui dolorem ipsum quia dolor..."; and then an item
 "Ut Enim".  In that case, you'd want to format it like so:
 
   Neque
-  
+
   Porro
-  
+
   Quisquam Est
     Qui dolorem ipsum quia dolor sit amet, consectetur, adipisci
     velit, sed quia non numquam eius modi tempora incidunt ut
@@ -1534,7 +1534,7 @@ authors to distinguish which grouping is meant by the above
 
   Ut Enim
 
-That is, there should be (at least roughtly) equal spacing between
+That is, there should be (at least roughly) equal spacing between
 items as between paragraphs (although that spacing may well be less
 than the full height of a line of text).  This leaves it to the reader
 to use (con)textual cues to figure out whether the "Qui dolorem
@@ -1554,9 +1554,9 @@ to be used (typically passed through) when rendering the document to
 a specific format:
 
   =begin rtf
-  
+
   \par{\pard\qr\sa4500{\i Printed\~\chdate\~\chtime}\par}
-  
+
   =end rtf
 
 The exact same effect could, incidentally, be achieved with a single
@@ -1570,11 +1570,11 @@ meaning as one, and Pod parsers may parse it as one.)
 Another example of a data paragraph:
 
   =begin html
-  
+
   I like <em>PIE</em>!
-  
+
   <hr>Especially pecan pie!
-  
+
   =end html
 
 If these were ordinary paragraphs, the Pod parser would try to
@@ -1620,26 +1620,26 @@ Note that a "=begin I<identifier>"..."=end I<identifier>" region where
 I<identifier> begins with a colon, I<can> contain commands.  For example:
 
   =begin :biblio
-  
+
   Wirth's classic is available in several editions, including:
-  
+
   =for comment
    hm, check abebooks.com for how much used copies cost.
-  
+
   =over
-  
+
   =item
-  
+
   Wirth, Niklaus.  1975.  I<Algorithmen und Datenstrukturen.>
   Teubner, Stuttgart.  [Yes, it's in German.]
-  
+
   =item
-  
+
   Wirth, Niklaus.  1976.  I<Algorithms + Data Structures =
   Programs.>  Prentice-Hall, Englewood Cliffs, NJ.
-  
+
   =back
-  
+
   =end :biblio
 
 Note, however, a "=begin I<identifier>"..."=end I<identifier>"
@@ -1648,13 +1648,13 @@ directly contain "=head1" ... "=head4" commands, nor "=over", nor "=back",
 nor "=item".  For example, this may be considered invalid:
 
   =begin somedata
-  
+
   This is a data paragraph.
-  
+
   =head1 Don't do this!
-  
+
   This is a data paragraph too.
-  
+
   =end somedata
 
 A Pod processor may signal that the above (specifically the "=head1"
@@ -1662,48 +1662,48 @@ paragraph) is an error.  Note, however, that the following should
 I<not> be treated as an error:
 
   =begin somedata
-  
+
   This is a data paragraph.
-  
+
   =cut
-  
+
   # Yup, this isn't Pod anymore.
   sub excl { (rand() > .5) ? "hoo!" : "hah!" }
-  
+
   =pod
-  
+
   This is a data paragraph too.
-  
+
   =end somedata
 
 And this too is valid:
 
   =begin someformat
-  
+
   This is a data paragraph.
-  
+
     And this is a data paragraph.
-  
+
   =begin someotherformat
-  
+
   This is a data paragraph too.
-  
+
     And this is a data paragraph too.
-  
+
   =begin :yetanotherformat
 
   =head2 This is a command paragraph!
 
   This is an ordinary paragraph!
-  
+
     And this is a verbatim paragraph!
-  
+
   =end :yetanotherformat
-  
+
   =end someotherformat
-  
+
   Another data paragraph!
-  
+
   =end someformat
 
 The contents of the above "=begin :yetanotherformat" ...
@@ -1720,35 +1720,35 @@ other than "=end", "=pod", and "=cut".
 Also consider this valid structure:
 
   =begin :biblio
-  
+
   Wirth's classic is available in several editions, including:
-  
+
   =over
-  
+
   =item
-  
+
   Wirth, Niklaus.  1975.  I<Algorithmen und Datenstrukturen.>
   Teubner, Stuttgart.  [Yes, it's in German.]
-  
+
   =item
-  
+
   Wirth, Niklaus.  1976.  I<Algorithms + Data Structures =
   Programs.>  Prentice-Hall, Englewood Cliffs, NJ.
 
   =back
-  
+
   Buy buy buy!
-  
+
   =begin html
-  
+
   <img src='wirth_spokesmodeling_book.png'>
-  
+
   <hr>
-  
+
   =end html
-  
+
   Now now now!
-  
+
   =end :biblio
 
 There, the "=begin html"..."=end html" region is nested inside
@@ -1774,22 +1774,22 @@ contentless "=for I<something>" and "=for :I<something>"
 paragraphs.  I.e., these should be tolerated:
 
   =for html
-  
+
   =begin html
-  
+
   =end html
-  
+
   =begin :biblio
-  
+
   =end :biblio
 
 Incidentally, note that there's no easy way to express a data
 paragraph starting with something that looks like a command.  Consider:
 
   =begin stuff
-  
+
   =shazbot
-  
+
   =end stuff
 
 There, "=shazbot" will be parsed as a Pod command "shazbot", not as a data
@@ -1804,40 +1804,40 @@ Note that =end commands must match the currently open =begin command.  That
 is, they must properly nest.  For example, this is valid:
 
   =begin outer
-  
+
   X
-  
+
   =begin inner
-  
+
   Y
-  
+
   =end inner
-  
+
   Z
-  
+
   =end outer
 
 while this is invalid:
 
   =begin outer
-  
+
   X
-  
+
   =begin inner
-  
+
   Y
-  
+
   =end outer
-  
+
   Z
-  
+
   =end inner
-  
+
 This latter is improper because when the "=end outer" command is seen, the
 currently open region has the formatname "inner", not "outer".  (It just
 happens that "outer" is the format name of a higher-up region.)  This is
 an error.  Processors must by default report this as an error, and may halt
-processing the document containing that error.  A corrolary of this is that
+processing the document containing that error.  A corollary of this is that
 regions cannot "overlap" -- i.e., the latter block above does not represent
 a region called "outer" which contains X and Y, overlapping a region called
 "inner" which contains Y and Z.  But because it is invalid (as all
@@ -1847,7 +1847,7 @@ anything at all.
 Similarly, this is invalid:
 
   =begin thing
-  
+
   =end hting
 
 This is an error because the region is opened by "thing", and the "=end"
@@ -1856,7 +1856,7 @@ tries to close "hting" [sic].
 This is also invalid:
 
   =begin thing
-  
+
   =end
 
 This is invalid because every "=end" command must have a formatname
diff --git a/pod/perlport.pod b/pod/perlport.pod
index 287eaf5131..3b11a4f45e 100644
--- a/pod/perlport.pod
+++ b/pod/perlport.pod
@@ -559,7 +559,7 @@ often happens when tests spawn off other processes or call external
 programs to aid in the testing, or when (as noted above) the tests
 assume certain things about the filesystem and paths.  Be careful
 not to depend on a specific output style for errors, such as when
-checking C<$!> after an system call.  Some platforms expect a certain
+checking C<$!> after a system call.  Some platforms expect a certain
 output format, and perl on those platforms may have been adjusted
 accordingly.  Most specifically, don't anchor a regex when testing
 an error value.
@@ -1416,6 +1416,17 @@ Implemented via Spawn. (VM/ESA)
 Does not automatically flush output handles on some platforms.
 (SunOS, Solaris, HP-UX)
 
+=item exit EXPR
+
+=item exit
+
+Emulates UNIX exit() (which considers C<exit 1> to indicate an error) by
+mapping the C<1> to SS$_ABORT (C<44>).  This behavior may be overridden
+with the pragma C<use vmsish 'exit'>.  As with the CRTL's exit()
+function, C<exit 0> is also mapped to an exit status of SS$_NORMAL
+(C<1>); this mapping cannot be overridden.  Any other argument to exit()
+is used directly as Perl's exit status. (VMS)
+
 =item fcntl FILEHANDLE,FUNCTION,SCALAR
 
 Not implemented. (Win32, VMS)
@@ -1559,17 +1570,6 @@ Not implemented. (S<Mac OS>, Win32, Plan9)
 
 Not implemented. (Plan9, Win32)
 
-=item exit EXPR
-
-=item exit
-
-Emulates UNIX exit() (which considers C<exit 1> to indicate an error) by
-mapping the C<1> to SS$_ABORT (C<44>).  This behavior may be overridden
-with the pragma C<use vmsish 'exit'>.  As with the CRTL's exit()
-function, C<exit 0> is also mapped to an exit status of SS$_NORMAL
-(C<1>); this mapping cannot be overridden.  Any other argument to exit()
-is used directly as Perl's exit status. (VMS)
-
 =item getsockopt SOCKET,LEVEL,OPTNAME
 
 Not implemented. (Plan9)
@@ -1658,11 +1658,11 @@ Not implemented. (Win32, VMS, S<RISC OS>)
 
 =item select RBITS,WBITS,EBITS,TIMEOUT
 
-Only implemented on sockets. (Win32)
+Only implemented on sockets. (Win32, VMS)
 
 Only reliable on sockets. (S<RISC OS>)
 
-Note that the C<socket FILEHANDLE> form is generally portable.
+Note that the C<select FILEHANDLE> form is generally portable.
 
 =item semctl ID,SEMNUM,CMD,ARG
 
@@ -1937,7 +1937,7 @@ First public release with perl5.005.
 
 As of early 2001 (the Perl releases 5.6.1 and 5.7.1), the following
 platforms are able to build Perl from the standard source code
-distribution available at http://www.perl.com/CPAN/src/index.html
+distribution available at http://www.cpan.org/src/index.html
 
 	AIX
 	AmigaOS
@@ -2063,7 +2063,7 @@ Support for the following platform is planned for a future Perl release:
 	Netware
 
 The following platforms have their own source code distributions and
-binaries available via http://www.perl.com/CPAN/ports/index.html:
+binaries available via http://www.cpan.org/ports/index.html:
 
 				Perl release
 
@@ -2072,7 +2072,7 @@ binaries available via http://www.perl.com/CPAN/ports/index.html:
 	Tandem Guardian		5.004
 
 The following platforms have only binaries available via
-http://www.perl.com/CPAN/ports/index.html :
+http://www.cpan.org/ports/index.html :
 
 				Perl release
 
@@ -2083,7 +2083,7 @@ http://www.perl.com/CPAN/ports/index.html :
 Although we do suggest that you always build your own Perl from
 the source code, both for maximal configurability and for security,
 in case you are in a hurry you can check
-http://www.perl.com/CPAN/ports/index.html for binary distributions.
+http://www.cpan.org/ports/index.html for binary distributions.
 
 =head1 SEE ALSO
 
diff --git a/pod/perlre.pod b/pod/perlre.pod
index 874fed419f..5c7e76b5ad 100644
--- a/pod/perlre.pod
+++ b/pod/perlre.pod
@@ -184,7 +184,9 @@ In addition, Perl defines the following:
     \PP	Match non-P
     \X	Match eXtended Unicode "combining character sequence",
         equivalent to C<(?:\PM\pM*)>
-    \C	Match a single C char (octet) even under utf8.
+    \C	Match a single C char (octet) even under Unicode.
+	B<NOTE:> breaks up characters into their UTF-8 bytes,
+	so you may end up with malformed pieces of UTF-8.
 
 A C<\w> matches a single alphanumeric character or C<_>, not a whole word.
 Use C<\w+> to match a string of Perl-identifier characters (which isn't 
@@ -193,7 +195,7 @@ list of alphabetic characters generated by C<\w> is taken from the
 current locale.  See L<perllocale>.  You may use C<\w>, C<\W>, C<\s>, C<\S>,
 C<\d>, and C<\D> within character classes, but if you try to use them
 as endpoints of a range, that's not a range, the "-" is understood literally.
-See L<utf8> for details about C<\pP>, C<\PP>, and C<\X>.
+See L<perlunicode> for details about C<\pP>, C<\PP>, and C<\X>.
 
 The POSIX character class syntax
 
@@ -230,9 +232,10 @@ whole character class.  For example:
 
 matches zero, one, any alphabetic character, and the percentage sign.
 
-If the C<utf8> pragma is used, the following equivalences to Unicode
-\p{} constructs and equivalent backslash character classes (if available),
-will hold:
+The following equivalences to Unicode \p{} constructs and equivalent
+backslash character classes (if available), will hold:
+
+    [:...:]	\p{...}		backslash
 
     alpha       IsAlpha
     alnum       IsAlnum
@@ -291,7 +294,7 @@ work just fine) it is included for completeness.
 You can negate the [::] character classes by prefixing the class name
 with a '^'. This is a Perl extension.  For example:
 
-    POSIX	trad. Perl  utf8 Perl
+    POSIX	traditional Unicode
 
     [:^digit:]      \D      \P{IsDigit}
     [:^space:]	    \S	    \P{IsSpace}
@@ -1024,7 +1027,7 @@ Some people get too used to writing things like:
 
 This is grandfathered for the RHS of a substitute to avoid shocking the
 B<sed> addicts, but it's a dirty habit to get into.  That's because in
-PerlThink, the righthand side of a C<s///> is a double-quoted string.  C<\1> in
+PerlThink, the righthand side of an C<s///> is a double-quoted string.  C<\1> in
 the usual double-quoted string means a control-A.  The customary Unix
 meaning of C<\1> is kludged in for C<s///>.  However, if you get into the habit
 of doing that, you get yourself into trouble if you then add an C</e>
diff --git a/pod/perlref.pod b/pod/perlref.pod
index e8e9ab78fa..7255162fcd 100644
--- a/pod/perlref.pod
+++ b/pod/perlref.pod
@@ -31,7 +31,7 @@ have been officially "blessed" into a class package.)
 
 Symbolic references are names of variables or other objects, just as a
 symbolic link in a Unix filesystem contains merely the name of a file.
-The C<*glob> notation is something of a of symbolic reference.  (Symbolic
+The C<*glob> notation is something of a symbolic reference.  (Symbolic
 references are sometimes called "soft references", but please don't call
 them that; references are confusing enough without useless synonyms.)
 
diff --git a/pod/perlrequick.pod b/pod/perlrequick.pod
index 1b483c0012..a31adab5eb 100644
--- a/pod/perlrequick.pod
+++ b/pod/perlrequick.pod
@@ -238,7 +238,7 @@ C<cat> is able to match earlier in the string.
     "cats"          =~ /cats|cat|ca|c/; # matches "cats"
 
 At a given character position, the first alternative that allows the
-regex match to succeed wil be the one that matches. Here, all the
+regex match to succeed will be the one that matches. Here, all the
 alternatives match at the first string position, so th first matches.
 
 =head2 Grouping things and hierarchical matching
diff --git a/pod/perlretut.pod b/pod/perlretut.pod
index cc8f5c4c9b..bb2423b8af 100644
--- a/pod/perlretut.pod
+++ b/pod/perlretut.pod
@@ -550,7 +550,7 @@ to give them a chance to match.
 
 The last example points out that character classes are like
 alternations of characters.  At a given character position, the first
-alternative that allows the regexp match to succeed wil be the one
+alternative that allows the regexp match to succeed will be the one
 that matches.
 
 =head2 Grouping things and hierarchical matching
@@ -587,7 +587,7 @@ are
 
 Alternations behave the same way in groups as out of them: at a given
 string position, the leftmost alternative that allows the regexp to
-match is taken.  So in the last example at tth first string position,
+match is taken.  So in the last example at the first string position,
 C<"20"> matches the second alternative, but there is nothing left over
 to match the next two digits C<\d\d>.  So perl moves on to the next
 alternative, which is the null alternative and that works, since
@@ -1415,7 +1415,7 @@ naive regexp
     $dna = "ATCGTTGAATGCAAATGACATGAC";
     $dna =~ /TGA/;
 
-doesn't work; it may match an C<TGA>, but there is no guarantee that
+doesn't work; it may match a C<TGA>, but there is no guarantee that
 the match is aligned with codon boundaries, e.g., the substring
 S<C<GTT GAA> > gives a match.  A better solution is
 
@@ -1653,12 +1653,11 @@ Unicode characters in the range of 128-255 use two hexadecimal digits
 with braces: C<\x{ab}>.  Note that this is different than C<\xab>,
 which is just a hexadecimal byte with no Unicode significance.
 
-B<NOTE>: in perl 5.6.0 it used to be that one needed to say C<use utf8>
-to use any Unicode features.  This is no more the case: for almost all
-Unicode processing, the explicit C<utf8> pragma is not needed.
-(The only case where it matters is if your Perl script is in Unicode,
-that is, encoded in UTF-8/UTF-16/UTF-EBCDIC: then an explicit C<use utf8>
-is needed.)
+B<NOTE>: in Perl 5.6.0 it used to be that one needed to say C<use
+utf8> to use any Unicode features.  This is no more the case: for
+almost all Unicode processing, the explicit C<utf8> pragma is not
+needed.  (The only case where it matters is if your Perl script is in
+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
diff --git a/pod/perlrun.pod b/pod/perlrun.pod
index 0e3017fabd..4b86d77b51 100644
--- a/pod/perlrun.pod
+++ b/pod/perlrun.pod
@@ -569,12 +569,39 @@ the implicit loop, just as in B<awk>.
 
 =item B<-P>
 
-causes your program to be run through the C preprocessor before
+B<NOTE: Use of -P is strongly discouraged because of its inherent
+problems, including poor portability.>
+
+This option causes your program to be run through the C preprocessor before
 compilation by Perl.  Because both comments and B<cpp> directives begin
 with the # character, you should avoid starting comments with any words
 recognized by the C preprocessor such as C<"if">, C<"else">, or C<"define">.
-Also, in some platforms the C preprocessor knows too much: it knows
-about the C++ -style until-end-of-line comments starting with C<"//">.
+
+If you're considering using C<-P>, you might also want to look at the
+Filter::cpp module from CPAN.
+
+The problems of -P include, but are not limited to:
+
+=over 10
+
+=item *
+
+The C<#!> line is stripped, so any switches there don't apply.
+
+=item *
+
+A C<-P> on a C<#!> line doesn't work.
+
+=item *
+
+B<All> lines that begin with (whitespace and) a C<#> but
+do not look like cpp commands, are stripped, including anything
+inside Perl strings, regular expressions, and here-docs . 
+
+=item *
+
+In some platforms the C preprocessor knows too much: it knows about
+the C++ -style until-end-of-line comments starting with C<"//">.
 This will cause problems with common Perl constructs like
 
     s/foo//;
@@ -588,6 +615,23 @@ like for example C<"!">:
 
     s!foo!!;
 
+
+
+=item *
+
+It requires not only a working C preprocessor but also a working
+F<sed>.  If not on UNIX, you are probably out of luck on this.
+
+=item *
+
+Script line numbers are not preserved.
+
+=item *
+
+The C<-x> does not work with C<-P>.
+
+=back
+
 =item B<-s>
 
 enables rudimentary switch parsing for switches on the command
diff --git a/pod/perltoc.pod b/pod/perltoc.pod
index fef52a3724..4a9495771f 100644
--- a/pod/perltoc.pod
+++ b/pod/perltoc.pod
@@ -23,6 +23,8 @@ through to locate the proper section you're looking for.
 
 =item Tutorials
 
+=item Reference Manual
+
 =item Internals and C Language Interface
 
 =item Miscellaneous
@@ -396,36 +398,37 @@ I<-X> FILEHANDLE, I<-X> EXPR, I<-X>, abs VALUE, abs, accept
 NEWSOCKET,GENERICSOCKET, alarm SECONDS, alarm, atan2 Y,X, bind SOCKET,NAME,
 binmode FILEHANDLE, DISCIPLINE, binmode FILEHANDLE, bless REF,CLASSNAME,
 bless REF, caller EXPR, caller, chdir EXPR, chmod LIST, chomp VARIABLE,
-chomp LIST, chomp, chop VARIABLE, chop LIST, chop, chown LIST, chr NUMBER,
-chr, chroot FILENAME, chroot, close FILEHANDLE, close, closedir DIRHANDLE,
-connect SOCKET,NAME, continue BLOCK, cos EXPR, cos, crypt PLAINTEXT,SALT,
-dbmclose HASH, dbmopen HASH,DBNAME,MASK, defined EXPR, defined, delete
-EXPR, die LIST, do BLOCK, do SUBROUTINE(LIST), do EXPR, dump LABEL, dump,
-each HASH, eof FILEHANDLE, eof (), eof, eval EXPR, eval BLOCK, exec LIST,
-exec PROGRAM LIST, exists EXPR, exit EXPR, exp EXPR, exp, fcntl
-FILEHANDLE,FUNCTION,SCALAR, fileno FILEHANDLE, flock FILEHANDLE,OPERATION,
-fork, format, formline PICTURE,LIST, getc FILEHANDLE, getc, getlogin,
-getpeername SOCKET, getpgrp PID, getppid, getpriority WHICH,WHO, getpwnam
-NAME, getgrnam NAME, gethostbyname NAME, getnetbyname NAME, getprotobyname
-NAME, getpwuid UID, getgrgid GID, getservbyname NAME,PROTO, gethostbyaddr
-ADDR,ADDRTYPE, getnetbyaddr ADDR,ADDRTYPE, getprotobynumber NUMBER,
-getservbyport PORT,PROTO, getpwent, getgrent, gethostent, getnetent,
-getprotoent, getservent, setpwent, setgrent, sethostent STAYOPEN, setnetent
-STAYOPEN, setprotoent STAYOPEN, setservent STAYOPEN, endpwent, endgrent,
-endhostent, endnetent, endprotoent, endservent, getsockname SOCKET,
-getsockopt SOCKET,LEVEL,OPTNAME, glob EXPR, glob, gmtime EXPR, goto LABEL,
-goto EXPR, goto &NAME, grep BLOCK LIST, grep EXPR,LIST, hex EXPR, hex,
-import, index STR,SUBSTR,POSITION, index STR,SUBSTR, int EXPR, int, ioctl
-FILEHANDLE,FUNCTION,SCALAR, join EXPR,LIST, keys HASH, kill SIGNAL, LIST,
-last LABEL, last, lc EXPR, lc, lcfirst EXPR, lcfirst, length EXPR, length,
-link OLDFILE,NEWFILE, listen SOCKET,QUEUESIZE, local EXPR, localtime EXPR,
-lock, log EXPR, log, lstat EXPR, lstat, m//, map BLOCK LIST, map EXPR,LIST,
-mkdir FILENAME,MASK, mkdir FILENAME, msgctl ID,CMD,ARG, msgget KEY,FLAGS,
-msgrcv ID,VAR,SIZE,TYPE,FLAGS, msgsnd ID,MSG,FLAGS, my EXPR, my EXPR :
-ATTRIBUTES, next LABEL, next, no Module LIST, oct EXPR, oct, open
-FILEHANDLE,EXPR, open FILEHANDLE,MODE,EXPR, open FILEHANDLE,MODE,EXPR,LIST,
-open FILEHANDLE, opendir DIRHANDLE,EXPR, ord EXPR, ord, our EXPR, our EXPR
-: ATTRIBUTES, pack TEMPLATE,LIST, package NAMESPACE, package, pipe
+chomp( LIST ), chomp, chop VARIABLE, chop( LIST ), chop, chown LIST, chr
+NUMBER, chr, chroot FILENAME, chroot, close FILEHANDLE, close, closedir
+DIRHANDLE, connect SOCKET,NAME, continue BLOCK, cos EXPR, cos, crypt
+PLAINTEXT,SALT, dbmclose HASH, dbmopen HASH,DBNAME,MASK, defined EXPR,
+defined, delete EXPR, die LIST, do BLOCK, do SUBROUTINE(LIST), do EXPR,
+dump LABEL, dump, each HASH, eof FILEHANDLE, eof (), eof, eval EXPR, eval
+BLOCK, exec LIST, exec PROGRAM LIST, exists EXPR, exit EXPR, exp EXPR, exp,
+fcntl FILEHANDLE,FUNCTION,SCALAR, fileno FILEHANDLE, flock
+FILEHANDLE,OPERATION, fork, format, formline PICTURE,LIST, getc FILEHANDLE,
+getc, getlogin, getpeername SOCKET, getpgrp PID, getppid, getpriority
+WHICH,WHO, getpwnam NAME, getgrnam NAME, gethostbyname NAME, getnetbyname
+NAME, getprotobyname NAME, getpwuid UID, getgrgid GID, getservbyname
+NAME,PROTO, gethostbyaddr ADDR,ADDRTYPE, getnetbyaddr ADDR,ADDRTYPE,
+getprotobynumber NUMBER, getservbyport PORT,PROTO, getpwent, getgrent,
+gethostent, getnetent, getprotoent, getservent, setpwent, setgrent,
+sethostent STAYOPEN, setnetent STAYOPEN, setprotoent STAYOPEN, setservent
+STAYOPEN, endpwent, endgrent, endhostent, endnetent, endprotoent,
+endservent, getsockname SOCKET, getsockopt SOCKET,LEVEL,OPTNAME, glob EXPR,
+glob, gmtime EXPR, goto LABEL, goto EXPR, goto &NAME, grep BLOCK LIST, grep
+EXPR,LIST, hex EXPR, hex, import, index STR,SUBSTR,POSITION, index
+STR,SUBSTR, int EXPR, int, ioctl FILEHANDLE,FUNCTION,SCALAR, join
+EXPR,LIST, keys HASH, kill SIGNAL, LIST, last LABEL, last, lc EXPR, lc,
+lcfirst EXPR, lcfirst, length EXPR, length, link OLDFILE,NEWFILE, listen
+SOCKET,QUEUESIZE, local EXPR, localtime EXPR, lock, log EXPR, log, lstat
+EXPR, lstat, m//, map BLOCK LIST, map EXPR,LIST, mkdir FILENAME,MASK, mkdir
+FILENAME, msgctl ID,CMD,ARG, msgget KEY,FLAGS, msgrcv
+ID,VAR,SIZE,TYPE,FLAGS, msgsnd ID,MSG,FLAGS, my EXPR, my EXPR : ATTRIBUTES,
+next LABEL, next, no Module LIST, oct EXPR, oct, open FILEHANDLE,EXPR, open
+FILEHANDLE,MODE,EXPR, open FILEHANDLE,MODE,EXPR,LIST, open FILEHANDLE,
+opendir DIRHANDLE,EXPR, ord EXPR, ord, our EXPR, our EXPR : ATTRIBUTES,
+pack TEMPLATE,LIST, package NAMESPACE, package, pipe
 READHANDLE,WRITEHANDLE, pop ARRAY, pop, pos SCALAR, pos, print FILEHANDLE
 LIST, print LIST, print, printf FILEHANDLE FORMAT, LIST, printf FORMAT,
 LIST, prototype FUNCTION, push ARRAY,LIST, q/STRING/, qq/STRING/,
@@ -534,11 +537,11 @@ more elaborate constructs
 
 =over 4
 
-=item Declaration of a ARRAY OF ARRAYS
+=item Declaration of an ARRAY OF ARRAYS
 
-=item Generation of a ARRAY OF ARRAYS
+=item Generation of an ARRAY OF ARRAYS
 
-=item Access and Printing of a ARRAY OF ARRAYS
+=item Access and Printing of an ARRAY OF ARRAYS
 
 =back
 
@@ -558,11 +561,11 @@ more elaborate constructs
 
 =over 4
 
-=item Declaration of a ARRAY OF HASHES
+=item Declaration of an ARRAY OF HASHES
 
-=item Generation of a ARRAY OF HASHES
+=item Generation of an ARRAY OF HASHES
 
-=item Access and Printing of a ARRAY OF HASHES
+=item Access and Printing of an ARRAY OF HASHES
 
 =back
 
@@ -764,7 +767,7 @@ Discontinuance, Deprecation, Discontinuance, Discontinuance
 
 =item Parsing Traps
 
-Parsing, Parsing, Parsing, Parsing
+Parsing, Parsing, Parsing, Parsing, Parsing
 
 =item Numerical Traps
 
@@ -848,7 +851,8 @@ B<-x> I<directory>
 
 HOME, LOGDIR, PATH, PERL5LIB, PERL5OPT, PERLLIB, PERL5DB, PERL5SHELL
 (specific to the Win32 port), PERL_DEBUG_MSTATS, PERL_DESTRUCT_LEVEL,
-PERL_ROOT (specific to the VMS port), SYS$LOGIN (specific to the VMS port)
+PERL_ENCODING, PERL_ROOT (specific to the VMS port), SYS$LOGIN (specific to
+the VMS port)
 
 =back
 
@@ -1016,17 +1020,17 @@ C<substr $var, $-[3], $+[3] - $-[3])>, HANDLE->format_name(EXPR),
 $FORMAT_NAME, $~, HANDLE->format_top_name(EXPR), $FORMAT_TOP_NAME, $^,
 IO::Handle->format_line_break_characters EXPR,
 $FORMAT_LINE_BREAK_CHARACTERS, $:, IO::Handle->format_formfeed EXPR,
-$FORMAT_FORMFEED, $^L, $ACCUMULATOR, $^A, $CHILD_ERROR, $?, $OS_ERROR,
-$ERRNO, $!, $EXTENDED_OS_ERROR, $^E, $EVAL_ERROR, $@, $PROCESS_ID, $PID,
-$$, $REAL_USER_ID, $UID, $<, $EFFECTIVE_USER_ID, $EUID, $>, $REAL_GROUP_ID,
-$GID, $(, $EFFECTIVE_GROUP_ID, $EGID, $), $PROGRAM_NAME, $0, $[, $],
-$COMPILING, $^C, $DEBUGGING, $^D, $SYSTEM_FD_MAX, $^F, $^H, %^H,
-$INPLACE_EDIT, $^I, $^M, $OSNAME, $^O, $PERLDB, $^P, 0x01, 0x02, 0x04,
-0x08, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200, $LAST_REGEXP_CODE_RESULT, $^R,
-$EXCEPTIONS_BEING_CAUGHT, $^S, $BASETIME, $^T, ${^TAINT}, $PERL_VERSION,
-$^V, $WARNING, $^W, ${^WARNING_BITS}, ${^WIDE_SYSTEM_CALLS},
-$EXECUTABLE_NAME, $^X, ARGV, $ARGV, @ARGV, @F, @INC, @_, %INC, %ENV,
-$ENV{expr}, %SIG, $SIG{expr}
+$FORMAT_FORMFEED, $^L, $ACCUMULATOR, $^A, $CHILD_ERROR, $?, ${^ENCODING},
+$OS_ERROR, $ERRNO, $!, $EXTENDED_OS_ERROR, $^E, $EVAL_ERROR, $@,
+$PROCESS_ID, $PID, $$, $REAL_USER_ID, $UID, $<, $EFFECTIVE_USER_ID, $EUID,
+$>, $REAL_GROUP_ID, $GID, $(, $EFFECTIVE_GROUP_ID, $EGID, $),
+$PROGRAM_NAME, $0, $[, $], $COMPILING, $^C, $DEBUGGING, $^D,
+$SYSTEM_FD_MAX, $^F, $^H, %^H, $INPLACE_EDIT, $^I, $^M, $OSNAME, $^O,
+$PERLDB, $^P, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200,
+$LAST_REGEXP_CODE_RESULT, $^R, $EXCEPTIONS_BEING_CAUGHT, $^S, $BASETIME,
+$^T, ${^TAINT}, $PERL_VERSION, $^V, $WARNING, $^W, ${^WARNING_BITS},
+${^WIDE_SYSTEM_CALLS}, $EXECUTABLE_NAME, $^X, ARGV, $ARGV, @ARGV, @F, @INC,
+@_, %INC, %ENV, $ENV{expr}, %SIG, $SIG{expr}
 
 =item Error Indicators
 
@@ -1968,20 +1972,21 @@ http://testers.cpan.org/
 -I<X> FILEHANDLE, -I<X> EXPR, -I<X>, alarm SECONDS, alarm, binmode
 FILEHANDLE, chmod LIST, chown LIST, chroot FILENAME, chroot, crypt
 PLAINTEXT,SALT, dbmclose HASH, dbmopen HASH,DBNAME,MODE, dump LABEL, exec
-LIST, fcntl FILEHANDLE,FUNCTION,SCALAR, flock FILEHANDLE,OPERATION, fork,
-getlogin, getpgrp PID, getppid, getpriority WHICH,WHO, getpwnam NAME,
-getgrnam NAME, getnetbyname NAME, getpwuid UID, getgrgid GID, getnetbyaddr
-ADDR,ADDRTYPE, getprotobynumber NUMBER, getservbyport PORT,PROTO, getpwent,
-getgrent, gethostent, getnetent, getprotoent, getservent, setpwent,
-setgrent, sethostent STAYOPEN, setnetent STAYOPEN, setprotoent STAYOPEN,
-setservent STAYOPEN, endpwent, endgrent, endhostent, endnetent,
-endprotoent, endservent, exit EXPR, exit, getsockopt SOCKET,LEVEL,OPTNAME,
-glob EXPR, glob, ioctl FILEHANDLE,FUNCTION,SCALAR, kill SIGNAL, LIST, link
-OLDFILE,NEWFILE, lstat FILEHANDLE, lstat EXPR, lstat, msgctl ID,CMD,ARG,
-msgget KEY,FLAGS, msgsnd ID,MSG,FLAGS, msgrcv ID,VAR,SIZE,TYPE,FLAGS, open
-FILEHANDLE,EXPR, open FILEHANDLE, pipe READHANDLE,WRITEHANDLE, readlink
-EXPR, readlink, select RBITS,WBITS,EBITS,TIMEOUT, semctl ID,SEMNUM,CMD,ARG,
-semget KEY,NSEMS,FLAGS, semop KEY,OPSTRING, setgrent, setpgrp PID,PGRP,
+LIST, exit EXPR, exit, fcntl FILEHANDLE,FUNCTION,SCALAR, flock
+FILEHANDLE,OPERATION, fork, getlogin, getpgrp PID, getppid, getpriority
+WHICH,WHO, getpwnam NAME, getgrnam NAME, getnetbyname NAME, getpwuid UID,
+getgrgid GID, getnetbyaddr ADDR,ADDRTYPE, getprotobynumber NUMBER,
+getservbyport PORT,PROTO, getpwent, getgrent, gethostent, getnetent,
+getprotoent, getservent, setpwent, setgrent, sethostent STAYOPEN, setnetent
+STAYOPEN, setprotoent STAYOPEN, setservent STAYOPEN, endpwent, endgrent,
+endhostent, endnetent, endprotoent, endservent, getsockopt
+SOCKET,LEVEL,OPTNAME, glob EXPR, glob, ioctl FILEHANDLE,FUNCTION,SCALAR,
+kill SIGNAL, LIST, link OLDFILE,NEWFILE, lstat FILEHANDLE, lstat EXPR,
+lstat, msgctl ID,CMD,ARG, msgget KEY,FLAGS, msgsnd ID,MSG,FLAGS, msgrcv
+ID,VAR,SIZE,TYPE,FLAGS, open FILEHANDLE,EXPR, open FILEHANDLE, pipe
+READHANDLE,WRITEHANDLE, readlink EXPR, readlink, select
+RBITS,WBITS,EBITS,TIMEOUT, semctl ID,SEMNUM,CMD,ARG, semget
+KEY,NSEMS,FLAGS, semop KEY,OPSTRING, setgrent, setpgrp PID,PGRP,
 setpriority WHICH,WHO,PRIORITY, setpwent, setsockopt
 SOCKET,LEVEL,OPTNAME,OPTVAL, shmctl ID,CMD,ARG, shmget KEY,SIZE,FLAGS,
 shmread ID,VAR,POS,SIZE, shmwrite ID,STRING,POS,SIZE, sockatmark SOCKET,
@@ -2106,6 +2111,56 @@ LC_NUMERIC, LC_TIME, LANG
 
 =back
 
+=head2 perluniintro - Perl Unicode introduction
+
+=over 4
+
+=item DESCRIPTION
+
+=over 4
+
+=item Unicode
+
+=item Perl's Unicode Support
+
+=item Perl's Unicode Model
+
+=item Creating Unicode
+
+=item Handling Unicode
+
+=item Legacy Encodings
+
+=item Unicode I/O
+
+=item Special Cases
+
+=item Advanced Topics
+
+=item Miscellaneous
+
+=item Questions With Answers
+
+Will My Old Scripts Break?, How Do I Make My Scripts Work With Unicode?,
+How Do I Know Whether My String Is In Unicode?, How Do I Detect Invalid
+UTF-8?, How Do I Convert Data Into UTF-8?  Or Vice Versa?, How Do I Display
+Unicode?  How Do I Input Unicode?, How Does Unicode Work With Traditional
+Locales?
+
+=item Hexadecimal Notation
+
+=item Further Resources
+
+=back
+
+=item SEE ALSO
+
+=item ACKNOWLEDGEMENTS
+
+=item AUTHOR, COPYRIGHT, AND LICENSE
+
+=back
+
 =head2 perlunicode - Unicode support in Perl
 
 =over 4
@@ -2135,6 +2190,19 @@ to enable UTF-8/UTF-EBCDIC in scripts
 
 =item UNICODE REGULAR EXPRESSION SUPPORT LEVEL
 
+=over 4
+
+=item Unicode Encodings
+
+UTF-8, UTF-16, UTF-16BE, UTF16-LE, Surrogates, and BOMs (Byte Order Marks),
+UTF-32, UTF-32BE, UTF32-LE, UCS-2, UCS-4, UTF-7
+
+=item Security Implications of Malformed UTF-8
+
+=item Unicode in Perl on EBCDIC
+
+=back
+
 =item SEE ALSO
 
 =back
@@ -2575,8 +2643,8 @@ tarball, Announce to the modules list, Announce to clpa, Fix bugs!
 
 =back
 
-=head2 perlfaq1 - General Questions About Perl ($Revision: 1.1 $, $Date:
-2001/09/20 03:03:00 $)
+=head2 perlfaq1 - General Questions About Perl ($Revision: 1.2 $, $Date:
+2001/11/09 08:06:04 $)
 
 =over 4
 
@@ -2622,8 +2690,8 @@ Scheme, or Tcl?
 
 =back
 
-=head2 perlfaq2 - Obtaining and Learning about Perl ($Revision: 1.2 $,
-$Date: 2001/10/16 13:27:22 $)
+=head2 perlfaq2 - Obtaining and Learning about Perl ($Revision: 1.3 $,
+$Date: 2001/11/09 08:06:04 $)
 
 =over 4
 
@@ -2678,8 +2746,8 @@ References, Tutorials, Task-Oriented, Special Topics
 
 =back
 
-=head2 perlfaq3 - Programming Tools ($Revision: 1.8 $, $Date: 2001/10/17
-14:14:20 $)
+=head2 perlfaq3 - Programming Tools ($Revision: 1.9 $, $Date: 2001/11/09
+08:06:04 $)
 
 =over 4
 
@@ -2748,6 +2816,8 @@ stringification, Pass by reference, Tie large variables to disk
 
 =item Where can I learn about CGI or Web programming in Perl?
 
+=item Where can I learn about object-oriented Perl programming?
+
 =item Where can I learn about linking C with Perl? [h2xs, xsubpp]
 
 =item I've read perlembed, perlguts, etc., but I can't embed perl in
@@ -2764,8 +2834,8 @@ mean?
 
 =back
 
-=head2 perlfaq4 - Data Manipulation ($Revision: 1.7 $, $Date: 2001/10/26
-19:46:03 $)
+=head2 perlfaq4 - Data Manipulation ($Revision: 1.8 $, $Date: 2001/11/09
+08:06:04 $)
 
 =over 4
 
@@ -2979,8 +3049,8 @@ array of hashes or arrays?
 
 =back
 
-=head2 perlfaq5 - Files and Formats ($Revision: 1.3 $, $Date: 2001/10/16
-13:27:22 $)
+=head2 perlfaq5 - Files and Formats ($Revision: 1.4 $, $Date: 2001/11/09
+08:06:04 $)
 
 =over 4
 
@@ -3072,7 +3142,7 @@ protected files?  Isn't this a bug in Perl?
 
 =back
 
-=head2 perlfaq6 - Regexes ($Revision: 1.3 $, $Date: 2001/10/16 13:27:22 $)
+=head2 perlfaq6 - Regexes ($Revision: 1.4 $, $Date: 2001/11/09 08:06:04 $)
 
 =over 4
 
@@ -3138,8 +3208,8 @@ file?
 
 =back
 
-=head2 perlfaq7 - Perl Language Issues ($Revision: 1.3 $, $Date: 2001/10/19
-14:39:24 $)
+=head2 perlfaq7 - Perl Language Issues ($Revision: 1.4 $, $Date: 2001/11/07
+02:27:50 $)
 
 =over 4
 
@@ -3217,8 +3287,8 @@ is in scope?
 
 =back
 
-=head2 perlfaq8 - System Interaction ($Revision: 1.2 $, $Date: 2001/10/16
-13:27:22 $)
+=head2 perlfaq8 - System Interaction ($Revision: 1.4 $, $Date: 2001/11/09
+08:06:04 $)
 
 =over 4
 
@@ -3345,7 +3415,7 @@ search path?
 
 =back
 
-=head2 perlfaq9 - Networking ($Revision: 1.3 $, $Date: 2001/10/16 13:27:22
+=head2 perlfaq9 - Networking ($Revision: 1.5 $, $Date: 2001/11/09 08:06:04
 $)
 
 =over 4
@@ -3746,6 +3816,10 @@ C<!!!>, C<!!>, C<!>
 
 =item The Typemap
 
+=item Safely Storing Static Data in XS
+
+MY_CXT_KEY, typedef my_cxt_t, START_MY_CXT, MY_CXT_INIT, dMY_CXT, MY_CXT
+
 =back
 
 =item EXAMPLES
@@ -4151,31 +4225,31 @@ hv_iterval, hv_magic, hv_store, hv_store_ent, hv_undef, isALNUM, isALPHA,
 isDIGIT, isLOWER, isSPACE, isUPPER, is_utf8_char, is_utf8_string, items,
 ix, LEAVE, load_module, looks_like_number, MARK, mg_clear, mg_copy,
 mg_find, mg_free, mg_get, mg_length, mg_magical, mg_set, Move, New, newAV,
-Newc, newCONSTSUB, newHV, newRV_inc, newRV_noinc, newSV, NEWSV, newSViv,
+Newc, newCONSTSUB, newHV, newRV_inc, newRV_noinc, NEWSV, newSV, newSViv,
 newSVnv, newSVpv, newSVpvf, newSVpvn, newSVpvn_share, newSVrv, newSVsv,
-newSVuv, newXS, newXSproto, Newz, Nullav, Nullch, Nullcv, Nullhv, Nullsv,
-ORIGMARK, perl_alloc, perl_clone, perl_construct, perl_destruct, perl_free,
-perl_parse, perl_run, PL_modglobal, PL_na, PL_sv_no, PL_sv_undef,
-PL_sv_yes, POPi, POPl, POPn, POPp, POPpbytex, POPpx, POPs, PUSHi, PUSHMARK,
-PUSHn, PUSHp, PUSHs, PUSHu, PUTBACK, Renew, Renewc, require_pv, RETVAL,
-Safefree, savepv, savepvn, SAVETMPS, scan_bin, scan_hex, scan_oct,
-sharedsv_find, sharedsv_init, sharedsv_lock, sharedsv_new,
-sharedsv_thrcnt_dec, sharedsv_thrcnt_inc, sharedsv_unlock, sortsv, SP,
-SPAGAIN, ST, strEQ, strGE, strGT, strLE, strLT, strNE, strnEQ, strnNE,
-StructCopy, SvCUR, SvCUR_set, SvEND, SvGETMAGIC, SvGROW, SvIOK, SvIOKp,
-SvIOK_notUV, SvIOK_off, SvIOK_on, SvIOK_only, SvIOK_only_UV, SvIOK_UV,
-SvIV, SvIVX, SvIVx, SvLEN, SvNIOK, SvNIOKp, SvNIOK_off, SvNOK, SvNOKp,
-SvNOK_off, SvNOK_on, SvNOK_only, SvNV, SvNVX, SvNVx, SvOK, SvOOK, SvPOK,
-SvPOKp, SvPOK_off, SvPOK_on, SvPOK_only, SvPOK_only_UTF8, SvPV, SvPVbyte,
-SvPVbytex, SvPVbytex_force, SvPVbyte_force, SvPVbyte_nolen, SvPVutf8,
-SvPVutf8x, SvPVutf8x_force, SvPVutf8_force, SvPVutf8_nolen, SvPVx, SvPVX,
-SvPV_force, SvPV_force_nomg, SvPV_nolen, SvREFCNT, SvREFCNT_dec,
-SvREFCNT_inc, SvROK, SvROK_off, SvROK_on, SvRV, SvSETMAGIC, SvSetMagicSV,
-SvSetMagicSV_nosteal, SvSetSV, SvSetSV_nosteal, SvSTASH, SvTAINT,
-SvTAINTED, SvTAINTED_off, SvTAINTED_on, SvTRUE, SvTYPE, svtype, SVt_IV,
-SVt_NV, SVt_PV, SVt_PVAV, SVt_PVCV, SVt_PVHV, SVt_PVMG, SvUOK, SvUPGRADE,
-SvUTF8, SvUTF8_off, SvUTF8_on, SvUV, SvUVX, SvUVx, sv_2bool, sv_2cv,
-sv_2io, sv_2iv, sv_2mortal, sv_2nv, sv_2pvbyte, sv_2pvbyte_nolen,
+newSVuv, newXS, newXSproto, Newz, new_vstring, Nullav, Nullch, Nullcv,
+Nullhv, Nullsv, ORIGMARK, perl_alloc, perl_clone, perl_construct,
+perl_destruct, perl_free, perl_parse, perl_run, PL_modglobal, PL_na,
+PL_sv_no, PL_sv_undef, PL_sv_yes, POPi, POPl, POPn, POPp, POPpbytex, POPpx,
+POPs, PUSHi, PUSHMARK, PUSHn, PUSHp, PUSHs, PUSHu, PUTBACK, Renew, Renewc,
+require_pv, RETVAL, Safefree, savepv, savepvn, SAVETMPS, scan_bin,
+scan_hex, scan_oct, sharedsv_find, sharedsv_init, sharedsv_lock,
+sharedsv_new, sharedsv_thrcnt_dec, sharedsv_thrcnt_inc, sharedsv_unlock,
+sortsv, SP, SPAGAIN, ST, strEQ, strGE, strGT, strLE, strLT, strNE, strnEQ,
+strnNE, StructCopy, SvCUR, SvCUR_set, SvEND, SvGETMAGIC, SvGROW, SvIOK,
+SvIOKp, SvIOK_notUV, SvIOK_off, SvIOK_on, SvIOK_only, SvIOK_only_UV,
+SvIOK_UV, SvIV, SvIVX, SvIVx, SvLEN, SvNIOK, SvNIOKp, SvNIOK_off, SvNOK,
+SvNOKp, SvNOK_off, SvNOK_on, SvNOK_only, SvNV, SvNVx, SvNVX, SvOK, SvOOK,
+SvPOK, SvPOKp, SvPOK_off, SvPOK_on, SvPOK_only, SvPOK_only_UTF8, SvPV,
+SvPVbyte, SvPVbytex, SvPVbytex_force, SvPVbyte_force, SvPVbyte_nolen,
+SvPVutf8, SvPVutf8x, SvPVutf8x_force, SvPVutf8_force, SvPVutf8_nolen,
+SvPVX, SvPVx, SvPV_force, SvPV_force_nomg, SvPV_nolen, SvREFCNT,
+SvREFCNT_dec, SvREFCNT_inc, SvROK, SvROK_off, SvROK_on, SvRV, SvSETMAGIC,
+SvSetMagicSV, SvSetMagicSV_nosteal, SvSetSV, SvSetSV_nosteal, SvSTASH,
+SvTAINT, SvTAINTED, SvTAINTED_off, SvTAINTED_on, SvTRUE, svtype, SvTYPE,
+SVt_IV, SVt_NV, SVt_PV, SVt_PVAV, SVt_PVCV, SVt_PVHV, SVt_PVMG, SvUOK,
+SvUPGRADE, SvUTF8, SvUTF8_off, SvUTF8_on, SvUV, SvUVx, SvUVX, sv_2bool,
+sv_2cv, sv_2io, sv_2iv, sv_2mortal, sv_2nv, sv_2pvbyte, sv_2pvbyte_nolen,
 sv_2pvutf8, sv_2pvutf8_nolen, sv_2pv_flags, sv_2pv_nolen, sv_2uv,
 sv_backoff, sv_bless, sv_catpv, sv_catpvf, sv_catpvf_mg, sv_catpvn,
 sv_catpvn_flags, sv_catpvn_mg, sv_catpv_mg, sv_catsv, sv_catsv_flags,
@@ -4185,21 +4259,22 @@ sv_gets, sv_grow, sv_inc, sv_insert, sv_isa, sv_isobject, sv_iv, sv_len,
 sv_len_utf8, sv_magic, sv_mortalcopy, sv_newmortal, sv_newref, sv_nv,
 sv_pos_b2u, sv_pos_u2b, sv_pv, sv_pvbyte, sv_pvbyten, sv_pvbyten_force,
 sv_pvn, sv_pvn_force, sv_pvn_force_flags, sv_pvutf8, sv_pvutf8n,
-sv_pvutf8n_force, sv_reftype, sv_replace, sv_report_used, sv_reset,
-sv_rvweaken, sv_setiv, sv_setiv_mg, sv_setnv, sv_setnv_mg, sv_setpv,
-sv_setpvf, sv_setpvf_mg, sv_setpviv, sv_setpviv_mg, sv_setpvn,
-sv_setpvn_mg, sv_setpv_mg, sv_setref_iv, sv_setref_nv, sv_setref_pv,
-sv_setref_pvn, sv_setref_uv, sv_setsv, sv_setsv_flags, sv_setsv_mg,
-sv_setuv, sv_setuv_mg, sv_taint, sv_tainted, sv_true, sv_unmagic, sv_unref,
-sv_unref_flags, sv_untaint, sv_upgrade, sv_usepvn, sv_usepvn_mg,
-sv_utf8_decode, sv_utf8_downgrade, sv_utf8_encode, sv_utf8_upgrade,
-sv_utf8_upgrade_flags, sv_uv, sv_vcatpvfn, sv_vsetpvfn, THIS, toLOWER,
-toUPPER, utf8n_to_uvchr, utf8n_to_uvuni, utf8_distance, utf8_hop,
-utf8_length, utf8_to_bytes, utf8_to_uvchr, utf8_to_uvuni, uvchr_to_utf8,
-uvuni_to_utf8, warn, XPUSHi, XPUSHn, XPUSHp, XPUSHs, XPUSHu, XS, XSRETURN,
-XSRETURN_EMPTY, XSRETURN_IV, XSRETURN_NO, XSRETURN_NV, XSRETURN_PV,
-XSRETURN_UNDEF, XSRETURN_YES, XST_mIV, XST_mNO, XST_mNV, XST_mPV,
-XST_mUNDEF, XST_mYES, XS_VERSION, XS_VERSION_BOOTCHECK, Zero
+sv_pvutf8n_force, sv_recode_to_utf8, sv_reftype, sv_replace,
+sv_report_used, sv_reset, sv_rvweaken, sv_setiv, sv_setiv_mg, sv_setnv,
+sv_setnv_mg, sv_setpv, sv_setpvf, sv_setpvf_mg, sv_setpviv, sv_setpviv_mg,
+sv_setpvn, sv_setpvn_mg, sv_setpv_mg, sv_setref_iv, sv_setref_nv,
+sv_setref_pv, sv_setref_pvn, sv_setref_uv, sv_setsv, sv_setsv_flags,
+sv_setsv_mg, sv_setuv, sv_setuv_mg, sv_taint, sv_tainted, sv_true,
+sv_unmagic, sv_unref, sv_unref_flags, sv_untaint, sv_upgrade, sv_usepvn,
+sv_usepvn_mg, sv_utf8_decode, sv_utf8_downgrade, sv_utf8_encode,
+sv_utf8_upgrade, sv_utf8_upgrade_flags, sv_uv, sv_vcatpvfn, sv_vsetpvfn,
+THIS, toLOWER, toUPPER, to_utf8_case, utf8n_to_uvchr, utf8n_to_uvuni,
+utf8_distance, utf8_hop, utf8_length, utf8_to_bytes, utf8_to_uvchr,
+utf8_to_uvuni, uvchr_to_utf8, uvuni_to_utf8, warn, XPUSHi, XPUSHn, XPUSHp,
+XPUSHs, XPUSHu, XS, XSRETURN, XSRETURN_EMPTY, XSRETURN_IV, XSRETURN_NO,
+XSRETURN_NV, XSRETURN_PV, XSRETURN_UNDEF, XSRETURN_YES, XST_mIV, XST_mNO,
+XST_mNV, XST_mPV, XST_mUNDEF, XST_mYES, XS_VERSION, XS_VERSION_BOOTCHECK,
+Zero
 
 =item AUTHORS
 
@@ -4240,9 +4315,6 @@ sv_clean_all, sv_clean_objs, sv_free_arenas
 
 =item Data Structures
 
-1. The functions and attributes of the "layer class", 2. The per-instance
-data for a particular handle
-
 =item Functions and Attributes
 
 =item Per-instance Data
@@ -4392,8 +4464,6 @@ PerlIO_apply_layers(f,mode,layers), PerlIO_binmode(f,ptype,imode,layers),
 
 =item Custom opcodes
 
-=item spawnvp() on Win32
-
 =item DLL Versioning
 
 =item Introduce @( and @)
@@ -4478,7 +4548,7 @@ PerlIO_apply_layers(f,mode,layers), PerlIO_binmode(f,ptype,imode,layers),
 
 =item Prototypes versus indirect objects
 
-=item Install HMTL
+=item Install HTML
 
 =item Prototype method calls
 
@@ -4512,6 +4582,8 @@ PerlIO_apply_layers(f,mode,layers), PerlIO_binmode(f,ptype,imode,layers),
 
 =item Use fchown/fchmod internally
 
+=item Make v-strings overloaded objects
+
 =back
 
 =item Vague ideas
@@ -4756,7 +4828,7 @@ finish, 'enter', print
 =item Writing a test
 
 F<t/base/>, F<t/cmd/>, F<t/comp/>, F<t/io/>, F<t/lib/>, F<t/op/>,
-F<t/pod/>, F<t/run/>
+F<t/pod/>, F<t/run/>, t/base t/comp, t/cmd t/run t/io t/op, t/lib ext lib
 
 =back
 
@@ -4933,7 +5005,7 @@ I<The Road goes ever on and on, down from the door where it began.>
 
 =item Cygwin intermittent failures of lib/Memoize/t/expire_file 11 and 12
 
-=item HP-UX lib/io_multihomed Fails When LP64-Configur
+=item HP-UX lib/io_multihomed Fails When LP64-Configured
 
 =item  HP-UX lib/posix Subtest 9 Fails When LP64-Configured
 
@@ -6252,6 +6324,50 @@ Source, Compiled Module Source, Perl Modules/Scripts
 
 =back
 
+=head2 perldos - Perl under DOS, W31, W95.
+
+=over 4
+
+=item SYNOPSIS
+
+=item DESCRIPTION
+
+=over 4
+
+=item Prerequisites for Compiling Perl on DOS
+
+DJGPP, Pthreads
+
+=item Shortcomings of Perl under DOS
+
+=item Building Perl on DOS
+
+=item Testing Perl on DOS
+
+=item Installation of Perl on DOS
+
+=back
+
+=item BUILDING AND INSTALLING MODULES ON DOS
+
+=over 4
+
+=item Building Prerequisites for Perl on DOS
+
+=item Unpacking CPAN Modules on DOS
+
+=item Building Non-XS Modules on DOS
+
+=item Building XS Modules on DOS
+
+=back
+
+=item AUTHOR
+
+=item SEE ALSO
+
+=back
+
 =head2 perlepoc, README.epoc - Perl for EPOC
 
 =over 4
@@ -6422,7 +6538,7 @@ op/lexassign.t, pragma/warnings.t
 
 =item NOTE
 
-=item What's New in Perl ffor MPE/iX
+=item What's New in Perl for MPE/iX
 
 =item Welcome to Perl/iX
 
@@ -7130,6 +7246,48 @@ LIST, waitpid PID,FLAGS
 
 =back
 
+=head2 perlwin32 - Perl under Win32
+
+=over 4
+
+=item SYNOPSIS
+
+=item DESCRIPTION
+
+=over 4
+
+=item Setting Up Perl on Win32
+
+Make, Command Shell, Borland C++, Microsoft Visual C++, Mingw32 with GCC
+
+=item Building
+
+=item Testing Perl on Win32
+
+=item Installation of Perl on Win32
+
+=item Usage Hints for Perl on Win32
+
+Environment Variables, File Globbing, Using perl from the command line,
+Building Extensions, Command-line Wildcard Expansion, Win32 Specific
+Extensions, Running Perl Scripts, Miscellaneous Things
+
+=back
+
+=item BUGS AND CAVEATS
+
+=item AUTHORS
+
+Gary Ng E<lt>71564.1743@CompuServe.COME<gt>, Gurusamy Sarathy
+E<lt>gsar@activestate.comE<gt>, Nick Ing-Simmons
+E<lt>nick@ing-simmons.netE<gt>
+
+=item SEE ALSO
+
+=item HISTORY
+
+=back
+
 =head1 PRAGMA DOCUMENTATION
 
 =head2 attrs - set/get attributes of a subroutine (deprecated)
@@ -7163,11 +7321,12 @@ data structures between threads
 
 =item DESCRIPTION
 
-=over 4
-
 =item EXPORT
 
-=back
+=item FUNCTIONS
+
+share VARIABLE, lock VARIABLE, unlock VARIABLE, cond_wait VARIABLE,
+cond_signal VARIABLE, cond_broadcast VARIABLE
 
 =item BUGS
 
@@ -7186,8 +7345,8 @@ from perl
 
 =item DESCRIPTION
 
-new, function, LIST, $threads->join, $threads->detach, threads->self,
-$threads->tid
+$thread = new(function, LIST), $thread->join, $thread->detach,
+threads->self, $thread->tid
 
 =item TODO
 
@@ -7249,6 +7408,18 @@ FETCH_I<type>_ATTRIBUTES, MODIFY_I<type>_ATTRIBUTES
 
 =back
 
+=head2 attrs - set/get attributes of a subroutine (deprecated)
+
+=over 4
+
+=item SYNOPSIS
+
+=item DESCRIPTION
+
+method, locked
+
+=back
+
 =head2 autouse - postpone load of modules until a function is used
 
 =over 4
@@ -7307,7 +7478,7 @@ semantics
 =back
 
 =head2 charnames - define character names for C<\N{named}> string literal
-escape.
+escapes.
 
 =over 4
 
@@ -7317,6 +7488,8 @@ escape.
 
 =item CUSTOM TRANSLATORS
 
+=item charnames::viacode(code)
+
 =item BUGS
 
 =back
@@ -7378,6 +7551,21 @@ diagnostics
 
 =back
 
+=head2 encoding - pragma to control the conversion of legacy data into
+Unicode
+
+=over 4
+
+=item SYNOPSIS
+
+=item DESCRIPTION
+
+=item KNOWN PROBLEMS
+
+=item SEE ALSO
+
+=back
+
 =head2 fields - compile-time class fields
 
 =over 4
@@ -7653,6 +7841,58 @@ C<strict refs>, C<strict vars>, C<strict subs>
 
 =back
 
+=head2 threads - Perl extension allowing use of interpreter based threads
+from perl
+
+=over 4
+
+=item SYNOPSIS
+
+=item DESCRIPTION
+
+$thread = new(function, LIST), $thread->join, $thread->detach,
+threads->self, $thread->tid
+
+=item TODO
+
+Fix so the return value is returned when you join, Add join_all, Fix memory
+leaks!
+
+=item AUTHOR and COPYRIGHT
+
+=item BUGS
+
+creating a thread from within a thread is unsafe under win32,
+PERL_OLD_SIGNALS are not threadsafe, will not be
+
+=item SEE ALSO
+
+=back
+
+=head2 threadshared, threads::shared - Perl extension for sharing data
+structures between threads
+
+=over 4
+
+=item SYNOPSIS
+
+=item DESCRIPTION
+
+=item EXPORT
+
+=item FUNCTIONS
+
+share VARIABLE, lock VARIABLE, unlock VARIABLE, cond_wait VARIABLE,
+cond_signal VARIABLE, cond_broadcast VARIABLE
+
+=item BUGS
+
+=item AUTHOR
+
+=item SEE ALSO
+
+=back
+
 =head2 utf8 - Perl pragma to enable/disable UTF-8 (or UTF-EBCDIC) in source
 code
 
@@ -7685,6 +7925,18 @@ utf8::encode($string), $flag = utf8::decode($string)
 
 =back
 
+=head2 vmsish - Perl pragma to control VMS-specific language features
+
+=over 4
+
+=item SYNOPSIS
+
+=item DESCRIPTION
+
+C<vmsish status>, C<vmsish exit>, C<vmsish time>, C<vmsish hushed>
+
+=back
+
 =head2 warnings - Perl pragma to control optional warnings
 
 =over 4
@@ -8307,8 +8559,8 @@ TIMEDIFF, [ STYLE, [ FORMAT ] ] )
 =item Optional Exports
 
 clearcache ( COUNT ), clearallcache ( ), cmpthese ( COUT, CODEHASHREF, [
-STYLE ] ), cmpthese ( RESULTSHASHREF ), countit(TIME, CODE), disablecache (
-), enablecache ( ), timesum ( T1, T2 )
+STYLE ] ), cmpthese ( RESULTSHASHREF, [ STYLE ] ), countit(TIME, CODE),
+disablecache ( ), enablecache ( ), timesum ( T1, T2 )
 
 =back
 
@@ -8527,7 +8779,8 @@ B<Parameters:>
 
 =item CREATING A CLICKABLE IMAGE BUTTON
 
-B<Parameters:>
+B<Parameters:>, 3. The third option (-align, optional) is an alignment
+type, and may be TOP, BOTTOM or MIDDLE
 
 =item CREATING A JAVASCRIPT ACTION BUTTON
 
@@ -8557,8 +8810,9 @@ the <FORM> tag
 =item FETCHING ENVIRONMENT VARIABLES
 
 B<Accept()>, B<raw_cookie()>, B<user_agent()>, B<path_info()>,
-B<path_translated()>, B<remote_host()>, B<script_name()>, B<referer()>,
-B<auth_type ()>, B<server_name ()>, B<virtual_host ()>, B<server_port ()>,
+B<path_translated()>, B<remote_host()>, B<script_name()> Return the script
+name as a partial URL, for self-refering scripts, B<referer()>, B<auth_type
+()>, B<server_name ()>, B<virtual_host ()>, B<server_port ()>,
 B<server_software ()>, B<remote_user ()>, B<user_name ()>,
 B<request_method()>, B<content_type()>, B<http()>, B<https()>
 
@@ -9539,7 +9793,8 @@ $Data::Dumper::Quotekeys  I<or>  $I<OBJ>->Quotekeys(I<[NEWVAL]>),
 $Data::Dumper::Bless  I<or>  $I<OBJ>->Bless(I<[NEWVAL]>),
 $Data::Dumper::Maxdepth  I<or>	$I<OBJ>->Maxdepth(I<[NEWVAL]>),
 $Data::Dumper::Useperl	I<or>  $I<OBJ>->Useperl(I<[NEWVAL]>),
-$Data::Dumper::Sortkeys  I<or>	$I<OBJ>->Sortkeys(I<[NEWVAL]>)
+$Data::Dumper::Sortkeys  I<or>	$I<OBJ>->Sortkeys(I<[NEWVAL]>),
+$Data::Dumper::Deparse	I<or>  $I<OBJ>->Deparse(I<[NEWVAL]>)
 
 =item Exports
 
@@ -9589,6 +9844,8 @@ Dumper
 
 =over 4
 
+=item Runtime debugging
+
 =item Memory footprint debugging
 
 =back
@@ -9786,8 +10043,8 @@ Fixed length 32-bit encodings, Multi-byte encodings, "Escape" encodings
 
 =item Encoding Names
 
-The MIME name as defined in IETF RFC-XXXX, The name in the IANA registry,
-The name used by the organization that defined it
+The MIME name as defined in IETF RFCs, The name in the IANA registry, The
+name used by the organization that defined it
 
 =back
 
@@ -9904,6 +10161,22 @@ arrays
 
 =back
 
+=head2 Errno - System errno constants
+
+=over 4
+
+=item SYNOPSIS
+
+=item DESCRIPTION
+
+=item CAVEATS
+
+=item AUTHOR
+
+=item COPYRIGHT
+
+=back
+
 =head2 Exporter - Implements default import method for modules
 
 =over 4
@@ -10358,6 +10631,8 @@ prefixify
 
 processPL (o)
 
+quote_paren
+
 realclean (o)
 
 replace_manpage_separator
@@ -10613,8 +10888,9 @@ MAKEAPERL, MAKEFILE, MAN1PODS, MAN3PODS, MAP_TARGET, MYEXTLIB, NAME,
 NEEDS_LINKING, NOECHO, NORECURS, NO_VC, OBJECT, OPTIMIZE, PERL, PERL_CORE,
 PERLMAINCC, PERL_ARCHLIB, PERL_LIB, PERL_MALLOC_OK, PERLRUN, PERM_RW,
 PERM_RWX, PL_FILES, PM, PMLIBDIRS, PM_FILTER, POLLUTE, PPM_INSTALL_EXEC,
-PPM_INSTALL_SCRIPT, PREFIX, PREREQ_PM, PREREQ_FATAL, SKIP, TEST_LIBS,
-VERSION, VERSION_FROM, XS, XSOPT, XSPROTOARG, XS_VERSION
+PPM_INSTALL_SCRIPT, PREFIX, PREREQ_PM, PREREQ_FATAL, PREREQ_PRINT,
+PRINT_PREREQ, SKIP, TEST_LIBS, VERSION, VERSION_FROM, XS, XSOPT,
+XSPROTOARG, XS_VERSION
 
 =item Additional lowercase attributes
 
@@ -10867,6 +11143,8 @@ C<wanted>, C<bydepth>, C<preprocess>, C<postprocess>, C<follow>,
 C<follow_fast>, C<follow_skip>, C<dangling_symlinks>, C<no_chdir>,
 C<untaint>, C<untaint_pattern>, C<untaint_skip>
 
+=item WARNINGS
+
 =item CAVEAT
 
 $dont_use_nlink, symlinks
@@ -11334,6 +11612,19 @@ $fh->print, $fh->printf, $fh->getline, $fh->getlines
 
 =item All-in-one interface
 
+=item Filtering only specific components of source code
+
+C<"code">, C<"executable">, C<"quotelike">, C<"string">, C<"regex">,
+C<"all">
+
+=item Filtering only the code parts of source code
+
+Most source code ceases to be grammatically correct when it is broken up
+into the pieces between string literals and regexes. So the C<'code'>
+component filter behaves slightly differently from the other partial
+filters
+described in the previous section.
+
 =item Using Filter::Simple and Exporter together
 
 =item How it works
@@ -12379,40 +12670,6 @@ set ( NAME => VALUE [, NAME => VALUE ...] ), setall ( VALUES ), setval ( N
 
 =back
 
-=head2 Lingua::KO::Hangul::Util - utility functions for Hangul Syllables
-
-=over 4
-
-=item SYNOPSIS
-
-=item DESCRIPTION
-
-=over 4
-
-=item Composition and Decomposition
-
-C<$string_decomposed = decomposeHangul($codepoint)>, C<@codepoints =
-decomposeHangul($codepoint)>, C<$string_composed =
-composeHangul($src_string)>, C<@codepoints_composed =
-composeHangul($src_string)>
-
-=item Hangul Syllable Name
-
-C<$name = getHangulName($codepoint)>, C<$codepoint =
-parseHangulName($name)>
-
-=item EXPORT
-
-=back
-
-=item AUTHOR
-
-=item SEE ALSO
-
-http://www.unicode.org/unicode/reports/tr15
-
-=back
-
 =head2 List::Util - A selection of general-utility list subroutines
 
 =over 4
@@ -12886,8 +13143,9 @@ Out of Memory!, Fails to load Calc on Perl prior 5.6.0
 
 =item CAVEATS
 
-stringify, bstr(), bsstr() and 'cmp', int(), bdiv, bdiv, Modifying and =,
-bpow, Overloading -$x, Mixing different object types, bsqrt()
+stringify, bstr(), bsstr() and 'cmp', int(), length, bdiv, infinity
+handling, Modifying and =, bpow, Overloading -$x, Mixing different object
+types, bsqrt()
 
 =item LICENSE
 
@@ -13521,7 +13779,7 @@ functions
 
 =over 4
 
-=item How do I download files from a FTP server ?
+=item How do I download files from an FTP server ?
 
 =item How do I transfer files in binary mode ?
 
@@ -13534,13 +13792,13 @@ functions
 
 =item Can I do a reget operation like the ftp command ?
 
-=item How do I get a directory listing from a FTP server ?
+=item How do I get a directory listing from an FTP server ?
 
-=item Changeing directory to "" does not fail ?
+=item Changing directory to "" does not fail ?
 
 =item I am behind a SOCKS firewall, but the Firewall option does not work ?
 
-=item I am behind a FTP proxy firewall, but cannot access machines outside
+=item I am behind an FTP proxy firewall, but cannot access machines outside
 ?
 
 =item My ftp proxy firewall does not listen on port 21
@@ -14477,7 +14735,7 @@ B<_clean_latex_commands>
 
 =item DESCRIPTION
 
-center, date, fixed, fixedbold, fixeditalic, fixedbolditalic, quotes,
+center, date, fixed, fixedbold, fixeditalic, fixedbolditalic, name, quotes,
 release, section
 
 =item DIAGNOSTICS
@@ -14496,6 +14754,20 @@ escape EE<lt>%sE<gt>, %s:%d: Unknown sequence %s, %s:%d: Unmatched =back
 
 =back
 
+=head2 Pod::ParseLink -- Parse an L<> formatting code in POD text
+
+=over 4
+
+=item SYNOPSIS
+
+=item DESCRIPTION
+
+=item AUTHOR
+
+=item COPYRIGHT AND LICENSE
+
+=back
+
 =head2 Pod::ParseUtils - helpers for POD parsing and conversion
 
 =over 4
@@ -15318,6 +15590,8 @@ C<Storable::is_retrieving>
 
 =item BUGS
 
+=item LIMITATION
+
 =item COPYRIGHT
 
 =back
@@ -15978,8 +16252,7 @@ unexpand(1)
 
 =back
 
-=head2 Thread - manipulate threads in Perl (EXPERIMENTAL, subject to
-change)
+=head2 Thread - manipulate threads in Perl
 
 =over 4
 
@@ -15991,9 +16264,9 @@ change)
 
 =item FUNCTIONS
 
-new \&start_sub, new \&start_sub, LIST, lock VARIABLE, async BLOCK;,
-Thread->self, Thread->list, cond_wait VARIABLE, cond_signal VARIABLE,
-cond_broadcast VARIABLE, yield
+$thread = Thread->new(\&start_sub), $thread = Thread->new(\&start_sub,
+LIST), lock VARIABLE, async BLOCK;, Thread->self, cond_wait VARIABLE,
+cond_signal VARIABLE, cond_broadcast VARIABLE, yield
 
 =item METHODS
 
@@ -16250,8 +16523,8 @@ function
 
 =item DESCRIPTION
 
-isa ( TYPE ), can ( METHOD ), VERSION ( [ REQUIRE ] ), UNIVERSAL::isa (
-VAL, TYPE ), UNIVERSAL::can ( VAL, METHOD )
+$obj->isa( TYPE ), CLASS->isa( TYPE ), isa( VAL, TYPE ), $obj->can( METHOD
+), CLASS->can( METHOD ), can( VAL, METHOD ), VERSION ( [ REQUIRE ] )
 
 =back
 
@@ -16273,10 +16546,14 @@ undefChar, katakana_before_hiragana, upper_before_lower
 
 =item Other methods
 
-C<@sorted = $UCA-E<gt>sort(@not_sorted)>, C<$result = $UCA-E<gt>cmp($a,
-$b)>, C<$sortKey = $UCA-E<gt>getSortKey($string)>, C<$position =
-$UCA-E<gt>index($string, $substring)>, C<($position, $length) =
-$UCA-E<gt>index($string, $substring)>
+C<@sorted = $Collator-E<gt>sort(@not_sorted)>, C<$result =
+$Collator-E<gt>cmp($a, $b)>, C<$result = $Collator-E<gt>eq($a, $b)>,
+C<$result = $Collator-E<gt>ne($a, $b)>, C<$result = $Collator-E<gt>lt($a,
+$b)>, C<$result = $Collator-E<gt>le($a, $b)>, C<$result =
+$Collator-E<gt>gt($a, $b)>, C<$result = $Collator-E<gt>ge($a, $b)>,
+C<$sortKey = $Collator-E<gt>getSortKey($string)>, C<$position =
+$Collator-E<gt>index($string, $substring)>, C<($position, $length) =
+$Collator-E<gt>index($string, $substring)>
 
 =item EXPORT
 
@@ -16288,8 +16565,7 @@ $UCA-E<gt>index($string, $substring)>
 
 =item SEE ALSO
 
-L<Lingua::KO::Hangul::Util>, L<Unicode::Normalize>, Unicode Collation
-Algorithm - Unicode TR #10
+Unicode Collation Algorithm - Unicode TR #10, L<Unicode::Normalize>
 
 =back
 
@@ -16403,6 +16679,8 @@ L<Lingua::KO::Hangul::Util>, http://www.unicode.org/unicode/reports/tr15/
 
 =over 4
 
+=item BUGS
+
 =item AUTHOR
 
 =back
diff --git a/pod/perltodo.pod b/pod/perltodo.pod
index 1898b118d4..f0b1b721c2 100644
--- a/pod/perltodo.pod
+++ b/pod/perltodo.pod
@@ -54,6 +54,9 @@ Possible options, controlled by the flags:
 - append a "..." to the produced string if the maximum length is exceeded
 - really fancy: print unicode characters as \N{...}
 
+NOTE: pv_display(), pv_uni_display(), sv_uni_display() are doing
+something like the above.
+
 =head2 Overloadable regex assertions
 
 This may or may not be possible with the current regular expression
@@ -170,7 +173,7 @@ C<[1234567890]> aren't the only numerals any more.
 
 =head2 POSIX Unicode character classes
 
-([=a=] for equivalance classes, [.ch.] for collation.)
+(C<[=a=]> for equivalance classes, C<[.ch.]> for collation.)
 These are dependent on Unicode normalization and collation.
 
 =head2 Factoring out common suffices/prefices in regexps (trie optimization)
@@ -191,7 +194,7 @@ Cozens has some ideas on this.
 
 =head2 DLL Versioning
 
-Windows needs a way to know what version of a XS or C<libperl> DLL it's
+Windows needs a way to know what version of an XS or C<libperl> DLL it's
 loading.
 
 =head2 Introduce @( and @)
@@ -210,7 +213,7 @@ fp_setmask(), fp_getmask(), fp_setround(), fp_getround()
 (no metaconfig units yet for these).  Don't forget finitel(), fp_classl(),
 fp_class_l(), (yes, both do, unfortunately, exist), and unorderedl().)
 
-As of Perl 5.6.1 is a Perl macro, Perl_isnan().
+As of Perl 5.6.1, there is a Perl macro, Perl_isnan().
 
 =head2 IV/UV preservation
 
@@ -276,7 +279,7 @@ mark-and-sweep GC implementation.
 
 Alan notes that: The basic idea was to extend the parser token stack
 (C<YYSTYPE>) to include a type field so we knew what sort of thing each
-element of the stack was.  The F<<perly.c> code would then have to be
+element of the stack was.  The F<perly.c> code would then have to be
 postprocessed to record the type of each entry on the stack as it was
 created, and the parser patched so that it could unroll the stack
 properly on error.
@@ -319,11 +322,11 @@ Damian Conway is planning to work on this, but it hasn't happened yet.
 
 =head2 Using POSIX calls internally
 
-When faced with a BSD vs. SySV -style interface to some library or
+When faced with a BSD vs. SysV -style interface to some library or
 system function, perl's roots show in that it typically prefers the BSD
 interface (but falls back to the SysV one).  One example is getpgrp().
 Other examples include C<memcpy> vs. C<bcopy>.  There are others, mostly in
-F<<pp_sys.c>.
+F<pp_sys.c>.
 
 Mostly, this item is a suggestion for which way to start a journey into
 an C<#ifdef> forest.  It is not primarily a suggestion to eliminate any of
@@ -441,7 +444,7 @@ Look at the "reification" code in C<av.c>
 
 Currently, indirect object syntax bypasses prototype checks.
 
-=head2 Install HMTL
+=head2 Install HTML
 
 HTML versions of the documentation need to be installed by default; a
 call to C<installhtml> from C<installperl> may be all that's necessary.
@@ -508,6 +511,12 @@ Hugo van der Sanden plans to look at this.
 This has been done in places, but needs a thorough code review.
 Also fchdir is available in some platforms.
 
+=head2 Make v-strings overloaded objects
+
+Instead of having to guess whether a string is a v-string and thus
+needs to be displayed with %vd, make v-strings (readonly) objects
+(class "vstring"?) with a stringify overload.
+
 =head1 Vague ideas
 
 Ideas which have been discussed, and which may or may not happen.
@@ -612,11 +621,11 @@ can be found on the CPAN.
 
 =head2 gettimeofday
 
-C<Time::Hires> has been integrated into the core.
+C<Time::HiRes> has been integrated into the core.
 
 =head2 setitimer and getimiter
 
-Adding C<Time::Hires> got us this too.
+Adding C<Time::HiRes> got us this too.
 
 =head2 Testing __DIE__ hook
 
diff --git a/pod/perltooc.pod b/pod/perltooc.pod
index c162220061..2ba6b42a0b 100644
--- a/pod/perltooc.pod
+++ b/pod/perltooc.pod
@@ -646,7 +646,7 @@ name them whatever you care to.  Blindly and obediently using new()
 for each and every constructor you ever write is to speak Perl with
 such a severe C++ accent that you do a disservice to both languages.
 There's no reason to insist that each class have but one constructor,
-or that that constructor be named new(), or that that constructor be
+or that a constructor be named new(), or that a constructor be
 used solely as a class method and not an object method.
 
 The next section shows how useful it can be to further distance ourselves
diff --git a/pod/perltrap.pod b/pod/perltrap.pod
index 753e721fcb..831d2d5402 100644
--- a/pod/perltrap.pod
+++ b/pod/perltrap.pod
@@ -651,6 +651,16 @@ are to used around the name.
     # perl4 prints: {a}
     # perl5 prints: 2
 
+=item * Parsing
+
+When perl sees C<map {> (or C<grep {>), it has to guess whether the C<{>
+starts a BLOCK or a hash reference. If it guesses wrong, it will report
+a syntax error near the C<}> and the missing (or unexpected) comma.
+
+Use unary C<+> before C<{> on a hash reference, and unary C<+> applied
+to the first thing in a BLOCK (after C<{>), for perl to guess right all
+the time. (See L<perlfunc/map>.)
+
 =back
 
 =head2 Numerical Traps
@@ -688,7 +698,7 @@ If in doubt:
 
 Assignment of return values from numeric equality tests
 does not work in perl5 when the test evaluates to false (0).
-Logical tests now return an null, instead of 0
+Logical tests now return a null, instead of 0
 
     $p = ($test == 1);
     print $p,"\n";
diff --git a/pod/perlunicode.pod b/pod/perlunicode.pod
index 106a4bf610..64116bcae1 100644
--- a/pod/perlunicode.pod
+++ b/pod/perlunicode.pod
@@ -6,19 +6,9 @@ perlunicode - Unicode support in Perl
 
 =head2 Important Caveats
 
-WARNING: While the implementation of Unicode support in Perl is now
-fairly complete it is still evolving to some extent.
-
-In particular the way Unicode is handled on EBCDIC platforms is still
-rather experimental. On such a platform references to UTF-8 encoding
-in this document and elsewhere should be read as meaning UTF-EBCDIC as
-specified in Unicode Technical Report 16 unless ASCII vs EBCDIC issues
-are specifically discussed. There is no C<utfebcdic> pragma or
-":utfebcdic" layer, rather "utf8" and ":utf8" are re-used to mean
-platform's "natural" 8-bit encoding of Unicode. See L<perlebcdic> for
-more discussion of the issues.
-
-The following areas are still under development.
+Unicode support is an extensive requirement. While perl does not
+implement the Unicode standard or the accompanying technical reports
+from cover to cover, Perl does support many Unicode features.
 
 =over 4
 
@@ -27,30 +17,30 @@ The following areas are still under development.
 A filehandle can be marked as containing perl's internal Unicode
 encoding (UTF-8 or UTF-EBCDIC) by opening it with the ":utf8" layer.
 Other encodings can be converted to perl's encoding on input, or from
-perl's encoding on output by use of the ":encoding()" layer.  There is
-not yet a clean way to mark the Perl source itself as being in an
-particular encoding.
+perl's encoding on output by use of the ":encoding(...)" layer.
+See L<open>.
+
+To mark the Perl source itself as being in a particular encoding,
+see L<encoding>.
 
 =item Regular Expressions
 
-The regular expression compiler does now attempt to produce
-polymorphic opcodes.  That is the pattern should now adapt to the data
-and automatically switch to the Unicode character scheme when
-presented with Unicode data, or a traditional byte scheme when
-presented with byte data.  The implementation is still new and
-(particularly on EBCDIC platforms) may need further work.
+The regular expression compiler produces polymorphic opcodes.  That is,
+the pattern adapts to the data and automatically switch to the Unicode
+character scheme when presented with Unicode data, or a traditional
+byte scheme when presented with byte data.
 
 =item C<use utf8> still needed to enable UTF-8/UTF-EBCDIC in scripts
 
 The C<utf8> pragma implements the tables used for Unicode support.
-These tables are automatically loaded on demand, so the C<utf8> pragma
-need not normally be used.
+However, these tables are automatically loaded on demand, so the
+C<utf8> pragma should not normally be used.
 
-However, as a compatibility measure, this pragma must be explicitly
-used to enable recognition of UTF-8 in the Perl scripts themselves on
-ASCII based machines or recognize UTF-EBCDIC on EBCDIC based machines.
-B<NOTE: this should be the only place where an explicit C<use utf8> is
-needed>.
+As a compatibility measure, this pragma must be explicitly used to
+enable recognition of UTF-8 in the Perl scripts themselves on ASCII
+based machines or recognize UTF-EBCDIC on EBCDIC based machines.
+B<NOTE: this should be the only place where an explicit C<use utf8>
+is needed>.
 
 You can also use the C<encoding> pragma to change the default encoding
 of the data in your script; see L<encoding>.
@@ -81,11 +71,11 @@ character data.  Such data may come from filehandles, from calls to
 external programs, from information provided by the system (such as %ENV),
 or from literals and constants in the source text.
 
-If the C<-C> command line switch is used, (or the
+On Windows platforms, 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.  Note that this is
-currently only implemented on Windows since other platforms API
-standard on this area.
+currently only implemented on Windows since other platforms lack an
+API standard on this area.
 
 Regardless of the above, the C<bytes> pragma can always be used to
 force byte semantics in a particular lexical scope.  See L<bytes>.
@@ -285,6 +275,8 @@ have their directionality defined:
     BidiWS      Whitespace
     BidiON      Other Neutrals
 
+=back
+
 =head2 Scripts
 
 The scripts available for C<\p{In...}> and C<\P{In...}>, for example
@@ -491,6 +483,8 @@ below list that have the C<Block> appended).
    Yi Radicals
    Yi Syllables
 
+=over 4
+
 =item *
 
 The special pattern C<\X> match matches any extended Unicode sequence
@@ -573,7 +567,7 @@ than one Unicode character
 
 =back
 
-What doesn't yet work are the followng cases:
+What doesn't yet work are the following cases:
 
 =over 8
 
@@ -632,20 +626,29 @@ Level 1 - Basic Unicode Support
         2.2 Categories                          - done          [3][4]
         2.3 Subtraction                         - MISSING       [5][6]
         2.4 Simple Word Boundaries              - done          [7]
-        2.5 Simple Loose Matches                - MISSING       [8]
+        2.5 Simple Loose Matches                - done          [8]
         2.6 End of Line                         - MISSING       [9][10]
 
         [ 1] \x{...}
         [ 2] \N{...}
         [ 3] . \p{Is...} \P{Is...}
-        [ 4] now scripts (see UTR#24 Script Names) in  addition to blocks
+        [ 4] now scripts (see UTR#24 Script Names) in addition to blocks
         [ 5] have negation
-        [ 6] can use look-ahead to emulate subtracion
+        [ 6] can use look-ahead to emulate subtraction (*)
         [ 7] include Letters in word characters
-        [ 8] see UTR#21 Case Mappings
+        [ 8] see UTR#21 Case Mappings: Perl implements 1:1 mappings
         [ 9] see UTR#13 Unicode Newline Guidelines
         [10] should do ^ and $ also on \x{2028} and \x{2029}
 
+(*) Instead of [\u0370-\u03FF-[{UNASSIGNED}]] as suggested by the TR
+18 you can use negated lookahead: to match currently assigned modern
+Greek characters use for example
+
+		/(?!\p{Cn})[\x{0370}-\x{03ff}]/
+
+In other words: the matched character must not be a non-assigned
+character, but it must be in the block of modern Greek characters.
+
 =item *
 
 Level 2 - Extended Unicode Support
@@ -677,8 +680,109 @@ Level 3 - Locale-Sensitive Support
 
 =back
 
+=head2 Unicode Encodings
+
+Unicode characters are assigned to I<code points> which are abstract
+numbers.  To use these numbers various encodings are needed.
+
+=over 4
+
+=item UTF-8
+
+UTF-8 is the encoding used internally by Perl.  UTF-8 is a variable
+length (1 to 6 bytes, current character allocations require 4 bytes), 
+byteorder independent encoding.  For ASCII, UTF-8 is transparent
+(and we really do mean 7-bit ASCII, not any 8-bit encoding).
+
+=item UTF-16, UTF-16BE, UTF16-LE, Surrogates, and BOMs (Byte Order Marks)
+
+UTF-16 is a 2 or 4 byte encoding.  The Unicode code points
+0x0000..0xFFFF are stored in two 16-bit units, and the code points
+0x010000..0x10FFFF in four 16-bit units.  The latter case is
+using I<surrogates>, the first 16-bit unit being the I<high
+surrogate>, and the second being the I<low surrogate>.
+
+Surrogates are code points set aside to encode the 0x01000..0x10FFFF
+range of Unicode code points in pairs of 16-bit units.  The I<high
+surrogates> are the range 0xD800..0xDBFF, and the I<low surrogates>
+are the range 0xDC00..0xDFFFF.  The surrogate encoding is
+
+	$hi = ($uni - 0x10000) / 0x400 + 0xD800;
+	$lo = ($uni - 0x10000) % 0x400 + 0xDC00;
+
+and the decoding is
+
+	$uni = 0x10000 + ($hi - 0xD8000) * 0x400 + ($lo - 0xDC00);
+
+Because of the 16-bitness, UTF-16 is byteorder dependent.  UTF-16
+itself can be used for in-memory computations, but if storage or
+transfer is required, either UTF-16BE (Big Endian) or UTF-16LE
+(Little Endian) must be chosen.
+
+This introduces another problem: what if you just know that your data
+is UTF-16, but you don't know which endianness?  Byte Order Marks
+(BOMs) are a solution to this.  A special character has been reserved
+in Unicode to function as a byte order marker: the character with the
+code point 0xFEFF is the BOM.
+
+The trick is that if you read a BOM, you will know the byte order,
+since if it was written on a big endian platform, you will read the
+bytes 0xFE 0xFF, but if it was written on a little endian platform,
+you will read the bytes 0xFF 0xFE.  (And if the originating platform
+was writing in UTF-8, you will read the bytes 0xEF 0xBB 0xBF.)
+
+The way this trick works is that the character with the code point
+0xFFFE is guaranteed not to be a valid Unicode character, so the
+sequence of bytes 0xFF 0xFE is unambiguously "BOM, represented in
+little-endian format" and cannot be "0xFFFE, represented in big-endian
+format".
+
+=item UTF-32, UTF-32BE, UTF32-LE
+
+The UTF-32 family is pretty much like the UTF-16 family, expect that
+the units are 32-bit, and therefore the surrogate scheme is not
+needed.  The BOM signatures will be 0x00 0x00 0xFE 0xFF for BE and
+0xFF 0xFE 0x00 0x00 for LE.
+
+=item UCS-2, UCS-4
+
+Encodings defined by the ISO 10646 standard.  UCS-2 is a 16-bit
+encoding, UCS-4 is a 32-bit encoding.  Unlike UTF-16, UCS-2
+is not extensible beyond 0xFFFF, because it does not use surrogates.
+
+=item UTF-7
+
+A seven-bit safe (non-eight-bit) encoding, useful if the
+transport/storage is not eight-bit safe.  Defined by RFC 2152.
+
+=head2 Security Implications of Malformed UTF-8
+
+Unfortunately, the specification of UTF-8 leaves some room for
+interpretation of how many bytes of encoded output one should generate
+from one input Unicode character.  Strictly speaking, one is supposed
+to always generate the shortest possible sequence of UTF-8 bytes,
+because otherwise there is potential for input buffer overflow at the
+receiving end of a UTF-8 connection.  Perl always generates the shortest
+length UTF-8, and with warnings on (C<-w> or C<use warnings;>) Perl will
+warn about non-shortest length UTF-8 (and other malformations, too,
+such as the surrogates, which are not real character code points.)
+
+=head2 Unicode in Perl on EBCDIC
+
+The way Unicode is handled on EBCDIC platforms is still rather
+experimental.  On such a platform, references to UTF-8 encoding in this
+document and elsewhere should be read as meaning UTF-EBCDIC as
+specified in Unicode Technical Report 16 unless ASCII vs EBCDIC issues
+are specifically discussed. There is no C<utfebcdic> pragma or
+":utfebcdic" layer, rather, "utf8" and ":utf8" are re-used to mean
+the platform's "natural" 8-bit encoding of Unicode. See L<perlebcdic>
+for more discussion of the issues.
+
+=back
+
 =head1 SEE ALSO
 
-L<bytes>, L<utf8>, L<perlretut>, L<perlvar/"${^WIDE_SYSTEM_CALLS}">
+L<perluniintro>, L<encoding>, L<Encode>, L<open>, L<utf8>, L<bytes>,
+L<perlretut>, L<perlvar/"${^WIDE_SYSTEM_CALLS}">
 
 =cut
diff --git a/pod/perluniintro.pod b/pod/perluniintro.pod
new file mode 100644
index 0000000000..cdd0b4075e
--- /dev/null
+++ b/pod/perluniintro.pod
@@ -0,0 +1,689 @@
+=head1 NAME
+
+perluniintro - Perl Unicode introduction
+
+=head1 DESCRIPTION
+
+This document gives a general idea of Unicode and how to use Unicode
+in Perl.
+
+=head2 Unicode
+
+Unicode is a character set standard with plans to cover all of the
+writing systems of the world, plus many other symbols.
+
+Unicode and ISO/IEC 10646 are coordinated standards that provide code
+points for the characters in almost all modern character set standards,
+covering more than 30 writing systems and hundreds of languages,
+including all commercially important modern languages.  All characters
+in the largest Chinese, Japanese, and Korean dictionaries are also
+encoded. The standards will eventually cover almost all characters in
+more than 250 writing systems and thousands of languages.
+
+A Unicode I<character> is an abstract entity.  It is not bound to any
+particular integer width, and especially not to the C language C<char>.
+Unicode is language neutral and display neutral: it doesn't encode the
+language of the text, and it doesn't define fonts or other graphical
+layout details.  Unicode operates on characters and on text built from
+those characters.
+
+Unicode defines characters like C<LATIN CAPITAL LETTER A> or C<GREEK
+SMALL LETTER ALPHA>, and then unique numbers for those, hexadecimal
+0x0041 or 0x03B1 for those particular characters.  Such unique
+numbers are called I<code points>.
+
+The Unicode standard prefers using hexadecimal notation for the code
+points.  (In case this notation, numbers like 0x0041, is unfamiliar to
+you, take a peek at a later section, L</"Hexadecimal Notation">.)
+The Unicode standard uses the notation C<U+0041 LATIN CAPITAL LETTER A>,
+which gives the hexadecimal code point, and the normative name of
+the character.
+
+Unicode also defines various I<properties> for the characters, like
+"uppercase" or "lowercase", "decimal digit", or "punctuation":
+these properties are independent of the names of the characters.
+Furthermore, various operations on the characters like uppercasing,
+lowercasing, and collating (sorting), are defined.
+
+A Unicode character consists either of a single code point, or a
+I<base character> (like C<LATIN CAPITAL LETTER A>), followed by one or
+more I<modifiers> (like C<COMBINING ACUTE ACCENT>).  This sequence of
+a base character and modifiers is called a I<combining character
+sequence>.
+
+Whether to call these combining character sequences, as a whole,            
+"characters" depends on your point of view. If you are a programmer, you     
+probably would tend towards seeing each element in the sequences as one
+unit, one "character", but from the user viewpoint, the sequence as a
+whole is probably considered one "character", since that's probably what   
+it looks like in the context of the user's language.
+
+With this "as a whole" view of characters, the number of characters is
+open-ended. But in the programmer's "one unit is one character" point of
+view, the concept of "characters" is more deterministic, and so we take
+that point of view in this document: one "character" is one Unicode
+code point, be it a base character or a combining character.
+
+For some of the combinations there are I<precomposed> characters,
+for example C<LATIN CAPITAL LETTER A WITH ACUTE> is defined as
+a single code point.  These precomposed characters are, however,
+often available only for some combinations, and mainly they are
+meant to support round-trip conversions between Unicode and legacy
+standards (like the ISO 8859), and in general case the composing
+method is more extensible.  To support conversion between the
+different compositions of the characters, various I<normalization
+forms> are also defined.
+
+Because of backward compatibility with legacy encodings, the "a unique
+number for every character" breaks down a bit: "at least one number
+for every character" is closer to truth.  (This happens when the same
+character has been encoded in several legacy encodings.)  The converse
+is also not true: not every code point has an assigned character.
+Firstly, there are unallocated code points within otherwise used
+blocks.  Secondly, there are special Unicode control characters that
+do not represent true characters.
+
+A common myth about Unicode is that it would be "16-bit", that is,
+0x10000 (or 65536) characters from 0x0000 to 0xFFFF.  B<This is untrue.>
+Since Unicode 2.0 Unicode has been defined all the way up to 21 bits
+(0x10FFFF), and since 3.1 characters have been defined beyond 0xFFFF.
+The first 0x10000 characters are called the I<Plane 0>, or the I<Basic
+Multilingual Plane> (BMP).  With the Unicode 3.1, 17 planes in all are
+defined (but nowhere near full of defined characters yet).
+
+Another myth is that the 256-character blocks have something to do
+with languages: a block per language.  B<Also this is untrue.>
+The division into the blocks exists but it is almost completely
+accidental, an artifact of how the characters have been historically
+allocated.  Instead, there is a concept called I<scripts>, which may
+be more useful: there is C<Latin> script, C<Greek> script, and so on.
+Scripts usually span several parts of several blocks.  For further
+information see L<Unicode::UCD>.
+
+The Unicode code points are just abstract numbers.  To input and
+output these abstract numbers, the numbers must be I<encoded> somehow.
+Unicode defines several I<character encoding forms>, of which I<UTF-8>
+is perhaps the most popular.  UTF-8 is a variable length encoding that
+encodes Unicode characters as 1 to 6 bytes (only 4 with the currently
+defined characters).  Other encodings are UTF-16 and UTF-32 and their
+big and little endian variants (UTF-8 is byteorder independent).
+The ISO/IEC 10646 defines the UCS-2 and UCS-4 encoding forms.
+
+For more information about encodings, for example to learn what
+I<surrogates> and I<byte order marks> (BOMs) are, see L<perlunicode>.
+
+=head2 Perl's Unicode Support
+
+Starting from Perl 5.6.0, Perl has had the capability of handling
+Unicode natively.  The first recommended release for serious Unicode
+work is Perl 5.8.0, however.  The maintenance release 5.6.1 fixed many
+of the problems of the initial implementation of Unicode, but for
+example regular expressions didn't really work with Unicode.
+
+B<Starting from Perl 5.8.0, the use of C<use utf8> is no longer
+necessary.> In earlier releases the C<utf8> pragma was used to declare
+that operations in the current block or file would be Unicode-aware.
+This model was found to be wrong, or at least clumsy: the Unicodeness
+is now carried with the data, not attached to the operations.  (There
+is one remaining case where an explicit C<use utf8> is needed: if your
+Perl script is in UTF-8, you can use UTF-8 in your variable and
+subroutine names, and in your string and regular expression literals,
+by saying C<use utf8>.  This is not the default because that would
+break existing scripts having legacy 8-bit data in them.)
+
+=head2 Perl's Unicode Model
+
+Perl supports both the old, pre-5.6, model of strings of eight-bit
+native bytes, and strings of Unicode characters.  The principle is
+that Perl tries to keep its data as eight-bit bytes for as long as
+possible, but as soon as Unicodeness cannot be avoided, the data is
+transparently upgraded to Unicode.
+
+The internal encoding of Unicode in Perl is UTF-8.  The internal
+encoding is normally hidden, however, and one need not and should not
+worry about the internal encoding at all: it is all just characters.
+
+Perl 5.8.0 will also support Unicode on EBCDIC platforms.  There the
+support is somewhat harder to implement since additional conversions
+are needed at every step.  Because of these difficulties the Unicode
+support won't be quite as full as in other, mainly ASCII-based,
+platforms (the Unicode support will be better than in the 5.6 series,
+which didn't work much at all for EBCDIC platform).  On EBCDIC
+platforms the internal encoding form used is UTF-EBCDIC.
+
+=head2 Creating Unicode
+
+To create Unicode literals, use the C<\x{...}> notation in
+doublequoted strings:
+
+    my $smiley = "\x{263a}";
+
+Similarly for regular expression literals
+
+    $smiley =~ /\x{263a}/;
+
+At run-time you can use C<chr()>:
+
+    my $hebrew_alef = chr(0x05d0);
+
+(See L</"Further Resources"> for how to find all these numeric codes.)
+
+Naturally, C<ord()> will do the reverse: turn a character to a code point.
+
+Note that C<\x..>, C<\x{..}> and C<chr(...)> for arguments less than
+0x100 (decimal 256) will generate an eight-bit character for backward
+compatibility with older Perls.  For arguments of 0x100 or more,
+Unicode will always be produced.  If you want UTF-8 always, use
+C<pack("U", ...)> instead of C<\x..>, C<\x{..}>, or C<chr()>.
+
+You can also use the C<charnames> pragma to invoke characters
+by name in doublequoted strings:
+
+    use charnames ':full';
+    my $arabic_alef = "\N{ARABIC LETTER ALEF}";
+
+And, as mentioned above, you can also C<pack()> numbers into Unicode
+characters:
+
+   my $georgian_an  = pack("U", 0x10a0);
+
+=head2 Handling Unicode
+
+Handling Unicode is for the most part transparent: just use the
+strings as usual.  Functions like C<index()>, C<length()>, and
+C<substr()> will work on the Unicode characters; regular expressions
+will work on the Unicode characters (see L<perlunicode> and L<perlretut>).
+
+Note that Perl does B<not> consider combining character sequences
+to be characters, such for example
+
+    use charnames ':full';
+    print length("\N{LATIN CAPITAL LETTER A}\N{COMBINING ACUTE ACCENT}"), "\n";
+
+will print 2, not 1.  The only exception is that regular expressions
+have C<\X> for matching a combining character sequence.
+
+When life is not quite so transparent is working with legacy
+encodings, and I/O, and certain special cases.
+
+=head2 Legacy Encodings
+
+When you combine legacy data and Unicode the legacy data needs
+to be upgraded to Unicode.  Normally ISO 8859-1 (or EBCDIC, if
+applicable) is assumed.  You can override this assumption by
+using the C<encoding> pragma, for example
+
+    use encoding 'latin2'; # ISO 8859-2
+
+in which case literals (string or regular expression) and chr/ord
+in your whole script are assumed to produce Unicode characters from
+ISO 8859-2 code points.  Note that the matching for the encoding 
+names is forgiving: instead of C<latin2> you could have said 
+C<Latin 2>, or C<iso8859-2>, and so forth.  With just
+
+    use encoding;
+
+first the environment variable C<PERL_ENCODING> will be consulted,
+and if that doesn't exist, ISO 8859-1 (Latin 1) will be assumed.
+
+The C<Encode> module knows about many encodings and it has interfaces
+for doing conversions between those encodings:
+
+    use Encode 'from_to';
+    from_to($data, "iso-8859-3", "utf-8"); # from legacy to utf-8
+
+=head2 Unicode I/O
+
+Normally writing out Unicode data
+
+    print chr(0x100), "\n";
+
+will print out the raw UTF-8 bytes.
+
+But reading in correctly formed UTF-8 data will not magically turn
+the data into Unicode in Perl's eyes.
+
+You can use either the C<':utf8'> I/O discipline when opening files
+
+    open(my $fh,'<:utf8', 'anything');
+    my $line_of_utf8 = <$fh>;
+
+The I/O disciplines can also be specified more flexibly with
+the C<open> pragma; see L<open>:
+
+    use open ':utf8'; # input and output will be UTF-8
+    open X, ">utf8";
+    print X chr(0x100), "\n"; # this would have been UTF-8 without the pragma
+    close X;
+    open Y, "<utf8";
+    printf "%#x\n", ord(<Y>); # this should print 0x100
+    close Y;
+
+With the C<open> pragma you can use the C<:locale> discipline
+
+    $ENV{LANG} = 'ru_RU.KOI8-R';
+    # the :locale will probe the locale environment variables like LANG
+    use open OUT => ':locale'; # russki parusski
+    open(O, ">koi8");
+    print O chr(0x430); # Unicode CYRILLIC SMALL LETTER A = KOI8-R 0xc1
+    close O;
+    open(I, "<koi8");
+    printf "%#x\n", ord(<I>), "\n"; # this should print 0xc1
+    close I;
+
+or you can also use the C<':encoding(...)'> discipline
+
+    open(my $epic,'<:encoding(iso-8859-7)','iliad.greek');
+    my $line_of_iliad = <$epic>;
+
+Both of these methods install a transparent filter on the I/O stream that
+will convert data from the specified encoding when it is read in from the
+stream.  In the first example the F<anything> file is assumed to be UTF-8
+encoded Unicode, in the second example the F<iliad.greek> file is assumed
+to be ISO-8858-7 encoded Greek, but the lines read in will be in both
+cases Unicode.
+
+The L<open> pragma affects all the C<open()> calls after the pragma by
+setting default disciplines.  If you want to affect only certain
+streams, use explicit disciplines directly in the C<open()> call.
+
+You can switch encodings on an already opened stream by using
+C<binmode()>, see L<perlfunc/binmode>.
+
+The C<:locale> does not currently work with C<open()> and
+C<binmode()>, only with the C<open> pragma.  The C<:utf8> and
+C<:encoding(...)> do work with all of C<open()>, C<binmode()>,
+and the C<open> pragma.
+
+Similarly, you may use these I/O disciplines on input streams to
+automatically convert data from the specified encoding when it is
+written to the stream.
+
+    open(my $unicode, '<:utf8',                 'japanese.uni');
+    open(my $nihongo, '>:encoding(iso2022-jp)', 'japanese.jp');
+    while (<$unicode>) { print $nihongo }
+
+The naming of encodings, both by the C<open()> and by the C<open>
+pragma, is similarly understanding as with the C<encoding> pragma:
+C<koi8-r> and C<KOI8R> will both be understood.
+
+Common encodings recognized by ISO, MIME, IANA, and various other
+standardisation organisations are recognised, for a more detailed
+list see L<Encode>.
+
+C<read()> reads characters and returns the number of characters.
+C<seek()> and C<tell()> operate on byte counts, as do C<sysread()>
+and C<sysseek()>.
+
+Notice that because of the default behaviour "input is not UTF-8"
+it is easy to mistakenly write code that keeps on expanding a file
+by repeatedly encoding it in UTF-8:
+
+    # BAD CODE WARNING
+    open F, "file";
+    local $/; # read in the whole file
+    $t = <F>;
+    close F;
+    open F, ">:utf8", "file";
+    print F $t;
+    close F;
+
+If you run this code twice, the contents of the F<file> will be twice
+UTF-8 encoded.  A C<use open ':utf8'> would have avoided the bug.
+
+=head2 Special Cases
+
+=over 4
+
+=item *
+
+Bit Complement Operator ~ And vec()
+
+The bit complement operator C<~> will produce surprising results if
+used on strings containing Unicode characters.  The results are
+consistent with the internal UTF-8 encoding of the characters, but not
+with much else.  So don't do that.  Similarly for vec(): you will be
+operating on the UTF-8 bit patterns of the Unicode characters, not on
+the bytes, which is very probably not what you want.
+
+=item *
+
+Peeking At UTF-8
+
+One way of peeking inside the internal encoding of Unicode characters
+is to use C<unpack("C*", ...> to get the bytes, or C<unpack("H*", ...)>
+to display the bytes:
+
+    # this will print c4 80 for the UTF-8 bytes 0xc4 0x80
+    print join(" ", unpack("H*", pack("U", 0x100))), "\n";
+
+Yet another way would be to use the Devel::Peek module:
+
+    perl -MDevel::Peek -e 'Dump(chr(0x100))'
+
+That will show the UTF8 flag in FLAGS and both the UTF-8 bytes
+and Unicode characters in PV.  See also later in this document
+the discussion about the C<is_utf8> function of the C<Encode> module.
+
+=back
+
+=head2 Advanced Topics
+
+=over 4
+
+=item *
+
+String Equivalence
+
+The question of string equivalence turns somewhat complicated
+in Unicode: what do you mean by equal?
+
+    Is C<LATIN CAPITAL LETTER A WITH ACUTE> equal to
+    C<LATIN CAPITAL LETTER A>?
+
+The short answer is that by default Perl compares equivalence
+(C<eq>, C<ne>) based only on code points of the characters.
+In the above case, no (because 0x00C1 != 0x0041).  But sometimes any
+CAPITAL LETTER As being considered equal, or even any As of any case,
+would be desirable.
+
+The long answer is that you need to consider character normalization
+and casing issues: see L<Unicode::Normalize>, and Unicode Technical
+Reports #15 and #21, I<Unicode Normalization Forms> and I<Case
+Mappings>, http://www.unicode.org/unicode/reports/tr15/
+http://www.unicode.org/unicode/reports/tr21/
+
+As of Perl 5.8.0, the's regular expression case-ignoring matching
+implements only 1:1 semantics: one character matches one character.
+In I<Case Mappings> both 1:N and N:1 matches are defined.
+
+=item *
+
+String Collation
+
+People like to see their strings nicely sorted, or as Unicode
+parlance goes, collated.  But again, what do you mean by collate?
+
+    Does C<LATIN CAPITAL LETTER A WITH ACUTE> come before or after
+    C<LATIN CAPITAL LETTER A WITH GRAVE>?
+
+The short answer is that by default Perl compares strings (C<lt>,
+C<le>, C<cmp>, C<ge>, C<gt>) based only on the code points of the
+characters.  In the above case, after, since 0x00C1 > 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>
+http://www.unicode.org/unicode/reports/tr10/
+
+=back
+
+=head2 Miscellaneous
+
+=over 4
+
+=item *
+
+Character Ranges
+
+Character ranges in regular expression character classes (C</[a-z]/>)
+and in the C<tr///> (also known as C<y///>) operator are not magically
+Unicode-aware.  What this means that C<[a-z]> will not magically start
+to mean "all alphabetic letters" (not that it does mean that even for
+8-bit characters, you should be using C</[[:alpha]]/> for that).
+
+For specifying things like that in regular expressions you can use the
+various Unicode properties, C<\pL> in this particular case.  You can
+use Unicode code points as the end points of character ranges, but
+that means that particular code point range, nothing more.  For
+further information, see L<perlunicode>.
+
+=item *
+
+String-To-Number Conversions
+
+Unicode does define several other decimal (and numeric) characters
+than just the familiar 0 to 9, such as the Arabic and Indic digits.
+Perl does not support string-to-number conversion for digits other
+than the 0 to 9 (and a to f for hexadecimal).
+
+=back
+
+=head2 Questions With Answers
+
+=over 4
+
+=item Will My Old Scripts Break?
+
+Very probably not.  Unless you are generating Unicode characters
+somehow, any old behaviour should be preserved.  About the only
+behaviour that has changed and which could start generating Unicode
+is the old behaviour of C<chr()> where supplying an argument more
+than 255 produced a character modulo 255 (for example, C<chr(300)>
+was equal to C<chr(45)>).
+
+=item How Do I Make My Scripts Work With Unicode?
+
+Very little work should be needed since nothing changes until you
+somehow generate Unicode data.  The greatest trick will be getting
+input as Unicode, and for that see the earlier I/O discussion.
+
+=item How Do I Know Whether My String Is In Unicode?
+
+You shouldn't care.  No, you really shouldn't.  If you have
+to care (beyond the cases described above), it means that we
+didn't get the transparency of Unicode quite right.
+
+Okay, if you insist:
+
+    use Encode 'is_utf8';
+    print is_utf8($string) ? 1 : 0, "\n";
+
+But note that this doesn't mean that any of the characters in the
+string are necessary UTF-8 encoded, or that any of the characters have
+code points greater than 0xFF (255) or even 0x80 (128), or that the
+string has any characters at all.  All the C<is_utf8()> does is to
+return the value of the internal "utf8ness" flag attached to the
+$string.  If the flag is on, characters added to that string will be
+automatically upgraded to UTF-8 (and even then only if they really
+need to be upgraded, that is, if their code point is greater than 0xFF).
+
+Sometimes you might really need to know the byte length of a string
+instead of the character length.  For that use the C<bytes> pragma
+and its only defined function C<length()>:
+
+    my $unicode = chr(0x100);
+    print length($unicode), "\n"; # will print 1
+    use bytes;
+    print length($unicode), "\n"; # will print 2 (the 0xC4 0x80 of the UTF-8)
+
+=item How Do I Detect Invalid UTF-8?
+
+Either
+
+    use Encode 'encode_utf8';
+    if (encode_utf8($string)) {
+        # valid
+    } else {
+        # invalid
+    }
+
+or
+
+    use warnings;
+    @chars = unpack("U0U*", "\xFF"); # will warn
+
+The warning will be C<Malformed UTF-8 character (byte 0xff) in
+unpack>.  The "U0" means "expect strictly UTF-8 encoded Unicode".
+Without that the C<unpack("U*", ...)> would accept also data like
+C<chr(0xFF>).
+
+=item How Do I Convert Data Into UTF-8?  Or Vice Versa?
+
+This probably isn't as useful (or simple) as you might think.
+Also, normally you shouldn't need to.
+
+In one sense what you are asking doesn't make much sense: UTF-8 is
+(intended as an) Unicode encoding, so converting "data" into UTF-8
+isn't meaningful unless you know in what character set and encoding
+the binary data is in, and in this case you can use C<Encode>.
+
+    use Encode 'from_to';
+    from_to($data, "iso-8859-1", "utf-8"); # from latin-1 to utf-8
+
+If you have ASCII (really 7-bit US-ASCII), you already have valid
+UTF-8, the lowest 128 characters of UTF-8 encoded Unicode and US-ASCII
+are equivalent.
+
+If you have Latin-1 (or want Latin-1), you can just use pack/unpack:
+
+    $latin1 = pack("C*", unpack("U*", $utf8));
+    $utf8   = pack("U*", unpack("C*", $latin1));
+
+(The same works for EBCDIC.)
+
+If you have a sequence of bytes you B<know> is valid UTF-8,
+but Perl doesn't know it yet, you can make Perl a believer, too:
+
+    use Encode 'decode_utf8';
+    $utf8 = decode_utf8($bytes);
+
+You can convert well-formed UTF-8 to a sequence of bytes, but if
+you just want to convert random binary data into UTF-8, you can't.
+Any random collection of bytes isn't well-formed UTF-8.  You can
+use C<unpack("C*", $string)> for the former, and you can create
+well-formed Unicode/UTF-8 data by C<pack("U*", 0xff, ...)>.
+
+=item How Do I Display Unicode?  How Do I Input Unicode?
+
+See http://www.hclrss.demon.co.uk/unicode/ and
+http://www.cl.cam.ac.uk/~mgk25/unicode.html
+
+=item How Does Unicode Work With Traditional Locales?
+
+In Perl, not very well.  Avoid using locales through the C<locale>
+pragma.  Use only one or the other.
+
+=back
+
+=head2 Hexadecimal Notation
+
+The Unicode standard prefers using hexadecimal notation because that
+shows better the division of Unicode into blocks of 256 characters.
+Hexadecimal is also simply shorter than decimal.  You can use decimal
+notation, too, but learning to use hexadecimal just makes life easier
+with the Unicode standard.
+
+The C<0x> prefix means a hexadecimal number, the digits are 0-9 I<and>
+a-f (or A-F, case doesn't matter).  Each hexadecimal digit represents
+four bits, or half a byte.  C<print 0x..., "\n"> will show a
+hexadecimal number in decimal, and C<printf "%x\n", $decimal> will
+show a decimal number in hexadecimal.  If you have just the
+"hexdigits" of a hexadecimal number, you can use the C<hex()>
+function.
+
+    print 0x0009, "\n";    # 9
+    print 0x000a, "\n";    # 10
+    print 0x000f, "\n";    # 15
+    print 0x0010, "\n";    # 16
+    print 0x0011, "\n";    # 17
+    print 0x0100, "\n";    # 256
+
+    print 0x0041, "\n";    # 65
+
+    printf "%x\n",  65;    # 41
+    printf "%#x\n", 65;    # 0x41
+
+    print hex("41"), "\n"; # 65
+
+=head2 Further Resources
+
+=over 4
+
+=item *
+
+Unicode Consortium
+
+    http://www.unicode.org/
+
+=item *
+
+Unicode FAQ
+
+    http://www.unicode.org/unicode/faq/
+
+=item *
+
+Unicode Glossary
+
+    http://www.unicode.org/glossary/
+
+=item *
+
+Unicode Useful Resources
+
+    http://www.unicode.org/unicode/onlinedat/resources.html
+
+=item *
+
+Unicode and Multilingual Support in HTML, Fonts, Web Browsers and Other Applications
+
+    http://www.hclrss.demon.co.uk/unicode/
+
+=item *
+
+UTF-8 and Unicode FAQ for Unix/Linux
+
+    http://www.cl.cam.ac.uk/~mgk25/unicode.html
+
+=item *
+
+Legacy Character Sets
+
+    http://www.czyborra.com/
+    http://www.eki.ee/letter/
+
+=item *
+
+The Unicode support files live within the Perl installation in the
+directory
+
+    $Config{installprivlib}/unicore
+
+in Perl 5.8.0 or newer, and 
+
+    $Config{installprivlib}/unicode
+
+in the Perl 5.6 series.  (The renaming to F<lib/unicore> was done to
+avoid naming conflicts with lib/Unicode in case-insensitive filesystems.)
+The main Unicode data file is F<Unicode.txt> (or F<Unicode.301> in
+Perl 5.6.1.)  You can find the C<$Config{installprivlib}> by
+
+    perl "-V:installprivlib"
+
+Note that some of the files have been renamed from the Unicode
+standard since the Perl installation tries to live by the "8.3"
+filenaming restrictions.  The renamings are shown in the
+accompanying F<rename> file.
+
+You can explore various information from the Unicode data files using
+the C<Unicode::UCD> module.
+
+=back
+
+=head1 SEE ALSO
+
+L<perlunicode>, L<Encode>, L<encoding>, L<open>, L<utf8>, L<bytes>,
+L<perlretut>, L<Unicode::Collate>, L<Unicode::Normalize>, L<Unicode::UCD>
+
+=head1 ACKNOWLEDGEMENTS
+
+Thanks to the kind readers of the perl5-porters@perl.org,
+perl-unicode@perl.org, linux-utf8@nl.linux.org, and unicore@unicode.org
+mailing lists for their valuable feedback.
+
+=head1 AUTHOR, COPYRIGHT, AND LICENSE
+
+Copyright 2001 Jarkko Hietaniemi <jhi@iki.fi>
+
+This document may be distributed under the same terms as Perl itself.
diff --git a/pod/perlvar.pod b/pod/perlvar.pod
index d34daa6580..2f39d561c2 100644
--- a/pod/perlvar.pod
+++ b/pod/perlvar.pod
@@ -261,7 +261,7 @@ with the rightmost closing parenthesis) of the last successful search
 pattern.  (Mnemonic: the (possibly) Nested parenthesis that most
 recently closed.)
 
-This is primarly used inside C<(?{...})> blocks for examining text
+This is primarily used inside C<(?{...})> blocks for examining text
 recently matched. For example, to effectively capture text to a variable
 (in addition to C<$1>, C<$2>, etc.), replace C<(...)> with
 
@@ -1381,7 +1381,7 @@ expression matches in a program, regardless of whether they occur
 in the scope of C<use English>.  For that reason, saying C<use
 English> in libraries is strongly discouraged.  See the
 Devel::SawAmpersand module documentation from CPAN
-(http://www.perl.com/CPAN/modules/by-module/Devel/)
+(http://www.cpan.org/modules/by-module/Devel/)
 for more information.
 
 Having to even think about the C<$^S> variable in your exception
diff --git a/pod/perlxs.pod b/pod/perlxs.pod
index ab38dcc40c..5146a1e45d 100644
--- a/pod/perlxs.pod
+++ b/pod/perlxs.pod
@@ -816,7 +816,7 @@ pointer would not modify the Perl parameter, but is put in the output
 list.
 
 The C<OUTLIST>/C<OUT> parameter differ from C<IN_OUTLIST>/C<IN_OUT>
-parameters only by the the initial value of the Perl parameter not
+parameters only by the initial value of the Perl parameter not
 being read (and not being given to the C function - which gets some
 garbage instead).  For example, the same C function as above can be
 interfaced with as
@@ -1344,7 +1344,7 @@ of C<&>, but provide a pointer to this value when the C function is called.
 
 This is useful to avoid a CODE: block for a C function which takes a parameter
 by reference.  Typically, the parameter should be not a pointer type (an
-C<int> or C<long> but not a C<int*> or C<long*>).
+C<int> or C<long> but not an C<int*> or C<long*>).
 
 The following XSUB will generate incorrect C code.  The B<xsubpp> compiler will
 turn this into code which calls C<rpcb_gettime()> with parameters C<(char
@@ -1702,6 +1702,133 @@ The INPUT and OUTPUT sections substitute underscores for double-colons
 on the fly, giving the desired effect.  This example demonstrates some
 of the power and versatility of the typemap facility.
 
+=head2 Safely Storing Static Data in XS
+
+Starting with Perl 5.8, a macro framework has been defined to allow
+static data to be safely stored in XS modules that will be accessed from
+a multi-threaded Perl.
+
+Although primarily designed for use with multi-threaded Perl, the macros
+have been designed so that they will work with non-threaded Perl as well.
+
+It is therefore strongly recommended that these macros be used by all
+XS modules that make use of static data.
+
+The easiest way to get a template set of macros to use is by specifiying
+the C<-g> (C<--global>) option with h2xs (see L<h2xs>).
+
+Below is an example module that makes use of the macros.
+
+    #include "EXTERN.h"
+    #include "perl.h"
+    #include "XSUB.h"
+ 
+    /* Global Data */
+ 
+    #define MY_CXT_KEY "BlindMice::_guts" XS_VERSION
+ 
+    typedef struct {
+        int count;
+        char name[3][100];
+    } my_cxt_t;
+ 
+    START_MY_CXT
+ 
+    MODULE = BlindMice           PACKAGE = BlindMice
+ 
+    BOOT:
+    {
+        MY_CXT_INIT;
+        MY_CXT.count = 0;
+        strcpy(MY_CXT.name[0], "None");
+        strcpy(MY_CXT.name[1], "None");
+        strcpy(MY_CXT.name[2], "None");
+    }                              
+
+    int
+    newMouse(char * name)
+        char * name;
+        PREINIT:
+          dMY_CXT;
+        CODE:
+          if (MY_CXT.count >= 3) {
+              warn("Already have 3 blind mice") ;
+              RETVAL = 0;
+          }
+          else {
+              RETVAL = ++ MY_CXT.count;
+              strcpy(MY_CXT.name[MY_CXT.count - 1], name);
+          }
+
+    char *
+    get_mouse_name(index)
+      int index
+      CODE:
+        dMY_CXT;
+        RETVAL = MY_CXT.lives ++;
+        if (index > MY_CXT.count)
+          croak("There are only 3 blind mice.");
+        else
+          RETVAL = newSVpv(MY_CXT.name[index - 1]);
+
+
+B<REFERENCE>
+
+=over 5
+
+=item MY_CXT_KEY
+
+This macro is used to define a unique key to refer to the static data
+for an XS module. The suggested naming scheme, as used by h2xs, is to
+use a string that consists of the module name, the string "::_guts"
+and the module version number.
+
+    #define MY_CXT_KEY "MyModule::_guts" XS_VERSION
+
+=item typedef my_cxt_t
+
+This struct typedef I<must> always be called C<my_cxt_t> -- the other
+C<CXT*> macros assume the existence of the C<my_cxt_t> typedef name.
+
+Declare a typedef named C<my_cxt_t> that is a structure that contains
+all the data that needs to be interpreter-local.
+
+    typedef struct {
+        int some_value;
+    } my_cxt_t;
+
+=item START_MY_CXT
+
+Always place the START_MY_CXT macro directly after the declaration
+of C<my_cxt_t>.
+
+=item MY_CXT_INIT
+
+The MY_CXT_INIT macro initialises storage for the C<my_cxt_t> struct.
+
+It I<must> be called exactly once -- typically in a BOOT: section.
+
+=item dMY_CXT
+
+Use the dMY_CXT macro (a declaration) in all the functions that access
+MY_CXT.
+
+=item MY_CXT
+
+Use the MY_CXT macro to access members of the C<my_cxt_t> struct. For
+example, if C<my_cxt_t> is 
+
+    typedef struct {
+        int index;
+    } my_cxt_t;
+
+then use this to access the C<index> member
+
+    dMY_CXT;
+    MY_CXT.index = 2;
+
+=back
+
 =head1 EXAMPLES
 
 File C<RPC.xs>: Interface to some ONC+ RPC bind library functions.
diff --git a/pod/pod2man.PL b/pod/pod2man.PL
index 5a1deeaed3..86426418de 100644
--- a/pod/pod2man.PL
+++ b/pod/pod2man.PL
@@ -36,7 +36,7 @@ $Config{startperl}
 print OUT <<'!NO!SUBS!';
 
 # pod2man -- Convert POD data to formatted *roff input.
-# $Id: pod2man.PL,v 1.7 2001/10/20 08:24:15 eagle Exp $
+# $Id: pod2man.PL,v 1.8 2001/11/05 04:55:47 eagle Exp $
 #
 # Copyright 1999, 2000, 2001 by Russ Allbery <rra@stanford.edu>
 #
@@ -66,8 +66,8 @@ my %options;
 Getopt::Long::config ('bundling_override');
 GetOptions (\%options, 'section|s=s', 'release|r=s', 'center|c=s',
             'date|d=s', 'fixed=s', 'fixedbold=s', 'fixeditalic=s',
-            'fixedbolditalic=s', 'official|o', 'quotes|q=s', 'lax|l',
-            'help|h', 'verbose|v') or exit 1;
+            'fixedbolditalic=s', 'name|n=s', 'official|o', 'quotes|q=s',
+            'lax|l', 'help|h', 'verbose|v') or exit 1;
 pod2usage (0) if $options{help};
 
 # Official sets --center, but don't override things explicitly set.
@@ -100,8 +100,9 @@ pod2man - Convert POD data to formatted *roff input
 pod2man [B<--section>=I<manext>] [B<--release>=I<version>]
 [B<--center>=I<string>] [B<--date>=I<string>] [B<--fixed>=I<font>]
 [B<--fixedbold>=I<font>] [B<--fixeditalic>=I<font>]
-[B<--fixedbolditalic>=I<font>] [B<--official>] [B<--lax>]
-[B<--quotes>=I<quotes>] [B<--verbose>] [I<input> [I<output>] ...]
+[B<--fixedbolditalic>=I<font>] [B<--name>=I<name>] [B<--official>]
+[B<--lax>] [B<--quotes>=I<quotes>] [B<--verbose>]
+[I<input> [I<output>] ...]
 
 pod2man B<--help>
 
@@ -185,6 +186,19 @@ Print out usage information.
 Don't complain when required sections are missing.  Not currently used, as
 POD checking functionality is not yet implemented in Pod::Man.
 
+=item B<-n> I<name>, B<--name>=I<name>
+
+Set the name of the manual page to I<name>.  Without this option, the manual
+name is set to the uppercased base name of the file being converted unless
+the manual section is 3, in which case the path is parsed to see if it is a
+Perl module path.  If it is, a path like C<.../lib/Pod/Man.pm> is converted
+into a name like C<Pod::Man>.  This option, if given, overrides any
+automatic determination of the name.
+
+Note that this option is probably not useful when converting multiple POD
+files at once.  The convention for Unix man pages for commands is for the
+man page title to be in all-uppercase even if the command isn't.
+
 =item B<-o>, B<--official>
 
 Set the default header to indicate that this page is part of the standard