=head1 NAME
-perldelta - what's new for perl v5.6 (as of v5.005_64)
+perldelta - what's new for perl v5.6.0
=head1 DESCRIPTION
-This is an unsupported alpha release, meant for intrepid Perl developers
-only. The included sources may not even build correctly on some platforms.
-Subscribing to perl5-porters is the best way to monitor and contribute
-to the progress of development releases (see www.perl.org for info).
+This is an unsupported alpha release, meant for intrepid Perl
+developers only. The included sources may not even build correctly on
+some platforms. Subscribing to perl5-porters is the best way to
+monitor and contribute to the progress of development releases (see
+http://www.hut.fi/~jhi/perl5-porters.html for info).
This document describes differences between the 5.005 release and this one.
See L<perldata>.
+=head2 Perl's version numbering has changed
+
+Beginning with Perl version 5.6.0, the version number convention has been
+changed to a "dotted integer" scheme that is more commonly found in open
+source projects.
+
+Maintenance versions of v5.6.0 will be released as v5.6.1, v5.6.2 etc.
+The next development series following v5.6.0 will be numbered v5.7.x,
+beginning with v5.7.0, and the next major production release following
+v5.6.0 will be v5.8.0.
+
+The English module now sets $PERL_VERSION to $^V (a string value) rather
+than C<$]> (a numeric value). (This is a potential incompatibility.
+Send us a report via perlbug if you are affected by this.)
+
+The v1.2.3 syntax is also now legal in Perl.
+See L<Support for strings represented as a vector of ordinals> for more on that.
+
+To cope with the new versioning system's use of at least three significant
+digits for each version component, the method used for incrementing the
+subversion number has also changed slightly. We assume that versions older
+than v5.6.0 have been incrementing the subversion component in multiples of
+10. Versions after v5.6.0 will increment them by 1. Thus, using the new
+notation, 5.005_03 is the "same" as v5.5.30, and the first maintenance
+version following v5.6.0 will be v5.6.1 (which should be read as being
+equivalent to a floating point value of 5.006_001 in the older format,
+stored in C<$]>).
+
+=item Literals of the form C<1.2.3> parse differently
+
+Previously, numeric literals with more than one dot in them were
+interpreted as a floating point number concatenated with one or more
+numbers. Such "numbers" are now parsed as strings composed of the
+specified ordinals.
+
+For example, C<print 97.98.99> used to output C<97.9899> in earlier
+versions, but now prints C<abc>.
+
+See L<Support for strings represented as a vector of ordinals> below.
+
=item Possibly changed pseudo-random number generator
In 5.005_0x and earlier, perl's rand() function used the C library
the same effect as assigning C<undef> to the readonly value--it
throws an exception.
-=item Close-on-exec bit may be set on pipe() handles
+=item Close-on-exec bit may be set on pipe and socket handles
On systems that support a close-on-exec flag on filehandles, the
-flag will be set for any handles created by pipe(), if that is
-warranted by the value of $^F that may be in effect. Earlier
-versions neglected to set the flag for handles created with
-pipe(). See L<perlfunc/pipe> and L<perlvar/$^F>.
+flag will be set for any handles created by pipe(), socketpair(),
+socket(), and accept(), if that is warranted by the value of $^F
+that may be in effect. Earlier versions neglected to set the flag
+for handles created with these operators. See L<perlfunc/pipe>,
+L<perlfunc/socketpair>, L<perlfunc/socket>, L<perlfunc/accept>,
+and L<perlvar/$^F>.
=item Writing C<"$$1"> to mean C<"${$}1"> is unsupported
in situations where the subroutine must distinguish between a simple
scalar and a typeglob. See L<perlsub/Prototypes>.
+=head2 On 64-bit platforms the semantics of bit operators have changed
+
+If your platform is either natively 64-bit or your Perl has been
+configured to used 64-bit integers (say C<perl -V> and see what is
+your ivsize: if it is 8, you are 64-bit) , be warned that the
+semantics of all the bitwise numeric operators (& | ^ ~ << >>) have
+been changed. They used to be forced to be 32 bits wide, but now in
+the aforementioned platforms they are 64 bits wide. Most dramatically
+this affects the unary ~: what used to be 32 bits wide, is now 64 bits
+wide. If you depend on your integers being 32 bits wide, mask off the
+excess bits with C<& 0xffffffff>.
+
=back
=head2 C Source Incompatibilities
included (as required before), so there is no source incompatibility
from the change.
-=item Support for C++ exceptions
-
-change#3386, also needs perlguts documentation
-[TODO - Chip Salzenberg <chip@perlsupport.com>]
-
=back
=head2 Binary Incompatibilities
The -Dusethreads flag now enables the experimental interpreter-based thread
support by default. To get the flavor of experimental threads that was in
-5.005 instead, you need to ask for -Duse5005threads.
+5.005 instead, you need to run Configure with "-Dusethreads -Duse5005threads".
As of v5.5.640, interpreter-threads support is still lacking a way to
create new threads from Perl (i.e., C<use Thread;> will not work with
interpreter threads). C<use Thread;> continues to be available when you
-ask for -Duse5005threads, bugs and all.
-
-=head2 Perl's version numbering has changed
-
-Beginning with Perl version 5.6, the version number convention has been
-changed to a "dotted tuple" scheme that is more commonly found in open
-source projects.
-
-Maintenance versions of v5.6.0 will be released as v5.6.1, v5.6.2 etc.
-The next development series following v5.6 will be numbered v5.7.x,
-beginning with v5.7.0, and the next major production release following
-v5.6 will be v5.8.
-
-The v1.2.3 syntax is also now legal in Perl. See L<Support for version tuples>
-for more on that.
-
-To cope with the new versioning system's use of at least three significant
-digits for each version component, the method used for incrementing the
-subversion number has also changed slightly. We assume that versions older
-than v5.6 have been incrementing the subversion component in multiples of
-10. Versions after v5.6 will increment them by 1. Thus, using the new
-notation, 5.005_03 is the same as v5.5.30, and the first maintenance
-version following v5.6 will be v5.6.1, which amounts to a floating point
-value of 5.006_001).
+ask for use5005threads, bugs and all.
=head2 New Configure flags
by running Configure with C<-Dflag>.
usemultiplicity
- use5005threads
+ usethreads useithreads (new interpreter threads: no Perl API yet)
+ usethreads use5005threads (threads as they were in 5.005)
+
+ use64bitint (equal to now deprecated 'use64bits')
+ use64bitall
uselongdouble
usemorebits
uselargefiles
+ usesocks (only SOCKS v5 supported)
-=head2 -Dusethreads and -Duse64bits now more daring
+=head2 Threadedness and 64-bitness now more daring
The Configure options enabling the use of threads and the use of
64-bitness are now more daring in the sense that they no more have an
capabilities. In other words: if your operating system has the
necessary APIs and datatypes, you should be able just to go ahead and
use them, for threads by Configure -Dusethreads, and for 64 bits
-either explicitly by Configure -Duse64bits or implicitly if your
+either explicitly by Configure -Duse64bitint or implicitly if your
system has 64 bit wide datatypes. See also L<"64-bit support">.
=head2 Long Doubles
=head2 -Dusemorebits
-You can enable both -Duse64bits and -Dlongdouble by -Dusemorebits.
+You can enable both -Duse64bitint and -Dlongdouble by -Dusemorebits.
See also L<"64-bit support">.
=head2 -Duselargefiles
=head2 Enhanced Installation Directories
-The installation structure has been enriched to improve the support for
-maintaining multiple versions of perl, to provide locations for
-vendor-supplied modules and scripts, and to ease maintenance of
-locally-added modules and scripts. See the section on Installation
-Directories in the INSTALL file for complete details. For most users
-building and installing from source, the defaults should be fine.
+The installation structure has been enriched to improve the support
+for maintaining multiple versions of perl, to provide locations for
+vendor-supplied modules, scripts, and manpages, and to ease maintenance
+of locally-added modules, scripts, and manpages. See the section on
+Installation Directories in the INSTALL file for complete details.
+For most users building and installing from source, the defaults should
+be fine.
+
+If you previously used C<Configure -Dsitelib> or C<-Dsitearch> to set
+special values for library directories, you might wish to consider using
+the new C<-Dsiteprefix> setting instead. Also, if you wish to re-use a
+config.sh file from an earlier version of perl, you should be sure to
+check that Configure makes sensible choices for the new directories.
+See INSTALL for complete details.
=head1 Core Changes
=head2 Unicode and UTF-8 support
Perl can optionally use UTF-8 as its internal representation for character
-strings. The C<utf8> and C<byte> pragmas are used to control this support
-in the current lexical scope. See L<perlunicode>, L<utf8> and L<byte> for
+strings. The C<utf8> and C<bytes> pragmas are used to control this support
+in the current lexical scope. See L<perlunicode>, L<utf8> and L<bytes> for
more information.
=head2 Interpreter cloning, threads, and concurrency
additional functionality of the perl_clone() API call and other
support for running B<cloned> interpreters concurrently.
-[XXX TODO - the Compiler backends may be broken when USE_ITHREADS is
-enabled.]
-
=head2 Lexically scoped warning categories
You can now control the granularity of warnings emitted by perl at a finer
the opportunity to introduce typing and other attributes for such
variables. See L<perlfunc/our>.
-=head2 Support for version tuples
+=head2 Support for strings represented as a vector of ordinals
-Literals of the form v1.2.3.4 are now parsed as the utf8 string
-C<"\x{1}\x{2}\x{3}\x{4}">. This allows comparing version numbers using
-regular string comparison operators C<eq>, C<ne>, C<lt>, C<gt> etc.
+Literals of the form C<v1.2.3.4> are now parsed as a string composed of
+of characters with the specified ordinals. This is an alternative, more
+readable way to construct (possibly unicode) strings instead of
+interpolating characters, as in C<"\x{1}\x{2}\x{3}\x{4}">. The leading
+C<v> may be omitted if there are more than two ordinals, so C<1.2.3> is
+parsed the same as C<v1.2.3>.
-These "dotted tuples" are dual-valued. They are both strings of utf8
-characters, and floating point numbers. Thus v1.2.3.4 has the string
-value C<"\x{1}\x{2}\x{3}\x{4}"> and the numeric value 1.002_003_004.
-As another example, v5.5.640 has the string value C<"\x{5}\x{5}\x{280}">
-(remember 280 hexadecimal is 640 decimal) and the numeric value
-5.005_64.
+Strings written in this form are also useful to represent version "numbers".
+It is easy to compare such version "numbers" (which are really just plain
+strings) using any of the usual string comparison operators C<eq>, C<ne>,
+C<lt>, C<gt>, etc., or perform bitwise string operations on them using C<|>,
+C<&>, etc.
In conjunction with the new C<$^V> magic variable (which contains
-the perl version in this format), such literals can be used to
-check if you're running a particular version of Perl.
+the perl version as a string), such literals can be used as a readable way
+to check if you're running a particular version of Perl:
+ # this will parse in older versions of Perl also
if ($^V and $^V gt v5.5.640) {
- # new style version numbers are supported
+ # new features supported
}
-C<require> and C<use> also support such literals:
+C<require> and C<use> also have some special magic to support such literals.
+They will be interpreted as a version rather than as a module name:
- require v5.6.0; # croak if $^V lt v5.6.0
- use v5.6.0; # same, but croaks at compile-time
+ require v5.6.0; # croak if $^V lt v5.6.0
+ use v5.6.0; # same, but croaks at compile-time
-C<sprintf> and C<printf> support the Perl-specific format type C<%v>
-to print arbitrary strings as dotted tuples.
+Alternatively, the C<v> may be omitted if there is more than one dot:
- printf "v%v", $^V; # prints current version, such as "v5.5.650"
+ require 5.6.0;
+ use 5.6.0;
+
+Also, C<sprintf> and C<printf> support the Perl-specific format flag C<%v>
+to print ordinals of characters in arbitrary strings:
+
+ printf "v%vd", $^V; # prints current version, such as "v5.5.650"
+ printf "%*vX", ":", $addr; # formats IPv6 address
+ printf "%*vb", " ", $bits; # displays bitstring
+
+See L<perldata/"Scalar value constructors"> for additional information.
=head2 Weak references
Perl now allows the arrow to be omitted in many constructs
involving subroutine calls through references. For example,
-C<$foo[10]-E<gt>('foo')> may now be written C<$foo[10]('foo')>.
+C<< $foo[10]->('foo') >> may now be written C<$foo[10]('foo')>.
This is rather similar to how the arrow may be omitted from
-C<$foo[10]-E<gt>{'foo'}>. Note however, that the arrow is still
-required for C<foo(10)-E<gt>('bar')>.
+C<< $foo[10]->{'foo'} >>. Note however, that the arrow is still
+required for C<< foo(10)->('bar') >>.
=head2 exists() is supported on subroutine names
=head2 File and directory handles can be autovivified
-Similar to how constructs such as C<$x-E<gt>[0]> autovivify a reference,
+Similar to how constructs such as C<< $x->[0] >> autovivify a reference,
handle constructors (open(), opendir(), pipe(), socketpair(), sysopen(),
socket(), and accept()) now autovivify a file or directory handle
if the handle passed to them is an uninitialized scalar variable. This
# $f implicitly closed here
}
-[TODO - this idiom needs more pod penetration]
=head2 64-bit support
-All platforms that have 64-bit integers either (a) natively as longs
-or ints (b) via special compiler flags (c) using long long are able to
+ NOTE: The Configure flags -Duselonglong and -Duse64bits
+ have been deprecated. Use -Duse64bitint instead.
+
+Any platform that has 64-bit integers either (a) natively as longs or
+ints (b) via special compiler flags (c) using long long are able to
use "quads" (64-integers) as follows:
=over 4
=item *
-in basic arithmetics: + - * / %
+in basic arithmetics: + - * / % (NOTE: operating close to the limits
+of the integer values may produce surprising results)
=item *
-vec() (but see the below note about bit arithmetics)
+in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced
+to be 32 bits wide.)
+
+=item *
+
+vec()
=back
Note that unless you have the case (a) you will have to configure
-and compile Perl using the -Duse64bits Configure flag.
-
-Unfortunately bit arithmetics (&, |, ^, ~, <<, >>) for numbers are not
-64-bit clean, they are explictly forced to be 32-bit because of
-tangled backward compatibility issues. This limitation is subject to
-change. Bit arithmetics for bit vector scalars (created by vec()) are
-not limited in their width.
+and compile Perl using the -Duse64bitint Configure flag.
+
+There are actually two modes of 64-bitness: the first one is achieved
+using Configure -Duse64bitint and the second one using Configure
+-Duse64bitall. The difference is that the first one is minimal and
+the second one maximal. The first one does only as much as is
+required to get 64-bit integers into Perl (this may mean, for example,
+using "long longs") while your memory may still be limited to 2
+gigabytes (because your pointers most likely are 32-bit); the second
+one goes all the way by attempting to switch also longs (and pointers)
+being 64-bit. This may create an even more binary incompatible Perl
+than -Duse64bitint: the resulting executable may not run at all in a
+CPU-bit box, or you may have to reboot/reconfigure/rebuild your
+operating system to be 64-bit aware.
+
+Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint
+nor -Duse64bitall.
Last but not least: note that due to Perl's habit of always using
floating point numbers the quads are still not true integers.
change#4052
[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
-=head2 Experimental support for user-hooks in @INC
-
-[TODO - Ken Fox <kfox@ford.com>]
-
=head2 C<require> and C<do> may be overridden
C<require> and C<do 'file'> operations may be overridden locally
enables perl code to determine whether actions that make sense
only during normal running are warranted. See L<perlvar>.
-=head2 New variable $^V contains Perl version in v5.6.0 format
+=head2 New variable $^V contains Perl version as a string
+
+C<$^V> contains the Perl version number as a string composed of
+characters whose ordinals match the version numbers, e.g., v5.6.0.
+This may be used in string comparisons.
-C<$^V> contains the Perl version number as a version tuple that
-can be used in string or numeric comparisons. See
-C<Support for version tuples> for an example.
+See C<Support for strings represented as a vector of ordinals> for an
+example.
=head2 Optional Y2K warnings
with another number.
This behavior must be specifically enabled when running Configure.
-See L<INSTALL> and L<README.Y2K>.
+See F<INSTALL> and F<README.Y2K>.
=head1 Significant bug fixes
-=head2 E<lt>HANDLEE<gt> on empty files
+=head2 <HANDLE> on empty files
With C<$/> set to C<undef>, "slurping" an empty file returns a string of
zero length (instead of C<undef>, as it used to) the first time the
=head2 Better diagnostics on meaningless filehandle operations
-Constructs such as C<open(E<lt>FHE<gt>)> and C<close(E<lt>FHE<gt>)>
+Constructs such as C<< open(<FH>) >> and C<< close(<FH>) >>
are compile time errors. Attempting to read from filehandles that
were opened only for writing will now produce warnings (just as
writing to read-only filehandles does).
=head2 Where possible, buffered data discarded from duped input filehandle
-C<open(NEW, "E<lt>&OLD")> now attempts to discard any data that
+C<< open(NEW, "<&OLD") >> now attempts to discard any data that
was previously read and buffered in C<OLD> before duping the handle.
On platforms where doing this is allowed, the next read operation
on C<NEW> will return the same data as the corresponding operation
=head2 eof() has the same old magic as <>
-C<eof()> would return true if no attempt to read from C<E<lt>E<gt>> had
+C<eof()> would return true if no attempt to read from C<< <> >> had
yet been made. C<eof()> has been changed to have a little magic of its
-own, it now opens the C<E<lt>E<gt>> files.
+own, it now opens the C<< <> >> files.
=head2 system(), backticks and pipe open now reflect exec() failure
=head2 Pseudo-hashes work better
Dereferencing some types of reference values in a pseudo-hash,
-such as C<$ph-E<gt>{foo}[1]>, was accidentally disallowed. This has
+such as C<< $ph->{foo}[1] >>, was accidentally disallowed. This has
been corrected.
When applied to a pseudo-hash element, exists() now reports whether
or slice it deletes the values corresponding to the keys (but not the keys
themselves). See L<perlref/"Pseudo-hashes: Using an array as a hash">.
+Pseudo-hash slices with constant keys are now optimized to array lookups
+at compile-time.
+
+The C<fields> pragma now provides ways to create pseudo-hashes, via
+fields::new() and fields::phash(). See L<fields>.
+
=head2 C<goto &sub> and AUTOLOAD
The C<goto &sub> construct works correctly when C<&sub> happens
optimized to directly set the lexical variable on the LHS,
eliminating redundant copying overheads.
-=head2 Method lookups optimized
-
-[TODO - Chip Salzenberg <chip@perlsupport.com>]
-
=head2 Faster mechanism to invoke XSUBs
change#4044,4125
=head1 Platform specific changes
-=head2 Additional supported platforms
+=head2 Supported platforms
=over 4
=item *
-Rhapsody is now supported.
+Rhapsody/Darwin is now supported.
=item *
[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+=head2 OS390 (OpenEdition MVS)
+
+Support for this EBCDIC platform has not been renewed in this release.
+There are difficulties in reconciling Perl's standardization on UTF-8
+as its internal representation for characters with the EBCDIC character
+set, because the two are incompatible.
+
+It is unclear whether future versions will renew support for this
+platform, but the possibility exists.
+
=head2 VMS
-[TODO - Charles Bailey <bailey@newman.upenn.edu>]
+Numerous revisions and extensions to configuration, build, testing, and
+installation process to accomodate core changes and VMS-specific options
+
+Expand %ENV-handling code to allow runtime mapping to logical names,
+CLI symbols, and CRTL environ array
+
+Extension of subprocess invocation code to accept filespecs as command "verbs"
+
+Add to Perl command line processing the ability to use default file types and
+to recognize Unix-style C<2E<gt>&1>.
+
+Expansion of File::Spec::VMS routines, and integration into ExtUtils::MM_VMS
+
+Extension of ExtUtils::MM_VMS to handle complex extensions more flexibly
+
+Barewords at start of Unix-syntax paths may be treated as text rather than
+only as logical names
+
+Optional secure translation of several logical names used internally by Perl
+
+Miscellaneous bugfixing and porting of new core code to VMS
+
+Thanks are gladly extended to the many people who have contributed VMS
+patches, testing, and ideas.
=head2 Win32
handles. kill() accepts any real process id, rather than strictly
return values from system(1,...).
+For better compatibility with Unix, C<kill(0, $pid)> can now be used to
+test whether a process exists.
+
The C<Shell> module is supported.
Rudimentary support for building under command.com in Windows 95
token; if not, the DATA filehandle will be left open in binary mode.
Earlier versions always opened the DATA filehandle in text mode.
-The glob() operator is implemented via the L<File::Glob> extension,
+The glob() operator is implemented via the C<File::Glob> extension,
which supports glob syntax of the C shell. This increases the flexibility
of the glob() operator, but there may be compatibility issues for
programs that relied on the older globbing syntax. If you want to
Compatibility tests for C<sub : attrs> vs the older C<use attrs>.
+=item lib/env
+
+Tests for new environment scalar capability (e.g., C<use Env qw($BAR);>).
+
+=item lib/env-array
+
+Tests for new environment array capability (e.g., C<use Env qw(@PATH);>).
+
=item lib/io_const
IO constants (SEEK_*, _IO*).
=item B
-The Perl Compiler suite has been extensively reworked for this
-release.
+WARNING: The Compiler suite is still highly experimental. The
+generated code may not be correct, even it manages to execute
+without errors.
-[TODO - Vishal Bhatia <vishal@gol.com>,
-Nick Ing-Simmons <nick@ni-s.u-net.com>]
+The Perl Compiler suite has been extensively reworked for this
+release. More of the standard Perl testsuite passes when run
+under the Compiler, but there is still a significant way to
+go to achieve production quality compiled executables.
=item ByteLoader
The Devel::Peek module provides access to the internal representation
of Perl variables and data. It is a data debugging tool for the XS programmer.
+=item English
+
+$PERL_VERSION now stands for C<$^V> (a string value) rather than for C<$]>
+(a numeric value).
+
+=item Env
+
+Env now supports accessing environment variables like PATH as array
+variables.
+
=item ExtUtils::MakeMaker
change#4135, also needs docs in module pod
See L<Pod::Usage> for details.
-A bug that prevented the non-option call-back E<lt>E<gt> from being
+A bug that prevented the non-option call-back <> from being
specified as the first argument has been fixed.
-To specify the characters E<lt> and E<gt> as option starters, use
-E<gt>E<lt>. Note, however, that changing option starters is strongly
-deprecated.
+To specify the characters < and > as option starters, use ><. Note,
+however, that changing option starters is strongly deprecated.
=item IO
A bug that prevented the IO::Socket::protocol() accessor
from ever returning the correct value has been corrected.
+IO::Socket::connect now uses non-blocking IO instead of alarm()
+to do connect timeouts.
+
+IO::Socket::accept now uses select() instead of alarm() for doing
+timeouts.
+
+IO::Socket::INET->new now sets $! correctly on failure. $@ is
+still set for backwards compatability.
+
=item JPL
Java Perl Lingo is now distributed with Perl. See jpl/README
=item Math::BigInt
-The bitwise operations C<E<lt>E<lt>>, C<E<gt>E<gt>>, C<&>, C<|>,
+The bitwise operations C<<< << >>>, C<<< >> >>>, C<&>, C<|>,
and C<~> are now supported on bigints.
=item Math::Complex
The accessor methods Re, Im, arg, abs, rho, and theta can now also
act as mutators (accessor $z->Re(), mutator $z->Re(3)).
+The class method C<display_format> and the corresponding object method
+C<display_format>, in addition to accepting just one argument, now can
+also accept a parameter hash. Recognized keys of a parameter hash are
+C<"style">, which corresponds to the old one parameter case, and two
+new parameters: C<"format">, which is a printf()-style format string
+(defaults usually to C<"%.15g">, you can revert to the default by
+setting the format string to C<undef>) used for both parts of a
+complex number, and C<"polar_pretty_print"> (defaults to true),
+which controls whether an attempt is made to try to recognize small
+multiples and rationals of pi (2pi, pi/2) at the argument (angle) of a
+polar complex number.
+
+The potentially disruptive change is that in list context both methods
+now I<return the parameter hash>, instead of only the value of the
+C<"style"> parameter.
+
=item Math::Trig
A little bit of radial trigonometry (cylindrical and spherical),
returns found pod files, along with their canonical names (like
C<File::Spec::Unix>). L<Pod::ParseUtils|Pod::ParseUtils> contains
B<Pod::List> (useful for storing pod list information), B<Pod::Hyperlink>
-(for parsing the contents of C<LE<gt>E<lt>> sequences) and B<Pod::Cache>
+(for parsing the contents of C<LE<lt>E<gt>> sequences) and B<Pod::Cache>
(for caching information about pod files, e.g. link nodes).
=item Pod::Select, podselect
=item Pod::Text and Pod::Man
-[TODO - Russ Allbery <rra@stanford.edu>]
+Pod::Text has been rewritten to use Pod::Parser. While pod2text() is
+still available for backwards compatibility, the module now has a new
+preferred interface. See L<Pod::Text> for the details. The new Pod::Text
+module is easily subclassed for tweaks to the output, and two such
+subclasses (Pod::Text::Termcap for man-page-style bold and underlining
+using termcap information, and Pod::Text::Color for markup with ANSI color
+sequences) are now standard.
+
+pod2man has been turned into a module, Pod::Man, which also uses
+Pod::Parser. In the process, several outstanding bugs related to quotes
+in section headers, quoting of code escapes, and nested lists have been
+fixed. pod2man is now a wrapper script around this module.
=item SDBM_File
Sys::Hostname now uses XSUBs to call the C library's gethostname() or
uname() if they exist.
+=item Term::ANSIColor
+
+Term::ANSIColor is a very simple module to provide easy and readable
+access to the ANSI color and highlighting escape sequences, supported by
+most ANSI terminal emulators. It is now included standard.
+
=item Time::Local
The timelocal() and timegm() functions used to silently return bogus
A tutorial that introduces the essentials of references.
+=item perlboot.pod
+
+A tutorial for beginners on object-oriented Perl.
+
=item perltootc.pod
A tutorial on managing class data for object modules.
=item <> should be quotes
-(F) You wrote C<require E<lt>fileE<gt>> when you should have written
+(F) You wrote C<< require <file> >> when you should have written
C<require 'file'>.
=item Attempt to join self
malloc()ed in the first place. Mandatory, but can be disabled by
setting environment variable C<PERL_BADFREE> to 1.
+=item Bareword found in conditional
+
+(W) The compiler found a bareword where it expected a conditional,
+which often indicates that an || or && was parsed as part of the
+last argument of the previous construct, for example:
+
+ open FOO || die;
+
+It may also indicate a misspelled constant that has been interpreted
+as a bareword:
+
+ use constant TYPO => 1;
+ if (TYOP) { print "foo" }
+
+The C<strict> pragma is useful in avoiding such errors.
+
=item Binary number > 0b11111111111111111111111111111111 non-portable
(W) The binary number you specified is larger than 2**32-1
(W) You tried to read from a filehandle opened only for writing. If you
intended it to be a read/write filehandle, you needed to open it with
-"+E<lt>" or "+E<gt>" or "+E<gt>E<gt>" instead of with "E<lt>" or nothing. If
-you intended only to read from the file, use "E<lt>". See
+"+<" or "+>" or "+>>" instead of with "<" or nothing. If
+you intended only to read from the file, use "<". See
L<perlfunc/open>.
=item flock() on closed filehandle %s
my ($foo, $bar) = @_;
-Remember that "my", "our" and "local" bind closer than comma.
+Remember that "my", "our", and "local" bind tighter than comma.
=item Possible Y2K bug: %s
=item Unknown open() mode '%s'
(F) The second argument of 3-argument open() is not among the list
-of valid modes: C<E<lt>>, C<E<gt>>, C<E<gt>E<gt>>, C<+E<lt>>,
-C<+E<gt>>, C<+E<gt>E<gt>>, C<-|>, C<|E<45>>.
+of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
+C<< +> >>, C<<< +>> >>>, C<-|>, C<|->.
=item Unknown process %x sent message to prime_env_iter: %s
might directly modify logical name tables and introduce nonstandard names,
or it may indicate that a logical name table has been corrupted.
+=item Probable precedence problem on %s
+
+(W) The compiler found a bareword where it expected a conditional,
+which often indicates that an || or && was parsed as part of the
+last argument of the previous construct, for example:
+
+ open FOO || die;
+
=item regexp too big
(F) The current implementation of regular expressions uses shorts as
projects / p5sagit/p5-mst-13.2.git / blobdiff