This document describes differences between the 5.005 release and this one.
-=head1 Incompatible Changes
+=head1 Core Enhancements
-=head2 Perl Source Incompatibilities
+=head2 Interpreter cloning, threads, and concurrency
-Beware that any new warnings that have been added or old ones
-that have been enhanced are B<not> considered incompatible changes.
+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.
-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.
+On the Windows platform, this feature is used to emulate fork() at the
+interpreter level. See L<perlfork> for details about that.
-=over 4
+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.
-=item CHECK is a new keyword
+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.
-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.
+-Dusethreads enables the cpp macro USE_ITHREADS by default, which in turn
+enables Perl source code changes that provide a clear separation between
+the op tree and the data it operates with. The former is 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.
-=item Treatment of list slices of undef has changed
+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.
-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.
+ NOTE: This is an experimental feature. Implementation details are
+ subject to change.
-The new behavior is to produce an empty list if (and only if)
-the original list was empty. Consider the following example:
+=head2 Lexically scoped warning categories
- @a = (1,undef,undef,2)[2,1,2];
+You can now control the granularity of warnings emitted by perl at a finer
+level using the C<use warnings> pragma. L<warnings> and L<perllexwarn>
+have copious documentation on this feature.
-The old behavior would have resulted in @a having no elements.
-The new behavior ensures it has three undefined elements.
+=head2 Unicode and UTF-8 support
-Note in particular that the behavior of slices of the following
-cases remains unchanged:
+Perl now uses UTF-8 as its internal representation for character
+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.
- @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'};
+This feature is expected to evolve quickly to support some form of I/O
+disciplines that can be used to specify the kind of input and output data
+(bytes or characters). Until that happens, additional modules from CPAN
+will be needed to complete the toolkit for dealing with Unicode.
-See L<perldata>.
+ NOTE: This should be considered an experimental feature. Implementation
+ details are subject to change.
+
+=head2 Support for interpolating named characters
+
+The new C<\N> escape interpolates named characters within strings.
+For example, C<"Hi! \N{WHITE SMILING FACE}"> evaluates to a string
+with a unicode smiley face at the end.
+
+=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 strings represented as a vector of ordinals
+
+Literals of the form C<v1.2.3.4> are now parsed as a string composed
+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>.
+
+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 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.6.0) {
+ # new features supported
+ }
+
+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
+
+Alternatively, the C<v> may be omitted if there is more than one dot:
+
+ 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 Perl's version numbering has changed
+=head2 Improved Perl version numbering system
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
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
+=head2 New syntax for declaring subroutine attributes
-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.
+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 declaration syntax, like this:
-For example, C<print 97.98.99> used to output C<97.9899> in earlier
-versions, but now prints C<abc>.
+ sub mymethod : locked method ;
+ ...
+ sub mymethod : locked method {
+ ...
+ }
-See L<Support for strings represented as a vector of ordinals> below.
+ sub othermethod :locked :method ;
+ ...
+ sub othermethod :locked :method {
+ ...
+ }
-=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.
+(Note how only the first C<:> is mandatory, and whitespace surrounding
+the C<:> is optional.)
-=item Hashing function for hash keys has changed
+F<AutoSplit.pm> and F<SelfLoader.pm> have been updated to keep the attributes
+with the stubs they provide. See L<attributes>.
-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.
+=head2 File and directory handles can be autovivified
-=item C<undef> fails on read only values
+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
+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:
-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.
+ sub myopen {
+ open my $fh, "@_"
+ or die "Can't open '@_': $!";
+ return $fh;
+ }
-=item Close-on-exec bit may be set on pipe and socket handles
+ {
+ my $f = myopen("</etc/motd");
+ print <$f>;
+ # $f implicitly closed here
+ }
-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>.
+=head2 open() with more than two arguments
-=item Writing C<"$$1"> to mean C<"${$}1"> is unsupported
+If open() is passed three arguments instead of two, the second argument
+is used as the mode and the third argument is taken to be the file name.
+This is primarily useful for protecting against unintended magic behavior
+of the traditional two-argument form. See L<perlfunc/open>.
-Perl 5.004 deprecated the interpretation of C<$$1> and
-similar within interpolated strings to mean C<$$ . "1">,
-but still allowed it.
+=head2 64-bit support
-In Perl 5.6.0 and later, C<"$$1"> always means C<"${$1}">.
+Any platform that has 64-bit integers either
-=item delete(), values() and C<\(%h)> operate on aliases to values, not copies
+ (1) natively as longs or ints
+ (2) via special compiler flags
+ (3) using long long or int64_t
-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.
+is able to use "quads" (64-bit integers) as follows:
-Keys in the hash are still returned as copies when iterating on
-a hash.
+=over 4
-=item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS
+=item *
-vec() generates a run-time error if the BITS argument is not
-a valid power-of-two integer.
+constants (decimal, hexadecimal, octal, binary) in the code
-=item Text of some diagnostic output has changed
+=item *
-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.
+arguments to oct() and hex()
-=item C<%@> has been removed
+=item *
-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.
+arguments to print(), printf() and sprintf() (flag prefixes ll, L, q)
-=item Parenthesized not() behaves like a list operator
+=item *
-The C<not> operator now falls under the "if it looks like a function,
-it behaves like a function" rule.
+printed as such
-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:
+=item *
- grep not($_), @things;
+pack() and unpack() "q" and "Q" formats
-On the other hand, using C<not> with a literal list slice may not
-work. The following previously allowed construct:
+=item *
- print not (1,2,3)[0];
+in basic arithmetics: + - * / % (NOTE: operating close to the limits
+of the integer values may produce surprising results)
-needs to be written with additional parentheses now:
+=item *
- print not((1,2,3)[0]);
+in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced
+to be 32 bits wide but now operate on the full native width.)
-The behavior remains unaffected when C<not> is not followed by parentheses.
+=item *
-=item Semantics of bareword prototype C<(*)> have changed
+vec()
-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 On 64-bit platforms the semantics of bit operators have changed
+Note that unless you have the case (a) you will have to configure
+and compile Perl using the -Duse64bitint Configure flag.
-If your platform is either natively 64-bit or your Perl has been
-configured to used 64-bit integers, i.e., $Config{ivsize} is 8,
-be warned that the semantics of all the bitwise numeric operators
-(& | ^ ~ << >>) have been changed. These operators used to strictly
-operate on the lower 32 bits of integers, but now operate over the
-entire width of native integers. In particular, note that unary C<~>
-will produce different results on platforms that have different
-$Config{ivsize}. For portability, be sure to mask off the excess bits
-in the result of unary C<~>, e.g., C<~$x & 0xffffffff>.
+ NOTE: The Configure flags -Duselonglong and -Duse64bits have been
+ deprecated. Use -Duse64bitint instead.
-=back
+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 works in more places than the second.
-=head2 C Source Incompatibilities
+The C<use64bitint> 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 could still be 32-bit). Note that the name C<64bitint> does
+not imply that your C compiler will be using 64-bit C<int>s (it might,
+but it doesn't have to): the C<use64bitint> means that you will be
+able to have 64 bits wide scalar values.
-=over 4
+The C<use64bitall> goes all the way by attempting to switch also
+integers (if it can), longs (and pointers) to being 64-bit. This may
+create an even more binary incompatible Perl than -Duse64bitint: the
+resulting executable may not run at all in a 32-bit box, or you may
+have to reboot/reconfigure/rebuild your operating system to be 64-bit
+aware.
-=item C<PERL_POLLUTE>
+Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint
+nor -Duse64bitall.
-Release 5.005 grandfathered old global symbol names by providing preprocessor
-macros for extension source compatibility. As of release 5.6.0, these
-preprocessor definitions are not available by default. You need to explicitly
-compile perl with C<-DPERL_POLLUTE> to get these definitions. For
-extensions still using the old symbols, this option can be
-specified via MakeMaker:
+Last but not least: note that due to Perl's habit of always using
+floating point numbers, the quads are still not true integers.
+When quads overflow their limits (0...18_446_744_073_709_551_615 unsigned,
+-9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they
+are silently promoted to floating point numbers, after which they will
+start losing precision (in their lower digits).
- perl Makefile.PL POLLUTE=1
+ NOTE: 64-bit support is still experimental on most platforms.
+ Existing support only covers the LP64 data model. In particular, the
+ LLP64 data model is not yet supported. 64-bit libraries and system
+ APIs on many platforms have not stabilized--your mileage may vary.
-=item C<PERL_IMPLICIT_CONTEXT>
+=head2 Large file support
- NOTE: 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.
+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.
-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)>
-amounts to a macro invocation that actually translates to something like
-C<Perl_sv_setsv(my_perl,foo,bar)>. While this is generally expected
-to not have any significant source compatibility issues, the difference
-between a macro and a real function call will need to be considered.
+ NOTE: The default action is to enable large file support, if
+ available on the platform.
-This means that there B<is> a source compatibility issue as a result of
-this if your extensions attempt to use pointers to any of the Perl API
-functions.
+If the large file support is on, and you have a Fcntl constant
+O_LARGEFILE, the O_LARGEFILE is automatically added to the flags
+of sysopen().
-Note that the above issue is not relevant to the default build of
-Perl, whose interfaces continue to match those of prior versions
-(but subject to the other options described here).
+Beware that unless your filesystem also supports "sparse files" seeking
+to umpteen petabytes may be inadvisable.
-See L<perlguts/"The Perl API"> for detailed information on the
-ramifications of building Perl with this option.
+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.
-=item C<PERL_POLLUTE_MALLOC>
+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.
-Enabling Perl's malloc in release 5.005 and earlier caused the namespace of
-the system's malloc family of functions to be usurped by the Perl versions,
-since by default they used the same names. Besides causing problems on
-platforms that do not allow these functions to be cleanly replaced, this
-also meant that the system versions could not be called in programs that
-used Perl's malloc. Previous versions of Perl have allowed this behaviour
-to be suppressed with the HIDEMYMALLOC and EMBEDMYMALLOC preprocessor
-definitions.
+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.
-As of release 5.6.0, Perl's malloc family of functions have default names
-distinct from the system versions. You need to explicitly compile perl with
-C<-DPERL_POLLUTE_MALLOC> to get the older behaviour. HIDEMYMALLOC
-and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now
-the default.
+=head2 Long doubles
-Note that these functions do B<not> constitute Perl's memory allocation API.
-See L<perlguts/"Memory Allocation"> for further information about that.
+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).
-=back
+=head2 "more bits"
-=head2 Compatible C Source API Changes
+You can "Configure -Dusemorebits" to turn on both the 64-bit support
+and the long double support.
-=over
+=head2 Enhanced support for sort() subroutines
-=item C<PATCHLEVEL> is now C<PERL_VERSION>
+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>.
-The cpp macros C<PERL_REVISION>, C<PERL_VERSION>, and C<PERL_SUBVERSION>
-are now available by default from perl.h, and reflect the base revision,
-patchlevel, and subversion respectively. C<PERL_REVISION> had no
-prior equivalent, while C<PERL_VERSION> and C<PERL_SUBVERSION> were
-previously available as C<PATCHLEVEL> and C<SUBVERSION>.
+For unprototyped sort subroutines, the historical behavior of passing
+the elements to be compared as the global variables $a and $b remains
+unchanged.
-The new names cause less pollution of the B<cpp> namespace and reflect what
-the numbers have come to stand for in common practice. For compatibility,
-the old names are still supported when F<patchlevel.h> is explicitly
-included (as required before), so there is no source incompatibility
-from the change.
+=head2 C<sort $coderef @foo> allowed
-=back
+sort() did not accept a subroutine reference as the comparison
+function in earlier versions. This is now permitted.
-=head2 Binary Incompatibilities
+=head2 File globbing implemented internally
-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.
+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.
-The usethreads or usemultiplicity builds are B<not> binary compatible
-with the corresponding builds in 5.005.
+ NOTE: This is currently an experimental feature. Interfaces and
+ implementation are subject to change.
-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.
+=item Support for CHECK blocks
-For the full list of public API functions, see L<perlapi>.
+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.
-=head1 Installation and Configuration Improvements
+=head2 POSIX character class syntax [: :] supported
-=head2 -Dusethreads means something different
+For example to match alphabetic characters use /[[:alpha:]]/.
+See L<perlre> for details.
- WARNING: Support for threads continues to be an experimental feature.
- Interfaces and implementation are subject to sudden and drastic changes.
+=item Better pseudo-random number generator
-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 run Configure with "-Dusethreads -Duse5005threads".
+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.
-As of v5.6.0, 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
-specify the -Duse5005threads option to Configure, bugs and all.
+These changes should result in better random numbers from rand().
-=head2 New Configure flags
+=head2 Improved C<qw//> operator
-The following new flags may be enabled on the Configure command line
-by running Configure with C<-Dflag>.
+The C<qw//> operator is now evaluated at compile time into a true list
+instead of being replaced with a run time call to C<split()>. This
+removes the confusing misbehaviour of C<qw//> in scalar context, which
+had inherited that behaviour from split().
- usemultiplicity
- usethreads useithreads (new interpreter threads: no Perl API yet)
- usethreads use5005threads (threads as they were in 5.005)
+Thus:
- use64bitint (equal to now deprecated 'use64bits')
- use64bitall
+ $foo = ($bar) = qw(a b c); print "$foo|$bar\n";
- uselongdouble
- usemorebits
- uselargefiles
- usesocks (only SOCKS v5 supported)
+now correctly prints "3|a", instead of "2|a".
-=head2 Threadedness and 64-bitness now more daring
+=item Better worst-case behavior of hashes
-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 -Duse64bitint or implicitly if your
-system has 64-bit wide datatypes. See also L<"64-bit support">.
+Small changes in the hashing algorithm have been implemented in
+order to improve the distribution of lower order bits in the
+hashed value. This is expected to yield better performance on
+keys that are repeated sequences.
+
+=head2 pack() format 'Z' supported
+
+The new format type 'Z' is useful for packing and unpacking null-terminated
+strings. See L<perlfunc/"pack">.
+
+=head2 pack() format modifier '!' supported
+
+The new format type modifier '!' is useful for packing and unpacking
+native shorts, ints, and longs. See L<perlfunc/"pack">.
+
+=head2 pack() and unpack() support counted strings
+
+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 Weak references
+
+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.
+
+ NOTE: This is an experimental feature. Details are subject to change.
+
+=head2 Binary numbers supported
+
+Binary numbers are now supported as literals, in s?printf formats, and
+C<oct()>:
+
+ $answer = 0b101010;
+ printf "The answer is: %b\n", oct("0b101010");
+
+=head2 Lvalue subroutines
+
+Subroutines can now return modifiable lvalues.
+See L<perlsub/"Lvalue subroutines">.
+
+ NOTE: This is an experimental feature. Details are subject to change.
+
+=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]->('foo') >> may now be written C<$foo[10]('foo')>.
+This is rather similar to how the arrow may be omitted from
+C<< $foo[10]->{'foo'} >>. Note however, that the arrow is still
+required for C<< foo(10)->('bar') >>.
+
+=head2 Boolean assignment operators are legal lvalues
+
+Constructs such as C<($a ||= 2) += 1> are now allowed.
+
+=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 Pseudo-hashes work better
+
+Dereferencing some types of reference values in a pseudo-hash,
+such as C<< $ph->{foo}[1] >>, was accidentally disallowed. This has
+been corrected.
+
+When applied to a pseudo-hash element, exists() now reports whether
+the specified value exists, not merely if the key is valid.
+
+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">.
+
+Pseudo-hash slices with constant keys are now optimized to array lookups
+at compile-time.
+
+List assignments to pseudo-hash slices are now supported.
+
+The C<fields> pragma now provides ways to create pseudo-hashes, via
+fields::new() and fields::phash(). See L<fields>.
+
+ NOTE: The pseudo-hash data type continues to be experimental.
+ Limiting oneself to the interface elements provided by the
+ fields pragma will provide protection from any future changes.
+
+=head2 Automatic flushing of output buffers
+
+fork(), exec(), system(), qx//, and pipe open()s now flush buffers
+of all files opened for output when the operation was attempted. This
+mostly eliminates confusing buffering mishaps suffered by users unaware
+of how Perl internally handles I/O.
+
+This is not supported on some platforms like Solaris where a suitably
+correct implementation of fflush(NULL) isn't available.
+
+=head2 Better diagnostics on meaningless filehandle operations
+
+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, "<&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.
+
+=head2 eof() has the same old magic as <>
+
+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<< <> >> files.
+
+=head2 binmode() can be used to set :crlf and :raw modes
+
+binmode() now accepts a second argument that specifies a discipline
+for the handle in question. The two pseudo-disciplines ":raw" and
+":crlf" are currently supported on DOS-derivative platforms.
+See L<perlfunc/"binmode"> and L<open>.
+
+=head2 C<-T> filetest recognizes UTF-8 encoded files as "text"
+
+The algorithm used for the C<-T> filetest has been enhanced to
+correctly identify UTF-8 content as "text".
+
+=head2 system(), backticks and pipe open now reflect exec() failure
+
+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.
+
+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 $!.
+
+=head2 Improved diagnostics
+
+Line numbers are no longer suppressed (under most likely circumstances)
+during the global destruction phase.
+
+Diagnostics emitted from code running in threads other than the main
+thread are now accompanied by the thread ID.
+
+Embedded null characters in diagnostics now actually show up. They
+used to truncate the message in prior versions.
+
+$foo::a and $foo::b are now exempt from "possible typo" warnings only
+if sort() is encountered in package C<foo>.
+
+Unrecognized alphabetic escapes encountered when parsing quote
+constructs now generate a warning, since they may take on new
+semantics in later versions of Perl.
+
+Many diagnostics now report the internal operation in which the warning
+was provoked, like so:
+
+ Use of uninitialized value in concatenation (.) at (eval 1) line 1.
+ Use of uninitialized value in print at (eval 1) line 1.
+
+Diagnostics that occur within eval may also report the file and line
+number where the eval is located, in addition to the eval sequence
+number and the line number within the evaluated text itself. For
+example:
+
+ Not enough arguments for scalar at (eval 4)[newlib/perl5db.pl:1411] line 2, at EOF
+
+=head2 Diagnostics follow STDERR
+
+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>.
+
+=item More consistent close-on-exec behavior
+
+On systems that support a close-on-exec flag on filehandles, the
+flag is now 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>.
+
+=head2 syswrite() ease-of-use
+
+The length argument of C<syswrite()> has become optional.
+
+=head2 Better syntax checks on parenthesized unary operators
+
+Expressions such as:
+
+ print defined(&foo,&bar,&baz);
+ print uc("foo","bar","baz");
+ undef($foo,&bar);
+
+used to be accidentally allowed in earlier versions, and produced
+unpredictable behaviour. Some produced ancillary warnings
+when used in this way; others silently did the wrong thing.
+
+The parenthesized forms of most unary operators that expect a single
+argument now ensure that they are not called with more than one
+argument, making the cases shown above syntax errors. The usual
+behaviour of:
+
+ print defined &foo, &bar, &baz;
+ print uc "foo", "bar", "baz";
+ undef $foo, &bar;
+
+remains unchanged. See L<perlop>.
+
+=head2 Bit operators support full native integer width
+
+The bit operators (& | ^ ~ << >>) now operate on the full native
+integral width (the exact size of which is available in $Config{ivsize}).
+For example, if your platform is either natively 64-bit or if Perl
+has been configured to use 64-bit integers, these operations apply
+to 8 bytes (as opposed to 4 bytes on 32-bit platforms).
+For portability, be sure to mask off the excess bits in the result of
+unary C<~>, e.g., C<~$x & 0xffffffff>.
+
+=head2 Improved security features
+
+More potentially unsafe operations taint their results for improved
+security.
+
+The C<passwd> and C<shell> fields returned by the getpwent(), getpwnam(),
+and getpwuid() are now tainted, because the user can affect their own
+encrypted password and login shell.
+
+The variable modified by shmread(), and messages returned by msgrcv()
+(and its object-oriented interface IPC::SysV::Msg::rcv) are also tainted,
+because other untrusted processes can modify messages and shared memory
+segments for their own nefarious purposes.
+
+=item More functional bareword prototype (*)
+
+Bareword prototypes have been rationalized to enable them to be used
+to override builtins that accept barewords and interpret them in
+a special way, such as C<require> or C<do>.
+
+Arguments prototyped as C<*> will now be visible within the subroutine
+as either a simple scalar or as a reference to a typeglob.
+See L<perlsub/Prototypes>.
+
+=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 $^X variables may now have names longer than one character
+
+Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax
+error. Now variable names that begin with a control character may be
+arbitrarily long. However, for compatibility reasons, these variables
+I<must> be written with explicit braces, as C<${^XY}> for example.
+C<${^XYZ}> is synonymous with ${"\cXYZ"}. Variable names with more
+than one control character, such as C<${^XY^Z}>, are illegal.
+
+The old syntax has not changed. As before, `^X' may be either a
+literal control-X character or the two-character sequence `caret' plus
+`X'. When braces are omitted, the variable name stops after the
+control character. Thus C<"$^XYZ"> continues to be synonymous with
+C<$^X . "YZ"> as before.
+
+As before, lexical variables may not have names beginning with control
+characters. As before, variables whose names begin with a control
+character are always forced to be in package `main'. All such variables
+are reserved for future extensions, except those that begin with
+C<^_>, which may be used by user programs and are guaranteed not to
+acquire special meaning in any future version of Perl.
+
+=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 as a string
+
+C<$^V> contains the Perl version number as a string composed of
+characters whose ordinals match the version numbers, i.e. v5.6.0.
+This may be used in string comparisons.
+
+See C<Support for strings represented as a vector of ordinals> for an
+example.
-=head2 Long Doubles
+=head2 Optional Y2K warnings
-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.
+If Perl is built with the cpp macro C<PERL_Y2KWARN> defined,
+it emits optional warnings when concatenating the number 19
+with another number.
-=head2 -Dusemorebits
+This behavior must be specifically enabled when running Configure.
+See F<INSTALL> and F<README.Y2K>.
-You can enable both -Duse64bitint and -Duselongdouble with -Dusemorebits.
-See also L<"64-bit support">.
+=head1 Modules and Pragmata
-=head2 -Duselargefiles
+=head2 Modules
-Some platforms support system APIs that are capable of handling large files
-(typically, files larger than two gigabytes). Perl will try to use these
-APIs if you ask for -Duselargefiles.
+=over 4
-See L<"Large file support"> for more information.
+=item attributes
-=head2 installusrbinperl
+While used internally by Perl as a pragma, this module also
+provides a way to fetch subroutine and variable attributes.
+See L<attributes>.
-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.
+=item B
-=head2 SOCKS support
+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.
-You can use "Configure -Dusesocks" which causes Perl to probe
-for the SOCKS proxy protocol library (v5, not v4). For more information
-on SOCKS, see:
+ NOTE: The Compiler suite remains highly experimental. The
+ generated code may not be correct, even it manages to execute
+ without errors.
- http://www.socks.nec.com/
+=item Benchmark
-=head2 C<-A> flag
+Overall, Benchmark results exhibit lower average error and better timing
+accuracy.
-You can "post-edit" the Configure variables using the Configure C<-A>
-switch. 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.
+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:
-=head2 Enhanced Installation Directories
+ use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}})
-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.
+will now output something like this:
-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.
+ 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)
-=head1 Core Changes
+New features: "each for at least N CPU seconds...", "wallclock secs",
+and the "@ operations/CPU second (n=operations)".
-=head2 Unicode and UTF-8 support
+timethese() now returns a reference to a hash of Benchmark objects containing
+the test results, keyed on the names of the tests.
- WARNING: This is an experimental feature. Implementation details are
- subject to change.
+timethis() now returns the iterations field in the Benchmark result object
+instead of 0.
-Perl now uses UTF-8 as its internal representation for character
-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.
+timethese(), timethis(), and the new cmpthese() (see below) can also take
+a format specifier of 'none' to suppress output.
-=head2 Interpreter cloning, threads, and concurrency
+A new function countit() is just like timeit() except that it takes a
+TIME instead of a COUNT.
- WARNING: This is an experimental feature. Implementation details are
- subject to change.
+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.
-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.
+For other details, see L<Benchmark>.
-On Windows, this feature is used to emulate fork() at the interpreter
-level. See L<perlfork>.
+=item ByteLoader
-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.
+The ByteLoader is a dedicated extension to generate and run
+Perl bytecode. See L<ByteLoader>.
-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.
+=item constant
--Dusethreads enables the cpp macro USE_ITHREADS by default, which in turn
-enables Perl source code changes that provide a clear separation between
-the op tree and the data it operates with. The former is 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.
+References can now be used.
-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.
+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.
-=head2 Lexically scoped warning categories
+See L<constant>.
-You can now control the granularity of warnings emitted by perl at a finer
-level using the C<use warnings> pragma. See L<warnings> and L<perllexwarn>
-for details.
+=item charnames
-=head2 Lvalue subroutines
+This pragma implements the C<\N> string escape. See L<charnames>.
- WARNING: This is an experimental feature. Details are subject to change.
+=item Data::Dumper
-Subroutines can now return modifiable lvalues.
-See L<perlsub/"Lvalue subroutines">.
+A C<Maxdepth> setting can be specified to avoid venturing
+too deeply into deep data structures. See L<Data::Dumper>.
-=head2 "our" declarations
+The XSUB implementation of Dump() is now automatically called if the
+C<Useqq> setting is not in use.
-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>.
+Dumping C<qr//> objects works correctly.
-=head2 Support for strings represented as a vector of ordinals
+=item DB
-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>.
+C<DB> is an experimental module that exposes a clean abstraction
+to Perl's debugging API.
-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.
+=item DB_File
-In conjunction with the new C<$^V> magic variable (which contains
-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:
+DB_File can now be built with Berkeley DB versions 1, 2 or 3.
+See C<ext/DB_File/Changes>.
- # this will parse in older versions of Perl also
- if ($^V and $^V gt v5.6.0) {
- # new features supported
- }
+=item Devel::DProf
-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:
+Devel::DProf, a Perl source code profiler has been added. See
+L<Devel::DProf> and L<dprofpp>.
- require v5.6.0; # croak if $^V lt v5.6.0
- use v5.6.0; # same, but croaks at compile-time
+=item Devel::Peek
-Alternatively, the C<v> may be omitted if there is more than one dot:
+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.
- require 5.6.0;
- use 5.6.0;
+=item Dumpvalue
-Also, C<sprintf> and C<printf> support the Perl-specific format flag C<%v>
-to print ordinals of characters in arbitrary strings:
+The Dumpvalue module provides screen dumps of Perl data.
- printf "v%vd", $^V; # prints current version, such as "v5.5.650"
- printf "%*vX", ":", $addr; # formats IPv6 address
- printf "%*vb", " ", $bits; # displays bitstring
+=item DynaLoader
-See L<perldata/"Scalar value constructors"> for additional information.
+DynaLoader now supports a dl_unload_file() function on platforms that
+support unloading shared objects using dlclose().
-=head2 Weak references
+Perl can also optionally arrange to unload all extension shared objects
+loaded by Perl. To enable this, build Perl with the Configure option
+C<-Accflags=-DDL_UNLOAD_ALL_AT_EXIT>. (This maybe useful if you are
+using Apache with mod_perl.)
- WARNING: This is an experimental feature.
+=item English
-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.
+$PERL_VERSION now stands for C<$^V> (a string value) rather than for C<$]>
+(a numeric value).
-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.
+=item Env
-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.
+Env now supports accessing environment variables like PATH as array
+variables.
-To use this feature, you need the WeakRef package from CPAN, which
-contains additional documentation.
+=item Fcntl
-=head2 File globbing implemented internally
+More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for
+large file (more than 4GB) access (NOTE: the O_LARGEFILE is
+automatically added to sysopen() flags if large file support has been
+configured, as is the default), 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
- WARNING: This is currently an experimental feature. Interfaces and
- implementation are likely to change.
+A compare_text() function has been added, which allows custom
+comparison functions. See L<File::Compare>.
-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.
+=item File::Find
-=head2 Binary numbers supported
+File::Find now works correctly when the wanted() function is either
+autoloaded or is a symbolic reference.
-Binary numbers are now supported as literals, in s?printf formats, and
-C<oct()>:
+A bug that caused File::Find to lose track of the working directory
+when pruning top-level directories has been fixed.
- $answer = 0b101010;
- printf "The answer is: %b\n", oct("0b101010");
+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.
-=head2 Some arrows may be omitted in calls through references
+See L<File::Find>.
-Perl now allows the arrow to be omitted in many constructs
-involving subroutine calls through references. For example,
-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]->{'foo'} >>. Note however, that the arrow is still
-required for C<< foo(10)->('bar') >>.
+=item File::Glob
-=head2 exists() is supported on subroutine names
+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>.
-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.
+=item File::Spec
-=head2 exists() and delete() are supported on array elements
+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.
-The exists() and delete() builtins now work on simple arrays as well.
-The behavior is similar to that on hash elements.
+=item File::Spec::Functions
-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.
+The new File::Spec::Functions modules provides a function interface
+to the File::Spec module. Allows shorthand
-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.
+ $fullname = catfile($dir1, $dir2, $file);
-See L<perlfunc/exists> and L<perlfunc/delete> for examples.
+instead of
-=head2 syswrite() ease-of-use
+ $fullname = File::Spec->catfile($dir1, $dir2, $file);
-The length argument of C<syswrite()> has become optional.
+=item Getopt::Long
-=head2 File and directory handles can be autovivified
+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.
-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
-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:
+Getopt::Long encourages the use of Pod::Usage to produce help
+messages. For example:
- sub myopen {
- open my $fh, "@_"
- or die "Can't open '@_': $!";
- return $fh;
- }
+ 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;
- {
- my $f = myopen("</etc/motd");
- print <$f>;
- # $f implicitly closed here
- }
+ __END__
-=head2 open() with more than two arguments
+ =head1 NAME
-If open() is passed three arguments instead of two, the second arguments
-is used as the mode and the third argument is taken to be the file name.
-This is primarily useful for protecting against unintended magic behavior
-of the traditional two-argument form. See L<perlfunc/open>.
+ sample - Using GetOpt::Long and Pod::Usage
-=head2 64-bit support
+ =head1 SYNOPSIS
- NOTE: The Configure flags -Duselonglong and -Duse64bits have been
- deprecated. Use -Duse64bitint instead.
+ sample [options] [file ...]
-Any platform that has 64-bit integers either
+ Options:
+ -help brief help message
+ -man full documentation
- (1) natively as longs or ints
- (2) via special compiler flags
- (3) using long long or int64_t
+ =head1 OPTIONS
-are able to use "quads" (64-bit integers) as follows:
+ =over 8
-=over 4
+ =item B<-help>
-=item *
+ Print a brief help message and exits.
-constants (decimal, hexadecimal, octal, binary) in the code
+ =item B<-man>
-=item *
+ Prints the manual page and exits.
-arguments to oct() and hex()
+ =back
-=item *
+ =head1 DESCRIPTION
-arguments to print(), printf() and sprintf() (flag prefixes ll, L, q)
+ B<This program> will read the given input file(s) and do someting
+ useful with the contents thereof.
-=item *
+ =cut
-printed as such
+See L<Pod::Usage> for details.
-=item *
+A bug that prevented the non-option call-back <> from being
+specified as the first argument has been fixed.
-pack() and unpack() "q" and "Q" formats
+To specify the characters < and > as option starters, use ><. Note,
+however, that changing option starters is strongly deprecated.
-=item *
+=item IO
-in basic arithmetics: + - * / % (NOTE: operating close to the limits
-of the integer values may produce surprising results)
+write() and syswrite() will now accept a single-argument
+form of the call, for consistency with Perl's syswrite().
-=item *
+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.
-in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced
-to be 32 bits wide but now operate on the full native width.)
+A bug that prevented the IO::Socket::protocol() accessor
+from ever returning the correct value has been corrected.
-=item *
+IO::Socket::connect now uses non-blocking IO instead of alarm()
+to do connect timeouts.
-vec()
+IO::Socket::accept now uses select() instead of alarm() for doing
+timeouts.
-=back
+IO::Socket::INET->new now sets $! correctly on failure. $@ is
+still set for backwards compatability.
-Note that unless you have the case (a) you will have to configure
-and compile Perl using the -Duse64bitint Configure flag.
+=item JPL
-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.
+Java Perl Lingo is now distributed with Perl. See jpl/README
+for more information.
-The C<use64bitint> 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 could still be 32-bit). Note that the name C<64bitint> does
-not imply that your C compiler will be using 64-bit C<int>s (it might,
-but it doesn't have to): the C<use64bitint> means that you will be
-able to have 64 bits wide scalar values.
+=item lib
-The C<use64bitall> goes all the way by attempting to switch also
-integers (if it can), longs (and pointers) to being 64-bit. This may
-create an even more binary incompatible Perl than -Duse64bitint: the
-resulting executable may not run at all in a 32-bit box, or you may
-have to reboot/reconfigure/rebuild your operating system to be 64-bit
-aware.
+C<use lib> now weeds out any trailing duplicate entries.
+C<no lib> removes all named entries.
-Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint
-nor -Duse64bitall.
+=item Math::BigInt
-Last but not least: note that due to Perl's habit of always using
-floating point numbers, the quads are still not true integers.
-When quads overflow their limits (0...18_446_744_073_709_551_615 unsigned,
--9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they
-are silently promoted to floating point numbers, after which they will
-start losing precision (in their lower digits).
+The bitwise operations C<<< << >>>, C<<< >> >>>, C<&>, C<|>,
+and C<~> are now supported on bigints.
-=head2 Large file support
+=item Math::Complex
-If you have filesystems that support "large files" (files larger than
-2 gigabytes), you may now also be able to create and access them from
-Perl. NOTE: the default action is to use the large file support, if
-available on the platform.
+The accessor methods Re, Im, arg, abs, rho, and theta can now also
+act as mutators (accessor $z->Re(), mutator $z->Re(3)).
-If the large file support is on, and you have a Fcntl constant
-O_LARGEFILE, the O_LARGEFILE is automatically added to the flags
-of sysopen().
+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.
-Beware: unless your filesystem also supports "sparse files" seeking to
-umpteen petabytes may be unadvisable.
+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.
-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.
+=item Math::Trig
-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.
+A little bit of radial trigonometry (cylindrical and spherical),
+radial coordinate conversions, and the great circle distance were added.
-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.
+=item Pod::Parser, Pod::InputObjects
-=head2 Long doubles
+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.
-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).
+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.
-=head2 "more bits"
+As of release 5.6.0 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.
-You can "Configure -Dusemorebits" to turn on both the 64-bit support
-and the long double support.
+For further information, please see L<Pod::Parser> and L<Pod::InputObjects>.
-=head2 Enhanced support for sort() subroutines
+=item Pod::Checker, podchecker
-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>.
+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>.
-For unprototyped sort subroutines, the historical behavior of passing
-the elements to be compared as the global variables $a and $b remains
-unchanged.
+=item Pod::ParseUtils, Pod::Find
-=head2 Better syntax checks on parenthesized unary operators
+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<lt>E<gt>> sequences) and B<Pod::Cache>
+(for caching information about pod files, e.g., link nodes).
-Expressions such as:
+=item Pod::Select, podselect
- print defined(&foo,&bar,&baz);
- print uc("foo","bar","baz");
- undef($foo,&bar);
+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>.
-used to be accidentally allowed in earlier versions, and produced
-unpredictable behaviour. Some produced ancillary warnings
-when used in this way; others silently did the wrong thing.
+=item Pod::Usage, pod2usage
-The parenthesized forms of most unary operators that expect a single
-argument now ensure that they are not called with more than one
-argument, making the cases shown above syntax errors. The usual
-behaviour of:
+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.
- print defined &foo, &bar, &baz;
- print uc "foo", "bar", "baz";
- undef $foo, &bar;
+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).
-remains unchanged. See L<perlop>.
+For details and examples, please see L<Pod::Usage>.
-=head2 POSIX character class syntax [: :] supported
+=item Pod::Text and Pod::Man
-For example to match alphabetic characters use /[[:alpha:]]/.
-See L<perlre> for details.
+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.
-=head2 Improved C<qw//> operator
+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.
-The C<qw//> operator is now evaluated at compile time into a true list
-instead of being replaced with a run time call to C<split()>. This
-removes the confusing misbehaviour of C<qw//> in scalar context, which
-had inherited that behaviour from split().
+=item SDBM_File
-Thus:
+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.
- $foo = ($bar) = qw(a b c); print "$foo|$bar\n";
+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.
-now correctly prints "3|a", instead of "2|a".
+=item Sys::Syslog
-=head2 pack() format 'Z' supported
+Sys::Syslog now uses XSUBs to access facilities from syslog.h so it
+no longer requires syslog.ph to exist.
-The new format type 'Z' is useful for packing and unpacking null-terminated
-strings. See L<perlfunc/"pack">.
+=item Sys::Hostname
-=head2 pack() format modifier '!' supported
+Sys::Hostname now uses XSUBs to call the C library's gethostname() or
+uname() if they exist.
-The new format type modifier '!' is useful for packing and unpacking
-native shorts, ints, and longs. See L<perlfunc/"pack">.
+=item Term::ANSIColor
-=head2 pack() and unpack() support counted strings
+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.
-The template character '/' can be used to specify a counted string
-type to be packed or unpacked. See L<perlfunc/"pack">.
+=item Time::Local
-=head2 Comments in pack() templates
+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.
-The '#' character in a template introduces a comment up to
-end of the line. This facilitates documentation of pack()
-templates.
+=item Win32
-=head2 $^X variables may now have names longer than one character
+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:
-Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax
-error. Now variable names that begin with a control character may be
-arbitrarily long. However, for compatibility reasons, these variables
-I<must> be written with explicit braces, as C<${^XY}> for example.
-C<${^XYZ}> is synonymous with ${"\cXYZ"}. Variable names with more
-than one control character, such as C<${^XY^Z}>, are illegal.
+ Win32::FsType
+ Win32::GetOSVersion
-The old syntax has not changed. As before, `^X' may be either a
-literal control-X character or the two-character sequence `caret' plus
-`X'. When braces are omitted, the variable name stops after the
-control character. Thus C<"$^XYZ"> continues to be synonymous with
-C<$^X . "YZ"> as before.
+The remaining functions are unchanged and continue to return C<undef> on
+error even in list context.
-As before, lexical variables may not have names beginning with control
-characters. As before, variables whose names begin with a control
-character are always forced to be in package `main'. All such variables
-are reserved for future extensions, except those that begin with
-C<^_>, which may be used by user programs and are guaranteed not to
-acquire special meaning in any future version of Perl.
+The Win32::SetLastError(ERROR) function has been added as a complement
+to the Win32::GetLastError() function.
-=head2 C<use attrs> implicit in subroutine attributes
+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>.
-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 declaration syntax, like this:
+=item XSLoader
- sub mymethod : locked method ;
- ...
- sub mymethod : locked method {
- ...
- }
+The XSLoader extension is a simpler alternative to DynaLoader.
+See L<XSLoader>.
- sub othermethod :locked :method ;
- ...
- sub othermethod :locked :method {
- ...
- }
+=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:
-(Note how only the first C<:> is mandatory, and whitespace surrounding
-the C<:> is optional.)
+ filter_store_key
+ filter_store_value
+ filter_fetch_key
+ filter_fetch_value
-F<AutoSplit.pm> and F<SelfLoader.pm> have been updated to keep the attributes
-with the stubs they provide. See L<attributes>.
+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.
-=head2 Support for interpolating named characters
+=back
-The new C<\N> escape interpolates named characters within strings.
-For example, C<"Hi! \N{WHITE SMILING FACE}"> evaluates to a string
-with a unicode smiley face at the end.
+=head2 Pragmata
-=head2 C<require> and C<do> may be overridden
+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<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">.
+Lexical warnings pragma, C<use warnings;>, to control optional warnings.
+See L<perllexwarn>.
-=head2 New variable $^C reflects C<-c> switch
+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.
-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>.
+The C<open> pragma can be used to specify default disciplines for
+handle constructors (e.g. open()) and for qx//. The two
+pseudo-disciplines C<:raw> and C<:crlf> are currently supported on
+DOS-derivative platforms (i.e. where binmode is not a no-op).
+See also L</"binmode() can be used to set :crlf and :raw modes">.
-=head2 New variable $^V contains Perl version as a string
+=head1 Utility Changes
-C<$^V> contains the Perl version number as a string composed of
-characters whose ordinals match the version numbers, i.e. v5.6.0.
-This may be used in string comparisons.
+=head2 dprofpp
-See C<Support for strings represented as a vector of ordinals> for an
-example.
+C<dprofpp> is used to display profile data generated using C<Devel::DProf>.
+See L<dprofpp>.
-=head2 Optional Y2K warnings
+=head2 find2perl
-If Perl is built with the cpp macro C<PERL_Y2KWARN> defined,
-it emits optional warnings when concatenating the number 19
-with another number.
+The C<find2perl> utility now uses the enhanced features of the File::Find
+module. The -depth and -follow options are supported. Pod documentation
+is also included in the script.
-This behavior must be specifically enabled when running Configure.
-See F<INSTALL> and F<README.Y2K>.
+=head2 h2xs
-=head1 Significant bug fixes
+The C<h2xs> tool can now work in conjunction with C<C::Scan> (available
+from CPAN) to automatically parse real-life header files. The C<-M>,
+C<-a>, C<-k>, and C<-o> options are new.
-=head2 <HANDLE> on empty files
+=head2 perlcc
-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 after C<$/> is set to C<undef>. Further reads yield
-C<undef>.
+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.
-This means that the following will append "foo" to an empty file (it used
-to do nothing):
+Support for non-Unix platforms has been improved.
- perl -0777 -pi -e 's/^/foo/' empty_file
+=head2 perldoc
-The behaviour of:
+C<perldoc> has been reworked to avoid possible security holes.
+It will not by default let itself be run as the superuser, but you
+may still use the B<-U> switch to try to make it drop privileges
+first.
- perl -pi -e 's/^/foo/' empty_file
+=head2 The Perl Debugger
-is unchanged (it continues to leave the file empty).
+Many bug fixes and enhancements were added to F<perl5db.pl>, the
+Perl debugger. The help documentation was rearranged. New commands
+include C<< < ? >>, C<< > ? >>, and C<< { ? >> to list out current
+actions, C<man I<docpage>> to run your doc viewer on some perl
+docset, and support for quoted options. The help information was
+rearranged, and should be viewable once again if you're using B<less>
+as your pager. A serious security hole was plugged--you should
+immediately remove all older versions of the Perl debugger as
+installed in previous releases, all the way back to perl3, from
+your system to avoid being bitten by this.
-=head2 C<eval '...'> improvements
+=head1 Improved Documentation
-Line numbers (as reflected by caller() and most diagnostics) within
-C<eval '...'> were often incorrect where here documents were involved.
-This has been corrected.
+Many of the platform-specific README files are now part of the perl
+installation. See L<perl> for the complete list.
-Lexical lookups for variables appearing in C<eval '...'> within
-functions that were themselves called within an C<eval '...'> were
-searching the wrong place for lexicals. The lexical search now
-correctly ends at the subroutine's block boundary.
+=over 4
-Parsing of here documents used to be flawed when they appeared as
-the replacement expression in C<eval 's/.../.../e'>. This has
-been fixed.
+=item perlapi.pod
-=head2 All compilation errors are true errors
+The official list of public Perl API functions.
-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.
+=item perlboot.pod
-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 C<eval "...">.
+A tutorial for beginners on object-oriented Perl.
-=head2 Automatic flushing of output buffers
+=item perlcompile.pod
-fork(), exec(), system(), qx//, and pipe open()s now flush buffers
-of all files opened for output when the operation was attempted. This
-mostly eliminates confusing buffering mishaps suffered by users unaware
-of how Perl internally handles I/O.
+An introduction to using the Perl Compiler suite.
-This is not supported on some platforms like Solaris where a suitably
-correct implementation of fflush(NULL) isn't available.
+=item perldbmfilter.pod
-=head2 Better diagnostics on meaningless filehandle operations
+A howto document on using the DBM filter facility.
-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).
+=item perldebug.pod
-=head2 Where possible, buffered data discarded from duped input filehandle
+All material unrelated to running the Perl debugger, plus all
+low-level guts-like details that risked crushing the casual user
+of the debugger, have been relocated from the old manpage to the
+next entry below.
-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
-on C<OLD>. Formerly, it would have returned the data from the start
-of the following disk block instead.
+=item perldebguts.pod
-=head2 eof() has the same old magic as <>
+This new manpage contains excessively low-level material not related
+to the Perl debugger, but slightly related to debugging Perl itself.
+It also contains some arcane internal details of how the debugging
+process works that may only be of interest to developers of Perl
+debuggers.
-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<< <> >> files.
+=item perlfork.pod
-=head2 system(), backticks and pipe open now reflect exec() failure
+Notes on the fork() emulation currently available for the Windows platform.
-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 perlfilter.pod
-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 $!.
+An introduction to writing Perl source filters.
-=head2 Implicitly closed filehandles are safer
+=item perlhack.pod
-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.
+Some guidelines for hacking the Perl source code.
-=head2 C<(\$)> prototype and C<$foo{a}>
+=item perlintern.pod
-A scalar reference prototype now correctly allows a hash or
-array element in that slot.
+A list of internal functions in the Perl source code.
+(List is currently empty.)
-=head2 Pseudo-hashes work better
+=item perllexwarn.pod
-Dereferencing some types of reference values in a pseudo-hash,
-such as C<< $ph->{foo}[1] >>, was accidentally disallowed. This has
-been corrected.
+Introduction and reference information about lexically scoped
+warning categories.
-When applied to a pseudo-hash element, exists() now reports whether
-the specified value exists, not merely if the key is valid.
+=item perlnumber.pod
-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">.
+Detailed information about numbers as they are represented in Perl.
-Pseudo-hash slices with constant keys are now optimized to array lookups
-at compile-time.
+=item perlopentut.pod
-The C<fields> pragma now provides ways to create pseudo-hashes, via
-fields::new() and fields::phash(). See L<fields>.
+A tutorial on using open() effectively.
-=head2 C<goto &sub> and AUTOLOAD
+=item perlreftut.pod
-The C<goto &sub> construct works correctly when C<&sub> happens
-to be autoloaded.
+A tutorial that introduces the essentials of references.
-=head2 C<-bareword> allowed under C<use integer>
+=item perltootc.pod
-The autoquoting of barewords preceded by C<-> did not work
-in prior versions when the C<integer> pragma was enabled.
-This has been fixed.
+A tutorial on managing class data for object modules.
-=head2 Boolean assignment operators are legal lvalues
+=item perltodo.pod
-Constructs such as C<($a ||= 2) += 1> are now allowed.
+Discussion of the most often wanted features that may someday be
+supported in Perl.
-=head2 C<sort $coderef @foo> allowed
+=item perlunicode.pod
-sort() did not accept a subroutine reference as the comparison
-function in earlier versions. This is now permitted.
+An introduction to Unicode support features in Perl.
-=head2 Failures in DESTROY()
+=back
-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.
+=head1 Performance enhancements
-=head2 Locale bugs fixed
+=head2 Simple sort() using { $a <=> $b } and the like are optimized
-printf() and sprintf() previously reset the numeric locale
-back to the default "C" locale. This has been fixed.
+Many common sort() operations using a simple inlined block are now
+optimized for faster performance.
-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. These warnings have been
-discontinued.
+=head2 Optimized assignments to lexical variables
-=head2 Memory leaks
+Certain operations in the RHS of assignment statements have been
+optimized to directly set the lexical variable on the LHS,
+eliminating redundant copying overheads.
-The C<eval 'return sub {...}'> construct could sometimes leak
-memory. This has been fixed.
+=head2 Faster subroutine calls
-Operations that aren't filehandle constructors used to leak memory
-when used on invalid filehandles. This has been fixed.
+Minor changes in how subroutine calls are handled internally
+provide marginal improvements in performance.
-Constructs that modified C<@_> could fail to deallocate values
-in C<@_> and thus leak memory. This has been corrected.
+=item delete(), each(), values() and hash iteration are faster
-=head2 Spurious subroutine stubs after failed subroutine calls
+The hash values returned by delete(), each(), values() and hashes in a
+list context are the actual values in the hash, instead of copies.
+This results in significantly better performance, because it eliminates
+needless copying in most situations.
-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.
+=head1 Installation and Configuration Improvements
-=head2 Taint failures under C<-U>
+=head2 -Dusethreads means something different
-When running in unsafe mode, taint violations could sometimes
-cause silent failures. This has been fixed.
+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 run Configure with "-Dusethreads -Duse5005threads".
-=head2 END blocks and the C<-c> switch
+As of v5.6.0, 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
+specify the -Duse5005threads option to Configure, bugs and all.
-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.
+ NOTE: Support for threads continues to be an experimental feature.
+ Interfaces and implementation are subject to sudden and drastic changes.
-See L<CHECK blocks> for how to run things when the compile phase ends.
+=head2 New Configure flags
-=head2 Potential to leak DATA filehandles
+The following new flags may be enabled on the Configure command line
+by running Configure with C<-Dflag>.
-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.
+ usemultiplicity
+ usethreads useithreads (new interpreter threads: no Perl API yet)
+ usethreads use5005threads (threads as they were in 5.005)
-This caveat is now better explained in the documentation.
-See L<perldata>.
+ use64bitint (equal to now deprecated 'use64bits')
+ use64bitall
-=head2 Diagnostics follow STDERR
+ uselongdouble
+ usemorebits
+ uselargefiles
+ usesocks (only SOCKS v5 supported)
-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>.
+=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
+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 -Duse64bitint or implicitly if your
+system has 64-bit wide datatypes. See also L<"64-bit support">.
-=head2 Other fixes for better diagnostics
+=head2 Long Doubles
-Line numbers are no longer suppressed (under most likely circumstances)
-during the global destruction phase.
+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.
-Diagnostics emitted from code running in threads other than the main
-thread are now accompanied by the thread ID.
+=head2 -Dusemorebits
-Embedded null characters in diagnostics now actually show up. They
-used to truncate the message in prior versions.
+You can enable both -Duse64bitint and -Duselongdouble with -Dusemorebits.
+See also L<"64-bit support">.
-$foo::a and $foo::b are now exempt from "possible typo" warnings only
-if sort() is encountered in package C<foo>.
+=head2 -Duselargefiles
-Unrecognized alphabetic escapes encountered when parsing quote
-constructs now generate a warning, since they may take on new
-semantics in later versions of Perl.
+Some platforms support system APIs that are capable of handling large files
+(typically, files larger than two gigabytes). Perl will try to use these
+APIs if you ask for -Duselargefiles.
-Many diagnostics now report the internal operation in which the warning
-was provoked, like so:
+See L<"Large file support"> for more information.
- Use of uninitialized value in concatenation (.) at (eval 1) line 1.
- Use of uninitialized value in print at (eval 1) line 1.
+=head2 installusrbinperl
-Diagnostics that occur within eval may also report the file and line
-number where the eval is located, in addition to the eval sequence
-number and the line number within the evaluated text itself. For
-example:
+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.
- Not enough arguments for scalar at (eval 4)[newlib/perl5db.pl:1411] line 2, at EOF
+=head2 SOCKS support
-=head1 Performance enhancements
+You can use "Configure -Dusesocks" which causes Perl to probe
+for the SOCKS proxy protocol library (v5, not v4). For more information
+on SOCKS, see:
-=head2 Simple sort() using { $a <=> $b } and the like are optimized
+ http://www.socks.nec.com/
-Many common sort() operations using a simple inlined block are now
-optimized for faster performance.
+=head2 C<-A> flag
-=head2 Optimized assignments to lexical variables
+You can "post-edit" the Configure variables using the Configure C<-A>
+switch. 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.
-Certain operations in the RHS of assignment statements have been
-optimized to directly set the lexical variable on the LHS,
-eliminating redundant copying overheads.
+=head2 Enhanced Installation Directories
-=head2 Faster subroutine calls
+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.
-Minor changes in how subroutine calls are handled internally
-provide marginal improvements in performance.
+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 Platform specific changes
EPOC is is now supported (on Psion 5).
+=item *
+
+The cygwin port (formerly cygwin32) has been greatly improved.
+
=back
=head2 DOS
perl with C<-MFile::DosGlob>. For details and compatibility information,
see L<File::Glob>.
-=head1 New tests
-
-=over 4
-
-=item lib/attrs
-
-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 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
+=head1 Significant bug fixes
-UNIX sockets.
+=head2 <HANDLE> on empty files
-=item op/attrs
+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 after C<$/> is set to C<undef>. Further reads yield
+C<undef>.
-Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>.
+This means that the following will append "foo" to an empty file (it used
+to do nothing):
-=item op/filetest
+ perl -0777 -pi -e 's/^/foo/' empty_file
-File test operators.
+The behaviour of:
-=item op/lex_assign
+ perl -pi -e 's/^/foo/' empty_file
-Verify operations that access pad objects (lexicals and temporaries).
+is unchanged (it continues to leave the file empty).
-=item op/exists_sub
+=head2 C<eval '...'> improvements
-Verify C<exists &sub> operations.
+Line numbers (as reflected by caller() and most diagnostics) within
+C<eval '...'> were often incorrect where here documents were involved.
+This has been corrected.
-=back
+Lexical lookups for variables appearing in C<eval '...'> within
+functions that were themselves called within an C<eval '...'> were
+searching the wrong place for lexicals. The lexical search now
+correctly ends at the subroutine's block boundary.
-=head1 Modules and Pragmata
+The use of C<return> within C<eval {...}> caused $@ not to be reset
+correctly when no exception occurred within the eval. This has
+been fixed.
-=head2 Modules
+Parsing of here documents used to be flawed when they appeared as
+the replacement expression in C<eval 's/.../.../e'>. This has
+been fixed.
-=over 4
+=head2 All compilation errors are true errors
-=item attributes
+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.
-While used internally by Perl as a pragma, this module also
-provides a way to fetch subroutine and variable attributes.
-See L<attributes>.
+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 C<eval "...">.
-=item B
+=head2 Implicitly closed filehandles are safer
- WARNING: The Compiler suite remains highly experimental. The
- generated code may not be correct, even it manages to execute
- without errors.
+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 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
+=head2 Behavior of list slices is more consistent
-The ByteLoader is a dedicated extension to generate and run
-Perl bytecode. See L<ByteLoader>.
+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.
-=item constant
+The new behavior is to produce an empty list if (and only if)
+the original list was empty. Consider the following example:
-References can now be used.
+ @a = (1,undef,undef,2)[2,1,2];
-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.
+The old behavior would have resulted in @a having no elements.
+The new behavior ensures it has three undefined elements.
-See L<constant>.
+Note in particular that the behavior of slices of the following
+cases remains unchanged:
-=item charnames
+ @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'};
-This pragma implements the C<\N> string escape. See L<charnames>.
+See L<perldata>.
-=item Data::Dumper
+=head2 C<(\$)> prototype and C<$foo{a}>
-A C<Maxdepth> setting can be specified to avoid venturing
-too deeply into deep data structures. See L<Data::Dumper>.
+A scalar reference prototype now correctly allows a hash or
+array element in that slot.
-The XSUB implementation of Dump() is now automatically called if the
-C<Useqq> setting is not in use.
+=head2 C<goto &sub> and AUTOLOAD
-Dumping C<qr//> objects works correctly.
+The C<goto &sub> construct works correctly when C<&sub> happens
+to be autoloaded.
-=item DB
+=head2 C<-bareword> allowed under C<use integer>
-C<DB> is an experimental module that exposes a clean abstraction
-to Perl's debugging API.
+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 DB_File
+=head2 Failures in DESTROY()
-DB_File can now be built with Berkeley DB versions 1, 2 or 3.
-See C<ext/DB_File/Changes>.
+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 Devel::DProf
+=head2 Locale bugs fixed
-Devel::DProf, a Perl source code profiler has been added. See
-L<Devel::DProf> and L<dprofpp>.
+printf() and sprintf() previously reset the numeric locale
+back to the default "C" locale. This has been fixed.
-=item Dumpvalue
+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. These warnings have been
+discontinued.
-The Dumpvalue module provides screen dumps of Perl data.
+=head2 Memory leaks
-=item Benchmark
+The C<eval 'return sub {...}'> construct could sometimes leak
+memory. This has been fixed.
-Overall, Benchmark results exhibit lower average error and better timing
-accuracy.
+Operations that aren't filehandle constructors used to leak memory
+when used on invalid filehandles. This has been fixed.
-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:
+Constructs that modified C<@_> could fail to deallocate values
+in C<@_> and thus leak memory. This has been corrected.
- use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}})
+=head2 Spurious subroutine stubs after failed subroutine calls
-will now output something like this:
+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.
- 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 Taint failures under C<-U>
-New features: "each for at least N CPU seconds...", "wallclock secs",
-and the "@ operations/CPU second (n=operations)".
+When running in unsafe mode, taint violations could sometimes
+cause silent failures. This has been fixed.
-timethese() now returns a reference to a hash of Benchmark objects containing
-the test results, keyed on the names of the tests.
+=head2 END blocks and the C<-c> switch
-timethis() now returns the iterations field in the Benchmark result object
-instead of 0.
+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.
-timethese(), timethis(), and the new cmpthese() (see below) can also take
-a format specifier of 'none' to suppress output.
+See L<CHECK blocks> for how to run things when the compile phase ends.
-A new function countit() is just like timeit() except that it takes a
-TIME instead of a COUNT.
+=head2 Potential to leak DATA filehandles
-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.
+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.
-For other details, see L<Benchmark>.
+This caveat is now better explained in the documentation.
+See L<perldata>.
-=item Devel::Peek
+=head1 New or Changed Diagnostics
-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.
+=over 4
-=item English
+=item "%s" variable %s masks earlier declaration in same %s
-$PERL_VERSION now stands for C<$^V> (a string value) rather than for C<$]>
-(a numeric value).
+(W misc) 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 Env
+=item "my sub" not yet implemented
-Env now supports accessing environment variables like PATH as array
-variables.
+(F) Lexically scoped subroutines are not yet implemented. Don't try that
+yet.
-=item Fcntl
+=item "our" variable %s redeclared
-More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for
-large file (more than 4GB) access (NOTE: the O_LARGEFILE is
-automatically added to sysopen() flags if large file support has been
-configured, as is the default), 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.
+(W misc) You seem to have already declared the same global once before in the
+current lexical scope.
-=item File::Compare
+=item '!' allowed only after types %s
-A compare_text() function has been added, which allows custom
-comparison functions. See L<File::Compare>.
+(F) The '!' is allowed in pack() and unpack() only after certain types.
+See L<perlfunc/pack>.
-=item File::Find
+=item / cannot take a count
-File::Find now works correctly when the wanted() function is either
-autoloaded or is a symbolic reference.
+(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>.
-A bug that caused File::Find to lose track of the working directory
-when pruning top-level directories has been fixed.
+=item / must be followed by a, A or Z
-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.
+(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>.
-See L<File::Find>.
+=item / must be followed by a*, A* or Z*
-=item File::Glob
+(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>.
-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 / must follow a numeric type
-=item File::Spec
+(F) You had an unpack template that contained a '#',
+but this did not follow some numeric unpack specification.
+See L<perlfunc/pack>.
-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 /%s/: Unrecognized escape \\%c passed through
-=item File::Spec::Functions
+(W regexp) 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.
-The new File::Spec::Functions modules provides a function interface
-to the File::Spec module. Allows shorthand
+=item /%s/: Unrecognized escape \\%c in character class passed through
- $fullname = catfile($dir1, $dir2, $file);
+(W regexp) You used a backslash-character combination which is not recognized
+by Perl inside character classes. The character was understood literally.
-instead of
+=item /%s/ should probably be written as "%s"
- $fullname = File::Spec->catfile($dir1, $dir2, $file);
+(W syntax) 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 Getopt::Long
+=item %s() called too early to check prototype
-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.
+(W prototype) 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>.
-Getopt::Long encourages the use of Pod::Usage to produce help
-messages. For example:
+=item %s argument is not a HASH or ARRAY element
- 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;
+(F) The argument to exists() must be a hash or array element, such as:
- __END__
+ $foo{$bar}
+ $ref->{"susie"}[12]
- =head1 NAME
+=item %s argument is not a HASH or ARRAY element or slice
- sample - Using GetOpt::Long and Pod::Usage
+(F) The argument to delete() must be either a hash or array element, such as:
- =head1 SYNOPSIS
+ $foo{$bar}
+ $ref->{"susie"}[12]
- sample [options] [file ...]
+or a hash or array slice, such as:
- Options:
- -help brief help message
- -man full documentation
+ @foo[$bar, $baz, $xyzzy]
+ @{$ref->[12]}{"susie", "queue"}
- =head1 OPTIONS
+=item %s argument is not a subroutine name
- =over 8
+(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.
- =item B<-help>
+=item %s package attribute may clash with future reserved word: %s
- Print a brief help message and exits.
+(W reserved) 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 B<-man>
+=item (in cleanup) %s
- Prints the manual page and exits.
+(W misc) 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.
- =back
+Failure of user callbacks dispatched using the C<G_KEEPERR> flag
+could also result in this warning. See L<perlcall/G_KEEPERR>.
- =head1 DESCRIPTION
+=item <> should be quotes
- B<This program> will read the given input file(s) and do someting
- useful with the contents thereof.
+(F) You wrote C<< require <file> >> when you should have written
+C<require 'file'>.
- =cut
+=item Attempt to join self
-See L<Pod::Usage> for details.
+(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.
-A bug that prevented the non-option call-back <> from being
-specified as the first argument has been fixed.
+=item Bad evalled substitution pattern
-To specify the characters < and > as option starters, use ><. Note,
-however, that changing option starters is strongly deprecated.
+(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 '}'.
-=item IO
+=item Bad realloc() ignored
-write() and syswrite() will now accept a single-argument
-form of the call, for consistency with Perl's syswrite().
+(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.
-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.
+=item Bareword found in conditional
-A bug that prevented the IO::Socket::protocol() accessor
-from ever returning the correct value has been corrected.
+(W bareword) 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:
-IO::Socket::connect now uses non-blocking IO instead of alarm()
-to do connect timeouts.
+ open FOO || die;
-IO::Socket::accept now uses select() instead of alarm() for doing
-timeouts.
+It may also indicate a misspelled constant that has been interpreted
+as a bareword:
-IO::Socket::INET->new now sets $! correctly on failure. $@ is
-still set for backwards compatability.
+ use constant TYPO => 1;
+ if (TYOP) { print "foo" }
-=item JPL
+The C<strict> pragma is useful in avoiding such errors.
-Java Perl Lingo is now distributed with Perl. See jpl/README
-for more information.
+=item Binary number > 0b11111111111111111111111111111111 non-portable
-=item lib
+(W portable) 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.
-C<use lib> now weeds out any trailing duplicate entries.
-C<no lib> removes all named entries.
+=item Bit vector size > 32 non-portable
-=item Math::BigInt
+(W portable) Using bit vector sizes larger than 32 is non-portable.
-The bitwise operations C<<< << >>>, C<<< >> >>>, C<&>, C<|>,
-and C<~> are now supported on bigints.
+=item Buffer overflow in prime_env_iter: %s
-=item Math::Complex
+(W internal) 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.
-The accessor methods Re, Im, arg, abs, rho, and theta can now also
-act as mutators (accessor $z->Re(), mutator $z->Re(3)).
+=item Can't check filesystem of script "%s"
-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.
+(P) For some reason you can't check the filesystem of the script for nosuid.
-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 Can't declare class for non-scalar %s in "%s"
-=item Math::Trig
+(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.
-A little bit of radial trigonometry (cylindrical and spherical),
-radial coordinate conversions, and the great circle distance were added.
+=item Can't declare %s in "%s"
-=item Pod::Parser, Pod::InputObjects
+(F) Only scalar, array, and hash variables may be declared as "my" or
+"our" variables. They must have ordinary identifiers as names.
-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.
+=item Can't ignore signal CHLD, forcing to default
-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.
+(W signal) 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.
-As of release 5.6.0 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.
+=item Can't modify non-lvalue subroutine call
-For further information, please see L<Pod::Parser> and L<Pod::InputObjects>.
+(F) Subroutines meant to be used in lvalue context should be declared as
+such, see L<perlsub/"Lvalue subroutines">.
-=item Pod::Checker, podchecker
+=item Can't read CRTL environ
-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>.
+(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 Pod::ParseUtils, Pod::Find
+=item Can't remove %s: %s, skipping file
-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<lt>E<gt>> sequences) and B<Pod::Cache>
-(for caching information about pod files, e.g., link nodes).
+(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 Pod::Select, podselect
+=item Can't return %s from lvalue subroutine
-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>.
+(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 Pod::Usage, pod2usage
+=item Can't weaken a nonreference
-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.
+(F) You attempted to weaken something that was not a reference. Only
+references can be weakened.
-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).
+=item Character class [:%s:] unknown
-For details and examples, please see L<Pod::Usage>.
+(F) The class in the character class [: :] syntax is unknown.
+See L<perlre>.
-=item Pod::Text and Pod::Man
+=item Character class syntax [%s] belongs inside character classes
-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.
+(W unsafe) 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.
-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 Constant is not %s reference
-=item SDBM_File
+(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>.
-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 constant(%s): %s
-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.
+(F) The parser found inconsistencies either while attempting to define an
+overloaded constant, or when trying to find the character name specified
+in the C<\N{...}> escape. Perhaps you forgot to load the corresponding
+C<overload> or C<charnames> pragma? See L<charnames> and L<overload>.
-=item Sys::Syslog
+=item CORE::%s is not a keyword
-Sys::Syslog now uses XSUBs to access facilities from syslog.h so it
-no longer requires syslog.ph to exist.
+(F) The CORE:: namespace is reserved for Perl keywords.
-=item Sys::Hostname
+=item defined(@array) is deprecated
-Sys::Hostname now uses XSUBs to call the C library's gethostname() or
-uname() if they exist.
+(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 Term::ANSIColor
+=item defined(%hash) is deprecated
-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.
+(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 Time::Local
+=item Did not produce a valid header
-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.
+See Server error.
-=item Win32
+=item (Did you mean "local" instead of "our"?)
-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:
+(W misc) Remember that "our" does not localize the declared global variable.
+You have declared it again in the same lexical scope, which seems superfluous.
- Win32::FsType
- Win32::GetOSVersion
+=item Document contains no data
-The remaining functions are unchanged and continue to return C<undef> on
-error even in list context.
+See Server error.
-The Win32::SetLastError(ERROR) function has been added as a complement
-to the Win32::GetLastError() function.
+=item entering effective %s failed
-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>.
+(F) While under the C<use filetest> pragma, switching the real and
+effective uids or gids failed.
-=item DBM Filters
+=item false [] range "%s" in regexp
-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 regexp) 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>.
- filter_store_key
- filter_store_value
- filter_fetch_key
- filter_fetch_value
+=item Filehandle %s opened only for output
-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.
+(W io) 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
+"+<" or "+>" or "+>>" instead of with "<" or nothing. If
+you intended only to read from the file, use "<". See
+L<perlfunc/open>.
-=back
+=item flock() on closed filehandle %s
-=head2 Pragmata
+(W closed) 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?
-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>.
+=item Global symbol "%s" requires explicit package name
-Lexical warnings pragma, C<use warnings;>, to control optional warnings.
-See L<perllexwarn>.
+(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 "::").
-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.
+=item Hexadecimal number > 0xffffffff non-portable
-=head1 Utility Changes
+(W portable) 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.
-=head2 perlcc
+=item Ill-formed CRTL environ value "%s"
-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.
+(W internal) 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.
-Support for non-Unix platforms has been improved.
+=item Ill-formed message in prime_env_iter: |%s|
-=head2 perldoc
+(W internal) 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.
-C<perldoc> has been reworked to avoid possible security holes.
-It will not by default let itself be run as the superuser, but you
-may still use the B<-U> switch to try to make it drop privileges
-first.
+=item Illegal binary digit %s
-=head2 The Perl Debugger
+(F) You used a digit other than 0 or 1 in a binary number.
-Many bug fixes and enhancements were added to F<perl5db.pl>, the
-Perl debugger. The help documentation was rearranged. New commands
-include C<< < ? >>, C<< > ? >>, and C<< { ? >> to list out current
-actions, C<man I<docpage>> to run your doc viewer on some perl
-docset, and support for quoted options. The help information was
-rearranged, and should be viewable once again if you're using B<less>
-as your pager. A serious security hole was plugged--you should
-immediately remove all older versions of the Perl debugger as
-installed in previous releases, all the way back to perl3, from
-your system to avoid being bitten by this.
+=item Illegal binary digit %s ignored
-=head1 Documentation Changes
+(W digit) 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.
-=over 4
+=item Illegal number of bits in vec
-=item perlapi.pod
+(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).
-The official list of public Perl API functions.
+=item Integer overflow in %s number
-=item perlcompile.pod
+(W overflow) 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.
-An introduction to using the Perl Compiler suite.
+=item Invalid %s attribute: %s
-=item perldebug.pod
+The indicated attribute for a subroutine or variable was not recognized
+by Perl or by a user-supplied handler. See L<attributes>.
-All material unrelated to running the Perl debugger, plus all
-low-level guts-like details that risked crushing the casual user
-of the debugger, have been relocated from the old manpage to the
-next entry below.
+=item Invalid %s attributes: %s
-=item perldebguts.pod
+The indicated attributes for a subroutine or variable were not recognized
+by Perl or by a user-supplied handler. See L<attributes>.
-This new manpage contains excessively low-level material not related
-to the Perl debugger, but slightly related to debugging Perl itself.
-It also contains some arcane internal details of how the debugging
-process works that may only be of interest to developers of Perl
-debuggers.
+=item invalid [] range "%s" in regexp
-=item perlfilter.pod
+The offending range is now explicitly displayed.
-An introduction to writing Perl source filters.
+=item Invalid separator character %s in attribute list
-=item perlhack.pod
+(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>.
-Some guidelines for hacking the Perl source code.
+=item Invalid separator character %s in subroutine attribute list
-=item perlintern.pod
+(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.
-A list of internal functions in the Perl source code.
-(List is currently empty.)
+=item leaving effective %s failed
-=item perlopentut.pod
+(F) While under the C<use filetest> pragma, switching the real and
+effective uids or gids failed.
-A tutorial on using open() effectively.
+=item Lvalue subs returning %s not implemented yet
-=item perlreftut.pod
+(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">.
-A tutorial that introduces the essentials of references.
+=item Method %s not permitted
-=item perlboot.pod
+See Server error.
-A tutorial for beginners on object-oriented Perl.
+=item Missing %sbrace%s on \N{}
-=item perltootc.pod
+(F) Wrong syntax of character name literal C<\N{charname}> within
+double-quotish context.
-A tutorial on managing class data for object modules.
+=item Missing command in piped open
-=item perlunicode.pod
+(W pipe) You used the C<open(FH, "| command")> or C<open(FH, "command |")>
+construction, but the command was missing or blank.
-An introduction to Unicode support features in Perl.
+=item Missing name in "my sub"
-=back
+(F) The reserved syntax for lexically scoped subroutines requires that they
+have a name with which they can be found.
-=head1 New or Changed Diagnostics
+=item No %s specified for -%c
-=over 4
+(F) The indicated command line switch needs a mandatory argument, but
+you haven't specified one.
-=item "%s" variable %s masks earlier declaration in same %s
+=item No package name allowed for variable %s in "our"
-(W misc) 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.
+(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 "my sub" not yet implemented
+=item No space allowed after -%c
-(F) Lexically scoped subroutines are not yet implemented. Don't try that
-yet.
+(F) The argument to the indicated command line switch must follow immediately
+after the switch, without intervening spaces.
-=item "our" variable %s redeclared
+=item no UTC offset information; assuming local time is UTC
-(W misc) You seem to have already declared the same global once before in the
-current lexical scope.
+(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 '!' allowed only after types %s
+=item Octal number > 037777777777 non-portable
-(F) The '!' is allowed in pack() and unpack() only after certain types.
-See L<perlfunc/pack>.
+(W portable) 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.
-=item / cannot take a count
+See also L<perlport> for writing portable code.
-(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 panic: del_backref
-=item / must be followed by a, A or Z
+(P) Failed an internal consistency check while trying to reset a weak
+reference.
-(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 panic: kid popen errno read
-=item / must be followed by a*, A* or Z*
+(F) forked child returned an incomprehensible message about its errno.
-(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 panic: magic_killbackrefs
-=item / must follow a numeric type
+(P) Failed an internal consistency check while trying to reset all weak
+references to an object.
-(F) You had an unpack template that contained a '#',
-but this did not follow some numeric unpack specification.
-See L<perlfunc/pack>.
+=item Parentheses missing around "%s" list
-=item /%s/: Unrecognized escape \\%c passed through
+(W parenthesis) You said something like
-(W regexp) 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.
+ my $foo, $bar = @_;
-=item /%s/: Unrecognized escape \\%c in character class passed through
+when you meant
-(W regexp) You used a backslash-character combination which is not recognized
-by Perl inside character classes. The character was understood literally.
+ my ($foo, $bar) = @_;
-=item /%s/ should probably be written as "%s"
+Remember that "my", "our", and "local" bind tighter than comma.
-(W syntax) 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 Possible Y2K bug: %s
-=item %s() called too early to check prototype
+(W y2k) You are concatenating the number 19 with another number, which
+could be a potential Year 2000 problem.
-(W prototype) 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 pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
-=item %s argument is not a HASH or ARRAY element
+(W deprecated) You have written somehing like this:
-(F) The argument to exists() must be a hash or array element, such as:
+ sub doit
+ {
+ use attrs qw(locked);
+ }
- $foo{$bar}
- $ref->[12]->["susie"]
+You should use the new declaration syntax instead.
-=item %s argument is not a HASH or ARRAY element or slice
+ sub doit : locked
+ {
+ ...
-(F) The argument to delete() must be either a hash or array element, such as:
+The C<use attrs> pragma is now obsolete, and is only provided for
+backward-compatibility. See L<perlsub/"Subroutine Attributes">.
- $foo{$bar}
- $ref->[12]->["susie"]
-or a hash or array slice, such as:
+=item Premature end of script headers
- @foo[$bar, $baz, $xyzzy]
- @{$ref->[12]}{"susie", "queue"}
+See Server error.
-=item %s argument is not a subroutine name
+=item Repeat count in pack overflows
-(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.
+(F) You can't specify a repeat count so large that it overflows
+your signed integers. See L<perlfunc/pack>.
-=item %s package attribute may clash with future reserved word: %s
+=item Repeat count in unpack overflows
-(W reserved) 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>.
+(F) You can't specify a repeat count so large that it overflows
+your signed integers. See L<perlfunc/unpack>.
-=item (in cleanup) %s
+=item realloc() of freed memory ignored
-(W misc) 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.
+(S) An internal routine called realloc() on something that had already
+been freed.
-Failure of user callbacks dispatched using the C<G_KEEPERR> flag
-could also result in this warning. See L<perlcall/G_KEEPERR>.
+=item Reference is already weak
-=item <> should be quotes
+(W misc) You have attempted to weaken a reference that is already weak.
+Doing so has no effect.
-(F) You wrote C<< require <file> >> when you should have written
-C<require 'file'>.
+=item setpgrp can't take arguments
-=item Attempt to join self
+(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.
-(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.
+=item Strange *+?{} on zero-length expression
-=item Bad evalled substitution pattern
+(W regexp) 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}/>.
-(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 '}'.
+=item switching effective %s is not implemented
-=item Bad realloc() ignored
+(F) While under the C<use filetest> pragma, we cannot switch the
+real and effective uids or gids.
-(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.
+=item This Perl can't reset CRTL environ elements (%s)
-=item Bareword found in conditional
+=item This Perl can't set CRTL environ elements (%s=%s)
-(W bareword) 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:
+(W internal) 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.
- open FOO || die;
+=item Too late to run %s block
-It may also indicate a misspelled constant that has been interpreted
-as a bareword:
+(W void) A CHECK or INIT block is being defined during run time proper,
+when the opportunity to run them has already passed. Perhaps you are
+loading a file with C<require> or C<do> when you should be using
+C<use> instead. Or perhaps you should put the C<require> or C<do>
+inside a BEGIN block.
- use constant TYPO => 1;
- if (TYOP) { print "foo" }
+=item Unknown open() mode '%s'
-The C<strict> pragma is useful in avoiding such errors.
+(F) The second argument of 3-argument open() is not among the list
+of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
+C<< +> >>, C<<< +>> >>>, C<-|>, C<|->.
+
+=item Unknown process %x sent message to prime_env_iter: %s
-=item Binary number > 0b11111111111111111111111111111111 non-portable
+(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.
-(W portable) 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 Unrecognized escape \\%c passed through
-=item Bit vector size > 32 non-portable
+(W misc) You used a backslash-character combination which is not recognized
+by Perl. The character was understood literally.
-(W portable) Using bit vector sizes larger than 32 is non-portable.
+=item Unterminated attribute parameter in attribute list
-=item Buffer overflow in prime_env_iter: %s
+(F) The lexer saw an opening (left) parenthesis character while parsing an
+attribute list, but the matching closing (right) parenthesis
+character was not found. You may need to add (or remove) a backslash
+character to get your parentheses to balance. See L<attributes>.
-(W internal) 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 Unterminated attribute list
-=item Can't check filesystem of script "%s"
+(F) The lexer found something other than a simple identifier at the start
+of an attribute, and it wasn't a semicolon or the start of a
+block. Perhaps you terminated the parameter list of the previous attribute
+too soon. See L<attributes>.
-(P) For some reason you can't check the filesystem of the script for nosuid.
+=item Unterminated attribute parameter in subroutine attribute list
-=item Can't declare class for non-scalar %s in "%s"
+(F) The lexer saw an opening (left) parenthesis character while parsing a
+subroutine attribute list, but the matching closing (right) parenthesis
+character was not found. You may need to add (or remove) a backslash
+character to get your parentheses to balance.
-(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 Unterminated subroutine attribute list
-=item Can't declare %s in "%s"
+(F) The lexer found something other than a simple identifier at the start
+of a subroutine attribute, and it wasn't a semicolon or the start of a
+block. Perhaps you terminated the parameter list of the previous attribute
+too soon.
-(F) Only scalar, array, and hash variables may be declared as "my" or
-"our" variables. They must have ordinary identifiers as names.
+=item Value of CLI symbol "%s" too long
-=item Can't ignore signal CHLD, forcing to default
+(W misc) 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.
-(W signal) 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 Version number must be a constant number
-=item Can't modify non-lvalue subroutine call
+(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.
-(F) Subroutines meant to be used in lvalue context should be declared as
-such, see L<perlsub/"Lvalue subroutines">.
+=back
-=item Can't read CRTL environ
+=head1 New tests
-(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.
+=over 4
-=item Can't remove %s: %s, skipping file
+=item lib/attrs
-(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.
+Compatibility tests for C<sub : attrs> vs the older C<use attrs>.
-=item Can't return %s from lvalue subroutine
+=item lib/env
-(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.
+Tests for new environment scalar capability (e.g., C<use Env qw($BAR);>).
-=item Can't weaken a nonreference
+=item lib/env-array
-(F) You attempted to weaken something that was not a reference. Only
-references can be weakened.
+Tests for new environment array capability (e.g., C<use Env qw(@PATH);>).
-=item Character class [:%s:] unknown
+=item lib/io_const
-(F) The class in the character class [: :] syntax is unknown.
-See L<perlre>.
+IO constants (SEEK_*, _IO*).
-=item Character class syntax [%s] belongs inside character classes
+=item lib/io_dir
-(W unsafe) 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.
+Directory-related IO methods (new, read, close, rewind, tied delete).
-=item Constant is not %s reference
+=item lib/io_multihomed
-(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>.
+INET sockets with multi-homed hosts.
-=item constant(%s): %s
+=item lib/io_poll
-(F) The parser found inconsistencies either while attempting to define an
-overloaded constant, or when trying to find the character name specified
-in the C<\N{...}> escape. Perhaps you forgot to load the corresponding
-C<overload> or C<charnames> pragma? See L<charnames> and L<overload>.
+IO poll().
-=item CORE::%s is not a keyword
+=item lib/io_unix
-(F) The CORE:: namespace is reserved for Perl keywords.
+UNIX sockets.
-=item defined(@array) is deprecated
+=item op/attrs
-(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.
+Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>.
-=item defined(%hash) is deprecated
+=item op/filetest
-(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.
+File test operators.
-=item Did not produce a valid header
+=item op/lex_assign
-See Server error.
+Verify operations that access pad objects (lexicals and temporaries).
-=item Did you mean "local" instead of "our"?
+=item op/exists_sub
-(W misc) Remember that "our" does not localize the declared global variable.
-You have declared it again in the same lexical scope, which seems superfluous.
+Verify C<exists &sub> operations.
-=item Document contains no data
+=back
-See Server error.
+=head1 Incompatible Changes
-=item entering effective %s failed
+=head2 Perl Source Incompatibilities
-(F) While under the C<use filetest> pragma, switching the real and
-effective uids or gids failed.
+Beware that any new warnings that have been added or old ones
+that have been enhanced are B<not> considered incompatible changes.
-=item false [] range "%s" in regexp
+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.
-(W regexp) 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>.
+=over 4
-=item Filehandle %s opened only for output
+=item CHECK is a new keyword
-(W io) 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
-"+<" or "+>" or "+>>" instead of with "<" or nothing. If
-you intended only to read from the file, use "<". See
-L<perlfunc/open>.
+All subroutine definitions named CHECK are now special. See
+C</"Support for CHECK blocks"> for more information.
-=item flock() on closed filehandle %s
+=item Treatment of list slices of undef has changed
-(W closed) 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?
+There is a potential incompatibility in the behavior of list slices
+that are comprised entirely of undefined values.
+See L</"Behavior of list slices is more consistent">.
-=item Global symbol "%s" requires explicit package name
+=head2 Format of $English::PERL_VERSION is different
-(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 "::").
+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.
-=item Hexadecimal number > 0xffffffff non-portable
+See L</"Improved Perl version numbering system"> for the reasons for
+this change.
-(W portable) 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 Literals of the form C<1.2.3> parse differently
-=item Ill-formed CRTL environ value "%s"
+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.
-(W internal) 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.
+For example, C<print 97.98.99> used to output C<97.9899> in earlier
+versions, but now prints C<abc>.
-=item Ill-formed message in prime_env_iter: |%s|
+See L</"Support for strings represented as a vector of ordinals">.
-(W internal) 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 Possibly changed pseudo-random number generator
-=item Illegal binary digit %s
+Perl programs that depend on reproducing a specific set of pseudo-random
+numbers may now produce different output due to improvements made to the
+rand() builtin. You can use C<sh Configure -Drandfunc=rand> to obtain
+the old behavior.
-(F) You used a digit other than 0 or 1 in a binary number.
+See L</"Better pseudo-random number generator">.
-=item Illegal binary digit %s ignored
+=item Hashing function for hash keys has changed
-(W digit) 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.
+Even though Perl hashes are not order preserving, the apparently
+random order encountered when iterating on the contents of a hash
+is actually determined by the hashing algorithm used. Improvements
+in the algorithm may yield a random order that is B<different> from
+that of previous versions, especially when iterating on hashes.
-=item Illegal number of bits in vec
+See L</"Better worst-case behavior of hashes"> for additional
+information.
-(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 C<undef> fails on read only values
-=item Integer overflow in %s number
+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.
-(W overflow) 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 Close-on-exec bit may be set on pipe and socket handles
-=item Invalid %s attribute: %s
+Pipe and socket handles are also now subject to the close-on-exec
+behavior determined by the special variable $^F.
-The indicated attribute for a subroutine or variable was not recognized
-by Perl or by a user-supplied handler. See L<attributes>.
+See L</"More consistent close-on-exec behavior">.
-=item Invalid %s attributes: %s
+=item Writing C<"$$1"> to mean C<"${$}1"> is unsupported
-The indicated attributes for a subroutine or variable were not recognized
-by Perl or by a user-supplied handler. See L<attributes>.
+Perl 5.004 deprecated the interpretation of C<$$1> and
+similar within interpolated strings to mean C<$$ . "1">,
+but still allowed it.
-=item invalid [] range "%s" in regexp
+In Perl 5.6.0 and later, C<"$$1"> always means C<"${$1}">.
-The offending range is now explicitly displayed.
+=item delete(), values() and C<\(%h)> operate on aliases to values, not copies
-=item Invalid separator character %s in attribute list
+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.
-(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>.
+See also L</"delete(), each(), values() and hash iteration are faster">.
-=item Invalid separator character %s in subroutine attribute list
+=item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS
-(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.
+vec() generates a run-time error if the BITS argument is not
+a valid power-of-two integer.
-=item leaving effective %s failed
+=item Text of some diagnostic output has changed
-(F) While under the C<use filetest> pragma, switching the real and
-effective uids or gids failed.
+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 Lvalue subs returning %s not implemented yet
+=item C<%@> has been removed
-(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">.
+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 Method %s not permitted
+=item Parenthesized not() behaves like a list operator
-See Server error.
+The C<not> operator now falls under the "if it looks like a function,
+it behaves like a function" rule.
-=item Missing %sbrace%s on \N{}
+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:
-(F) Wrong syntax of character name literal C<\N{charname}> within
-double-quotish context.
+ grep not($_), @things;
-=item Missing command in piped open
+On the other hand, using C<not> with a literal list slice may not
+work. The following previously allowed construct:
-(W pipe) You used the C<open(FH, "| command")> or C<open(FH, "command |")>
-construction, but the command was missing or blank.
+ print not (1,2,3)[0];
-=item Missing name in "my sub"
+needs to be written with additional parentheses now:
-(F) The reserved syntax for lexically scoped subroutines requires that they
-have a name with which they can be found.
+ print not((1,2,3)[0]);
-=item No %s specified for -%c
+The behavior remains unaffected when C<not> is not followed by parentheses.
-(F) The indicated command line switch needs a mandatory argument, but
-you haven't specified one.
+=item Semantics of bareword prototype C<(*)> have changed
-=item No package name allowed for variable %s in "our"
+The semantics of the bareword prototype C<*> have changed. 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. The new behavior is to not coerce bareword
+arguments to a typeglob. The value will always be visible as either
+a simple scalar or as a reference to a typeglob.
-(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.
+See L</"More functional bareword prototype (*)">.
-=item No space allowed after -%c
+=head2 Semantics of bit operators may have changed on 64-bit platforms
-(F) The argument to the indicated command line switch must follow immediately
-after the switch, without intervening spaces.
+If your platform is either natively 64-bit or if Perl has been
+configured to used 64-bit integers, i.e., $Config{ivsize} is 8,
+there may be a potential incompatibility in the behavior of bitwise
+numeric operators (& | ^ ~ << >>). These operators used to strictly
+operate on the lower 32 bits of integers in previous versions, but now
+operate over the entire native integral width. In particular, note
+that unary C<~> will produce different results on platforms that have
+different $Config{ivsize}. For portability, be sure to mask off
+the excess bits in the result of unary C<~>, e.g., C<~$x & 0xffffffff>.
-=item no UTC offset information; assuming local time is UTC
+See L</"Bit operators support full native integer width">.
-(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.
+=head2 More builtins taint their results
-=item Octal number > 037777777777 non-portable
+As described in L</"Improved security features">, there may be more
+sources of taint in a Perl program.
-(W portable) 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.
+To avoid these new tainting behaviors, you can build Perl with the
+Configure option C<-Accflags=-DINCOMPLETE_TAINTS>. Beware that the
+ensuing perl binary may be insecure.
-See also L<perlport> for writing portable code.
+=back
-=item panic: del_backref
+=head2 C Source Incompatibilities
-(P) Failed an internal consistency check while trying to reset a weak
-reference.
+=over 4
-=item panic: kid popen errno read
+=item C<PERL_POLLUTE>
-(F) forked child returned an incomprehensible message about its errno.
+Release 5.005 grandfathered old global symbol names by providing preprocessor
+macros for extension source compatibility. As of release 5.6.0, these
+preprocessor definitions are not available by default. You need to explicitly
+compile perl with C<-DPERL_POLLUTE> to get these definitions. For
+extensions still using the old symbols, this option can be
+specified via MakeMaker:
-=item panic: magic_killbackrefs
+ perl Makefile.PL POLLUTE=1
-(P) Failed an internal consistency check while trying to reset all weak
-references to an object.
+=item C<PERL_IMPLICIT_CONTEXT>
-=item Parentheses missing around "%s" list
+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)>
+amounts to a macro invocation that actually translates to something like
+C<Perl_sv_setsv(my_perl,foo,bar)>. While this is generally expected
+to not have any significant source compatibility issues, the difference
+between a macro and a real function call will need to be considered.
-(W parenthesis) You said something like
+This means that there B<is> a source compatibility issue as a result of
+this if your extensions attempt to use pointers to any of the Perl API
+functions.
- my $foo, $bar = @_;
+Note that the above issue is not relevant to the default build of
+Perl, whose interfaces continue to match those of prior versions
+(but subject to the other options described here).
-when you meant
+See L<perlguts/"The Perl API"> for detailed information on the
+ramifications of building Perl with this option.
- my ($foo, $bar) = @_;
+ NOTE: 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.
-Remember that "my", "our", and "local" bind tighter than comma.
+=item C<PERL_POLLUTE_MALLOC>
-=item Possible Y2K bug: %s
+Enabling Perl's malloc in release 5.005 and earlier caused the namespace of
+the system's malloc family of functions to be usurped by the Perl versions,
+since by default they used the same names. Besides causing problems on
+platforms that do not allow these functions to be cleanly replaced, this
+also meant that the system versions could not be called in programs that
+used Perl's malloc. Previous versions of Perl have allowed this behaviour
+to be suppressed with the HIDEMYMALLOC and EMBEDMYMALLOC preprocessor
+definitions.
-(W y2k) You are concatenating the number 19 with another number, which
-could be a potential Year 2000 problem.
+As of release 5.6.0, Perl's malloc family of functions have default names
+distinct from the system versions. You need to explicitly compile perl with
+C<-DPERL_POLLUTE_MALLOC> to get the older behaviour. HIDEMYMALLOC
+and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now
+the default.
-=item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
+Note that these functions do B<not> constitute Perl's memory allocation API.
+See L<perlguts/"Memory Allocation"> for further information about that.
-(W deprecated) You have written somehing like this:
+=back
- sub doit
- {
- use attrs qw(locked);
- }
+=head2 Compatible C Source API Changes
-You should use the new declaration syntax instead.
+=over
- sub doit : locked
- {
- ...
+=item C<PATCHLEVEL> is now C<PERL_VERSION>
-The C<use attrs> pragma is now obsolete, and is only provided for
-backward-compatibility. See L<perlsub/"Subroutine Attributes">.
+The cpp macros C<PERL_REVISION>, C<PERL_VERSION>, and C<PERL_SUBVERSION>
+are now available by default from perl.h, and reflect the base revision,
+patchlevel, and subversion respectively. C<PERL_REVISION> had no
+prior equivalent, while C<PERL_VERSION> and C<PERL_SUBVERSION> were
+previously available as C<PATCHLEVEL> and C<SUBVERSION>.
+The new names cause less pollution of the B<cpp> namespace and reflect what
+the numbers have come to stand for in common practice. For compatibility,
+the old names are still supported when F<patchlevel.h> is explicitly
+included (as required before), so there is no source incompatibility
+from the change.
-=item Premature end of script headers
+=back
-See Server error.
+=head2 Binary Incompatibilities
-=item Repeat count in pack overflows
+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.
-(F) You can't specify a repeat count so large that it overflows
-your signed integers. See L<perlfunc/pack>.
+The usethreads or usemultiplicity builds are B<not> binary compatible
+with the corresponding builds in 5.005.
-=item Repeat count in unpack overflows
+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.
-(F) You can't specify a repeat count so large that it overflows
-your signed integers. See L<perlfunc/unpack>.
+For the full list of public API functions, see L<perlapi>.
-=item realloc() of freed memory ignored
+=head1 Known Problems
-(S) An internal routine called realloc() on something that had already
-been freed.
+=head2 Thread test failures
-=item Reference is already weak
+The subtests 19 and 20 of lib/thr5005.t test are known to fail due to
+fundamental problems in the 5.005 threading implementation. These are
+not new failures--Perl 5.005_0x has the same bugs, but didn't have these
+tests.
-(W misc) You have attempted to weaken a reference that is already weak.
-Doing so has no effect.
+=head2 EBCDIC platforms not supported
-=item setpgrp can't take arguments
+In earlier releases of Perl, EBCDIC environments like OS390 (also
+known as Open Edition MVS) and VM-ESA were supported. Due to changes
+required by the UTF-8 (Unicode) support, the EBCDIC platforms are not
+supported in Perl 5.6.0.
-(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.
+=head2 In 64-bit HP-UX the lib/io_multihomed test may hang
-=item Strange *+?{} on zero-length expression
+The lib/io_multihomed test may hang in HP-UX if Perl has been
+configured to be 64-bit. Because other 64-bit platforms do not
+hang in this test, HP-UX is suspect. All other tests pass
+in 64-bit HP-UX. The test attempts to create and connect to
+"multihomed" sockets (sockets which have multiple IP addresses).
-(W regexp) 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}/>.
+=head2 NEXTSTEP 3.3 POSIX test failure
-=item switching effective %s is not implemented
+In NEXTSTEP 3.3p2 the implementation of the strftime(3) in the
+operating system libraries is buggy: the %j format numbers the days of
+a month starting from zero, which, while being logical to programmers,
+will cause the subtests 19 to 27 of the lib/posix test may fail.
-(F) While under the C<use filetest> pragma, we cannot switch the
-real and effective uids or gids.
+=head2 Tru64 (aka Digital UNIX, aka DEC OSF/1) lib/sdbm test failure with gcc
-=item This Perl can't reset CRTL environ elements (%s)
+If compiled with gcc 2.95 the lib/sdbm test will fail (dump core).
+The cure is to use the vendor cc, it comes with the operating system
+and produces good code.
-=item This Perl can't set CRTL environ elements (%s=%s)
+=head2 UNICOS/mk CC failures during Configure run
-(W internal) 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.
+In UNICOS/mk the following errors may appear during the Configure run:
-=item Too late to run %s block
+ Guessing which symbols your C compiler and preprocessor define...
+ CC-20 cc: ERROR File = try.c, Line = 3
+ ...
+ bad switch yylook 79bad switch yylook 79bad switch yylook 79bad switch yylook 79#ifdef A29K
+ ...
+ 4 errors detected in the compilation of "try.c".
-(W void) A CHECK or INIT block is being defined during run time proper,
-when the opportunity to run them has already passed. Perhaps you are
-loading a file with C<require> or C<do> when you should be using
-C<use> instead. Or perhaps you should put the C<require> or C<do>
-inside a BEGIN block.
+The culprit is the broken awk of UNICOS/mk. The effect is fortunately
+rather mild: Perl itself is not adversely affected by the error, only
+the h2ph utility coming with Perl, and that is rather rarely needed
+these days.
-=item Unknown open() mode '%s'
+=head2 Arrow operator and arrays
-(F) The second argument of 3-argument open() is not among the list
-of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
-C<< +> >>, C<<< +>> >>>, C<-|>, C<|->.
+When the left argument to the arrow operator C<< -> >> is an array, or
+the C<scalar> operator operating on an array, the result of the
+operation must be considered erroneous. For example:
-=item Unknown process %x sent message to prime_env_iter: %s
+ @x->[2]
+ scalar(@x)->[2]
-(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.
+These expressions will get run-time errors in some future release of
+Perl.
-=item Unrecognized escape \\%c passed through
+=head2 Windows 2000
-(W misc) You used a backslash-character combination which is not recognized
-by Perl. The character was understood literally.
+Windows 2000 is known to fail test 22 in lib/open3.t (cause unknown at
+this time). That test passes under Windows NT.
-=item Unterminated attribute parameter in attribute list
+=head2 Experimental features
-(F) The lexer saw an opening (left) parenthesis character while parsing an
-attribute list, but the matching closing (right) parenthesis
-character was not found. You may need to add (or remove) a backslash
-character to get your parentheses to balance. See L<attributes>.
+As discussed above, many features are still experimental. Interfaces and
+implementation of these features are subject to change, and in extreme cases,
+even subject to removal in some future release of Perl. These features
+include the following:
-=item Unterminated attribute list
+=over 4
-(F) The lexer found something other than a simple identifier at the start
-of an attribute, and it wasn't a semicolon or the start of a
-block. Perhaps you terminated the parameter list of the previous attribute
-too soon. See L<attributes>.
+=item Threads
-=item Unterminated attribute parameter in subroutine attribute list
+=item Unicode
-(F) The lexer saw an opening (left) parenthesis character while parsing a
-subroutine attribute list, but the matching closing (right) parenthesis
-character was not found. You may need to add (or remove) a backslash
-character to get your parentheses to balance.
+=item 64-bit support
-=item Unterminated subroutine attribute list
+=item Lvalue subroutines
-(F) The lexer found something other than a simple identifier at the start
-of a subroutine attribute, and it wasn't a semicolon or the start of a
-block. Perhaps you terminated the parameter list of the previous attribute
-too soon.
+=item Weak references
-=item Value of CLI symbol "%s" too long
+=item The pseudo-hash data type
-(W misc) 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 The Compiler suite
-=item Version number must be a constant number
+=item Internal implementation of file globbing
-(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.
+=item The DB module
+
+=item The regular expression constructs C<(?{ code })> and C<(??{ code })>
=back
=back
-=head1 BUGS
+=head1 Reporting Bugs
If you find what you think is a bug, you might check the
articles recently posted to the comp.lang.perl.misc newsgroup.
projects / p5sagit/p5-mst-13.2.git / blobdiff