=head1 NAME
-perldelta - what's new for perl v5.6 (as of v5.005_61)
+perldelta - what's new for perl v5.6 (as of v5.005_64)
=head1 DESCRIPTION
=head2 Perl Source Incompatibilities
-TODO
+Beware that any new warnings that have been added or old ones
+that have been enhanced are B<not> considered incompatible changes.
+
+Since all new warnings must be explicitly requested via the C<-w>
+switch or the C<warnings> pragma, it is ultimately the programmer's
+responsibility to ensure that warnings are enabled judiciously.
+
+=over 4
+
+=item CHECK is a new keyword
+
+In addition to C<BEGIN>, C<INIT>, C<END>, C<DESTROY> and C<AUTOLOAD>,
+subroutines named C<CHECK> are now special. These are queued up during
+compilation and behave similar to END blocks, except they are called at
+the end of compilation rather than at the end of execution. They cannot
+be called directly.
+
+=item Treatment of list slices of undef has changed
+
+When taking a slice of a literal list (as opposed to a slice of
+an array or hash), Perl used to return an empty list if the
+result happened to be composed of all undef values.
+
+The new behavior is to produce an empty list if (and only if)
+the original list was empty. Consider the following example:
+
+ @a = (1,undef,undef,2)[2,1,2];
+
+The old behavior would have resulted in @a having no elements.
+The new behavior ensures it has three undefined elements.
+
+Note in particular that the behavior of slices of the following
+cases remains unchanged:
+
+ @a = ()[1,2];
+ @a = (getpwent)[7,0];
+ @a = (anything_returning_empty_list())[2,1,2];
+ @a = @b[2,1,2];
+ @a = @c{'a','b','c'};
+
+See L<perldata>.
+
+=item Possibly changed pseudo-random number generator
+
+In 5.005_0x and earlier, perl's rand() function used the C library
+rand(3) function. As of 5.005_52, Configure tests for drand48(),
+random(), and rand() (in that order) and picks the first one it finds.
+Perl programs that depend on reproducing a specific set of pseudo-random
+numbers will now likely produce different output. You can use
+C<sh Configure -Drandfunc=rand> to obtain the old behavior.
+
+=item Hashing function for hash keys has changed
+
+Perl hashes are not order preserving. The apparently random order
+encountered when iterating on the contents of a hash is determined
+by the hashing algorithm used. To improve the distribution of lower
+bits in the hashed value, the algorithm has changed slightly as of
+5.005_52. When iterating over hashes, this may yield a random order
+that is B<different> from that of previous versions.
+
+=item C<undef> fails on read only values
+
+Using the C<undef> operator on a readonly value (such as $1) has
+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 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(), 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
+
+Perl 5.004 deprecated the interpretation of C<$$1> and
+similar within interpolated strings to mean C<$$ . "1">,
+but still allowed it.
+
+In Perl 5.6 and later, C<"$$1"> always means C<"${$1}">.
+
+=item delete(), values() and C<\(%h)> operate on aliases to values, not copies
+
+delete(), each(), values() and hashes in a list context return the actual
+values in the hash, instead of copies (as they used to in earlier
+versions). Typical idioms for using these constructs copy the
+returned values, but this can make a significant difference when
+creating references to the returned values.
+
+Keys in the hash are still returned as copies when iterating on
+a hash.
+
+=item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS
+
+vec() generates a run-time error if the BITS argument is not
+a valid power-of-two integer.
+
+=item Text of some diagnostic output has changed
+
+Most references to internal Perl operations in diagnostics
+have been changed to be more descriptive. This may be an
+issue for programs that may incorrectly rely on the exact
+text of diagnostics for proper functioning.
+
+=item C<%@> has been removed
+
+The undocumented special variable C<%@> that used to accumulate
+"background" errors (such as those that happen in DESTROY())
+has been removed, because it could potentially result in memory
+leaks.
+
+=item Parenthesized not() behaves like a list operator
+
+The C<not> operator now falls under the "if it looks like a function,
+it behaves like a function" rule.
+
+As a result, the parenthesized form can be used with C<grep> and C<map>.
+The following construct used to be a syntax error before, but it works
+as expected now:
+
+ grep not($_), @things;
+
+On the other hand, using C<not> with a literal list slice may not
+work. The following previously allowed construct:
+
+ print not (1,2,3)[0];
+
+needs to be written with additional parentheses now:
+
+ print not((1,2,3)[0]);
+
+The behavior remains unaffected when C<not> is not followed by parentheses.
+
+=item Semantics of bareword prototype C<(*)> have changed
+
+Arguments prototyped as C<*> will now be visible within the subroutine
+as either a simple scalar or as a reference to a typeglob. Perl 5.005
+always coerced simple scalar arguments to a typeglob, which wasn't useful
+in situations where the subroutine must distinguish between a simple
+scalar and a typeglob. See L<perlsub/Prototypes>.
+
+=back
=head2 C Source Incompatibilities
=item C<PERL_IMPLICIT_CONTEXT>
+PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built
+with one of -Dusethreads, -Dusemultiplicity, or both. It is not
+intended to be enabled by users at this time.
+
This new build option provides a set of macros for all API functions
such that an implicit interpreter/thread context argument is passed to
every API function. As a result of this, something like C<sv_setsv(foo,bar)>
Perl, whose interfaces continue to match those of prior versions
(but subject to the other options described here).
-PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built
-with one of -Dusethreads, -Dusemultiplicity, or both.
-
See L<perlguts/"The Perl API"> for detailed information on the
ramifications of building Perl using this option.
Note that these functions do B<not> constitute Perl's memory allocation API.
See L<perlguts/"Memory Allocation"> for further information about that.
-=item C<PL_na> and C<dTHR> Issues
-
-The C<PL_na> global is now thread local, so a C<dTHR> declaration is needed
-in the scope in which the global appears. XSUBs should handle this automatically,
-but if you have used C<PL_na> in support functions, you either need to
-change the C<PL_na> to a local variable (which is recommended), or put in
-a C<dTHR>.
-
=back
=head2 Compatible C Source API Changes
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 default build of this release is binary compatible with the 5.005
-release or its maintenance versions.
+In general, the default build of this release is expected to be binary
+compatible for extensions built with the 5.005 release or its maintenance
+versions. However, specific platforms may have broken binary compatibility
+due to changes in the defaults used in hints files. Therefore, please be
+sure to always check the platform-specific README files for any notes to
+the contrary.
The usethreads or usemultiplicity builds are B<not> binary compatible
with the corresponding builds in 5.005.
+On platforms that require an explicit list of exports (AIX, OS/2 and Windows,
+among others), purely internal symbols such as parser functions and the
+run time opcodes are not exported by default. Perl 5.005 used to export
+all functions irrespective of whether they were considered part of the
+public API or not.
+
+For the full list of public API functions, see L<perlapi>.
+
+=head1 Installation and Configuration Improvements
+
+=head2 -Dusethreads means something different
+
+WARNING: Support for threads continues to be an experimental feature.
+Interfaces and implementation are subject to sudden and drastic changes.
+
+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.
+
+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).
+
+=head2 New Configure flags
+
+The following new flags may be enabled on the Configure command line
+by running Configure with C<-Dflag>.
+
+ usemultiplicity
+ use5005threads
+
+ uselongdouble
+ usemorebits
+ uselargefiles
+
+=head2 -Dusethreads and -Duse64bits 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
+explicit list of operating systems of known threads/64-bit
+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
+system has 64 bit wide datatypes. See also L<"64-bit support">.
+
+=head2 Long Doubles
+
+Some platforms have "long doubles", floating point numbers of even
+larger range than ordinary "doubles". To enable using long doubles for
+Perl's scalars, use -Duselongdouble.
+
+=head2 -Dusemorebits
+
+You can enable both -Duse64bits and -Dlongdouble by -Dusemorebits.
+See also L<"64-bit support">.
+
+=head2 -Duselargefiles
+
+Some platforms support large files, files larger than two gigabytes.
+See L<"Large file support"> for more information.
+
+=head2 installusrbinperl
+
+You can use "Configure -Uinstallusrbinperl" which causes installperl
+to skip installing perl also as /usr/bin/perl. This is useful if you
+prefer not to modify /usr/bin for some reason or another but harmful
+because many scripts assume to find Perl in /usr/bin/perl.
+
+=head2 SOCKS support
+
+You can use "Configure -Dusesocks" which causes Perl to probe
+for the SOCKS (v5, not v4) proxy protocol library,
+http://www.socks.nec.com/
+
+=head2 C<-A> flag
+
+You can "post-edit" the Configure variables using the Configure C<-A>
+flag. The editing happens immediately after the platform specific
+hints files have been processed but before the actual configuration
+process starts. Run C<Configure -h> to find out the full C<-A> syntax.
+
+=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.
+
=head1 Core Changes
=head2 Unicode and UTF-8 support
Perl can optionally use UTF-8 as its internal representation for character
-strings. The C<use utf8> pragma enables this support in the current lexical
-scope. See L<utf8> for more information.
+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
+
+WARNING: This is an experimental feature in a pre-alpha state. Use
+at your own risk.
+
+Perl 5.005_63 introduces the beginnings of support for running multiple
+interpreters concurrently in different threads. In conjunction with
+the perl_clone() API call, which can be used to selectively duplicate
+the state of any given interpreter, it is possible to compile a
+piece of code once in an interpreter, clone that interpreter
+one or more times, and run all the resulting interpreters in distinct
+threads.
+
+On Windows, this feature is used to emulate fork() at the interpreter
+level. See L<perlfork>.
+
+This feature is still in evolution. It is eventually meant to be used
+to selectively clone a subroutine and data reachable from that
+subroutine in a separate interpreter and run the cloned subroutine
+in a separate thread. Since there is no shared data between the
+interpreters, little or no locking will be needed (unless parts of
+the symbol table are explicitly shared). This is obviously intended
+to be an easy-to-use replacement for the existing threads support.
+
+Support for cloning interpreters and interpreter concurrency can be
+enabled using the -Dusethreads Configure option (see win32/Makefile for
+how to enable it on Windows.) The resulting perl executable will be
+functionally identical to one that was built with -Dmultiplicity, but
+the perl_clone() API call will only be available in the former.
+
+-Dusethreads enables, the cpp macros USE_ITHREADS by default, which enables
+Perl source code changes that provide a clear separation between the op tree
+and the data it operates with. The former is considered immutable, and can
+therefore be shared between an interpreter and all of its clones, while the
+latter is considered local to each interpreter, and is therefore copied for
+each clone.
+
+Note that building Perl with the -Dusemultiplicity Configure option
+is adequate if you wish to run multiple B<independent> interpreters
+concurrently in different threads. -Dusethreads only provides the
+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
level using the C<use warnings> pragma. See L<warnings> and L<perllexwarn>
for details.
+=head2 Lvalue subroutines
+
+WARNING: This is an experimental feature.
+
+change#4081
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>,
+Tuomas Lukka <lukka@iki.fi>)]
+
+=head2 "our" declarations
+
+An "our" declaration introduces a value that can be best understood
+as a lexically scoped symbolic alias to a global variable in the
+package that was current where the variable was declared. This is
+mostly useful as an alternative to the C<vars> pragma, but also provides
+the opportunity to introduce typing and other attributes for such
+variables. See L<perlfunc/our>.
+
+=head2 Support for version tuples
+
+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.
+
+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.
+
+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.
+
+ if ($^V and $^V gt v5.5.640) {
+ # new style version numbers are supported
+ }
+
+C<require> and C<use> also support such literals:
+
+ require v5.6.0; # croak if $^V lt v5.6.0
+ use v5.6.0; # same, but croaks at compile-time
+
+C<sprintf> and C<printf> support the Perl-specific format type C<%v>
+to print arbitrary strings as dotted tuples.
+
+ printf "v%v", $^V; # prints current version, such as "v5.5.650"
+
+=head2 Weak references
+
+WARNING: This is an experimental feature.
+
+In previous versions of Perl, you couldn't cache objects so as
+to allow them to be deleted if the last reference from outside
+the cache is deleted. The reference in the cache would hold a
+reference count on the object and the objects would never be
+destroyed.
+
+Another familiar problem is with circular references. When an
+object references itself, its reference count would never go
+down to zero, and it would not get destroyed until the program
+is about to exit.
+
+Weak references solve this by allowing you to "weaken" any
+reference, that is, make it not count towards the reference count.
+When the last non-weak reference to an object is deleted, the object
+is destroyed and all the weak references to the object are
+automatically undef-ed.
+
+To use this feature, you need the WeakRef package from CPAN, which
+contains additional documentation.
+
+change#3385, also need perlguts documentation
+[TODO - Tuomas Lukka <lukka@iki.fi>]
+
+=head2 File globbing implemented internally
+
+WARNING: This is currently an experimental feature. Interfaces and
+implementation are likely to change.
+
+Perl now uses the File::Glob implementation of the glob() operator
+automatically. This avoids using an external csh process and the
+problems associated with it.
+
=head2 Binary numbers supported
Binary numbers are now supported as literals, in s?printf formats, and
$answer = 0b101010;
printf "The answer is: %b\n", oct("0b101010");
+=head2 Some arrows may be omitted in calls through 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')>.
+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')>.
+
+=head2 exists() is supported on subroutine names
+
+The exists() builtin now works on subroutine names. A subroutine
+is considered to exist if it has been declared (even if implicitly).
+See L<perlfunc/exists> for examples.
+
+=head2 exists() and delete() are supported on array elements
+
+The exists() and delete() builtins now work on simple arrays as well.
+The behavior is similar to that on hash elements.
+
+exists() can be used to check whether an array element has been
+initialized. This avoids autovivifying array elements that don't exist.
+If the array is tied, the EXISTS() method in the corresponding tied
+package will be invoked.
+
+delete() may be used to remove an element from the array and return
+it. The array element at that position returns to its unintialized
+state, so that testing for the same element with exists() will return
+false. If the element happens to be the one at the end, the size of
+the array also shrinks up to the highest element that tests true for
+exists(), or 0 if none such is found. If the array is tied, the DELETE()
+method in the corresponding tied package will be invoked.
+
+See L<perlfunc/exists> and L<perlfunc/delete> for examples.
+
=head2 syswrite() ease-of-use
-The length argument of C<syswrite()> is now optional.
+The length argument of C<syswrite()> has become optional.
+
+=head2 File and directory handles can be autovivified
+
+Similar to how constructs such as C<$x-E<gt>[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
+allows the constructs such as C<open(my $fh, ...)> and C<open(local $fh,...)>
+to be used to create filehandles that will conveniently be closed
+automatically when the scope ends, provided there are no other references
+to them. This largely eliminates the need for typeglobs when opening
+filehandles that must be passed around, as in the following example:
+
+ sub myopen {
+ open my $fh, "@_"
+ or die "Can't open '@_': $!";
+ return $fh;
+ }
+
+ {
+ my $f = myopen("</etc/motd");
+ print <$f>;
+ # $f implicitly closed here
+ }
+
+[TODO - this idiom needs more pod penetration]
=head2 64-bit support
=over 4
-=item constants (decimal, hexadecimal, octal, binary) in the code
+=item *
+
+constants (decimal, hexadecimal, octal, binary) in the code
+
+=item *
+
+arguments to oct() and hex()
+
+=item *
+
+arguments to print(), printf() and sprintf() (flag prefixes ll, L, q)
+
+=item *
+
+printed as such
+
+=item *
-=item arguments to oct() and hex()
+pack() and unpack() "q" and "Q" formats
-=item arguments to print(), printf() and sprintf() (flag prefixes ll, L, q)
+=item *
-=item printed as such
+in basic arithmetics: + - * / %
-=item pack() and unpack() "q" and "Q" formatS
+=item *
-=item in basic arithmetics: + - * / %
+vec() (but see the below note about bit arithmetics)
-=item vec() (but see the below note about bit arithmetics)
-
=back
Note that unless you have the case (a) you will have to configure
and compile Perl using the -Duse64bits Configure flag.
-Unfortunately bit arithmetics (&, |, ^, ~, <<, >>) are not 64-bit clean,
-they are explictly forced to be 32-bit.
+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.
Last but not least: note that due to Perl's habit of always using
floating point numbers the quads are still not true integers.
=head2 Large file support
If you have filesystems that support "large files" (files larger than
-2 gigabytes), you may now also be able to create and access them from Perl.
+2 gigabytes), you may now also be able to create and access them from
+Perl. You have to use Configure -Duselargefiles. Turning on the
+large file support turns on also the 64-bit support on many platforms.
+Beware that unless your filesystem also supports "sparse files" seeking
+to umpteen petabytes may be unadvisable.
+
+Note that in addition to requiring a proper file system to do large
+files you may also need to adjust your per-process (or your
+per-system, or per-process-group, or per-user-group) maximum filesize
+limits before running Perl scripts that try to handle large files,
+especially if you intend to write such files.
+
+Finally, in addition to your process/process group maximum filesize
+limits, you may have quota limits on your filesystems that stop you
+(your user id or your user group id) from using large files.
+
+Adjusting your process/user/group/file system/operating system limits
+is outside the scope of Perl core language. For process limits, you
+may try increasing the limits using your shell's limits/limit/ulimit
+command before running Perl. The BSD::Resource extension (not
+included with the standard Perl distribution) may also be of use, it
+offers the getrlimit/setrlimit interface that can be used to adjust
+process resource usage limits, including the maximum filesize limit.
-Note that in addition to requiring a proper file system to do this you
-may also need to adjust your per-process (or even your per-system)
-maximum filesize limits before running Perl scripts that try to handle
-large files, especially if you intend to write such files.
+=head2 Long doubles
-Adjusting your file system/system limits is outside the scope of Perl.
-For process limits, you may try to increase the limits using your
-shell's limit/ulimit command before running Perl. The BSD::Resource
-extension (not included with the standard Perl distribution) may also
-be of use.
-
-(Large file support is also related to 64-bit support, for obvious reasons)
+In some systems you may be able to use long doubles to enhance the
+range and precision of your double precision floating point numbers
+(that is, Perl's numbers). Use Configure -Duselongdouble to enable
+this support (if it is available).
+
+=head2 "more bits"
+
+You can "Configure -Dusemorebits" to turn on both the 64-bit support
+and the long double support.
+
+=head2 Enhanced support for sort() subroutines
+
+Perl subroutines with a prototype of C<($$)> and XSUBs in general can
+now be used as sort subroutines. In either case, the two elements to
+be compared are passed as normal parameters in @_. See L<perlfunc/sort>.
+
+For unprototyped sort subroutines, the historical behavior of passing
+the elements to be compared as the global variables $a and $b remains
+unchanged.
=head2 Better syntax checks on parenthesized unary operators
=head2 pack() and unpack() support counted strings
-The template character '#' can be used to specify a counted string
+The template character '/' can be used to specify a counted string
type to be packed or unpacked. See L<perlfunc/"pack">.
+=head2 Comments in pack() templates
+
+The '#' character in a template introduces a comment up to
+end of the line. This facilitates documentation of pack()
+templates.
+
=head2 $^X variables may now have names longer than one character
Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax
Formerly, if you wanted to mark a subroutine as being a method call or
as requiring an automatic lock() when it is entered, you had to declare
that with a C<use attrs> pragma in the body of the subroutine.
-That can now be accomplished with a declaration syntax, like this:
+That can now be accomplished with declaration syntax, like this:
+
+ sub mymethod : locked method ;
+ ...
+ sub mymethod : locked method {
+ ...
+ }
- sub mymethod : locked, method ;
+ sub othermethod :locked :method ;
...
- sub mymethod : locked, method {
+ sub othermethod :locked :method {
...
}
+
+(Note how only the first C<:> is mandatory, and whitespace surrounding
+the C<:> is optional.)
+
F<AutoSplit.pm> and F<SelfLoader.pm> have been updated to keep the attributes
with the stubs they provide. See L<attributes>.
+=head2 Regular expression improvements
+
+change#2827,2373,2372,2365,1813,1800,4112,4158,4215,4301
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+
+=head2 Overloading improvements
+
+change#2150
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+
+=head2 open() with more than two arguments
+
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+
+=head2 Support for interpolating named characters
+
+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
+by importing subroutines of the same name into the current package
+(or globally by importing them into the CORE::GLOBAL:: namespace).
+Overriding C<require> will also affect C<use>, provided the override
+is visible at compile-time.
+See L<perlsub/"Overriding Built-in Functions">.
+
+=head2 New variable $^C reflects C<-c> switch
+
+C<$^C> has a boolean value that reflects whether perl is being run
+in compile-only mode (i.e. via the C<-c> switch). Since
+BEGIN blocks are executed under such conditions, this variable
+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
+
+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.
+
+=head2 Optional Y2K warnings
+
+If Perl is built with the cpp macro C<PERL_Y2KWARN> defined,
+it emits optional warnings when concatenating the number 19
+with another number.
+
+This behavior must be specifically enabled when running Configure.
+See L<INSTALL> and L<README.Y2K>.
+
=head1 Significant bug fixes
=head2 E<lt>HANDLEE<gt> on empty files
-With C<$/> set to C<undef>, slurping an empty file returns a string of
+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
-HANDLE is read. Further reads yield C<undef>.
+HANDLE is read after C<$/> is set to C<undef>. Further reads yield
+C<undef>.
This means that the following will append "foo" to an empty file (it used
to do nothing):
the replacement expression in C<eval 's/.../.../e'>. This has
been fixed.
+=head2 All compilation errors are true errors
+
+Some "errors" encountered at compile time were by neccessity
+generated as warnings followed by eventual termination of the
+program. This enabled more such errors to be reported in a
+single run, rather than causing a hard stop at the first error
+that was encountered.
+
+The mechanism for reporting such errors has been reimplemented
+to queue compile-time errors and report them at the end of the
+compilation as true errors rather than as warnings. This fixes
+cases where error messages leaked through in the form of warnings
+when code was compiled at run time using C<eval STRING>, and
+also allows such errors to be reliably trapped using __DIE__ hooks.
+
=head2 Automatic flushing of output buffers
fork(), exec(), system(), qx//, and pipe open()s now flush buffers
were opened only for writing will now produce warnings (just as
writing to read-only filehandles does).
-=head2 Buffered data discarded from input filehandle when dup'ed.
+=head2 Where possible, buffered data discarded from duped input filehandle
-C<open(NEW, "E<lt>&OLD")> now discards any data that was previously
-read and buffered in C<OLD>. The next read operation on C<NEW> will
-return the same data as the corresponding operation on C<OLD>.
-Formerly, it would have returned the data from the start of the
-following disk block instead.
+C<open(NEW, "E<lt>&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
+on C<OLD>. Formerly, it would have returned the data from the start
+of the following disk block instead.
-=head1 Supported Platforms
+=head2 eof() has the same old magic as <>
-=over 4
+C<eof()> would return true if no attempt to read from C<E<lt>E<gt>> 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.
-=item *
+=head2 system(), backticks and pipe open now reflect exec() failure
-VM/ESA is now supported.
+On Unix and similar platforms, system(), qx() and open(FOO, "cmd |")
+etc., are implemented via fork() and exec(). When the underlying
+exec() fails, earlier versions did not report the error properly,
+since the exec() happened to be in a different process.
-=item *
+The child process now communicates with the parent about the
+error in launching the external command, which allows these
+constructs to return with their usual error value and set $!.
-Siemens BS2000 is now supported under the POSIX Shell.
+=head2 Implicitly closed filehandles are safer
-=item *
+Sometimes implicitly closed filehandles (as when they are localized,
+and Perl automatically closes them on exiting the scope) could
+inadvertently set $? or $!. This has been corrected.
-The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread
-extension.
+=head2 C<(\$)> prototype and C<$foo{a}>
-=item *
+An scalar reference prototype now correctly allows a hash or
+array element in that slot.
-GNU/Hurd is now supported.
+=head2 Pseudo-hashes work better
-=item *
+Dereferencing some types of reference values in a pseudo-hash,
+such as C<$ph-E<gt>{foo}[1]>, was accidentally disallowed. This has
+been corrected.
-Rhapsody is now supported.
+When applied to a pseudo-hash element, exists() now reports whether
+the specified value exists, not merely if the key is valid.
-=item *
+delete() now works on pseudo-hashes. When given a pseudo-hash element
+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">.
-EPOC is is now supported (on Psion 5).
+=head2 C<goto &sub> and AUTOLOAD
-=back
+The C<goto &sub> construct works correctly when C<&sub> happens
+to be autoloaded.
-=head1 New tests
+=head2 C<-bareword> allowed under C<use integer>
-=over 4
+The autoquoting of barewords preceded by C<-> did not work
+in prior versions when the C<integer> pragma was enabled.
+This has been fixed.
-=item lib/attrs
+=head2 Boolean assignment operators are legal lvalues
-Compatibility tests for C<sub : attrs> vs the older C<use attrs>.
+Constructs such as C<($a ||= 2) += 1> are now allowed.
-=item lib/io_const
+=head2 C<sort $coderef @foo> allowed
-IO constants (SEEK_*, _IO*).
+sort() did not accept a subroutine reference as the comparison
+function in earlier versions. This is now permitted.
-=item lib/io_dir
+=head2 Failures in DESTROY()
-Directory-related IO methods (new, read, close, rewind, tied delete).
+When code in a destructor threw an exception, it went unnoticed
+in earlier versions of Perl, unless someone happened to be
+looking in $@ just after the point the destructor happened to
+run. Such failures are now visible as warnings when warnings are
+enabled.
-=item lib/io_multihomed
+=head2 Locale bugs fixed
-INET sockets with multi-homed hosts.
+printf() and sprintf() previously reset the numeric locale
+back to the default "C" locale. This has been fixed.
-=item lib/io_poll
+Numbers formatted according to the local numeric locale
+(such as using a decimal comma instead of a decimal dot) caused
+"isn't numeric" warnings, even while the operations accessing
+those numbers produced correct results. The warnings are gone.
-IO poll().
+=head2 Memory leaks
-=item lib/io_unix
+The C<eval 'return sub {...}'> construct could sometimes leak
+memory. This has been fixed.
-UNIX sockets.
+Operations that aren't filehandle constructors used to leak memory
+when used on invalid filehandles. This has been fixed.
-=item op/attrs
+Constructs that modified C<@_> could fail to deallocate values
+in C<@_> and thus leak memory. This has been corrected.
-Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>.
+=head2 Spurious subroutine stubs after failed subroutine calls
-=item op/filetest
+Perl could sometimes create empty subroutine stubs when a
+subroutine was not found in the package. Such cases stopped
+later method lookups from progressing into base packages.
+This has been corrected.
-File test operators.
+=head2 Consistent numeric conversions
-=item op/lex_assign
+change#3378,3318
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
-Verify operations that access pad objects (lexicals and temporaries).
+=head2 Taint failures under C<-U>
-=back
+When running in unsafe mode, taint violations could sometimes
+cause silent failures. This has been fixed.
-=head1 Modules and Pragmata
+=head2 END blocks and the C<-c> switch
-=head2 Modules
+Prior versions used to run BEGIN B<and> END blocks when Perl was
+run in compile-only mode. Since this is typically not the expected
+behavior, END blocks are not executed anymore when the C<-c> switch
+is used.
-=over 4
+See L<CHECK blocks> for how to run things when the compile phase ends.
-=item attributes
+=head2 Potential to leak DATA filehandles
-While used internally by Perl as a pragma, this module also
-provides a way to fetch subroutine and variable attributes.
-See L<attributes>.
+Using the C<__DATA__> token creates an implicit filehandle to
+the file that contains the token. It is the program's
+responsibility to close it when it is done reading from it.
-=item ByteLoader
+This caveat is now better explained in the documentation.
+See L<perldata>.
-The ByteLoader is a dedication extension to generate and run
-Perl bytecode. See L<ByteLoader>.
+=head2 Diagnostics follow STDERR
-=item B
+Diagnostic output now goes to whichever file the C<STDERR> handle
+is pointing at, instead of always going to the underlying C runtime
+library's C<stderr>.
-The Perl Compiler suite has been extensively reworked for this
-release.
+=head2 Other fixes for better diagnostics
-=item Devel::DProf
+Line numbers are no longer suppressed (under most likely circumstances)
+during the global destruction phase.
-Devel::DProf, a Perl source code profiler has been added.
+Diagnostics emitted from code running in threads other than the main
+thread are now accompanied by the thread ID.
-=item Dumpvalue
+Embedded null characters in diagnostics now actually show up. They
+used to truncate the message in prior versions.
-Added Dumpvalue module provides screen dumps of Perl data.
+$foo::a and $foo::b are now exempt from "possible typo" warnings only
+if sort() is encountered in package foo.
-=item Benchmark
+Unrecognized alphabetic escapes encountered when parsing quote
+constructs now generate a warning, since they may take on new
+semantics in later versions of Perl.
-You can now run tests for I<n> seconds instead of guessing the right
-number of tests to run: e.g. timethese(-5, ...) will run each
-code for at least 5 CPU seconds. Zero as the "number of repetitions"
-means "for at least 3 CPU seconds". The output format has also
-changed. For example:
+=head1 Performance enhancements
-use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}})
+=head2 Simple sort() using { $a <=> $b } and the like are optimized
-will now output something like this:
+Many common sort() operations using a simple inlined block are now
+optimized for faster performance.
-Benchmark: running a, b, each for at least 5 CPU seconds...
- a: 5 wallclock secs ( 5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91/s (n=1156516)
- b: 4 wallclock secs ( 5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18/s (n=800686)
+=head2 Optimized assignments to lexical variables
-New features: "each for at least N CPU seconds...", "wallclock secs",
-and the "@ operations/CPU second (n=operations)".
+Certain operations in the RHS of assignment statements have been
+optimized to directly set the lexical variable on the LHS,
+eliminating redundant copying overheads.
-=item Devel::Peek
+=head2 Method lookups optimized
-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.
+[TODO - Chip Salzenberg <chip@perlsupport.com>]
-=item Fcntl
+=head2 Faster mechanism to invoke XSUBs
-More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for
-large (more than 4G) file access (64-bit support is not yet
-working, though, so no need to get overly excited), Free/Net/OpenBSD
-locking behaviour flags F_FLOCK, F_POSIX, Linux F_SHLCK, and
-O_ACCMODE: the mask of O_RDONLY, O_WRONLY, and O_RDWR.
+change#4044,4125
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
-=item File::Spec
+=head2 Perl_malloc() improvements
-New methods have been added to the File::Spec module: devnull() returns
-the name of the null device (/dev/null on Unix) and tmpdir() the name of
-the temp directory (normally /tmp on Unix). There are now also methods
+change#4237
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+
+=head2 Faster subroutine calls
+
+Minor changes in how subroutine calls are handled internally
+provide marginal improvements in performance.
+
+=head1 Platform specific changes
+
+=head2 Additional supported platforms
+
+=over 4
+
+=item *
+
+VM/ESA is now supported.
+
+=item *
+
+Siemens BS2000 is now supported under the POSIX Shell.
+
+=item *
+
+The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread
+extension.
+
+=item *
+
+GNU/Hurd is now supported.
+
+=item *
+
+Rhapsody is now supported.
+
+=item *
+
+EPOC is is now supported (on Psion 5).
+
+=back
+
+=head2 DOS
+
+=over 4
+
+=item *
+
+Perl now works with djgpp 2.02 (and 2.03 alpha).
+
+=item *
+
+Environment variable names are not converted to uppercase any more.
+
+=item *
+
+Wrong exit code from backticks now fixed.
+
+=item *
+
+This port is still using its own builtin globbing.
+
+=back
+
+=head2 OS/2
+
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+
+=head2 VMS
+
+[TODO - Charles Bailey <bailey@newman.upenn.edu>]
+
+=head2 Win32
+
+Site library searches failed to look for ".../site/5.XXX/lib"
+if ".../site/5.XXXYY/lib" wasn't found. This has been corrected.
+
+When given a pathname that consists only of a drivename, such
+as C<A:>, opendir() and stat() now use the current working
+directory for the drive rather than the drive root.
+
+The builtin XSUB functions in the Win32:: namespace are
+documented. See L<Win32>.
+
+$^X now contains the full path name of the running executable.
+
+A Win32::GetLongPathName() function is provided to complement
+Win32::GetFullPathName() and Win32::GetShortPathName(). See L<Win32>.
+
+POSIX::uname() is supported.
+
+system(1,...) now returns true process IDs rather than process
+handles. kill() accepts any real process id, rather than strictly
+return values from system(1,...).
+
+The C<Shell> module is supported.
+
+Rudimentary support for building under command.com in Windows 95
+has been added.
+
+Scripts are read in binary mode by default to allow ByteLoader (and
+the filter mechanism in general) to work properly. For compatibility,
+the DATA filehandle will be set to text mode if a carriage return is
+detected at the end of the line containing the __END__ or __DATA__
+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,
+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
+preserve compatibility with the older syntax, you might want to put
+a C<use File::DosGlob;> in your program. For details and compatibility
+information, see L<File::Glob>.
+
+[TODO - GSAR]
+
+=head1 New tests
+
+=over 4
+
+=item lib/attrs
+
+Compatibility tests for C<sub : attrs> vs the older C<use attrs>.
+
+=item lib/io_const
+
+IO constants (SEEK_*, _IO*).
+
+=item lib/io_dir
+
+Directory-related IO methods (new, read, close, rewind, tied delete).
+
+=item lib/io_multihomed
+
+INET sockets with multi-homed hosts.
+
+=item lib/io_poll
+
+IO poll().
+
+=item lib/io_unix
+
+UNIX sockets.
+
+=item op/attrs
+
+Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>.
+
+=item op/filetest
+
+File test operators.
+
+=item op/lex_assign
+
+Verify operations that access pad objects (lexicals and temporaries).
+
+=item op/exists_sub
+
+Verify C<exists &sub> operations.
+
+=back
+
+=head1 Modules and Pragmata
+
+=head2 Modules
+
+=over 4
+
+=item attributes
+
+While used internally by Perl as a pragma, this module also
+provides a way to fetch subroutine and variable attributes.
+See L<attributes>.
+
+=item B
+
+The Perl Compiler suite has been extensively reworked for this
+release.
+
+[TODO - Vishal Bhatia <vishal@gol.com>,
+Nick Ing-Simmons <nick@ni-s.u-net.com>]
+
+=item ByteLoader
+
+The ByteLoader is a dedicated extension to generate and run
+Perl bytecode. See L<ByteLoader>.
+
+=item constant
+
+References can now be used.
+
+The new version also allows a leading underscore in constant names, but
+disallows a double leading underscore (as in "__LINE__"). Some other names
+are disallowed or warned against, including BEGIN, END, etc. Some names
+which were forced into main:: used to fail silently in some cases; now they're
+fatal (outside of main::) and an optional warning (inside of main::).
+The ability to detect whether a constant had been set with a given name has
+been added.
+
+See L<constant>.
+
+=item charnames
+
+change#4052
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+
+=item Data::Dumper
+
+A C<Maxdepth> setting can be specified to avoid venturing
+too deeply into deep data structures. See L<Data::Dumper>.
+
+Dumping C<qr//> objects works correctly.
+
+=item DB
+
+C<DB> is an experimental module that exposes a clean abstraction
+to Perl's debugging API.
+
+=item DB_File
+
+DB_File can now be built with Berkeley DB versions 1, 2 or 3.
+See C<ext/DB_File/Changes>.
+
+=item Devel::DProf
+
+Devel::DProf, a Perl source code profiler has been added. See
+L<Devel::DProf> and L<dprofpp>.
+
+=item Dumpvalue
+
+The Dumpvalue module provides screen dumps of Perl data.
+
+=item Benchmark
+
+Overall, Benchmark results exhibit lower average error and better timing
+accuracy.
+
+You can now run tests for I<n> seconds instead of guessing the right
+number of tests to run: e.g. timethese(-5, ...) will run each
+code for at least 5 CPU seconds. Zero as the "number of repetitions"
+means "for at least 3 CPU seconds". The output format has also
+changed. For example:
+
+ use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}})
+
+will now output something like this:
+
+ Benchmark: running a, b, each for at least 5 CPU seconds...
+ a: 5 wallclock secs ( 5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91/s (n=1156516)
+ b: 4 wallclock secs ( 5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18/s (n=800686)
+
+New features: "each for at least N CPU seconds...", "wallclock secs",
+and the "@ operations/CPU second (n=operations)".
+
+timethese() now returns a reference to a hash of Benchmark objects containing
+the test results, keyed on the names of the tests.
+
+timethis() now returns the iterations field in the Benchmark result object
+instead of 0.
+
+timethese(), timethis(), and the new cmpthese() (see below) can also take
+a format specifier of 'none' to suppress output.
+
+A new function countit() is just like timeit() except that it takes a
+TIME instead of a COUNT.
+
+A new function cmpthese() prints a chart comparing the results of each test
+returned from a timethese() call. For each possible pair of tests, the
+percentage speed difference (iters/sec or seconds/iter) is shown.
+
+For other details, see L<Benchmark>.
+
+=item Devel::Peek
+
+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 ExtUtils::MakeMaker
+
+change#4135, also needs docs in module pod
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+
+=item Fcntl
+
+More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for
+large file (more than 4GB) access Note that the O_LARGEFILE is
+automatically/transparently added to sysopen() flags if large file
+support has been configured), Free/Net/OpenBSD locking behaviour flags
+F_FLOCK, F_POSIX, Linux F_SHLCK, and O_ACCMODE: the combined mask of
+O_RDONLY, O_WRONLY, and O_RDWR. The seek()/sysseek() constants
+SEEK_SET, SEEK_CUR, and SEEK_END are available via the C<:seek> tag.
+The chmod()/stat() S_IF* constants and S_IS* functions are available
+via the C<:mode> tag.
+
+
+=item File::Compare
+
+A compare_text() function has been added, which allows custom
+comparison functions. See L<File::Compare>.
+
+=item File::Find
+
+File::Find now works correctly when the wanted() function is either
+autoloaded or is a symbolic reference.
+
+A bug that caused File::Find to lose track of the working directory
+when pruning top-level directories has been fixed.
+
+File::Find now also supports several other options to control its
+behavior. It can follow symbolic links if the C<follow> option is
+specified. Enabling the C<no_chdir> option will make File::Find skip
+changing the current directory when walking directories. The C<untaint>
+flag can be useful when running with taint checks enabled.
+
+See L<File::Find>.
+
+=item File::Glob
+
+This extension implements BSD-style file globbing. By default,
+it will also be used for the internal implementation of the glob()
+operator. See L<File::Glob>.
+
+=item File::Spec
+
+New methods have been added to the File::Spec module: devnull() returns
+the name of the null device (/dev/null on Unix) and tmpdir() the name of
+the temp directory (normally /tmp on Unix). There are now also methods
to convert between absolute and relative filenames: abs2rel() and
rel2abs(). For compatibility with operating systems that specify volume
names in file paths, the splitpath(), splitdir(), and catdir() methods
have been added.
-=item File::Spec::Functions
+=item File::Spec::Functions
+
+The new File::Spec::Functions modules provides a function interface
+to the File::Spec module. Allows shorthand
+
+ $fullname = catfile($dir1, $dir2, $file);
+
+instead of
+
+ $fullname = File::Spec->catfile($dir1, $dir2, $file);
+
+=item Getopt::Long
+
+Getopt::Long licensing has changed to allow the Perl Artistic License
+as well as the GPL. It used to be GPL only, which got in the way of
+non-GPL applications that wanted to use Getopt::Long.
+
+Getopt::Long encourages the use of Pod::Usage to produce help
+messages. For example:
+
+ use Getopt::Long;
+ use Pod::Usage;
+ my $man = 0;
+ my $help = 0;
+ GetOptions('help|?' => \$help, man => \$man) or pod2usage(2);
+ pod2usage(1) if $help;
+ pod2usage(-exitstatus => 0, -verbose => 2) if $man;
+
+ __END__
+
+ =head1 NAME
+
+ sample - Using GetOpt::Long and Pod::Usage
+
+ =head1 SYNOPSIS
+
+ sample [options] [file ...]
+
+ Options:
+ -help brief help message
+ -man full documentation
+
+ =head1 OPTIONS
+
+ =over 8
+
+ =item B<-help>
+
+ Print a brief help message and exits.
+
+ =item B<-man>
+
+ Prints the manual page and exits.
+
+ =back
+
+ =head1 DESCRIPTION
+
+ B<This program> will read the given input file(s) and do someting
+ useful with the contents thereof.
+
+ =cut
+
+See L<Pod::Usage> for details.
+
+A bug that prevented the non-option call-back E<lt>E<gt> 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.
+
+=item IO
+
+write() and syswrite() will now accept a single-argument
+form of the call, for consistency with Perl's syswrite().
+
+You can now create a TCP-based IO::Socket::INET without forcing
+a connect attempt. This allows you to configure its options
+(like making it non-blocking) and then call connect() manually.
+
+A bug that prevented the IO::Socket::protocol() accessor
+from ever returning the correct value has been corrected.
+
+=item JPL
+
+Java Perl Lingo is now distributed with Perl. See jpl/README
+for more information.
+
+=item lib
+
+C<use lib> now weeds out any trailing duplicate entries.
+C<no lib> removes all named entries.
+
+=item Math::BigInt
+
+The bitwise operations C<E<lt>E<lt>>, C<E<gt>E<gt>>, 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)).
+
+=item Math::Trig
+
+A little bit of radial trigonometry (cylindrical and spherical),
+radial coordinate conversions, and the great circle distance were added.
+
+=item Pod::Parser, Pod::InputObjects
+
+Pod::Parser is a base class for parsing and selecting sections of
+pod documentation from an input stream. This module takes care of
+identifying pod paragraphs and commands in the input and hands off the
+parsed paragraphs and commands to user-defined methods which are free
+to interpret or translate them as they see fit.
+
+Pod::InputObjects defines some input objects needed by Pod::Parser, and
+for advanced users of Pod::Parser that need more about a command besides
+its name and text.
+
+As of release 5.6 of Perl, Pod::Parser is now the officially sanctioned
+"base parser code" recommended for use by all pod2xxx translators.
+Pod::Text (pod2text) and Pod::Man (pod2man) have already been converted
+to use Pod::Parser and efforts to convert Pod::HTML (pod2html) are already
+underway. For any questions or comments about pod parsing and translating
+issues and utilities, please use the pod-people@perl.org mailing list.
+
+For further information, please see L<Pod::Parser> and L<Pod::InputObjects>.
+
+=item Pod::Checker, podchecker
+
+This utility checks pod files for correct syntax, according to
+L<perlpod>. Obvious errors are flagged as such, while warnings are
+printed for mistakes that can be handled gracefully. The checklist is
+not complete yet. See L<Pod::Checker>.
+
+=item Pod::ParseUtils, Pod::Find
+
+These modules provide a set of gizmos that are useful mainly for pod
+translators. L<Pod::Find|Pod::Find> traverses directory structures and
+returns found pod files, along with their canonical names (like
+C<File::Spec::Unix>). L<Pod::ParseUtils|Pod::ParseUtils> contains
+B<Pod::List> (useful for storing pod list information), B<Pod::Hyperlink>
+(for parsing the contents of C<LE<gt>E<lt>> sequences) and B<Pod::Cache>
+(for caching information about pod files, e.g. link nodes).
+
+=item Pod::Select, podselect
+
+Pod::Select is a subclass of Pod::Parser which provides a function
+named "podselect()" to filter out user-specified sections of raw pod
+documentation from an input stream. podselect is a script that provides
+access to Pod::Select from other scripts to be used as a filter.
+See L<Pod::Select>.
+
+=item Pod::Usage, pod2usage
+
+Pod::Usage provides the function "pod2usage()" to print usage messages for
+a Perl script based on its embedded pod documentation. The pod2usage()
+function is generally useful to all script authors since it lets them
+write and maintain a single source (the pods) for documentation, thus
+removing the need to create and maintain redundant usage message text
+consisting of information already in the pods.
+
+There is also a pod2usage script which can be used from other kinds of
+scripts to print usage messages from pods (even for non-Perl scripts
+with pods embedded in comments).
+
+For details and examples, please see L<Pod::Usage>.
+
+=item Pod::Text and Pod::Man
+
+[TODO - Russ Allbery <rra@stanford.edu>]
+
+=item SDBM_File
+
+An EXISTS method has been added to this module (and sdbm_exists() has
+been added to the underlying sdbm library), so one can now call exists
+on an SDBM_File tied hash and get the correct result, rather than a
+runtime error.
+
+A bug that may have caused data loss when more than one disk block
+happens to be read from the database in a single FETCH() has been
+fixed.
+
+=item Sys::Syslog
+
+Sys::Syslog now uses XSUBs to access facilities from syslog.h so it
+no longer requires syslog.ph to exist.
+
+=item Sys::Hostname
+
+Sys::Hostname now uses XSUBs to call the C library's gethostname() or
+uname() if they exist.
+
+=item Time::Local
+
+The timelocal() and timegm() functions used to silently return bogus
+results when the date fell outside the machine's integer range. They
+now consistently croak() if the date falls in an unsupported range.
+
+=item Win32
+
+The error return value in list context has been changed for all functions
+that return a list of values. Previously these functions returned a list
+with a single element C<undef> if an error occurred. Now these functions
+return the empty list in these situations. This applies to the following
+functions:
+
+ Win32::FsType
+ Win32::GetOSVersion
+
+The remaining functions are unchanged and continue to return C<undef> on
+error even in list context.
+
+The Win32::SetLastError(ERROR) function has been added as a complement
+to the Win32::GetLastError() function.
+
+The new Win32::GetFullPathName(FILENAME) returns the full absolute
+pathname for FILENAME in scalar context. In list context it returns
+a two-element list containing the fully qualified directory name and
+the filename. See L<Win32>.
+
+=item DBM Filters
+
+A new feature called "DBM Filters" has been added to all the
+DBM modules--DB_File, GDBM_File, NDBM_File, ODBM_File, and SDBM_File.
+DBM Filters add four new methods to each DBM module:
+
+ filter_store_key
+ filter_store_value
+ filter_fetch_key
+ filter_fetch_value
+
+These can be used to filter key-value pairs before the pairs are
+written to the database or just after they are read from the database.
+See L<perldbmfilter> for further information.
+
+=back
+
+=head2 Pragmata
+
+C<use attrs> is now obsolete, and is only provided for
+backward-compatibility. It's been replaced by the C<sub : attributes>
+syntax. See L<perlsub/"Subroutine Attributes"> and L<attributes>.
+
+C<use utf8> to enable UTF-8 and Unicode support.
+
+Lexical warnings pragma, C<use warnings;>, to control optional warnings.
+See L<perllexwarn>.
+
+C<use filetest> to control the behaviour of filetests (C<-r> C<-w>
+...). Currently only one subpragma implemented, "use filetest
+'access';", that uses access(2) or equivalent to check permissions
+instead of using stat(2) as usual. This matters in filesystems
+where there are ACLs (access control lists): the stat(2) might lie,
+but access(2) knows better.
+
+=head1 Utility Changes
+
+=head2 h2ph
+
+[TODO - Kurt Starsinic <kstar@chapin.edu>]
+
+=head2 perlcc
+
+C<perlcc> now supports the C and Bytecode backends. By default,
+it generates output from the simple C backend rather than the
+optimized C backend.
+
+Support for non-Unix platforms has been improved.
+
+=head2 h2xs
+
+change#4232
+[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+
+=head1 Documentation Changes
+
+=over 4
+
+=item perlapi.pod
+
+The official list of public Perl API functions.
+
+=item perlcompile.pod
+
+An introduction to using the Perl Compiler suite.
+
+=item perlfilter.pod
+
+An introduction to writing Perl source filters.
+
+=item perlhack.pod
+
+Some guidelines for hacking the Perl source code.
+
+=item perlintern.pod
+
+A list of internal functions in the Perl source code.
+(List is currently empty.)
+
+=item perlopentut.pod
+
+A tutorial on using open() effectively.
+
+=item perlreftut.pod
+
+A tutorial that introduces the essentials of references.
+
+=item perltootc.pod
+
+A tutorial on managing class data for object modules.
+
+=item perlunicode.pod
+
+An introduction to Unicode support features in Perl.
+
+=back
+
+=head1 New or Changed Diagnostics
+
+=over 4
+
+=item "%s" variable %s masks earlier declaration in same %s
+
+(W) A "my" or "our" variable has been redeclared in the current scope or statement,
+effectively eliminating all access to the previous instance. This is almost
+always a typographical error. Note that the earlier variable will still exist
+until the end of the scope or until all closure referents to it are
+destroyed.
+
+=item "my sub" not yet implemented
+
+(F) Lexically scoped subroutines are not yet implemented. Don't try that
+yet.
+
+=item "our" variable %s redeclared
+
+(W) You seem to have already declared the same global once before in the
+current lexical scope.
+
+=item '!' allowed only after types %s
+
+(F) The '!' is allowed in pack() and unpack() only after certain types.
+See L<perlfunc/pack>.
+
+=item / cannot take a count
+
+(F) You had an unpack template indicating a counted-length string,
+but you have also specified an explicit size for the string.
+See L<perlfunc/pack>.
+
+=item / must be followed by a, A or Z
+
+(F) You had an unpack template indicating a counted-length string,
+which must be followed by one of the letters a, A or Z
+to indicate what sort of string is to be unpacked.
+See L<perlfunc/pack>.
+
+=item / must be followed by a*, A* or Z*
+
+(F) You had a pack template indicating a counted-length string,
+Currently the only things that can have their length counted are a*, A* or Z*.
+See L<perlfunc/pack>.
+
+=item / must follow a numeric type
+
+(F) You had an unpack template that contained a '#',
+but this did not follow some numeric unpack specification.
+See L<perlfunc/pack>.
-The new File::Spec::Functions modules provides a function interface
-to the File::Spec module. Allows shorthand
+=item /%s/: Unrecognized escape \\%c passed through
- $fullname = catfile($dir1, $dir2, $file);
+(W) You used a backslash-character combination which is not recognized
+by Perl. This combination appears in an interpolated variable or a
+C<'>-delimited regular expression. The character was understood literally.
-instead of
+=item /%s/: Unrecognized escape \\%c in character class passed through
- $fullname = File::Spec->catfile($dir1, $dir2, $file);
+(W) You used a backslash-character combination which is not recognized
+by Perl inside character classes. The character was understood literally.
-=item Math::BigInt
+=item /%s/ should probably be written as "%s"
-The logical operations C<E<lt>E<lt>>, C<E<gt>E<gt>>, C<&>, C<|>,
-and C<~> are now supported on bigints.
+(W) You have used a pattern where Perl expected to find a string,
+as in the first argument to C<join>. Perl will treat the true
+or false result of matching the pattern against $_ as the string,
+which is probably not what you had in mind.
-=item Math::Complex
+=item %s() called too early to check prototype
-The accessor methods Re, Im, arg, abs, rho, and theta can now also
-act as mutators (accessor $z->Re(), mutator $z->Re(3)).
+(W) You've called a function that has a prototype before the parser saw a
+definition or declaration for it, and Perl could not check that the call
+conforms to the prototype. You need to either add an early prototype
+declaration for the subroutine in question, or move the subroutine
+definition ahead of the call to get proper prototype checking. Alternatively,
+if you are certain that you're calling the function correctly, you may put
+an ampersand before the name to avoid the warning. See L<perlsub>.
-=item Math::Trig
+=item %s argument is not a HASH or ARRAY element
-A little bit of radial trigonometry (cylindrical and spherical),
-radial coordinate conversions, and the great circle distance were added.
+(F) The argument to exists() must be a hash or array element, such as:
-=item SDBM_File
+ $foo{$bar}
+ $ref->[12]->["susie"]
-An EXISTS method has been added to this module (and sdbm_exists() has
-been added to the underlying sdbm library), so one can now call exists
-on an SDBM_File tied hash and get the correct result, rather than a
-runtime error.
+=item %s argument is not a HASH or ARRAY element or slice
-=item Time::Local
+(F) The argument to delete() must be either a hash or array element, such as:
-The timelocal() and timegm() functions used to silently return bogus
-results when the date exceeded the machine's integer range. They
-now consistently croak() if the date falls in an unsupported range--
-but on the other hand they now accept "out-of-limits" day-of-month
-to make "Julian date" conversions easier.
+ $foo{$bar}
+ $ref->[12]->["susie"]
-=item Win32
+or a hash or array slice, such as:
-The error return value in list context has been changed for all functions
-that return a list of values. Previously these functions returned a list
-with a single element C<undef> if an error occurred. Now these functions
-return the empty list in these situations. This applies to the following
-functions:
+ @foo[$bar, $baz, $xyzzy]
+ @{$ref->[12]}{"susie", "queue"}
- Win32::FsType
- Win32::GetOSVersion
+=item %s argument is not a subroutine name
-The remaining functions are unchanged and continue to return C<undef> on
-error even in list context.
+(F) The argument to exists() for C<exists &sub> must be a subroutine
+name, and not a subroutine call. C<exists &sub()> will generate this error.
-The Win32::SetLastError(ERROR) function has been added as a complement
-to the Win32::GetLastError() function.
+=item %s package attribute may clash with future reserved word: %s
-The new Win32::GetFullPathName(FILENAME) returns the full absolute
-pathname for FILENAME in scalar context. In list context it returns
-a two-element list containing the fully qualified directory name and
-the filename.
+(W) A lowercase attribute name was used that had a package-specific handler.
+That name might have a meaning to Perl itself some day, even though it
+doesn't yet. Perhaps you should use a mixed-case attribute name, instead.
+See L<attributes>.
-=item DBM Filters
+=item (in cleanup) %s
-A new feature called "DBM Filters" has been added to all the
-DBM modules--DB_File, GDBM_File, NDBM_File, ODBM_File, and SDBM_File.
-DBM Filters add four new methods to each DBM module:
+(W) This prefix usually indicates that a DESTROY() method raised
+the indicated exception. Since destructors are usually called by
+the system at arbitrary points during execution, and often a vast
+number of times, the warning is issued only once for any number
+of failures that would otherwise result in the same message being
+repeated.
- filter_store_key
- filter_store_value
- filter_fetch_key
- filter_fetch_value
+Failure of user callbacks dispatched using the C<G_KEEPERR> flag
+could also result in this warning. See L<perlcall/G_KEEPERR>.
-These can be used to filter key-value pairs before the pairs are
-written to the database or just after they are read from the database.
-See L<perldbmfilter> for further information.
+=item <> should be quotes
-=back
+(F) You wrote C<require E<lt>fileE<gt>> when you should have written
+C<require 'file'>.
-=head2 Pragmata
+=item Attempt to join self
-C<use attrs> is now obsolescent, and is only provided for
-backward-compatibility. It's been replaced by the C<sub : attributes>
-syntax. See L<perlsub/"Subroutine Attributes"> and L<attributes>.
+(F) You tried to join a thread from within itself, which is an
+impossible task. You may be joining the wrong thread, or you may
+need to move the join() to some other thread.
-C<use utf8> to enable UTF-8 and Unicode support.
+=item Bad evalled substitution pattern
-C<use caller 'encoding'> allows modules to inherit pragmatic attributes
-from the caller's context. C<encoding> is currently the only supported
-attribute.
+(F) You've used the /e switch to evaluate the replacement for a
+substitution, but perl found a syntax error in the code to evaluate,
+most likely an unexpected right brace '}'.
-Lexical warnings pragma, C<use warnings;>, to control optional warnings.
+=item Bad realloc() ignored
-C<use filetest> to control the behaviour of filetests (C<-r> C<-w> ...).
-Currently only one subpragma implemented, "use filetest 'access';",
-that enables the use of access(2) or equivalent to check
-permissions instead of using stat(2) as usual. This matters
-in filesystems where there are ACLs (access control lists): the
-stat(2) might lie, but access(2) knows better.
+(S) An internal routine called realloc() on something that had never been
+malloc()ed in the first place. Mandatory, but can be disabled by
+setting environment variable C<PERL_BADFREE> to 1.
-=head1 Utility Changes
+=item Bareword found in conditional
-Todo.
+(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:
-=head1 Documentation Changes
+ open FOO || die;
-=over 4
+It may also indicate a misspelled constant that has been interpreted
+as a bareword:
-=item perlopentut.pod
+ use constant TYPO => 1;
+ if (TYOP) { print "foo" }
-A tutorial on using open() effectively.
+The C<strict> pragma is useful in avoiding such errors.
-=item perlreftut.pod
+=item Binary number > 0b11111111111111111111111111111111 non-portable
-A tutorial that introduces the essentials of references.
+(W) The binary number you specified is larger than 2**32-1
+(4294967295) and therefore non-portable between systems. See
+L<perlport> for more on portability concerns.
-=item perltootc.pod
+=item Bit vector size > 32 non-portable
-A tutorial on managing class data for object modules.
+(W) Using bit vector sizes larger than 32 is non-portable.
-=back
+=item Buffer overflow in prime_env_iter: %s
-=head1 New Diagnostics
+(W) A warning peculiar to VMS. While Perl was preparing to iterate over
+%ENV, it encountered a logical name or symbol definition which was too long,
+so it was truncated to the string shown.
-=item "my sub" not yet implemented
+=item Can't check filesystem of script "%s"
-(F) Lexically scoped subroutines are not yet implemented. Don't try that
-yet.
+(P) For some reason you can't check the filesystem of the script for nosuid.
-=item %s package attribute may clash with future reserved word: %s
+=item Can't declare class for non-scalar %s in "%s"
-(W) A lowercase attribute name was used that had a package-specific handler.
-That name might have a meaning to Perl itself some day, even though it
-doesn't yet. Perhaps you should use a mixed-case attribute name, instead.
-See L<attributes>.
+(S) Currently, only scalar variables can declared with a specific class
+qualifier in a "my" or "our" declaration. The semantics may be extended
+for other types of variables in future.
-=item /%s/: Unrecognized escape \\%c passed through
+=item Can't declare %s in "%s"
-(W) You used a backslash-character combination which is not recognized
-by Perl. This combination appears in an interpolated variable or a
-C<'>-delimited regular expression.
+(F) Only scalar, array, and hash variables may be declared as "my" or
+"our" variables. They must have ordinary identifiers as names.
+
+=item Can't ignore signal CHLD, forcing to default
+
+(W) Perl has detected that it is being run with the SIGCHLD signal
+(sometimes known as SIGCLD) disabled. Since disabling this signal
+will interfere with proper determination of exit status of child
+processes, Perl has reset the signal to its default value.
+This situation typically indicates that the parent program under
+which Perl may be running (e.g. cron) is being very careless.
+
+=item Can't modify non-lvalue subroutine call
+
+(F) Subroutines meant to be used in lvalue context should be declared as
+such, see L<perlsub/"Lvalue subroutines">.
+
+=item Can't read CRTL environ
+
+(S) A warning peculiar to VMS. Perl tried to read an element of %ENV
+from the CRTL's internal environment array and discovered the array was
+missing. You need to figure out where your CRTL misplaced its environ
+or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not searched.
+
+=item Can't remove %s: %s, skipping file
+
+(S) You requested an inplace edit without creating a backup file. Perl
+was unable to remove the original file to replace it with the modified
+file. The file was left unmodified.
+
+=item Can't return %s from lvalue subroutine
+
+(F) Perl detected an attempt to return illegal lvalues (such
+as temporary or readonly values) from a subroutine used as an lvalue.
+This is not allowed.
+
+=item Can't weaken a nonreference
+
+(F) You attempted to weaken something that was not a reference. Only
+references can be weakened.
+
+=item Character class [:%s:] unknown
+
+(F) The class in the character class [: :] syntax is unknown.
+See L<perlre>.
+
+=item Character class syntax [%s] belongs inside character classes
+
+(W) The character class constructs [: :], [= =], and [. .] go
+I<inside> character classes, the [] are part of the construct,
+for example: /[012[:alpha:]345]/. Note that [= =] and [. .]
+are not currently implemented; they are simply placeholders for
+future extensions.
+
+=item Constant is not %s reference
+
+(F) A constant value (perhaps declared using the C<use constant> pragma)
+is being dereferenced, but it amounts to the wrong type of reference. The
+message indicates the type of reference that was expected. This usually
+indicates a syntax error in dereferencing the constant value.
+See L<perlsub/"Constant Functions"> and L<constant>.
+
+=item constant(%s): %%^H is not localized
+
+(F) When setting compile-time-lexicalized hash %^H one should set the
+corresponding bit of $^H as well.
+
+=item constant(%s): %s
+
+(F) Compile-time-substitutions (such as overloaded constants and
+character names) were not correctly set up.
+
+=item defined(@array) is deprecated
+
+(D) defined() is not usually useful on arrays because it checks for an
+undefined I<scalar> value. If you want to see if the array is empty,
+just use C<if (@array) { # not empty }> for example.
+
+=item defined(%hash) is deprecated
+
+(D) defined() is not usually useful on hashes because it checks for an
+undefined I<scalar> value. If you want to see if the hash is empty,
+just use C<if (%hash) { # not empty }> for example.
+
+=item Did not produce a valid header
+
+See Server error.
+
+=item Did you mean "local" instead of "our"?
+
+(W) Remember that "our" does not localize the declared global variable.
+You have declared it again in the same lexical scope, which seems superfluous.
+
+=item Document contains no data
+
+See Server error.
+
+=item entering effective %s failed
+
+(F) While under the C<use filetest> pragma, switching the real and
+effective uids or gids failed.
+
+=item false [] range "%s" in regexp
+
+(W) A character class range must start and end at a literal character, not
+another character class like C<\d> or C<[:alpha:]>. The "-" in your false
+range is interpreted as a literal "-". Consider quoting the "-", "\-".
+See L<perlre>.
=item Filehandle %s opened only for output
(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
+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
L<perlfunc/open>.
+=item flock() on closed filehandle %s
+
+(W) The filehandle you're attempting to flock() got itself closed some
+time before now. Check your logic flow. flock() operates on filehandles.
+Are you attempting to call flock() on a dirhandle by the same name?
+
+=item Global symbol "%s" requires explicit package name
+
+(F) You've said "use strict vars", which indicates that all variables
+must either be lexically scoped (using "my"), declared beforehand using
+"our", or explicitly qualified to say which package the global variable
+is in (using "::").
+
+=item Hexadecimal number > 0xffffffff non-portable
+
+(W) The hexadecimal number you specified is larger than 2**32-1
+(4294967295) and therefore non-portable between systems. See
+L<perlport> for more on portability concerns.
+
+=item Ill-formed CRTL environ value "%s"
+
+(W) A warning peculiar to VMS. Perl tried to read the CRTL's internal
+environ array, and encountered an element without the C<=> delimiter
+used to spearate keys from values. The element is ignored.
+
+=item Ill-formed message in prime_env_iter: |%s|
+
+(W) A warning peculiar to VMS. Perl tried to read a logical name
+or CLI symbol definition when preparing to iterate over %ENV, and
+didn't see the expected delimiter between key and value, so the
+line was ignored.
+
+=item Illegal binary digit %s
+
+(F) You used a digit other than 0 or 1 in a binary number.
+
+=item Illegal binary digit %s ignored
+
+(W) You may have tried to use a digit other than 0 or 1 in a binary number.
+Interpretation of the binary number stopped before the offending digit.
+
+=item Illegal number of bits in vec
+
+(F) The number of bits in vec() (the third argument) must be a power of
+two from 1 to 32 (or 64, if your platform supports that).
+
+=item Integer overflow in %s number
+
+(W) The hexadecimal, octal or binary number you have specified either
+as a literal or as an argument to hex() or oct() is too big for your
+architecture, and has been converted to a floating point number. On a
+32-bit architecture the largest hexadecimal, octal or binary number
+representable without overflow is 0xFFFFFFFF, 037777777777, or
+0b11111111111111111111111111111111 respectively. Note that Perl
+transparently promotes all numbers to a floating point representation
+internally--subject to loss of precision errors in subsequent
+operations.
+
=item Invalid %s attribute: %s
The indicated attribute for a subroutine or variable was not recognized
The indicated attributes for a subroutine or variable were not recognized
by Perl or by a user-supplied handler. See L<attributes>.
+=item invalid [] range "%s" in regexp
+
+The offending range is now explicitly displayed.
+
=item Invalid separator character %s in attribute list
-(F) Something other than a comma or whitespace was seen between the
+(F) Something other than a colon or whitespace was seen between the
elements of an attribute list. If the previous attribute
had a parenthesised parameter list, perhaps that list was terminated
too soon. See L<attributes>.
+=item Invalid separator character %s in subroutine attribute list
+
+(F) Something other than a colon or whitespace was seen between the
+elements of a subroutine attribute list. If the previous attribute
+had a parenthesised parameter list, perhaps that list was terminated
+too soon.
+
+=item leaving effective %s failed
+
+(F) While under the C<use filetest> pragma, switching the real and
+effective uids or gids failed.
+
+=item Lvalue subs returning %s not implemented yet
+
+(F) Due to limitations in the current implementation, array and hash
+values cannot be returned in subroutines used in lvalue context.
+See L<perlsub/"Lvalue subroutines">.
+
+=item Method %s not permitted
+
+See Server error.
+
+=item Missing %sbrace%s on \N{}
+
+(F) Wrong syntax of character name literal C<\N{charname}> within
+double-quotish context.
+
=item Missing command in piped open
(W) You used the C<open(FH, "| command")> or C<open(FH, "command |")>
(F) The reserved syntax for lexically scoped subroutines requires that they
have a name with which they can be found.
+=item No %s specified for -%c
+
+(F) The indicated command line switch needs a mandatory argument, but
+you haven't specified one.
+
+=item No package name allowed for variable %s in "our"
+
+(F) Fully qualified variable names are not allowed in "our" declarations,
+because that doesn't make much sense under existing semantics. Such
+syntax is reserved for future extensions.
+
+=item No space allowed after -%c
+
+(F) The argument to the indicated command line switch must follow immediately
+after the switch, without intervening spaces.
+
+=item no UTC offset information; assuming local time is UTC
+
+(S) A warning peculiar to VMS. Perl was unable to find the local
+timezone offset, so it's assuming that local system time is equivalent
+to UTC. If it's not, define the logical name F<SYS$TIMEZONE_DIFFERENTIAL>
+to translate to the number of seconds which need to be added to UTC to
+get local time.
+
+=item Octal number > 037777777777 non-portable
+
+(W) The octal number you specified is larger than 2**32-1 (4294967295)
+and therefore non-portable between systems. See L<perlport> for more
+on portability concerns.
+
+See also L<perlport> for writing portable code.
+
+=item panic: del_backref
+
+(P) Failed an internal consistency check while trying to reset a weak
+reference.
+
+=item panic: kid popen errno read
+
+(F) forked child returned an incomprehensible message about its errno.
+
+=item panic: magic_killbackrefs
+
+(P) Failed an internal consistency check while trying to reset all weak
+references to an object.
+
+=item Parentheses missing around "%s" list
+
+(W) You said something like
+
+ my $foo, $bar = @_;
+
+when you meant
+
+ my ($foo, $bar) = @_;
+
+Remember that "my", "our" and "local" bind closer than comma.
+
+=item Possible Y2K bug: %s
+
+(W) You are concatenating the number 19 with another number, which
+could be a potential Year 2000 problem.
+
+=item Premature end of script headers
+
+See Server error.
+
+=item Repeat count in pack overflows
+
+(F) You can't specify a repeat count so large that it overflows
+your signed integers. See L<perlfunc/pack>.
+
+=item Repeat count in unpack overflows
+
+(F) You can't specify a repeat count so large that it overflows
+your signed integers. See L<perlfunc/unpack>.
+
+=item realloc() of freed memory ignored
+
+(S) An internal routine called realloc() on something that had already
+been freed.
+
+=item Reference is already weak
+
+(W) You have attempted to weaken a reference that is already weak.
+Doing so has no effect.
+
+=item setpgrp can't take arguments
+
+(F) Your system has the setpgrp() from BSD 4.2, which takes no arguments,
+unlike POSIX setpgid(), which takes a process ID and process group ID.
+
+=item Strange *+?{} on zero-length expression
+
+(W) You applied a regular expression quantifier in a place where it
+makes no sense, such as on a zero-width assertion.
+Try putting the quantifier inside the assertion instead. For example,
+the way to match "abc" provided that it is followed by three
+repetitions of "xyz" is C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>.
+
+=item switching effective %s is not implemented
+
+(F) While under the C<use filetest> pragma, we cannot switch the
+real and effective uids or gids.
+
+=item This Perl can't reset CRTL environ elements (%s)
+
+=item This Perl can't set CRTL environ elements (%s=%s)
+
+(W) Warnings peculiar to VMS. You tried to change or delete an element
+of the CRTL's internal environ array, but your copy of Perl wasn't
+built with a CRTL that contained the setenv() function. You'll need to
+rebuild Perl with a CRTL that does, or redefine F<PERL_ENV_TABLES> (see
+L<perlvms>) so that the environ array isn't the target of the change to
+%ENV which produced the warning.
+
+=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>>.
+
+=item Unknown process %x sent message to prime_env_iter: %s
+
+(P) An error peculiar to VMS. Perl was reading values for %ENV before
+iterating over it, and someone else stuck a message in the stream of
+data Perl expected. Someone's very confused, or perhaps trying to
+subvert Perl's population of %ENV for nefarious purposes.
+
=item Unrecognized escape \\%c passed through
(W) You used a backslash-character combination which is not recognized
-by Perl.
+by Perl. The character was understood literally.
=item Unterminated attribute parameter in attribute list
block. Perhaps you terminated the parameter list of the previous attribute
too soon. See L<attributes>.
-=item defined(@array) is deprecated
-
-(D) defined() is not usually useful on arrays because it checks for an
-undefined I<scalar> value. If you want to see if the array is empty,
-just use C<if (@array) { # not empty }> for example.
-
-=item defined(%hash) is deprecated
-
-(D) defined() is not usually useful on hashes because it checks for an
-undefined I<scalar> value. If you want to see if the hash is empty,
-just use C<if (%hash) { # not empty }> for example.
-
-=item Invalid separator character %s in subroutine attribute list
-
-(F) Something other than a comma or whitespace was seen between the
-elements of a subroutine attribute list. If the previous attribute
-had a parenthesised parameter list, perhaps that list was terminated
-too soon.
-
=item Unterminated attribute parameter in subroutine attribute list
(F) The lexer saw an opening (left) parenthesis character while parsing a
block. Perhaps you terminated the parameter list of the previous attribute
too soon.
-=item /%s/ should probably be written as "%s"
+=item Value of CLI symbol "%s" too long
-(W) You have used a pattern where Perl expected to find a string,
-like in the first argument to C<join>. Perl will treat the true
-or false result of matching the pattern against $_ as the string,
-which is probably not what you had in mind.
+(W) A warning peculiar to VMS. Perl tried to read the value of an %ENV
+element from a CLI symbol table, and found a resultant string longer
+than 1024 characters. The return value has been truncated to 1024
+characters.
+
+=item Version number must be a constant number
+
+(P) The attempt to translate a C<use Module n.n LIST> statement into
+its equivalent C<BEGIN> block found an internal inconsistency with
+the version number.
+
+=back
=head1 Obsolete Diagnostics
-Todo.
+=over 4
+
+=item Character class syntax [: :] is reserved for future extensions
-=head1 Configuration Changes
+(W) Within regular expression character classes ([]) the syntax beginning
+with "[:" and ending with ":]" is reserved for future extensions.
+If you need to represent those character sequences inside a regular
+expression character class, just quote the square brackets with the
+backslash: "\[:" and ":\]".
-=head2 installusrbinperl
+=item Ill-formed logical name |%s| in prime_env_iter
-You can use "Configure -Uinstallusrbinperl" which causes installperl
-to skip installing perl also as /usr/bin/perl. This is useful if you
-prefer not to modify /usr/bin for some reason or another but harmful
-because many scripts assume to find Perl in /usr/bin/perl.
+(W) A warning peculiar to VMS. A logical name was encountered when preparing
+to iterate over %ENV which violates the syntactic rules governing logical
+names. Because it cannot be translated normally, it is skipped, and will not
+appear in %ENV. This may be a benign occurrence, as some software packages
+might directly modify logical name tables and introduce nonstandard names,
+or it may indicate that a logical name table has been corrupted.
-=head2 SOCKS support
+=item Probable precedence problem on %s
-You can use "Configure -Dusesocks" which causes Perl to probe
-for the SOCKS proxy protocol library, http://www.socks.nec.com/
+(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
+address offsets within a string. Unfortunately this means that if
+the regular expression compiles to longer than 32767, it'll blow up.
+Usually when you want a regular expression this big, there is a better
+way to do it with multiple statements. See L<perlre>.
+
+=item Use of "$$<digit>" to mean "${$}<digit>" is deprecated
+
+(D) Perl versions before 5.004 misinterpreted any type marker followed
+by "$" and a digit. For example, "$$0" was incorrectly taken to mean
+"${$}0" instead of "${$0}". This bug is (mostly) fixed in Perl 5.004.
+
+However, the developers of Perl 5.004 could not fix this bug completely,
+because at least two widely-used modules depend on the old meaning of
+"$$0" in a string. So Perl 5.004 still interprets "$$<digit>" in the
+old (broken) way inside strings; but it generates this message as a
+warning. And in Perl 5.005, this special treatment will cease.
+
+=back
=head1 BUGS
-If you find what you think is a bug, you might check the headers of
+If you find what you think is a bug, you might check the
articles recently posted to the comp.lang.perl.misc newsgroup.
There may also be information at http://www.perl.com/perl/, the Perl
Home Page.
=head1 HISTORY
-Written by Gurusamy Sarathy <F<gsar@umich.edu>>, with many contributions
-from The Perl Porters.
+Written by Gurusamy Sarathy <F<gsar@activestate.com>>, with many
+contributions from The Perl Porters.
Send omissions or corrections to <F<perlbug@perl.com>>.