=head1 NAME
-perldelta - what's new for perl v5.6.0
+perldelta - what is new for perl v5.8.0
=head1 DESCRIPTION
-This document describes differences between the 5.005 release and this one.
+This document describes differences between the 5.6.0 release
+and the 5.8.0 release.
-=head1 Incompatible Changes
-
-=head2 Perl Source Incompatibilities
+Many of the bug fixes in 5.8.0 were already seen in the 5.6.1
+maintenance release since the two releases were kept closely
+coordinated.
-Beware that any new warnings that have been added or old ones
-that have been enhanced are B<not> considered incompatible changes.
+If you are upgrading from Perl 5.005_03, you might also want
+to read L<perl56delta>.
-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.
+=head1 Highlights In 5.8.0
=over 4
-=item CHECK is a new keyword
-
-In addition to C<BEGIN>, C<INIT>, C<END>, C<DESTROY> and C<AUTOLOAD>,
-subroutines named C<CHECK> are now special. These are queued up during
-compilation and behave similar to END blocks, except they are called at
-the end of compilation rather than at the end of execution. They cannot
-be called directly.
-
-=item Treatment of list slices of undef has changed
-
-When taking a slice of a literal list (as opposed to a slice of
-an array or hash), Perl used to return an empty list if the
-result happened to be composed of all undef values.
-
-The new behavior is to produce an empty list if (and only if)
-the original list was empty. Consider the following example:
+=item *
- @a = (1,undef,undef,2)[2,1,2];
+Better Unicode support
-The old behavior would have resulted in @a having no elements.
-The new behavior ensures it has three undefined elements.
+=item *
-Note in particular that the behavior of slices of the following
-cases remains unchanged:
+New Thread Implementation
- @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'};
+=item *
-See L<perldata>.
+Many New Modules
-=head2 Perl's version numbering has changed
+=item *
-Beginning with Perl version 5.6.0, the version number convention has been
-changed to a "dotted integer" scheme that is more commonly found in open
-source projects.
+Better Numeric Accuracy
-Maintenance versions of v5.6.0 will be released as v5.6.1, v5.6.2 etc.
-The next development series following v5.6.0 will be numbered v5.7.x,
-beginning with v5.7.0, and the next major production release following
-v5.6.0 will be v5.8.0.
+=item *
-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.)
+Safe Signals
-The v1.2.3 syntax is also now legal in Perl.
-See L<Support for strings represented as a vector of ordinals> for more on that.
+=item *
-To cope with the new versioning system's use of at least three significant
-digits for each version component, the method used for incrementing the
-subversion number has also changed slightly. We assume that versions older
-than v5.6.0 have been incrementing the subversion component in multiples of
-10. Versions after v5.6.0 will increment them by 1. Thus, using the new
-notation, 5.005_03 is the "same" as v5.5.30, and the first maintenance
-version following v5.6.0 will be v5.6.1 (which should be read as being
-equivalent to a floating point value of 5.006_001 in the older format,
-stored in C<$]>).
+More Extensive Regression Testing
-=item Literals of the form C<1.2.3> parse differently
+=back
-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.
+=head1 Incompatible Changes
-For example, C<print 97.98.99> used to output C<97.9899> in earlier
-versions, but now prints C<abc>.
+=head2 64-bit platforms and malloc
+
+If your pointers are 64 bits wide, the Perl malloc is no longer being
+used because it does not work well with 8-byte pointers. Also,
+usually the system mallocs on such platforms are much better optimized
+for such large memory models than the Perl malloc. Some memory-hungry
+Perl applications like the PDL don't work well with Perl's malloc.
+Finally, other applications than Perl (like modperl) tend to prefer
+the system malloc. Such platforms include Alpha and 64-bit HPPA,
+MIPS, PPC, and Sparc.
+
+=head2 AIX Dynaloading
+
+The AIX dynaloading now uses in AIX releases 4.3 and newer the native
+dlopen interface of AIX instead of the old emulated interface. This
+change will probably break backward compatibility with compiled
+modules. The change was made to make Perl more compliant with other
+applications like modperl which are using the AIX native interface.
+
+=head2 Attributes for C<my> variables now handled at run-time.
+
+The C<my EXPR : ATTRS> syntax now applies variable attributes at
+run-time. (Subroutine and C<our> variables still get attributes applied
+at compile-time.) See L<attributes> for additional details. In particular,
+however, this allows variable attributes to be useful for C<tie> interfaces,
+which was a deficiency of earlier releases. Note that the new semantics
+doesn't work with the Attribute::Handlers module (as of version 0.76).
+
+=head2 Socket Extension Dynamic in VMS
+
+The Socket extension is now dynamically loaded instead of being
+statically built in. This may or may not be a problem with ancient
+TCP/IP stacks of VMS: we do not know since we weren't able to test
+Perl in such configurations.
+
+=head2 IEEE-format Floating Point Default on OpenVMS Alpha
+
+Perl now uses IEEE format (T_FLOAT) as the default internal floating
+point format on OpenVMS Alpha, potentially breaking binary compatibility
+with external libraries or existing data. G_FLOAT is still available as
+a configuration option. The default on VAX (D_FLOAT) has not changed.
+
+=head2 Different Definition of the Unicode Character Classes \p{In...}
+
+As suggested by the Unicode consortium, the Unicode character classes
+now prefer I<scripts> as opposed to I<blocks> (as defined by Unicode);
+in Perl, when the C<\p{In....}> and the C<\p{In....}> regular expression
+constructs are used. This has changed the definition of some of those
+character classes.
+
+The difference between scripts and blocks is that scripts are the
+glyphs used by a language or a group of languages, while the blocks
+are more artificial groupings of 256 characters based on the Unicode
+numbering.
+
+In general this change results in more inclusive Unicode character
+classes, but changes to the other direction also do take place:
+for example while the script C<Latin> includes all the Latin
+characters and their various diacritic-adorned versions, it
+does not include the various punctuation or digits (since they
+are not solely C<Latin>).
+
+Changes in the character class semantics may have happened if a script
+and a block happen to have the same name, for example C<Hebrew>.
+In such cases the script wins and C<\p{InHebrew}> now means the script
+definition of Hebrew. The block definition in still available,
+though, by appending C<Block> to the name: C<\p{InHebrewBlock}> means
+what C<\p{InHebrew}> meant in perl 5.6.0. For the full list
+of affected character classes, see L<perlunicode/Blocks>.
+
+=head2 Perl Parser Stress Tested
+
+The Perl parser has been stress tested using both random input and
+Markov chain input and the few found crashes and lockups have been
+fixed.
-See L<Support for strings represented as a vector of ordinals> below.
+=head2 REF(...) Instead Of SCALAR(...)
-=item Possibly changed pseudo-random number generator
+A reference to a reference now stringifies as "REF(0x81485ec)" instead
+of "SCALAR(0x81485ec)" in order to be more consistent with the return
+value of ref().
-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.
+=head2 Deprecations
-=item Hashing function for hash keys has changed
+=over 4
-Perl hashes are not order preserving. The apparently random order
-encountered when iterating on the contents of a hash is determined
-by the hashing algorithm used. To improve the distribution of lower
-bits in the hashed value, the algorithm has changed slightly as of
-5.005_52. When iterating over hashes, this may yield a random order
-that is B<different> from that of previous versions.
+=item *
-=item C<undef> fails on read only values
+The semantics of bless(REF, REF) were unclear and until someone proves
+it to make some sense, it is forbidden.
-Using the C<undef> operator on a readonly value (such as $1) has
-the same effect as assigning C<undef> to the readonly value--it
-throws an exception.
+=item *
-=item Close-on-exec bit may be set on pipe and socket handles
+The obsolete chat2 library that should never have been allowed
+to escape the laboratory has been decommissioned.
-On systems that support a close-on-exec flag on filehandles, the
-flag will be set for any handles created by pipe(), socketpair(),
-socket(), and accept(), if that is warranted by the value of $^F
-that may be in effect. Earlier versions neglected to set the flag
-for handles created with these operators. See L<perlfunc/pipe>,
-L<perlfunc/socketpair>, L<perlfunc/socket>, L<perlfunc/accept>,
-and L<perlvar/$^F>.
+=item *
-=item Writing C<"$$1"> to mean C<"${$}1"> is unsupported
+The builtin dump() function has probably outlived most of its
+usefulness. The core-dumping functionality will remain in future
+available as an explicit call to C<CORE::dump()>, but in future
+releases the behaviour of an unqualified C<dump()> call may change.
-Perl 5.004 deprecated the interpretation of C<$$1> and
-similar within interpolated strings to mean C<$$ . "1">,
-but still allowed it.
+=item *
-In Perl 5.6.0 and later, C<"$$1"> always means C<"${$1}">.
+The very dusty examples in the eg/ directory have been removed.
+Suggestions for new shiny examples welcome but the main issue is that
+the examples need to be documented, tested and (most importantly)
+maintained.
-=item delete(), values() and C<\(%h)> operate on aliases to values, not copies
+=item *
-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.
+The (bogus) escape sequences \8 and \9 now give an optional warning
+("Unrecognized escape passed through"). There is no need to \-escape
+any C<\w> character.
-Keys in the hash are still returned as copies when iterating on
-a hash.
+=item *
-=item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS
+The list of filenames from glob() (or <...>) is now by default sorted
+alphabetically to be csh-compliant (which is what happened before
+in most UNIX platforms). (bsd_glob() does still sort platform
+natively, ASCII or EBCDIC, unless GLOB_ALPHASORT is specified.)
-vec() generates a run-time error if the BITS argument is not
-a valid power-of-two integer.
+=item *
-=item Text of some diagnostic output has changed
+Spurious syntax errors generated in certain situations, when glob()
+caused File::Glob to be loaded for the first time, have been fixed.
-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 *
-=item C<%@> has been removed
+Although "you shouldn't do that", it was possible to write code that
+depends on Perl's hashed key order (Data::Dumper does this). The new
+algorithm "One-at-a-Time" produces a different hashed key order.
+More details are in L</"Performance Enhancements">.
-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 *
-=item Parenthesized not() behaves like a list operator
+lstat(FILEHANDLE) now gives a warning because the operation makes no sense.
+In future releases this may become a fatal error.
-The C<not> operator now falls under the "if it looks like a function,
-it behaves like a function" rule.
+=item *
-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:
+The C<package;> syntax (C<package> without an argument) has been
+deprecated. Its semantics were never that clear and its
+implementation even less so. If you have used that feature to
+disallow all but fully qualified variables, C<use strict;> instead.
- grep not($_), @things;
+=item *
-On the other hand, using C<not> with a literal list slice may not
-work. The following previously allowed construct:
+The unimplemented POSIX regex features [[.cc.]] and [[=c=]] are still
+recognised but now cause fatal errors. The previous behaviour of
+ignoring them by default and warning if requested was unacceptable
+since it, in a way, falsely promised that the features could be used.
- print not (1,2,3)[0];
+=item *
-needs to be written with additional parentheses now:
+The current user-visible implementation of pseudo-hashes (the weird
+use of the first array element) is deprecated starting from Perl 5.8.0
+and will be removed in Perl 5.10.0, and the feature will be
+implemented differently. Not only is the current interface rather
+ugly, but the current implementation slows down normal array and hash
+use quite noticeably. The C<fields> pragma interface will remain
+available.
- print not((1,2,3)[0]);
+=item *
-The behavior remains unaffected when C<not> is not followed by parentheses.
+The syntaxes C<< @a->[...] >> and C<< %h->{...} >> have now been deprecated.
-=item Semantics of bareword prototype C<(*)> have changed
+=item *
-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>.
+After years of trying the suidperl is considered to be too complex to
+ever be considered truly secure. The suidperl functionality is likely
+to be removed in a future release.
-=head2 On 64-bit platforms the semantics of bit operators have changed
+=item *
-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>.
+The long deprecated uppercase aliases for the string comparison
+operators (EQ, NE, LT, LE, GE, GT) have now been removed.
-=head2 More builtins taint their results
+=item *
-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 tr///C and tr///U features have been removed and will not return;
+the interface was a mistake. Sorry about that. For similar
+functionality, see pack('U0', ...) and pack('C0', ...).
-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 *
-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.
+Earlier Perls treated "sub foo (@bar)" as equivalent to "sub foo (@)".
+The prototypes are now checked at compile-time for invalid characters.
+An optional warning is generated ("Illegal character in prototype...")
+but this may be upgraded to a fatal error in a future release.
=back
-=head2 C Source Incompatibilities
+=head1 Core Enhancements
+
+=head2 PerlIO is Now The Default
=over 4
-=item C<PERL_POLLUTE>
+=item *
-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:
+IO is now by default done via PerlIO rather than system's "stdio".
+PerlIO allows "layers" to be "pushed" onto a file handle to alter the
+handle's behaviour. Layers can be specified at open time via 3-arg
+form of open:
- perl Makefile.PL POLLUTE=1
+ open($fh,'>:crlf :utf8', $path) || ...
-=item C<PERL_IMPLICIT_CONTEXT>
+or on already opened handles via extended C<binmode>:
- 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.
+ binmode($fh,':encoding(iso-8859-7)');
-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.
+The built-in layers are: unix (low level read/write), stdio (as in
+previous Perls), perlio (re-implementation of stdio buffering in a
+portable manner), crlf (does CRLF <=> "\n" translation as on Win32,
+but available on any platform). A mmap layer may be available if
+platform supports it (mostly UNIXes).
-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.
+Layers to be applied by default may be specified via the 'open' pragma.
-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).
+See L</"Installation and Configuration Improvements"> for the effects
+of PerlIO on your architecture name.
-See L<perlguts/"The Perl API"> for detailed information on the
-ramifications of building Perl with this option.
+=item *
-=item C<PERL_POLLUTE_MALLOC>
+File handles can be marked as accepting Perl's internal encoding of Unicode
+(UTF-8 or UTF-EBCDIC depending on platform) by a pseudo layer ":utf8" :
-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.
+ open($fh,">:utf8","Uni.txt");
-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.
+Note for EBCDIC users: the pseudo layer ":utf8" is erroneously named
+for you since it's not UTF-8 what you will be getting but instead
+UTF-EBCDIC. See L<perlunicode>, L<utf8>, and
+http://www.unicode.org/unicode/reports/tr16/ for more information.
+In future releases this naming may change.
-Note that these functions do B<not> constitute Perl's memory allocation API.
-See L<perlguts/"Memory Allocation"> for further information about that.
+=item *
-=back
+File handles can translate character encodings from/to Perl's internal
+Unicode form on read/write via the ":encoding()" layer.
-=head2 Compatible C Source API Changes
+=item *
-=over
+File handles can be opened to "in memory" files held in Perl scalars via:
-=item C<PATCHLEVEL> is now C<PERL_VERSION>
+ open($fh,'>', \$variable) || ...
-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>.
+=item *
-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.
+Anonymous temporary files are available without need to
+'use FileHandle' or other module via
-=back
+ open($fh,"+>", undef) || ...
-=head2 Binary Incompatibilities
+That is a literal undef, not an undefined value.
-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.
+=item *
-The usethreads or usemultiplicity builds are B<not> binary compatible
-with the corresponding builds in 5.005.
+The list form of C<open> is now implemented for pipes (at least on UNIX):
-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.
+ open($fh,"-|", 'cat', '/etc/motd')
-For the full list of public API functions, see L<perlapi>.
+creates a pipe, and runs the equivalent of exec('cat', '/etc/motd') in
+the child process.
-=head1 Installation and Configuration Improvements
+=back
-=head2 -Dusethreads means something different
+=head2 Safe Signals
- WARNING: Support for threads continues to be an experimental feature.
- Interfaces and implementation are subject to sudden and drastic changes.
+Perl used to be fragile in that signals arriving at inopportune moments
+could corrupt Perl's internal state. Now Perl postpones handling of
+signals until it's safe (between opcodes).
-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".
+This change may have surprising side effects because signals no more
+interrupt Perl instantly. Perl will now first finish whatever it was
+doing, like finishing an internal operation (like sort()) or an
+external operation (like an I/O operation), and only then look at any
+arrived signals (and before starting the next operation). No more corrupt
+internal state since the current operation is always finished first,
+but the signal may take more time to get heard.
-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.
+=head2 Unicode Overhaul
-=head2 New Configure flags
+Unicode in general should be now much more usable than in Perl 5.6.0
+(or even in 5.6.1). Unicode can be used in hash keys, Unicode in
+regular expressions should work now, Unicode in tr/// should work now,
+Unicode in I/O should work now.
-The following new flags may be enabled on the Configure command line
-by running Configure with C<-Dflag>.
+=over 4
- usemultiplicity
- usethreads useithreads (new interpreter threads: no Perl API yet)
- usethreads use5005threads (threads as they were in 5.005)
+=item *
- use64bitint (equal to now deprecated 'use64bits')
- use64bitall
+The Unicode Character Database coming with Perl has been upgraded
+to Unicode 3.1.1. For more information, see http://www.unicode.org/.
- uselongdouble
- usemorebits
- uselargefiles
- usesocks (only SOCKS v5 supported)
+=item *
-=head2 Threadedness and 64-bitness now more daring
+For developers interested in enhancing Perl's Unicode capabilities:
+almost all the UCD files are included with the Perl distribution in
+the F<lib/unicore subdirectory>. The most notable omission, for space
+considerations, is the Unihan database.
-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">.
+=item *
-=head2 Long Doubles
+The Unicode character classes \p{Blank} and \p{SpacePerl} have been
+added. "Blank" is like C isblank(), that is, it contains only
+"horizontal whitespace" (the space character is, the newline isn't),
+and the "SpacePerl" is the Unicode equivalent of C<\s> (\p{Space}
+isn't, since that includes the vertical tabulator character, whereas
+C<\s> doesn't.)
-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.
+=back
-=head2 -Dusemorebits
+=head2 Understanding of Numbers
-You can enable both -Duse64bitint and -Duselongdouble with -Dusemorebits.
-See also L<"64-bit support">.
+In general a lot of fixing has happened in the area of Perl's
+understanding of numbers, both integer and floating point. Since in
+many systems the standard number parsing functions like C<strtoul()>
+and C<atof()> seem to have bugs, Perl tries to work around their
+deficiencies. This results hopefully in more accurate numbers.
-=head2 -Duselargefiles
+Perl now tries internally to use integer values in numeric conversions
+and basic arithmetics (+ - * /) if the arguments are integers, and
+tries also to keep the results stored internally as integers.
+This change leads to often slightly faster and always less lossy
+arithmetics. (Previously Perl always preferred floating point numbers
+in its math.)
-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.
+=head2 Miscellaneous Changes
-See L<"Large file support"> for more information.
+=over 4
-=head2 installusrbinperl
+=item *
-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.
+AUTOLOAD is now lvaluable, meaning that you can add the :lvalue attribute
+to AUTOLOAD subroutines and you can assign to the AUTOLOAD return value.
-=head2 SOCKS support
+=item *
-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:
+C<perl -d:Module=arg,arg,arg> now works (previously one couldn't pass
+in multiple arguments.)
- http://www.socks.nec.com/
+=item *
-=head2 C<-A> flag
+The builtin dump() now gives an optional warning
+C<Ambiguous call resolved as CORE::dump(), qualify as such or use &>
+meaning that by default C<dump(...)> is resolved as the builtin
+dump() which dumps core and aborts, not as (possibly) user-defined
+C<sub dump>. To call the latter, qualify the call as C<&dump(...)>.
+(The whole dump() feature is to considered deprecated, and possibly
+removed/changed in future releases.)
-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.
+=item *
-=head2 Enhanced Installation Directories
+chomp() and chop() have been demoted back to I<not> being overrideable
+because they cannot really be overridden-- the problem is that their
+prototype cannot be expressed and therefore one really cannot write
+replacements to override these builtins.
-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.
+=item *
-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.
+END blocks are now run even if you exit/die in a BEGIN block.
+Internally, the execution of END blocks is now controlled by
+PL_exit_flags & PERL_EXIT_DESTRUCT_END. This enables the new
+behaviour for Perl embedders. This will default in 5.10. See
+L<perlembed>.
-=head1 Core Changes
+=item *
-=head2 Unicode and UTF-8 support
+Formats now support zero-padded decimal fields.
- WARNING: This is an experimental feature. Implementation details are
- subject to change.
+=item *
-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.
+Lvalue subroutines can now return C<undef> in list context.
+However, the lvalue subroutine feature still remains experimental.
-=head2 Interpreter cloning, threads, and concurrency
+=item *
- WARNING: This is an experimental feature. Implementation details are
- subject to change.
+A lost warning "Can't declare ... dereference in my" has been
+restored (Perl had it earlier but it became lost in later releases.)
-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.
+=item *
-On Windows, this feature is used to emulate fork() at the interpreter
-level. See L<perlfork>.
+A new special regular expression variable has been introduced:
+C<$^N>, which contains the most-recently closed group (submatch).
-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 *
-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.
+C<no Module;> now works even if there is no "sub unimport" in the Module.
--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 *
-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 numerical comparison operators return C<undef> if either operand
+is a NaN. Previously the behaviour was unspecified.
-=head2 Lexically scoped warning categories
+=item *
-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.
+The following builtin functions are now overridable: each(), keys(),
+pop(), push(), shift(), splice(), unshift().
-=head2 Lvalue subroutines
+=item *
- WARNING: This is an experimental feature. Details are subject to change.
+C<pack('U0a*', ...)> can now be used to force a string to UTF8.
-Subroutines can now return modifiable lvalues.
-See L<perlsub/"Lvalue subroutines">.
+=item *
-=head2 "our" declarations
+my __PACKAGE__ $obj now works.
-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>.
+=item *
-=head2 Support for strings represented as a vector of ordinals
+The printf() and sprintf() now support parameter reordering using the
+C<%\d+\$> and C<*\d+\$> syntaxes. For example
-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>.
+ print "%2\$s %1\$s\n", "foo", "bar";
-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.
+will print "bar foo\n". This feature helps in writing
+internationalised software, and in general when the order
+of the parameters can vary.
-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:
+=item *
- # this will parse in older versions of Perl also
- if ($^V and $^V gt v5.6.0) {
- # new features supported
- }
+prototype(\&) is now available.
-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:
+=item *
- require v5.6.0; # croak if $^V lt v5.6.0
- use v5.6.0; # same, but croaks at compile-time
+prototype(\[$@%&]) is now available to implicitly create references
+(useful for example if you want to emulate the tie() interface).
-Alternatively, the C<v> may be omitted if there is more than one dot:
+=item *
- require 5.6.0;
- use 5.6.0;
+A new command-line option, C<-t> is available. It is the
+little brother of C<-T>: instead of dieing on taint violations,
+lexical warnings are given. B<This is only meant as a temporary
+debugging aid while securing the code of old legacy applications.
+This is not a substitute for -T.>
-Also, C<sprintf> and C<printf> support the Perl-specific format flag C<%v>
-to print ordinals of characters in arbitrary strings:
+=item *
- printf "v%vd", $^V; # prints current version, such as "v5.5.650"
- printf "%*vX", ":", $addr; # formats IPv6 address
- printf "%*vb", " ", $bits; # displays bitstring
+If tr/// is just counting characters, it doesn't attempt to
+modify its target.
-See L<perldata/"Scalar value constructors"> for additional information.
+=item *
-=head2 Weak references
+untie() will now call an UNTIE() hook if it exists. See L<perltie>
+for details.
- WARNING: This is an experimental feature. Details are subject to change.
+=item *
-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.
+L<utime> now supports C<utime undef, undef, @files> to change the
+file timestamps to the current time.
-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 *
-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.
+The rules for allowing underscores (underbars) in numeric constants
+have been relaxed and simplified: now you can have an underscore
+simply B<between digits>.
-To use this feature, you need the WeakRef package from CPAN, which
-contains additional documentation.
+=back
-=head2 File globbing implemented internally
+=head1 Modules and Pragmata
- WARNING: This is currently an experimental feature. Interfaces and
- implementation are likely to change.
+=head2 New Modules and Pragmata
-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.
+=over 4
-=head2 Binary numbers supported
+=item *
-Binary numbers are now supported as literals, in s?printf formats, and
-C<oct()>:
+C<Attribute::Handlers> allows a class to define attribute handlers.
- $answer = 0b101010;
- printf "The answer is: %b\n", oct("0b101010");
+ package MyPack;
+ use Attribute::Handlers;
+ sub Wolf :ATTR(SCALAR) { print "howl!\n" }
-=head2 Some arrows may be omitted in calls through references
+ # later, in some package using or inheriting from MyPack...
-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') >>.
+ my MyPack $Fluffy : Wolf; # the attribute handler Wolf will be called
-=head2 exists() is supported on subroutine names
+Both variables and routines can have attribute handlers. Handlers can
+be specific to type (SCALAR, ARRAY, HASH, or CODE), or specific to the
+exact compilation phase (BEGIN, CHECK, INIT, or END).
-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 *
-=head2 exists() and delete() are supported on array elements
+B<B::Concise> is a new compiler backend for walking the Perl syntax
+tree, printing concise info about ops, from Stephen McCamant. The
+output is highly customisable. See L<B::Concise>.
-The exists() and delete() builtins now work on simple arrays as well.
-The behavior is similar to that on hash elements.
+=item *
-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.
+C<Class::ISA> for reporting the search path for a class's ISA tree,
+by Sean Burke, has been added. See L<Class::ISA>.
-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.
+=item *
-See L<perlfunc/exists> and L<perlfunc/delete> for examples.
+C<Cwd> has now a split personality: if possible, an XS extension is
+used, (this will hopefully be faster, more secure, and more robust)
+but if not possible, the familiar Perl implementation is used.
-=head2 syswrite() ease-of-use
+=item *
-The length argument of C<syswrite()> has become optional.
+C<Devel::PPPort>, originally from Kenneth Albanowski and now
+maintained by Paul Marquess, has been added. It is primarily used
+by C<h2xs> to enhance portability of of XS modules between different
+versions of Perl.
-=head2 File and directory handles can be autovivified
+=item *
-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:
+C<Digest>, frontend module for calculating digests (checksums), from
+Gisle Aas, has been added. See L<Digest>.
- sub myopen {
- open my $fh, "@_"
- or die "Can't open '@_': $!";
- return $fh;
- }
+=item *
- {
- my $f = myopen("</etc/motd");
- print <$f>;
- # $f implicitly closed here
- }
+C<Digest::MD5> for calculating MD5 digests (checksums) as defined in
+RFC 1321, from Gisle Aas, has been added. See L<Digest::MD5>.
-=head2 open() with more than two arguments
+ use Digest::MD5 'md5_hex';
-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>.
+ $digest = md5_hex("Thirsty Camel");
-=head2 64-bit support
+ print $digest, "\n"; # 01d19d9d2045e005c3f1b80e8b164de1
- WARNING: 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.
+NOTE: the C<MD5> backward compatibility module is deliberately not
+included since its further use is discouraged.
-Any platform that has 64-bit integers either
+=item *
- (1) natively as longs or ints
- (2) via special compiler flags
- (3) using long long or int64_t
+C<Encode>, by Nick Ing-Simmons, provides a mechanism to translate
+between different character encodings. Support for Unicode,
+ISO-8859-*, ASCII, CP*, KOI8-R, and three variants of EBCDIC are
+compiled in to the module. Several other encodings (like Japanese,
+Chinese, and MacIntosh encodings) are included and will be loaded at
+runtime. See L<Encode>.
-are able to use "quads" (64-bit integers) as follows:
+Any encoding supported by Encode module is also available to the
+":encoding()" layer if PerlIO is used.
- NOTE: The Configure flags -Duselonglong and -Duse64bits have been
- deprecated. Use -Duse64bitint instead.
+=item *
-=over 4
+C<I18N::Langinfo> can be use to query locale information.
+See L<I18N::Langinfo>.
=item *
-constants (decimal, hexadecimal, octal, binary) in the code
+C<I18N::LangTags> has functions for dealing with RFC3066-style
+language tags, by Sean Burke. See L<I18N::LangTags>.
=item *
-arguments to oct() and hex()
+C<ExtUtils::Constant> is a new tool for extension writers for
+generating XS code to import C header constants, by Nicholas Clark.
+See L<ExtUtils::Constant>.
=item *
-arguments to print(), printf() and sprintf() (flag prefixes ll, L, q)
+C<Filter::Simple> is an easy-to-use frontend to Filter::Util::Call,
+from Damian Conway. See L<Filter::Simple>.
-=item *
+ # in MyFilter.pm:
+
+ package MyFilter;
-printed as such
+ use Filter::Simple sub {
+ while (my ($from, $to) = splice @_, 0, 2) {
+ s/$from/$to/g;
+ }
+ };
+
+ 1;
+
+ # in user's code:
+
+ use MyFilter qr/red/ => 'green';
+
+ print "red\n"; # this code is filtered, will print "green\n"
+ print "bored\n"; # this code is filtered, will print "bogreen\n"
+
+ no MyFilter;
+
+ print "red\n"; # this code is not filtered, will print "red\n"
=item *
-pack() and unpack() "q" and "Q" formats
+C<File::Temp> allows one to create temporary files and directories in
+an easy, portable, and secure way, by Tim Jenness. See L<File::Temp>.
=item *
-in basic arithmetics: + - * / % (NOTE: operating close to the limits
-of the integer values may produce surprising results)
+C<Filter::Util::Call> provides you with the framework to write
+I<Source Filters> in Perl, from Paul Marquess. For most uses the
+frontend Filter::Simple is to be preferred. See L<Filter::Util::Call>.
=item *
-in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced
-to be 32 bits wide but now operate on the full native width.)
+L<libnet> is a collection of perl5 modules related to network
+programming, from Graham Barr. See L<Net::FTP>, L<Net::NNTP>,
+L<Net::Ping>, L<Net::POP3>, L<Net::SMTP>, and L<Net::Time>.
+
+Perl installation leaves libnet unconfigured, use F<libnetcfg> to configure.
=item *
-vec()
+C<List::Util> is a selection of general-utility list subroutines, like
+sum(), min(), first(), and shuffle(), by Graham Barr. See L<List::Util>.
-=back
+=item *
-Note that unless you have the case (a) you will have to configure
-and compile Perl using the -Duse64bitint Configure flag.
-
-There are actually two modes of 64-bitness: the first one is achieved
-using Configure -Duse64bitint and the second one using Configure
--Duse64bitall. The difference is that the first one is minimal and
-the second one maximal. The first works in more places than the second.
+C<Locale::Constants>, C<Locale::Country>, C<Locale::Currency>, and
+C<Locale::Language>, from Neil Bowers, have been added. They provide the
+codes for various locale standards, such as "fr" for France, "usd" for
+US Dollar, and "jp" for Japanese.
-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.
+ use Locale::Country;
-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.
+ $country = code2country('jp'); # $country gets 'Japan'
+ $code = country2code('Norway'); # $code gets 'no'
-Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint
-nor -Duse64bitall.
+See L<Locale::Constants>, L<Locale::Country>, L<Locale::Currency>,
+and L<Locale::Language>.
-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).
+=item *
-=head2 Large file support
+C<Locale::Maketext> is localization framework from Sean Burke. See
+L<Locale::Maketext>, and L<Locale::Maketext::TPJ13>. The latter is an
+article about software localization, originally published in The Perl
+Journal #13, republished here with kind permission.
-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.
+=item *
-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().
+C<Memoize> can make your functions faster by trading space for time,
+from Mark-Jason Dominus. See L<Memoize>.
-Beware: unless your filesystem also supports "sparse files" seeking to
-umpteen petabytes may be unadvisable.
+=item *
-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.
+C<MIME::Base64> allows you to encode data in base64, from Gisle Aas,
+as defined in RFC 2045 - I<MIME (Multipurpose Internet Mail
+Extensions)>.
-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.
+ use MIME::Base64;
-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.
+ $encoded = encode_base64('Aladdin:open sesame');
+ $decoded = decode_base64($encoded);
-=head2 Long doubles
+ print $encoded, "\n"; # "QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
-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).
+See L<MIME::Base64>.
-=head2 "more bits"
+=item *
-You can "Configure -Dusemorebits" to turn on both the 64-bit support
-and the long double support.
+C<MIME::QuotedPrint> allows you to encode data in quoted-printable
+encoding, as defined in RFC 2045 - I<MIME (Multipurpose Internet Mail
+Extensions)>, from Gisle Aas.
-=head2 Enhanced support for sort() subroutines
+ use MIME::QuotedPrint;
-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>.
+ $encoded = encode_qp("Smiley in Unicode: \x{263a}");
+ $decoded = decode_qp($encoded);
-For unprototyped sort subroutines, the historical behavior of passing
-the elements to be compared as the global variables $a and $b remains
-unchanged.
+ print $encoded, "\n"; # "Smiley in Unicode: =263A"
-=head2 Better syntax checks on parenthesized unary operators
+MIME::QuotedPrint has been enhanced to provide the basic methods
+necessary to use it with PerlIO::Via as in :
-Expressions such as:
+ use MIME::QuotedPrint;
+ open($fh,">Via(MIME::QuotedPrint)",$path);
- print defined(&foo,&bar,&baz);
- print uc("foo","bar","baz");
- undef($foo,&bar);
+See L<MIME::QuotedPrint>.
-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 *
-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:
+C<NEXT> is pseudo-class for method redispatch, from Damian Conway.
+See L<NEXT>.
- print defined &foo, &bar, &baz;
- print uc "foo", "bar", "baz";
- undef $foo, &bar;
+=item *
-remains unchanged. See L<perlop>.
+C<open> is a new pragma for setting the default I/O disciplines
+for open().
-=head2 POSIX character class syntax [: :] supported
+=item *
-For example to match alphabetic characters use /[[:alpha:]]/.
-See L<perlre> for details.
+C<PerlIO::Scalar> provides the implementation of IO to "in memory"
+Perl scalars as discussed above, from Nick Ing-Simmons. It also
+serves as an example of a loadable PerlIO layer. Other future
+possibilities include PerlIO::Array and PerlIO::Code.
+See L<PerlIO::Scalar>.
-=head2 Improved C<qw//> operator
+=item *
-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().
+C<PerlIO::Via> acts as a PerlIO layer and wraps PerlIO layer
+functionality provided by a class (typically implemented in perl
+code), from Nick Ing-Simmons.
-Thus:
+ use MIME::QuotedPrint;
+ open($fh,">Via(MIME::QuotedPrint)",$path);
- $foo = ($bar) = qw(a b c); print "$foo|$bar\n";
+This will automatically convert everything output to C<$fh>
+to Quoted-Printable. See L<PerlIO::Via>.
-now correctly prints "3|a", instead of "2|a".
+=item *
-=head2 pack() format 'Z' supported
+C<Pod::ParseLink>, by Russ Allbery, has been added,
+to parse LZ<><> links in pods as described in the new
+perlpodspec.
-The new format type 'Z' is useful for packing and unpacking null-terminated
-strings. See L<perlfunc/"pack">.
+=item *
-=head2 pack() format modifier '!' supported
+C<Pod::Text::Overstrike>, by Joe Smith, has been added.
+It converts POD data to formatted overstrike text.
+See L<Pod::Text::Overstrike>.
-The new format type modifier '!' is useful for packing and unpacking
-native shorts, ints, and longs. See L<perlfunc/"pack">.
+=item *
-=head2 pack() and unpack() support counted strings
+C<Scalar::Util> is a selection of general-utility scalar subroutines,
+like blessed(), reftype(), and tainted(). See L<Scalar::Util>.
-The template character '/' can be used to specify a counted string
-type to be packed or unpacked. See L<perlfunc/"pack">.
+=item *
-=head2 Comments in pack() templates
+C<sort> is a new pragma for controlling the behaviour of sort().
-The '#' character in a template introduces a comment up to
-end of the line. This facilitates documentation of pack()
-templates.
+=item *
-=head2 $^X variables may now have names longer than one character
+C<Storable> gives persistence to Perl data structures by allowing the
+storage and retrieval of Perl data to and from files in a fast and
+compact binary format, from Raphael Manfredi. See L<Storable>.
-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.
+=item *
-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.
+C<Switch>, from Damian Conway, has been added. Just by saying
-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.
+ use Switch;
-=head2 C<use attrs> implicit in subroutine attributes
+you have C<switch> and C<case> available in Perl.
-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:
+ use Switch;
- sub mymethod : locked method ;
- ...
- sub mymethod : locked method {
- ...
- }
+ switch ($val) {
- sub othermethod :locked :method ;
- ...
- sub othermethod :locked :method {
- ...
+ case 1 { print "number 1" }
+ case "a" { print "string a" }
+ case [1..10,42] { print "number in list" }
+ case (@array) { print "number in list" }
+ case /\w+/ { print "pattern" }
+ case qr/\w+/ { print "pattern" }
+ case (%hash) { print "entry in hash" }
+ case (\%hash) { print "entry in hash" }
+ case (\&sub) { print "arg to subroutine" }
+ else { print "previous case not true" }
}
+See L<Switch>.
+
+=item *
-(Note how only the first C<:> is mandatory, and whitespace surrounding
-the C<:> is optional.)
+C<Test::More> is yet another framework for writing test scripts,
+more extensive than Test::Simple, by Michael Schwern. See L<Test::More>.
-F<AutoSplit.pm> and F<SelfLoader.pm> have been updated to keep the attributes
-with the stubs they provide. See L<attributes>.
+=item *
-=head2 Support for interpolating named characters
+C<Test::Simple> has basic utilities for writing tests, by Michael
+Schwern. See L<Test::Simple>.
-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.
+=item *
-=head2 C<require> and C<do> may be overridden
+C<Text::Balanced> has been added, for extracting delimited text
+sequences from strings, from Damian Conway.
-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">.
+ use Text::Balanced 'extract_delimited';
-=head2 New variable $^C reflects C<-c> switch
+ ($a, $b) = extract_delimited("'never say never', he never said", "'", '');
-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>.
+$a will be "'never say never'", $b will be ', he never said'.
-=head2 New variable $^V contains Perl version as a string
+In addition to extract_delimited() there are also extract_bracketed(),
+extract_quotelike(), extract_codeblock(), extract_variable(),
+extract_tagged(), extract_multiple(), gen_delimited_pat(), and
+gen_extract_tagged(). With these you can implement rather advanced
+parsing algorithms. See L<Text::Balanced>.
-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.
+=item *
-See C<Support for strings represented as a vector of ordinals> for an
-example.
+C<threads> is an interface to interpreter threads, by Arthur Bergman.
+Interpreter threads (ithreads) is the new thread model introduced in
+Perl 5.6 but only available as an internal interface for extension
+writers (and for Win32 Perl for C<fork()> emulation). See L<threads>.
-=head2 Optional Y2K warnings
+=item *
-If Perl is built with the cpp macro C<PERL_Y2KWARN> defined,
-it emits optional warnings when concatenating the number 19
-with another number.
+C<threads::shared> allows data sharing for interpreter threads, from
+Arthur Bergman. In the ithreads model any data sharing between
+threads must be explicit, as opposed to the old 5.005 thread model
+where data sharing was implicit. See L<threads::shared>.
-This behavior must be specifically enabled when running Configure.
-See F<INSTALL> and F<README.Y2K>.
+=item *
-=head1 Significant bug fixes
+C<Tie::RefHash::Nestable>, by Edward Avis, allows storing hash
+references (unlike the standard Tie::RefHash) The module is contained
+within Tie::RefHash, see L<Tie::RefHash>.
-=head2 <HANDLE> on empty files
+=item *
-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<Time::HiRes> provides high resolution timing (ualarm, usleep,
+and gettimeofday), from Douglas E. Wegscheid. See L<Time::HiRes>.
-This means that the following will append "foo" to an empty file (it used
-to do nothing):
+=item *
- perl -0777 -pi -e 's/^/foo/' empty_file
+C<Unicode::UCD> offers a querying interface to the Unicode Character
+Database. See L<Unicode::UCD>.
-The behaviour of:
+=item *
- perl -pi -e 's/^/foo/' empty_file
+C<Unicode::Collate> implements the UCA (Unicode Collation Algorithm)
+for sorting Unicode strings, by SADAHIRO Tomoyuki. See L<Unicode::Collate>.
-is unchanged (it continues to leave the file empty).
+=item *
-=head2 C<eval '...'> improvements
+C<Unicode::Normalize> implements the various Unicode normalization
+forms, by SADAHIRO Tomoyuki. See L<Unicode::Normalize>.
-Line numbers (as reflected by caller() and most diagnostics) within
-C<eval '...'> were often incorrect where here documents were involved.
-This has been corrected.
+=item *
-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.
+C<XS::Typemap>, by Tim Jenness, is a test extension that exercises XS
+typemaps. Nothing gets installed but for extension writers the code
+is worth studying.
-Parsing of here documents used to be flawed when they appeared as
-the replacement expression in C<eval 's/.../.../e'>. This has
-been fixed.
+=back
-=head2 All compilation errors are true errors
+=head2 Updated And Improved Modules and Pragmata
-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.
+=over 4
-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 *
-=head2 Automatic flushing of output buffers
+The following independently supported modules have been updated to the
+newest versions from CPAN: CGI, CPAN, DB_File, File::Spec, File::Temp,
+Getopt::Long, Math::BigFloat, Math::BigInt, the podlators bundle
+(Pod::Man, Pod::Text), Pod::LaTeX, Pod::Parser, Storable,
+Term::ANSIColor, Test, Text-Tabs+Wrap.
-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.
+=item *
-This is not supported on some platforms like Solaris where a suitably
-correct implementation of fflush(NULL) isn't available.
+The attributes::reftype() now works on tied arguments.
-=head2 Better diagnostics on meaningless filehandle operations
+=item *
-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).
+AutoLoader can now be disabled with C<no AutoLoader;>.
-=head2 Where possible, buffered data discarded from duped input filehandle
+=item *
-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.
+B::Deparse has been significantly enhanced. It now can deparse almost
+all of the standard test suite (so that the tests still succeed).
+There is a make target "test.deparse" for trying this out.
-=head2 eof() has the same old magic as <>
+=item *
-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.
+Class::Struct can now define the classes in compile time.
-=head2 system(), backticks and pipe open now reflect exec() failure
+=item *
-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.
+Class::Struct now assigns the array/hash element if the accessor
+is called with an array/hash element as the B<sole> argument.
-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 $!.
+=item *
-=head2 Implicitly closed filehandles are safer
+Data::Dumper has now an option to sort hashes.
-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.
+=item *
-=head2 C<(\$)> prototype and C<$foo{a}>
+Data::Dumper has now an option to dump code references
+using B::Deparse.
-A scalar reference prototype now correctly allows a hash or
-array element in that slot.
+=item *
-=head2 Pseudo-hashes work better
+DB_File now supports newer Berkeley DB versions, among
+other improvements.
- WARNING: 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.
+=item *
-Dereferencing some types of reference values in a pseudo-hash,
-such as C<< $ph->{foo}[1] >>, was accidentally disallowed. This has
-been corrected.
+The English module can now be used without the infamous performance
+hit by saying
-When applied to a pseudo-hash element, exists() now reports whether
-the specified value exists, not merely if the key is valid.
+ use English '-no_performance_hit';
-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">.
+(Assuming, of course, that one doesn't need the troublesome variables
+C<$`>, C<$&>, or C<$'>.) Also, introduced C<@LAST_MATCH_START> and
+C<@LAST_MATCH_END> English aliases for C<@-> and C<@+>.
-Pseudo-hash slices with constant keys are now optimized to array lookups
-at compile-time.
+=item *
-The C<fields> pragma now provides ways to create pseudo-hashes, via
-fields::new() and fields::phash(). See L<fields>.
+Fcntl, Socket, and Sys::Syslog have been rewritten to use the
+new-style constant dispatch section (see L<ExtUtils::Constant>).
+This means that they will be more robust and hopefully faster.
-=head2 C<goto &sub> and AUTOLOAD
+=item *
-The C<goto &sub> construct works correctly when C<&sub> happens
-to be autoloaded.
+File::Find now chdir()s correctly when chasing symbolic links.
-=head2 C<-bareword> allowed under C<use integer>
+=item *
-The autoquoting of barewords preceded by C<-> did not work
-in prior versions when the C<integer> pragma was enabled.
-This has been fixed.
+File::Find now has pre- and post-processing callbacks. It also
+correctly changes directories when chasing symbolic links. Callbacks
+(naughtily) exiting with "next;" instead of "return;" now work.
-=head2 Boolean assignment operators are legal lvalues
+=item *
-Constructs such as C<($a ||= 2) += 1> are now allowed.
+File::Find is now (again) reentrant. It also has been made
+more portable.
-=head2 C<sort $coderef @foo> allowed
+=item *
-sort() did not accept a subroutine reference as the comparison
-function in earlier versions. This is now permitted.
+File::Glob::glob() renamed to File::Glob::bsd_glob() to avoid
+prototype mismatch with CORE::glob().
-=head2 Failures in DESTROY()
+=item *
-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.
+File::Glob now supports C<GLOB_LIMIT> constant to limit the size of
+the returned list of filenames.
-=head2 Locale bugs fixed
+=item *
-printf() and sprintf() previously reset the numeric locale
-back to the default "C" locale. This has been fixed.
+Devel::Peek now has an interface for the Perl memory statistics
+(this works only if you are using perl's malloc, and if you have
+compiled with debugging).
-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.
+=item *
-=head2 Memory leaks
+IPC::Open3 now allows the use of numeric file descriptors.
-The C<eval 'return sub {...}'> construct could sometimes leak
-memory. This has been fixed.
+=item *
-Operations that aren't filehandle constructors used to leak memory
-when used on invalid filehandles. This has been fixed.
+IO::Socket has now atmark() method, which returns true if the socket
+is positioned at the out-of-band mark. The method is also exportable
+as a sockatmark() function.
-Constructs that modified C<@_> could fail to deallocate values
-in C<@_> and thus leak memory. This has been corrected.
+=item *
-=head2 Spurious subroutine stubs after failed subroutine calls
+IO::Socket::INET has support for ReusePort option (if your platform
+supports it). The Reuse option now has an alias, ReuseAddr. For clarity
+you may want to prefer ReuseAddr.
-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.
+=item *
-=head2 Taint failures under C<-U>
+IO::Socket::INET now supports C<LocalPort> of zero (usually meaning
+that the operating system will make one up.)
-When running in unsafe mode, taint violations could sometimes
-cause silent failures. This has been fixed.
+=item *
-=head2 END blocks and the C<-c> switch
+use lib now works identically to @INC. Removing directories
+with 'no lib' now works.
-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.
+=item *
-See L<CHECK blocks> for how to run things when the compile phase ends.
+ExtUtils::MakeMaker now uses File::Spec internally, which hopefully
+leads into better portability.
-=head2 Potential to leak DATA filehandles
+=item *
-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.
+Math::BigFloat and Math::BigInt have undergone a full rewrite.
+They are now magnitudes faster, and they support various
+bignum libraries such as GMP and PARI as their backends.
-This caveat is now better explained in the documentation.
-See L<perldata>.
+=item *
-=head2 Diagnostics follow STDERR
+Math::Complex handles inf, NaN etc., better.
-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 *
-=head2 Other fixes for better diagnostics
+Net::Ping has been muchly enhanced. Multihoming is now supported.
+There is now "external" protocol which uses Net::Ping::External module
+which runs external ping(1) and parses the output. A version of
+Net::Ping::External is available in CPAN.
-Line numbers are no longer suppressed (under most likely circumstances)
-during the global destruction phase.
+=item *
-Diagnostics emitted from code running in threads other than the main
-thread are now accompanied by the thread ID.
+POSIX::sigaction() is now much more flexible and robust.
+You can now install coderef handlers, 'DEFAULT', and 'IGNORE'
+handlers, installing new handlers was not atomic.
-Embedded null characters in diagnostics now actually show up. They
-used to truncate the message in prior versions.
+=item *
-$foo::a and $foo::b are now exempt from "possible typo" warnings only
-if sort() is encountered in package C<foo>.
+In Safe the C<%INC> now localised in a Safe compartment so that
+use/require work.
-Unrecognized alphabetic escapes encountered when parsing quote
-constructs now generate a warning, since they may take on new
-semantics in later versions of Perl.
+=item *
-Many diagnostics now report the internal operation in which the warning
-was provoked, like so:
+In SDBM_File on dosish platforms, some keys went missing because of
+lack of support for files with "holes". A workaround for the problem
+has been added.
- Use of uninitialized value in concatenation (.) at (eval 1) line 1.
- Use of uninitialized value in print at (eval 1) line 1.
+=item *
-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:
+In Search::Dict one can now have a pre-processing hook for the
+lines being searched.
- Not enough arguments for scalar at (eval 4)[newlib/perl5db.pl:1411] line 2, at EOF
+=item *
-=head1 Performance enhancements
+The Shell module now has an OO interface.
-=head2 Simple sort() using { $a <=> $b } and the like are optimized
+=item *
-Many common sort() operations using a simple inlined block are now
-optimized for faster performance.
+The Test module has been significantly enhanced.
-=head2 Optimized assignments to lexical variables
+=item *
-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 vars pragma now supports declaring fully qualified variables.
+(Something that C<our()> does not and will not support.)
-=head2 Faster subroutine calls
+=item *
-Minor changes in how subroutine calls are handled internally
-provide marginal improvements in performance.
+The C<utf8::> name space (as in the pragma) provides various
+Perl-callable functions to provide low level access to Perl's
+internal Unicode representation. At the moment only length()
+has been implemented.
-=head1 Platform specific changes
+=back
-=head2 Supported platforms
+=head1 Utility Changes
=over 4
=item *
-VM/ESA is now supported.
+Emacs perl mode (emacs/cperl-mode.el) has been updated to version
+4.31.
=item *
-Siemens BS2000 is now supported under the POSIX Shell.
+F<emacs/e2ctags.pl> is now much faster.
=item *
-The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread
-extension.
+C<h2ph> now supports C trigraphs.
=item *
-GNU/Hurd is now supported.
+C<h2xs> now produces a template README.
=item *
-Rhapsody/Darwin is now supported.
+C<h2xs> now uses C<Devel::PPort> for better portability between
+different versions of Perl.
=item *
-EPOC is is now supported (on Psion 5).
+C<h2xs> uses the new L<ExtUtils::Constant> module which will affect
+newly created extensions that define constants. Since the new code is
+more correct (if you have two constants where the first one is a
+prefix of the second one, the first constant B<never> gets defined),
+less lossy (it uses integers for integer constant, as opposed to the
+old code that used floating point numbers even for integer constants),
+and slightly faster, you might want to consider regenerating your
+extension code (the new scheme makes regenerating easy).
+L<h2xs> now also supports C trigraphs.
-=back
+=item *
-=head2 DOS
+C<libnetcfg> has been added to configure the libnet.
-=over 4
+=item *
+
+C<perlbug> is now much more robust. It also sends the bug report to
+perl.org, not perl.com.
=item *
-Perl now works with djgpp 2.02 (and 2.03 alpha).
+C<perlcc> has been rewritten and its user interface (that is,
+command line) is much more like that of the UNIX C compiler, cc.
+(The perlbc tools has been removed. Use C<perlcc -B> instead.)
=item *
-Environment variable names are not converted to uppercase any more.
+C<perlivp> is a new Installation Verification Procedure utility
+for running any time after installing Perl.
=item *
-Incorrect exit codes from backticks have been fixed.
+C<pod2html> now allows specifying a cache directory.
=item *
-This port continues to use its own builtin globbing (not File::Glob).
+C<s2p> has been completely rewritten in Perl. (It is in fact a full
+implementation of sed in Perl: you can use the sed functionality by
+using the C<psed> utility.)
+
+=item *
+
+C<xsubpp> now understands POD documentation embedded in the *.xs files.
+
+=item *
+
+C<xsubpp> now supports OUT keyword.
=back
-=head2 OS390 (OpenEdition MVS)
+=head1 New Documentation
-Support for this EBCDIC platform has not been renewed in this release.
-There are difficulties in reconciling Perl's standardization on UTF-8
-as its internal representation for characters with the EBCDIC character
-set, because the two are incompatible.
+=over 4
-It is unclear whether future versions will renew support for this
-platform, but the possibility exists.
+=item *
-=head2 VMS
+perl56delta details the changes between the 5.005 release and the
+5.6.0 release.
-Numerous revisions and extensions to configuration, build, testing, and
-installation process to accomodate core changes and VMS-specific options.
+=item *
-Expand %ENV-handling code to allow runtime mapping to logical names,
-CLI symbols, and CRTL environ array.
+perlclib documents the internal replacements for standard C library
+functions. (Interesting only for extension writers and Perl core
+hackers.)
-Extension of subprocess invocation code to accept filespecs as command
-"verbs".
+=item *
-Add to Perl command line processing the ability to use default file types and
-to recognize Unix-style C<2E<gt>&1>.
+perldebtut is a Perl debugging tutorial.
-Expansion of File::Spec::VMS routines, and integration into ExtUtils::MM_VMS.
+=item *
-Extension of ExtUtils::MM_VMS to handle complex extensions more flexibly.
+perlebcdic contains considerations for running Perl on EBCDIC platforms.
-Barewords at start of Unix-syntax paths may be treated as text rather than
-only as logical names.
+=item *
-Optional secure translation of several logical names used internally by Perl.
+perlintro is a gentle introduction to Perl.
-Miscellaneous bugfixing and porting of new core code to VMS.
+=item *
-Thanks are gladly extended to the many people who have contributed VMS
-patches, testing, and ideas.
+perliol documents the internals of PerlIO with layers.
-=head2 Win32
+=item *
-Perl can now emulate fork() internally, using multiple interpreters running
-in different concurrent threads. This support must be enabled at build
-time. See L<perlfork> for detailed information.
+perlmodstyle is a style guide for writing modules.
-When given a pathname that consists only of a drivename, such as C<A:>,
-opendir() and stat() now use the current working directory for the drive
-rather than the drive root.
+=item *
-The builtin XSUB functions in the Win32:: namespace are documented. See
-L<Win32>.
+perlnewmod tells about writing and submitting a new module.
-$^X now contains the full path name of the running executable.
+=item *
-A Win32::GetLongPathName() function is provided to complement
-Win32::GetFullPathName() and Win32::GetShortPathName(). See L<Win32>.
+perlpacktut is a pack() tutorial.
-POSIX::uname() is supported.
+=item *
-system(1,...) now returns true process IDs rather than process
-handles. kill() accepts any real process id, rather than strictly
-return values from system(1,...).
+perlpod has been rewritten to be clearer and to record the best
+practices gathered over the years.
-For better compatibility with Unix, C<kill(0, $pid)> can now be used to
-test whether a process exists.
+=item *
-The C<Shell> module is supported.
+perlpodspec is a more formal specification of the pod format,
+mainly of interest for writers of pod applications, not to
+people writing in pod.
-Better support for building Perl under command.com in Windows 95
-has been added.
+=item *
-Scripts are read in binary mode by default to allow ByteLoader (and
-the filter mechanism in general) to work properly. For compatibility,
-the DATA filehandle will be set to text mode if a carriage return is
-detected at the end of the line containing the __END__ or __DATA__
-token; if not, the DATA filehandle will be left open in binary mode.
-Earlier versions always opened the DATA filehandle in text mode.
+perlretut is a regular expression tutorial.
-The glob() operator is implemented via the C<File::Glob> extension,
-which supports glob syntax of the C shell. This increases the flexibility
-of the glob() operator, but there may be compatibility issues for
-programs that relied on the older globbing syntax. If you want to
-preserve compatibility with the older syntax, you might want to run
-perl with C<-MFile::DosGlob>. For details and compatibility information,
-see L<File::Glob>.
+=item *
-=head1 New tests
+perlrequick is a regular expressions quick-start guide.
+Yes, much quicker than perlretut.
-=over 4
+=item *
+
+perltodo has been updated.
+
+=item *
-=item lib/attrs
+perltootc has been renamed as perltooc (to not to conflict
+with perltoot in filesystems restricted to "8.3" names)
-Compatibility tests for C<sub : attrs> vs the older C<use attrs>.
+=item *
-=item lib/env
+perluniintro is an introduction to using Unicode in Perl.
+(perlunicode is more of a detailed reference and background
+information)
-Tests for new environment scalar capability (e.g., C<use Env qw($BAR);>).
+=item *
-=item lib/env-array
+perlutil explains the command line utilities packaged with the Perl
+distribution.
-Tests for new environment array capability (e.g., C<use Env qw(@PATH);>).
+=back
-=item lib/io_const
+The following platform-specific documents are available before
+the installation as README.I<platform>, and after the installation
+as perlI<platform>:
-IO constants (SEEK_*, _IO*).
+ perlaix perlamiga perlapollo perlbeos perlbs2000
+ perlce perlcygwin perldgux perldos perlepoc perlhpux
+ perlhurd perlmachten perlmacos perlmint perlmpeix
+ perlnetware perlos2 perlos390 perlplan9 perlqnx perlsolaris
+ perltru64 perluts perlvmesa perlvms perlvos perlwin32
-=item lib/io_dir
+=over 4
-Directory-related IO methods (new, read, close, rewind, tied delete).
+=item *
-=item lib/io_multihomed
+The documentation for the POSIX-BC platform is called "BS2000", to avoid
+confusion with the Perl POSIX module.
-INET sockets with multi-homed hosts.
+=item *
-=item lib/io_poll
+The documentation for the WinCE platform is called "CE", to avoid
+confusion with the perlwin32 documentation on 8.3-restricted filesystems.
-IO poll().
+=back
-=item lib/io_unix
+=head1 Performance Enhancements
-UNIX sockets.
+=over 4
-=item op/attrs
+=item *
-Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>.
+map() could get pathologically slow when the result list it generates
+is larger than the source list. The performance has been improved for
+common scenarios.
-=item op/filetest
+=item *
-File test operators.
+sort() has been changed to use primarily mergesort internally as
+opposed to the earlier quicksort. For very small lists this may
+result in slightly slower sorting times, but in general the speedup
+should be at least 20%. Additional bonuses are that the worst case
+behaviour of sort() is now better (in computer science terms it now
+runs in time O(N log N), as opposed to quicksort's Theta(N**2)
+worst-case run time behaviour), and that sort() is now stable
+(meaning that elements with identical keys will stay ordered as they
+were before the sort). See the C<sort> pragma for information.
+
+The story in more detail: suppose you want to serve yourself a little
+slice of Pi.
+
+ @digits = ( 3,1,4,1,5,9 );
+
+A numerical sort of the digits will yield (1,1,3,4,5,9), as expected.
+Which C<1> comes first is hard to know, since one C<1> looks pretty
+much like any other. You can regard this as totally trivial,
+or somewhat profound. However, if you just want to sort the even
+digits ahead of the odd ones, then what will
+
+ sort { ($a % 2) <=> ($b % 2) } @digits;
+
+yield? The only even digit, C<4>, will come first. But how about
+the odd numbers, which all compare equal? With the quicksort algorithm
+used to implement Perl 5.6 and earlier, the order of ties is left up
+to the sort. So, as you add more and more digits of Pi, the order
+in which the sorted even and odd digits appear will change.
+and, for sufficiently large slices of Pi, the quicksort algorithm
+in Perl 5.8 won't return the same results even if reinvoked with the
+same input. The justification for this rests with quicksort's
+worst case behavior. If you run
+
+ sort { $a <=> $b } ( 1 .. $N , 1 .. $N );
+
+(something you might approximate if you wanted to merge two sorted
+arrays using sort), doubling $N doesn't just double the quicksort time,
+it I<quadruples> it. Quicksort has a worst case run time that can
+grow like N**2, so-called I<quadratic> behaviour, and it can happen
+on patterns that may well arise in normal use. You won't notice this
+for small arrays, but you I<will> notice it with larger arrays,
+and you may not live long enough for the sort to complete on arrays
+of a million elements. So the 5.8 quicksort scrambles large arrays
+before sorting them, as a statistical defence against quadratic behaviour.
+But that means if you sort the same large array twice, ties may be
+broken in different ways.
+
+Because of the unpredictability of tie-breaking order, and the quadratic
+worst-case behaviour, quicksort was I<almost> replaced completely with
+a stable mergesort. I<Stable> means that ties are broken to preserve
+the original order of appearance in the input array. So
+
+ sort { ($a % 2) <=> ($b % 2) } (3,1,4,1,5,9);
+
+will yield (4,3,1,1,5,9), guaranteed. The even and odd numbers
+appear in the output in the same order they appeared in the input.
+Mergesort has worst case O(NlogN) behaviour, the best value
+attainable. And, ironically, this mergesort does particularly
+well where quicksort goes quadratic: mergesort sorts (1..$N, 1..$N)
+in O(N) time. But quicksort was rescued at the last moment because
+it is faster than mergesort on certain inputs and platforms.
+For example, if you really I<don't> care about the order of even
+and odd digits, quicksort will run in O(N) time; it's very good
+at sorting many repetitions of a small number of distinct elements.
+The quicksort divide and conquer strategy works well on platforms
+with relatively small, very fast, caches. Eventually, the problem gets
+whittled down to one that fits in the cache, from which point it
+benefits from the increased memory speed.
+
+Quicksort was rescued by implementing a sort pragma to control aspects
+of the sort. The B<stable> subpragma forces stable behaviour,
+regardless of algorithm. The B<_quicksort> and B<_mergesort>
+subpragmas are heavy-handed ways to select the underlying implementation.
+The leading C<_> is a reminder that these subpragmas may not survive
+beyond 5.8. More appropriate mechanisms for selecting the implementation
+exist, but they wouldn't have arrived in time to save quicksort.
-=item op/lex_assign
+=item *
-Verify operations that access pad objects (lexicals and temporaries).
+Hashes now use Bob Jenkins "One-at-a-Time" hashing key algorithm
+(http://burtleburtle.net/bob/hash/doobs.html). This algorithm is
+reasonably fast while producing a much better spread of values than
+the old hashing algorithm (originally by Chris Torek, later tweaked by
+Ilya Zakharevich). Hash values output from the algorithm on a hash of
+all 3-char printable ASCII keys comes much closer to passing the
+DIEHARD random number generation tests. According to perlbench, this
+change has not affected the overall speed of Perl.
-=item op/exists_sub
+=item *
-Verify C<exists &sub> operations.
+unshift() should now be noticeably faster.
=back
-=head1 Modules and Pragmata
+=head1 Installation and Configuration Improvements
-=head2 Modules
+=head2 Generic Improvements
=over 4
-=item attributes
+=item *
-While used internally by Perl as a pragma, this module also
-provides a way to fetch subroutine and variable attributes.
-See L<attributes>.
+INSTALL now explains how you can configure Perl to use 64-bit
+integers even on non-64-bit platforms.
-=item B
+=item *
- WARNING: The Compiler suite remains highly experimental. The
- generated code may not be correct, even it manages to execute
- without errors.
+Policy.sh policy change: if you are reusing a Policy.sh file
+(see INSTALL) and you use Configure -Dprefix=/foo/bar and in the old
+Policy $prefix eq $siteprefix and $prefix eq $vendorprefix, all of
+them will now be changed to the new prefix, /foo/bar. (Previously
+only $prefix changed.) If you do not like this new behaviour,
+specify prefix, siteprefix, and vendorprefix explicitly.
-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 *
-=item ByteLoader
+A new optional location for Perl libraries, otherlibdirs, is available.
+It can be used for example for vendor add-ons without disturbing Perl's
+own library directories.
-The ByteLoader is a dedicated extension to generate and run
-Perl bytecode. See L<ByteLoader>.
+=item *
-=item constant
+In many platforms the vendor-supplied 'cc' is too stripped-down to
+build Perl (basically, 'cc' doesn't do ANSI C). If this seems
+to be the case and 'cc' does not seem to be the GNU C compiler
+'gcc', an automatic attempt is made to find and use 'gcc' instead.
-References can now be used.
+=item *
-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.
+gcc needs to closely track the operating system release to avoid
+build problems. If Configure finds that gcc was built for a different
+operating system release than is running, it now gives a clearly visible
+warning that there may be trouble ahead.
-See L<constant>.
+=item *
-=item charnames
+If binary compatibility with the 5.005 release is not wanted, Configure
+no longer suggests including the 5.005 modules in @INC.
-This pragma implements the C<\N> string escape. See L<charnames>.
+=item *
-=item Data::Dumper
+Configure C<-S> can now run non-interactively.
-A C<Maxdepth> setting can be specified to avoid venturing
-too deeply into deep data structures. See L<Data::Dumper>.
+=item *
-The XSUB implementation of Dump() is now automatically called if the
-C<Useqq> setting is not in use.
+Configure support for pdp11-style memory models has been removed due
+to obsolescence.
-Dumping C<qr//> objects works correctly.
+=item *
-=item DB
+configure.gnu now works with options with whitespace in them.
-C<DB> is an experimental module that exposes a clean abstraction
-to Perl's debugging API.
+=item *
-=item DB_File
+installperl now outputs everything to STDERR.
-DB_File can now be built with Berkeley DB versions 1, 2 or 3.
-See C<ext/DB_File/Changes>.
+=item *
-=item Devel::DProf
+$Config{byteorder} is now computed dynamically (this is more robust
+with "fat binaries" where an executable image contains binaries for
+more than one binary platform.)
-Devel::DProf, a Perl source code profiler has been added. See
-L<Devel::DProf> and L<dprofpp>.
+=item *
+
+Because PerlIO is now the default on most platforms, "-perlio" doesn't
+get appended to the $Config{archname} (also known as $^O) anymore.
+Instead, if you explicitly choose not to use perlio (Configure command
+line option -Uuseperlio), you will get "-stdio" appended.
-=item Dumpvalue
+=item *
-The Dumpvalue module provides screen dumps of Perl data.
+Another change related to the architecture name is that "-64all"
+(-Duse64bitall, or "maximally 64-bit") is appended only if your
+pointers are 64 bits wide. (To be exact, the use64bitall is ignored.)
-=item DynaLoader
+=item *
-DynaLoader now supports a dl_unload_file() function on platforms that
-support unloading shared objects using dlclose().
+In AFS installations one can configure the root of the AFS to be
+somewhere else than the default F</afs> by using the Configure
+parameter C<-Dafsroot=/some/where/else>.
-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.)
+=item *
-=item Benchmark
+APPLLIB_EXP, a less-know configuration-time definition, has been
+documented. It can be used to prepend site-specific directories
+to Perl's default search path (@INC), see INSTALL for information.
-Overall, Benchmark results exhibit lower average error and better timing
-accuracy.
+=item *
-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:
+The version of Berkeley DB used when the Perl (and, presumably, the
+DB_File extension) was built is now available as
+C<@Config{qw(db_version_major db_version_minor db_version_patch)}>
+from Perl and as C<DB_VERSION_MAJOR_CFG DB_VERSION_MINOR_CFG
+DB_VERSION_PATCH_CFG> from C.
- use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}})
+=item *
-will now output something like this:
+Building Berkeley DB3 for compatibility modes for DB, NDBM, and ODBM
+has been documented in INSTALL.
- 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)
+=item *
-New features: "each for at least N CPU seconds...", "wallclock secs",
-and the "@ operations/CPU second (n=operations)".
+If you have CPAN access (either network or a local copy such as a
+CD-ROM) you can during specify extra modules to Configure to build and
+install with Perl using the -Dextras=... option. See INSTALL for
+more details.
-timethese() now returns a reference to a hash of Benchmark objects containing
-the test results, keyed on the names of the tests.
+=item *
-timethis() now returns the iterations field in the Benchmark result object
-instead of 0.
+In addition to config.over a new override file, config.arch, is
+available. That is supposed to be used by hints file writers for
+architecture-wide changes (as opposed to config.over which is for
+site-wide changes).
-timethese(), timethis(), and the new cmpthese() (see below) can also take
-a format specifier of 'none' to suppress output.
+=item *
-A new function countit() is just like timeit() except that it takes a
-TIME instead of a COUNT.
+If your file system supports symbolic links you can build Perl outside
+of the source directory by
-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.
+ mkdir /tmp/perl/build/directory
+ cd /tmp/perl/build/directory
+ sh /path/to/perl/source/Configure -Dmksymlinks ...
-For other details, see L<Benchmark>.
+This will create in /tmp/perl/build/directory a tree of symbolic links
+pointing to files in /path/to/perl/source. The original files are left
+unaffected. After Configure has finished you can just say
-=item Devel::Peek
+ make all test
-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.
+and Perl will be built and tested, all in /tmp/perl/build/directory.
-=item English
+=item *
-$PERL_VERSION now stands for C<$^V> (a string value) rather than for C<$]>
-(a numeric value).
+For Perl developers several new make targets for profiling
+and debugging have been added, see L<perlhack>.
-=item Env
+=over 8
-Env now supports accessing environment variables like PATH as array
-variables.
+=item *
-=item Fcntl
+Use of the F<gprof> tool to profile Perl has been documented in
+L<perlhack>. There is a make target called "perl.gprof" for
+generating a gprofiled Perl executable.
-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 *
-=item File::Compare
+If you have GCC 3, there is a make target called "perl.gcov" for
+creating a gcoved Perl executable for coverage analysis. See
+L<perlhack>.
-A compare_text() function has been added, which allows custom
-comparison functions. See L<File::Compare>.
+=item *
-=item File::Find
+If you are on IRIX or Tru64 platforms, new profiling/debugging options
+have been added, see L<perlhack> for more information about pixie and
+Third Degree.
-File::Find now works correctly when the wanted() function is either
-autoloaded or is a symbolic reference.
+=back
-A bug that caused File::Find to lose track of the working directory
-when pruning top-level directories has been fixed.
+=item *
-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.
+Guidelines of how to construct minimal Perl installations have
+been added to INSTALL.
-See L<File::Find>.
+=item *
-=item File::Glob
+The Thread extension is now not built at all under ithreads
+(C<Configure -Duseithreads>) because it wouldn't work anyway (the
+Thread extension requires being Configured with C<-Duse5005threads>).
-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>.
+But note that the Thread.pm interface is now shared by both
+thread models.
-=item File::Spec
+=back
-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.
+=head2 New Or Improved Platforms
-=item File::Spec::Functions
+For the list of platforms known to support Perl,
+see L<perlport/"Supported Platforms">.
-The new File::Spec::Functions modules provides a function interface
-to the File::Spec module. Allows shorthand
+=over 4
- $fullname = catfile($dir1, $dir2, $file);
+=item *
-instead of
+AIX dynamic loading should be now better supported.
- $fullname = File::Spec->catfile($dir1, $dir2, $file);
+=item *
-=item Getopt::Long
+AIX should now work better with gcc, threads, and 64-bitness. Also the
+long doubles support in AIX should be better now. See L<perlaix>.
-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.
+=item *
-Getopt::Long encourages the use of Pod::Usage to produce help
-messages. For example:
+After a long pause, AmigaOS has been verified to be happy with Perl.
- 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;
+=item *
- __END__
+AtheOS (http://www.atheos.cx/) is a new platform.
- =head1 NAME
+=item *
- sample - Using GetOpt::Long and Pod::Usage
+BeOS has been reclaimed.
- =head1 SYNOPSIS
+=item *
- sample [options] [file ...]
+DG/UX platform now supports the 5.005-style threads. See L<perldgux>.
- Options:
- -help brief help message
- -man full documentation
+=item *
- =head1 OPTIONS
+DYNIX/ptx platform (a.k.a. dynixptx) is supported at or near osvers 4.5.2.
- =over 8
+=item *
- =item B<-help>
+EBCDIC platforms (z/OS, also known as OS/390, POSIX-BC, and VM/ESA)
+have been regained. Many test suite tests still fail and the
+co-existence of Unicode and EBCDIC isn't quite settled, but the
+situation is much better than with Perl 5.6. See L<perlos390>,
+L<perlbs2000> (for POSIX-BC), and L<perlvmesa> for more information.
- Print a brief help message and exits.
+=item *
- =item B<-man>
+Building perl with -Duseithreads or -Duse5005threads now works under
+HP-UX 10.20 (previously it only worked under 10.30 or later). You will
+need a thread library package installed. See README.hpux.
- Prints the manual page and exits.
+=item *
- =back
+MacOS Classic (MacPerl has of course been available since
+perl 5.004 but now the source code bases of standard Perl
+and MacPerl have been synchronised)
- =head1 DESCRIPTION
+=item *
- B<This program> will read the given input file(s) and do someting
- useful with the contents thereof.
+MacOS X (or Darwin) should now be able to build Perl even on HFS+
+filesystems. (The case-insensitivity confused the Perl build process.)
- =cut
+=item *
-See L<Pod::Usage> for details.
+NCR MP-RAS is now supported.
-A bug that prevented the non-option call-back <> from being
-specified as the first argument has been fixed.
+=item *
-To specify the characters < and > as option starters, use ><. Note,
-however, that changing option starters is strongly deprecated.
+All the NetBSD specific patches (except for the installation
+specific ones) have been merged back to the main distribution.
-=item IO
+=item *
-write() and syswrite() will now accept a single-argument
-form of the call, for consistency with Perl's syswrite().
+NetWare from Novell is now supported. See L<perlnetware>.
-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 *
-A bug that prevented the IO::Socket::protocol() accessor
-from ever returning the correct value has been corrected.
+NonStop-UX is now supported.
-IO::Socket::connect now uses non-blocking IO instead of alarm()
-to do connect timeouts.
+=item *
-IO::Socket::accept now uses select() instead of alarm() for doing
-timeouts.
+NEC SUPER-UX is now supported.
-IO::Socket::INET->new now sets $! correctly on failure. $@ is
-still set for backwards compatability.
+=item *
-=item JPL
+All the OpenBSD specific patches (except for the installation
+specific ones) have been merged back to the main distribution.
-Java Perl Lingo is now distributed with Perl. See jpl/README
-for more information.
+=item *
-=item lib
+Perl has been tested with the GNU pth userlevel thread package
+( http://www.gnu.org/software/pth/pth.html ) . All but one thread
+test worked, and that one failure was because of test results arriving
+in unexpected order.
-C<use lib> now weeds out any trailing duplicate entries.
-C<no lib> removes all named entries.
+=item *
-=item Math::BigInt
+Amdahl UTS UNIX mainframe platform is now supported.
-The bitwise operations C<<< << >>>, C<<< >> >>>, C<&>, C<|>,
-and C<~> are now supported on bigints.
+=item *
-=item Math::Complex
+WinCE is now supported. See L<perlce>.
-The accessor methods Re, Im, arg, abs, rho, and theta can now also
-act as mutators (accessor $z->Re(), mutator $z->Re(3)).
+=item *
-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.
+z/OS (formerly known as OS/390, formerly known as MVS OE) has now
+support for dynamic loading. This is not selected by default,
+however, you must specify -Dusedl in the arguments of Configure.
-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.
+=back
-=item Math::Trig
+=head1 Selected Bug Fixes
-A little bit of radial trigonometry (cylindrical and spherical),
-radial coordinate conversions, and the great circle distance were added.
+Numerous memory leaks and uninitialized memory accesses have been
+hunted down. Most importantly anonymous subs used to leak quite
+a bit.
-=item Pod::Parser, Pod::InputObjects
+=over 4
-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 *
-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.
+The autouse pragma didn't work for Multi::Part::Function::Names.
-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 *
-For further information, please see L<Pod::Parser> and L<Pod::InputObjects>.
+caller() could cause core dumps in certain situations. Carp was sometimes
+affected by this problem.
-=item Pod::Checker, podchecker
+=item *
-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>.
+chop(@list) in list context returned the characters chopped in
+reverse order. This has been reversed to be in the right order.
-=item Pod::ParseUtils, Pod::Find
+=item *
-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).
+Configure no longer includes the DBM libraries (dbm, gdbm, db, ndbm)
+when building the Perl binary. The only exception to this is SunOS 4.x,
+which needs them.
-=item Pod::Select, podselect
+=item *
-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>.
+The behaviour of non-decimal but numeric string constants such as
+"0x23" was platform-dependent: in some platforms that was seen as 35,
+in some as 0, in some as a floating point number (don't ask). This
+was caused by Perl using the operating system libraries in a situation
+where the result of the string to number conversion is undefined: now
+Perl consistently handles such strings as zero in numeric contexts.
-=item Pod::Usage, pod2usage
+=item *
-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.
+The order of DESTROYs has been made more predictable.
-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 *
-For details and examples, please see L<Pod::Usage>.
+Several debugger fixes: exit code now reflects the script exit code,
+condition C<"0"> now treated correctly, the C<d> command now checks
+line number, the C<$.> no longer gets corrupted, all debugger output
+now goes correctly to the socket if RemotePort is set.
-=item Pod::Text and Pod::Man
+=item *
-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.
+Perl 5.6.0 could emit spurious warnings about redefinition of dl_error()
+when statically building extensions into perl. This has been corrected.
-pod2man has been turned into a module, Pod::Man, which also uses
-Pod::Parser. In the process, several outstanding bugs related to quotes
-in section headers, quoting of code escapes, and nested lists have been
-fixed. pod2man is now a wrapper script around this module.
-
-=item SDBM_File
-
-An EXISTS method has been added to this module (and sdbm_exists() has
-been added to the underlying sdbm library), so one can now call exists
-on an SDBM_File tied hash and get the correct result, rather than a
-runtime error.
-
-A bug that may have caused data loss when more than one disk block
-happens to be read from the database in a single FETCH() has been
-fixed.
+=item *
-=item Sys::Syslog
+L<dprofpp> -R didn't work.
-Sys::Syslog now uses XSUBs to access facilities from syslog.h so it
-no longer requires syslog.ph to exist.
+=item *
-=item Sys::Hostname
+C<*foo{FORMAT}> now works.
+=item *
-Sys::Hostname now uses XSUBs to call the C library's gethostname() or
-uname() if they exist.
+Infinity is now recognized as a number.
-=item Term::ANSIColor
+=item *
-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.
+UNIVERSAL::isa no longer caches methods incorrectly. (This broke
+the Tk extension with 5.6.0.)
-=item Time::Local
+=item *
-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.
+Lexicals I: lexicals outside an eval "" weren't resolved
+correctly inside a subroutine definition inside the eval "" if they
+were not already referenced in the top level of the eval""ed code.
-=item Win32
+=item *
-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:
+Lexicals II: lexicals leaked at file scope into subroutines that
+were declared before the lexicals.
- Win32::FsType
- Win32::GetOSVersion
+=item *
-The remaining functions are unchanged and continue to return C<undef> on
-error even in list context.
+Lexical warnings now propagating correctly between scopes
+and into C<eval "...">.
-The Win32::SetLastError(ERROR) function has been added as a complement
-to the Win32::GetLastError() function.
+=item *
-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>.
+C<use warnings qw(FATAL all)> did not work as intended. This has been
+corrected.
-=item XSLoader
+=item *
-The XSLoader extension is a simpler alternative to DynaLoader.
-See L<XSLoader>.
+warnings::enabled() now reports the state of $^W correctly if the caller
+isn't using lexical warnings.
-=item DBM Filters
+=item *
-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:
+Line renumbering with eval and C<#line> now works.
- filter_store_key
- filter_store_value
- filter_fetch_key
- filter_fetch_value
+=item *
-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.
+Fixed numerous memory leaks, especially in eval "".
-=back
+=item *
-=head2 Pragmata
+mkdir() now ignores trailing slashes in the directory name,
+as mandated by POSIX.
-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 *
-Lexical warnings pragma, C<use warnings;>, to control optional warnings.
-See L<perllexwarn>.
+Some versions of glibc have a broken modfl(). This affects builds
+with C<-Duselongdouble>. This version of Perl detects this brokenness
+and has a workaround for it. The glibc release 2.2.2 is known to have
+fixed the modfl() bug.
-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 *
-=head1 Utility Changes
+Modulus of unsigned numbers now works (4063328477 % 65535 used to
+return 27406, instead of 27047).
-=head2 perlcc
+=item *
-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.
+Some "not a number" warnings introduced in 5.6.0 eliminated to be
+more compatible with 5.005. Infinity is now recognised as a number.
-Support for non-Unix platforms has been improved.
+=item *
-=head2 perldoc
+Numeric conversions did not recognize changes in the string value
+properly in certain circumstances.
-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 *
-=head2 The Perl Debugger
+Attributes (like :shared) didn't work with our().
-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 *
-=head1 Documentation Changes
+our() variables will not cause "will not stay shared" warnings.
-=over 4
+=item *
-=item perlapi.pod
+"our" variables of the same name declared in two sibling blocks
+resulted in bogus warnings about "redeclaration" of the variables.
+The problem has been corrected.
-The official list of public Perl API functions.
+=item *
-=item perlcompile.pod
+pack "Z" now correctly terminates the string with "\0".
-An introduction to using the Perl Compiler suite.
+=item *
-=item perldebug.pod
+Fix password routines which in some shadow password platforms
+(e.g. HP-UX) caused getpwent() to return every other entry.
-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 *
-=item perldebguts.pod
+The PERL5OPT environment variable (for passing command line arguments
+to Perl) didn't work for more than a single group of options.
-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 *
-=item perlfilter.pod
+PERL5OPT with embedded spaces didn't work.
-An introduction to writing Perl source filters.
+=item *
-=item perlhack.pod
+printf() no longer resets the numeric locale to "C".
-Some guidelines for hacking the Perl source code.
+=item *
-=item perlintern.pod
+C<qw(a\\b)> now parses correctly as C<'a\\b'>.
-A list of internal functions in the Perl source code.
-(List is currently empty.)
+=item *
-=item perlopentut.pod
+pos() did not return the correct value within s///ge in earlier
+versions. This is now handled correctly.
-A tutorial on using open() effectively.
+=item *
-=item perlreftut.pod
+Printing quads (64-bit integers) with printf/sprintf now works
+without the q L ll prefixes (assuming you are on a quad-capable platform).
-A tutorial that introduces the essentials of references.
+=item *
-=item perlboot.pod
+Regular expressions on references and overloaded scalars now work.
-A tutorial for beginners on object-oriented Perl.
+=item *
-=item perltootc.pod
+Right-hand side magic (GMAGIC) could in many cases such as string
+concatenation be invoked too many times.
-A tutorial on managing class data for object modules.
+=item *
-=item perlunicode.pod
+scalar() now forces scalar context even when used in void context.
-An introduction to Unicode support features in Perl.
+=item *
-=back
+SOCKS support is now much more robust.
-=head1 New or Changed Diagnostics
+=item *
-=over 4
+sort() arguments are now compiled in the right wantarray context
+(they were accidentally using the context of the sort() itself).
+The comparison block is now run in scalar context, and the arguments
+to be sorted are always provided list context.
-=item "%s" variable %s masks earlier declaration in same %s
+=item *
-(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.
+Changed the POSIX character class C<[[:space:]]> to include the (very
+rarely used) vertical tab character. Added a new POSIX-ish character
+class C<[[:blank:]]> which stands for horizontal whitespace
+(currently, the space and the tab).
-=item "my sub" not yet implemented
+=item *
-(F) Lexically scoped subroutines are not yet implemented. Don't try that
-yet.
+The tainting behaviour of sprintf() has been rationalized. It does
+not taint the result of floating point formats anymore, making the
+behaviour consistent with that of string interpolation.
-=item "our" variable %s redeclared
+=item *
-(W misc) You seem to have already declared the same global once before in the
-current lexical scope.
+Some cases of inconsistent taint propagation (such as within hash
+values) have been fixed.
-=item '!' allowed only after types %s
+=item *
-(F) The '!' is allowed in pack() and unpack() only after certain types.
-See L<perlfunc/pack>.
+The RE engine found in Perl 5.6.0 accidentally pessimised certain kinds
+of simple pattern matches. These are now handled better.
-=item / cannot take a count
+=item *
-(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>.
+Regular expression debug output (whether through C<use re 'debug'>
+or via C<-Dr>) now looks better.
-=item / must be followed by a, A or Z
+=item *
-(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>.
+Multi-line matches like C<"a\nxb\n" =~ /(?!\A)x/m> were flawed. The
+bug has been fixed.
-=item / must be followed by a*, A* or Z*
+=item *
-(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>.
+Use of $& could trigger a core dump under some situations. This
+is now avoided.
-=item / must follow a numeric type
+=item *
-(F) You had an unpack template that contained a '#',
-but this did not follow some numeric unpack specification.
-See L<perlfunc/pack>.
+The regular expression captured submatches ($1, $2, ...) are now
+more consistently unset if the match fails, instead of leaving false
+data lying around in them.
-=item /%s/: Unrecognized escape \\%c passed through
+=item *
-(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.
+readline() on files opened in "slurp" mode could return an extra "" at
+the end in certain situations. This has been corrected.
-=item /%s/: Unrecognized escape \\%c in character class passed through
+=item *
-(W regexp) You used a backslash-character combination which is not recognized
-by Perl inside character classes. The character was understood literally.
+Autovivification of symbolic references of special variables described
+in L<perlvar> (as in C<${$num}>) was accidentally disabled. This works
+again now.
-=item /%s/ should probably be written as "%s"
+=item *
-(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.
+Sys::Syslog ignored the C<LOG_AUTH> constant.
-=item %s() called too early to check prototype
+=item *
-(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>.
+All but the first argument of the IO syswrite() method are now optional.
-=item %s argument is not a HASH or ARRAY element
+=item *
-(F) The argument to exists() must be a hash or array element, such as:
+$AUTOLOAD, sort(), lock(), and spawning subprocesses
+in multiple threads simultaneously are now thread-safe.
- $foo{$bar}
- $ref->[12]->["susie"]
+=item *
-=item %s argument is not a HASH or ARRAY element or slice
+Tie::ARRAY SPLICE method was broken.
-(F) The argument to delete() must be either a hash or array element, such as:
+=item *
- $foo{$bar}
- $ref->[12]->["susie"]
+Allow read-only string on left hand side of non-modifying tr///.
-or a hash or array slice, such as:
+=item *
- @foo[$bar, $baz, $xyzzy]
- @{$ref->[12]}{"susie", "queue"}
+Several Unicode fixes.
-=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 *
-=item %s package attribute may clash with future reserved word: %s
+BOMs (byte order marks) in the beginning of Perl files
+(scripts, modules) should now be transparently skipped.
+UTF-16 (UCS-2) encoded Perl files should now be read correctly.
-(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 *
-=item (in cleanup) %s
+The character tables have been updated to Unicode 3.1.1.
-(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.
+=item *
-Failure of user callbacks dispatched using the C<G_KEEPERR> flag
-could also result in this warning. See L<perlcall/G_KEEPERR>.
+Comparing with utf8 data does not magically upgrade non-utf8 data
+into utf8. (This was a problem for example if you were mixing data
+from I/O and Unicode data: your output might have got magically encoded
+as UTF-8.)
-=item <> should be quotes
+=item *
-(F) You wrote C<< require <file> >> when you should have written
-C<require 'file'>.
+Generating illegal Unicode code points like U+FFFE, or the UTF-16
+surrogates, now also generates an optional warning.
-=item Attempt to join self
+=item *
-(F) You tried to join a thread from within itself, which is an
-impossible task. You may be joining the wrong thread, or you may
-need to move the join() to some other thread.
+C<IsAlnum>, C<IsAlpha>, and C<IsWord> now match titlecase.
-=item Bad evalled substitution pattern
+=item *
-(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 '}'.
+Concatenation with the C<.> operator or via variable interpolation,
+C<eq>, C<substr>, C<reverse>, C<quotemeta>, the C<x> operator,
+substitution with C<s///>, single-quoted UTF8, should now work.
-=item Bad realloc() ignored
+=item *
-(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.
+The C<tr///> operator now works. Note that the C<tr///CU>
+functionality has been removed (but see pack('U0', ...)).
-=item Bareword found in conditional
+=item *
-(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:
+C<eval "v200"> now works.
- open FOO || die;
+=item *
-It may also indicate a misspelled constant that has been interpreted
-as a bareword:
+Perl 5.6.0 parsed m/\x{ab}/ incorrectly, leading to spurious warnings.
+This has been corrected.
- use constant TYPO => 1;
- if (TYOP) { print "foo" }
+=item *
-The C<strict> pragma is useful in avoiding such errors.
+Zero entries were missing from the Unicode classes like C<IsDigit>.
-=item Binary number > 0b11111111111111111111111111111111 non-portable
+=back
-(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 *
-=item Bit vector size > 32 non-portable
+Large unsigned numbers (those above 2**31) could sometimes lose their
+unsignedness, causing bogus results in arithmetic operations.
-(W portable) Using bit vector sizes larger than 32 is non-portable.
+=back
-=item Buffer overflow in prime_env_iter: %s
+=head2 Platform Specific Changes and Fixes
-(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.
+=over 4
-=item Can't check filesystem of script "%s"
+=item *
-(P) For some reason you can't check the filesystem of the script for nosuid.
+BSDI 4.*
-=item Can't declare class for non-scalar %s in "%s"
+Perl now works on post-4.0 BSD/OSes.
-(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 *
-=item Can't declare %s in "%s"
+All BSDs
-(F) Only scalar, array, and hash variables may be declared as "my" or
-"our" variables. They must have ordinary identifiers as names.
+Setting C<$0> now works (as much as possible; see L<perlvar> for details).
-=item Can't ignore signal CHLD, forcing to default
+=item *
-(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.
+Cygwin
-=item Can't modify non-lvalue subroutine call
+Numerous updates; currently synchronised with Cygwin 1.1.4.
-(F) Subroutines meant to be used in lvalue context should be declared as
-such, see L<perlsub/"Lvalue subroutines">.
+=item *
-=item Can't read CRTL environ
+Previously DYNIX/ptx had problems in its Configure probe for non-blocking I/O.
-(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 *
-=item Can't remove %s: %s, skipping file
+EPOC
-(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.
+EPOC update after Perl 5.6.0. See README.epoc.
-=item Can't return %s from lvalue subroutine
+=item *
-(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.
+FreeBSD 3.*
-=item Can't weaken a nonreference
+Perl now works on post-3.0 FreeBSDs.
-(F) You attempted to weaken something that was not a reference. Only
-references can be weakened.
+=item *
-=item Character class [:%s:] unknown
+HP-UX
-(F) The class in the character class [: :] syntax is unknown.
-See L<perlre>.
+README.hpux updated; C<Configure -Duse64bitall> now almost works.
-=item Character class syntax [%s] belongs inside character classes
+=item *
-(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.
+IRIX
-=item Constant is not %s reference
+Numerous compilation flag and hint enhancements; accidental mixing
+of 32-bit and 64-bit libraries (a doomed attempt) made much harder.
-(F) A constant value (perhaps declared using the C<use constant> pragma)
-is being dereferenced, but it amounts to the wrong type of reference. The
-message indicates the type of reference that was expected. This usually
-indicates a syntax error in dereferencing the constant value.
-See L<perlsub/"Constant Functions"> and L<constant>.
+=item *
-=item constant(%s): %s
+Linux
-(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>.
+=over 8
-=item CORE::%s is not a keyword
+=item *
-(F) The CORE:: namespace is reserved for Perl keywords.
+Long doubles should now work (see INSTALL).
-=item defined(@array) is deprecated
+=item *
-(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.
+Linux previously had problems related to sockaddrlen when using
+accept(), revcfrom() (in Perl: recv()), getpeername(), and getsockname().
-=item defined(%hash) is deprecated
+=back
-(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 *
-=item Did not produce a valid header
+MacOS Classic
-See Server error.
+Compilation of the standard Perl distribution in MacOS Classic should
+now work if you have the Metrowerks development environment and
+the missing Mac-specific toolkit bits. Contact the macperl mailing
+list for details.
-=item (Did you mean "local" instead of "our"?)
+=item *
-(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.
+MPE/iX
-=item Document contains no data
+MPE/iX update after Perl 5.6.0. See README.mpeix.
-See Server error.
+=item *
-=item entering effective %s failed
+NetBSD/sparc
-(F) While under the C<use filetest> pragma, switching the real and
-effective uids or gids failed.
+Perl now works on NetBSD/sparc.
-=item false [] range "%s" in regexp
+=item *
-(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>.
+OS/2
-=item Filehandle %s opened only for output
+Now works with usethreads (see INSTALL).
-(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>.
+=item *
-=item flock() on closed filehandle %s
+Solaris
-(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?
+64-bitness using the Sun Workshop compiler now works.
-=item Global symbol "%s" requires explicit package name
+=item *
-(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 "::").
+Tru64 (aka Digital UNIX, aka DEC OSF/1)
-=item Hexadecimal number > 0xffffffff non-portable
+The operating system version letter now recorded in $Config{osvers}.
+Allow compiling with gcc (previously explicitly forbidden). Compiling
+with gcc still not recommended because buggy code results, even with
+gcc 2.95.2.
-(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 *
-=item Ill-formed CRTL environ value "%s"
+Unicos
-(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.
+Fixed various alignment problems that lead into core dumps either
+during build or later; no longer dies on math errors at runtime;
+now using full quad integers (64 bits), previously was using
+only 46 bit integers for speed.
-=item Ill-formed message in prime_env_iter: |%s|
+=item *
-(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.
+VMS
-=item Illegal binary digit %s
+chdir() now works better despite a CRT bug; now works with MULTIPLICITY
+(see INSTALL); now works with Perl's malloc.
-(F) You used a digit other than 0 or 1 in a binary number.
+The tainting of C<%ENV> elements via C<keys> or C<values> was previously
+unimplemented. It now works as documented.
-=item Illegal binary digit %s ignored
+The C<waitpid> emulation has been improved. The worst bug (now fixed)
+was that a pid of -1 would cause a wildcard search of all processes on
+the system. The most significant enhancement is that we can now
+usually get the completion status of a terminated process.
-(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.
+POSIX-style signals are now emulated much better on VMS versions prior
+to 7.0.
-=item Illegal number of bits in vec
+The C<system> function and backticks operator have improved
+functionality and better error handling.
-(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 *
-=item Integer overflow in %s number
+Windows
-(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.
+=over 8
-=item Invalid %s attribute: %s
+=item *
-The indicated attribute for a subroutine or variable was not recognized
-by Perl or by a user-supplied handler. See L<attributes>.
+accept() no longer leaks memory.
-=item Invalid %s attributes: %s
+=item *
-The indicated attributes for a subroutine or variable were not recognized
-by Perl or by a user-supplied handler. See L<attributes>.
+Borland C++ v5.5 is now a supported compiler that can build Perl.
+However, the generated binaries continue to be incompatible with those
+generated by the other supported compilers (GCC and Visual C++).
-=item invalid [] range "%s" in regexp
+=item *
-The offending range is now explicitly displayed.
+Better chdir() return value for a non-existent directory.
-=item Invalid separator character %s in attribute list
+=item *
-(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>.
+Duping socket handles with open(F, ">&MYSOCK") now works under Windows 9x.
-=item Invalid separator character %s in subroutine attribute list
+=item *
-(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.
+New %ENV entries now propagate to subprocesses.
-=item leaving effective %s failed
+=item *
-(F) While under the C<use filetest> pragma, switching the real and
-effective uids or gids failed.
+Current directory entries in %ENV are now correctly propagated to child
+processes.
-=item Lvalue subs returning %s not implemented yet
+=item *
-(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">.
+$ENV{LIB} now used to search for libs under Visual C.
-=item Method %s not permitted
+=item *
-See Server error.
+fork() emulation has been improved in various ways, but still continues
+to be experimental. See L<perlfork> for known bugs and caveats.
-=item Missing %sbrace%s on \N{}
+=item *
-(F) Wrong syntax of character name literal C<\N{charname}> within
-double-quotish context.
+A failed (pseudo)fork now returns undef and sets errno to EAGAIN.
-=item Missing command in piped open
+=item *
-(W pipe) You used the C<open(FH, "| command")> or C<open(FH, "command |")>
-construction, but the command was missing or blank.
+Win32::GetCwd() correctly returns C:\ instead of C: when at the drive root.
+Other bugs in chdir() and Cwd::cwd() have also been fixed.
-=item Missing name in "my sub"
+=item *
-(F) The reserved syntax for lexically scoped subroutines requires that they
-have a name with which they can be found.
+HTML files will be installed in c:\perl\html instead of c:\perl\lib\pod\html
-=item No %s specified for -%c
+=item *
-(F) The indicated command line switch needs a mandatory argument, but
-you haven't specified one.
+The makefiles now provide a single switch to bulk-enable all the features
+enabled in ActiveState ActivePerl (a popular Win32 binary distribution).
-=item No package name allowed for variable %s in "our"
+=item *
-(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.
+Allow REG_EXPAND_SZ keys in the registry.
-=item No space allowed after -%c
+=item *
-(F) The argument to the indicated command line switch must follow immediately
-after the switch, without intervening spaces.
+Can now send() from all threads, not just the first one.
-=item no UTC offset information; assuming local time is UTC
+=item *
-(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.
+Fake signal handling reenabled, bugs and all.
-=item Octal number > 037777777777 non-portable
+=item *
-(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.
+%SIG has been enabled under USE_ITHREADS, but its use is completely
+unsupported under all configurations.
-See also L<perlport> for writing portable code.
+=item *
-=item panic: del_backref
+Less stack reserved per thread so that more threads can run
+concurrently. (Still 16M per thread.)
-(P) Failed an internal consistency check while trying to reset a weak
-reference.
+=item *
-=item panic: kid popen errno read
+C<File::Spec->tmpdir()> now prefers C:/temp over /tmp
+(works better when perl is running as service).
-(F) forked child returned an incomprehensible message about its errno.
+=item *
-=item panic: magic_killbackrefs
+Better UNC path handling under ithreads.
-(P) Failed an internal consistency check while trying to reset all weak
-references to an object.
+=item *
-=item Parentheses missing around "%s" list
+wait(), waitpid() and backticks now return the correct exit status under
+Windows 9x.
-(W parenthesis) You said something like
+=item *
- my $foo, $bar = @_;
+winsock handle leak fixed.
-when you meant
+=back
- my ($foo, $bar) = @_;
+=back
-Remember that "my", "our", and "local" bind tighter than comma.
+=head1 New or Changed Diagnostics
-=item Possible Y2K bug: %s
+=over 4
-(W y2k) You are concatenating the number 19 with another number, which
-could be a potential Year 2000 problem.
+=item *
-=item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
+All regular expression compilation error messages are now hopefully
+easier to understand both because the error message now comes before
+the failed regex and because the point of failure is now clearly
+marked by a C<E<lt>-- HERE> marker.
-(W deprecated) You have written somehing like this:
+=item *
- sub doit
- {
- use attrs qw(locked);
- }
+The various "opened only for", "on closed", "never opened" warnings
+drop the C<main::> prefix for filehandles in the C<main> package,
+for example C<STDIN> instead of C<main::STDIN>.
-You should use the new declaration syntax instead.
+=item *
- sub doit : locked
- {
- ...
+The "Unrecognized escape" warning has been extended to include C<\8>,
+C<\9>, and C<\_>. There is no need to escape any of the C<\w> characters.
-The C<use attrs> pragma is now obsolete, and is only provided for
-backward-compatibility. See L<perlsub/"Subroutine Attributes">.
+=item *
+Two new debugging options have been added: if you have compiled your
+Perl with debugging, you can use the -DT and -DR options to trace
+tokenising and to add reference counts to displaying variables,
+respectively.
-=item Premature end of script headers
+=item *
-See Server error.
+If an attempt to use a (non-blessed) reference as an array index
+is made, a warning is given.
-=item Repeat count in pack overflows
+=item *
-(F) You can't specify a repeat count so large that it overflows
-your signed integers. See L<perlfunc/pack>.
+C<push @a;> and C<unshift @a;> (with no values to push or unshift)
+now give a warning. This may be a problem for generated and evaled
+code.
-=item Repeat count in unpack overflows
+=item *
-(F) You can't specify a repeat count so large that it overflows
-your signed integers. See L<perlfunc/unpack>.
+If you try to L<perlfunc/pack> a number less than 0 or larger than 255
+using the C<"C"> format you will get an optional warning. Similarly
+for the C<"c"> format and a number less than -128 or more than 127.
-=item realloc() of freed memory ignored
+=item *
-(S) An internal routine called realloc() on something that had already
-been freed.
+Certain regex modifiers such as C<(?o)> make sense only if applied to
+the entire regex. You will an optional warning if you try to do otherwise.
-=item Reference is already weak
+=item *
-(W misc) You have attempted to weaken a reference that is already weak.
-Doing so has no effect.
+Using arrays or hashes as references (e.g. C<< %foo->{bar} >>
+has been deprecated for a while. Now you will get an optional warning.
-=item setpgrp can't take arguments
+=back
-(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.
+=head1 Changed Internals
-=item Strange *+?{} on zero-length expression
+=over 4
-(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}/>.
+=item *
-=item switching effective %s is not implemented
+perlapi.pod (a companion to perlguts) now attempts to document the
+internal API.
-(F) While under the C<use filetest> pragma, we cannot switch the
-real and effective uids or gids.
+=item *
-=item This Perl can't reset CRTL environ elements (%s)
+You can now build a really minimal perl called microperl.
+Building microperl does not require even running Configure;
+C<make -f Makefile.micro> should be enough. Beware: microperl makes
+many assumptions, some of which may be too bold; the resulting
+executable may crash or otherwise misbehave in wondrous ways.
+For careful hackers only.
-=item This Perl can't set CRTL environ elements (%s=%s)
+=item *
-(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.
+Added rsignal(), whichsig(), do_join(), op_clear, op_null,
+ptr_table_clear(), ptr_table_free(), sv_setref_uv(), and several UTF-8
+interfaces to the publicised API. For the full list of the available
+APIs see L<perlapi>.
-=item Too late to run %s block
+=item *
-(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.
+Made possible to propagate customised exceptions via croak()ing.
-=item Unknown open() mode '%s'
+=item *
-(F) The second argument of 3-argument open() is not among the list
-of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>,
-C<< +> >>, C<<< +>> >>>, C<-|>, C<|->.
+Now xsubs can have attributes just like subs. (Well, at least the
+built-in attributes.)
-=item Unknown process %x sent message to prime_env_iter: %s
+=item *
-(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.
+dTHR and djSP have been obsoleted; the former removed (because it's
+a no-op) and the latter replaced with dSP.
-=item Unrecognized escape \\%c passed through
+=item *
-(W misc) You used a backslash-character combination which is not recognized
-by Perl. The character was understood literally.
+PERL_OBJECT has been completely removed.
-=item Unterminated attribute parameter in attribute list
+=item *
-(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>.
+The MAGIC constants (e.g. C<'P'>) have been macrofied
+(e.g. C<PERL_MAGIC_TIED>) for better source code readability
+and maintainability.
-=item Unterminated attribute list
+=item *
-(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>.
+The regex compiler now maintains a structure that identifies nodes in
+the compiled bytecode with the corresponding syntactic features of the
+original regex expression. The information is attached to the new
+C<offsets> member of the C<struct regexp>. See L<perldebguts> for more
+complete information.
-=item Unterminated attribute parameter in subroutine attribute list
+=item *
-(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.
+The C code has been made much more C<gcc -Wall> clean. Some warning
+messages still remain in some platforms, so if you are compiling with
+gcc you may see some warnings about dubious practices. The warnings
+are being worked on.
-=item Unterminated subroutine attribute list
+=item *
-(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<perly.c>, F<sv.c>, and F<sv.h> have now been extensively commented.
-=item Value of CLI symbol "%s" too long
+=item *
-(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.
+Documentation on how to use the Perl source repository has been added
+to F<Porting/repository.pod>.
-=item Version number must be a constant number
+=item *
-(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.
+There are now several profiling make targets.
=back
-=head1 Obsolete Diagnostics
+=head1 Security Vulnerability Closed
+
+(This change was already made in 5.7.0 but bears repeating here.)
+
+A potential security vulnerability in the optional suidperl component
+of Perl was identified in August 2000. suidperl is neither built nor
+installed by default. As of November 2001 the only known vulnerable
+platform is Linux, most likely all Linux distributions. CERT and
+various vendors and distributors have been alerted about the vulnerability.
+See http://www.cpan.org/src/5.0/sperl-2000-08-05/sperl-2000-08-05.txt
+for more information.
+
+The problem was caused by Perl trying to report a suspected security
+exploit attempt using an external program, /bin/mail. On Linux
+platforms the /bin/mail program had an undocumented feature which
+when combined with suidperl gave access to a root shell, resulting in
+a serious compromise instead of reporting the exploit attempt. If you
+don't have /bin/mail, or if you have 'safe setuid scripts', or if
+suidperl is not installed, you are safe.
+
+The exploit attempt reporting feature has been completely removed from
+Perl 5.8.0 (and the maintenance release 5.6.1, and it was removed also
+from all the Perl 5.7 releases), so that particular vulnerability
+isn't there anymore. However, further security vulnerabilities are,
+unfortunately, always possible. The suidperl functionality is most
+probably going to be removed in Perl 5.10. In any case, suidperl
+should only be used by security experts who know exactly what they are
+doing and why they are using suidperl instead of some other solution
+such as sudo (see http://www.courtesan.com/sudo/).
+
+=head1 New Tests
+
+Several new tests have been added, especially for the F<lib>
+subsection. There are now about 34 000 individual tests (spread over
+about 530 test scripts), in the regression suite (5.6.1 has about
+11700 tests, in 258 test scripts) Many of the new tests are introduced
+by the new modules, but still in general Perl is now more thoroughly
+tested.
+
+Because of the large number of tests, running the regression suite
+will take considerably longer time than it used to: expect the suite
+to take up to 4-5 times longer to run than in perl 5.6. In a really
+fast machine you can hope to finish the suite in about 5 minutes
+(wallclock time).
+
+The tests are now reported in a different order than in earlier Perls.
+(This happens because the test scripts from under t/lib have been moved
+to be closer to the library/extension they are testing.)
+
+=head1 Known Problems
+
+=head2 AIX
=over 4
-=item Character class syntax [: :] is reserved for future extensions
+=item *
-(W) Within regular expression character classes ([]) the syntax beginning
-with "[:" and ending with ":]" is reserved for future extensions.
-If you need to represent those character sequences inside a regular
-expression character class, just quote the square brackets with the
-backslash: "\[:" and ":\]".
+In AIX 4.2 Perl extensions that use C++ functions that use statics
+may have problems in that the statics are not getting initialized.
+In newer AIX releases this has been solved by linking Perl with
+the libC_r library, but unfortunately in AIX 4.2 the said library
+has an obscure bug where the various functions related to time
+(such as time() and gettimeofday()) return broken values, and
+therefore in AIX 4.2 Perl is not linked against the libC_r.
-=item Ill-formed logical name |%s| in prime_env_iter
+=item *
-(W) A warning peculiar to VMS. A logical name was encountered when preparing
-to iterate over %ENV which violates the syntactic rules governing logical
-names. Because it cannot be translated normally, it is skipped, and will not
-appear in %ENV. This may be a benign occurrence, as some software packages
-might directly modify logical name tables and introduce nonstandard names,
-or it may indicate that a logical name table has been corrupted.
+vac 5.0.0.0 May Produce Buggy Code For Perl
-=item Probable precedence problem on %s
+The AIX C compiler vac version 5.0.0.0 may produce buggy code,
+resulting in few random tests failing, but when the failing tests
+are run by hand, they succeed. We suggest upgrading to at least
+vac version 5.0.1.0, that has been known to compile Perl correctly.
+"lslpp -L|grep vac.C" will tell you the vac version.
-(W) The compiler found a bareword where it expected a conditional,
-which often indicates that an || or && was parsed as part of the
-last argument of the previous construct, for example:
+=back
- open FOO || die;
+=head2 Amiga Perl Invoking Mystery
-=item regexp too big
+One cannot call Perl using the C<volume:> syntax, that is, C<perl -v>
+works, but for example C<bin:perl -v> doesn't. The exact reason isn't
+known but the current suspect is the F<ixemul> library.
-(F) The current implementation of regular expressions uses shorts as
-address offsets within a string. Unfortunately this means that if
-the regular expression compiles to longer than 32767, it'll blow up.
-Usually when you want a regular expression this big, there is a better
-way to do it with multiple statements. See L<perlre>.
+=head2 lib/ftmp-security tests warn 'system possibly insecure'
-=item Use of "$$<digit>" to mean "${$}<digit>" is deprecated
+Don't panic. Read INSTALL 'make test' section instead.
-(D) Perl versions before 5.004 misinterpreted any type marker followed
-by "$" and a digit. For example, "$$0" was incorrectly taken to mean
-"${$}0" instead of "${$0}". This bug is (mostly) fixed in Perl 5.004.
+=head2 Cygwin intermittent failures of lib/Memoize/t/expire_file 11 and 12
-However, the developers of Perl 5.004 could not fix this bug completely,
-because at least two widely-used modules depend on the old meaning of
-"$$0" in a string. So Perl 5.004 still interprets "$$<digit>" in the
-old (broken) way inside strings; but it generates this message as a
-warning. And in Perl 5.005, this special treatment will cease.
+The subtests 11 and 12 sometimes fail and sometimes work.
-=back
+=head2 HP-UX lib/io_multihomed Fails When LP64-Configured
-=head1 Known Problems
+The lib/io_multihomed test may hang in HP-UX if Perl has been
+configured to be 64-bit. Because other 64-bit platforms do not hang in
+this test, HP-UX is suspect. All other tests pass in 64-bit HP-UX. The
+test attempts to create and connect to "multihomed" sockets (sockets
+which have multiple IP addresses).
+
+=head2 HP-UX lib/posix Subtest 9 Fails When LP64-Configured
+
+If perl is configured with -Duse64bitall, the successful result of the
+subtest 10 of lib/posix may arrive before the successful result of the
+subtest 9, which confuses the test harness so much that it thinks the
+subtest 9 failed.
+
+=head2 Linux With Sfio Fails op/misc Test 48
+
+No known fix.
+
+=head2 Mac OS X
+
+The following tests are known to fail:
+
+ Failed Test Stat Wstat Total Fail Failed List of Failed
+ -------------------------------------------------------------------------
+ ../ext/DB_File/t/db-btree.t 0 11 ?? ?? % ??
+ ../ext/DB_File/t/db-recno.t 149 3 2.01% 61 63 65
+ ../ext/POSIX/t/posix.t 31 1 3.23% 10
+ ../lib/warnings.t 450 1 0.22% 316
+
+=head2 OS/390
+
+OS/390 has rather many test failures but the situation is actually
+better than it was in 5.6.0, it's just that so many new modules and
+tests have been added.
+
+ Failed Test Stat Wstat Total Fail Failed List of Failed
+ -----------------------------------------------------------------------------
+ ../ext/B/Deparse.t 14 1 7.14% 14
+ ../ext/B/Showlex.t 1 1 100.00% 1
+ ../ext/Encode/Encode/Tcl.t 610 13 2.13% 592 594 596 598
+ 600 602 604-610
+ ../ext/IO/lib/IO/t/io_unix.t 113 28928 5 3 60.00% 3-5
+ ../ext/POSIX/POSIX.t 29 1 3.45% 14
+ ../ext/Storable/t/lock.t 255 65280 5 3 60.00% 3-5
+ ../lib/locale.t 129 33024 117 19 16.24% 99-117
+ ../lib/warnings.t 434 1 0.23% 75
+ ../lib/ExtUtils.t 27 1 3.70% 25
+ ../lib/Math/BigInt/t/bigintpm.t 1190 1 0.08% 1145
+ ../lib/Unicode/UCD.t 81 48 59.26% 1-16 49-64 66-81
+ ../lib/User/pwent.t 9 1 11.11% 4
+ op/pat.t 660 6 0.91% 242-243 424-425
+ 626-627
+ op/split.t 0 9 ?? ?? % ??
+ op/taint.t 174 3 1.72% 156 162 168
+ op/tr.t 70 3 4.29% 50 58-59
+ Failed 16/422 test scripts, 96.21% okay. 105/23251 subtests failed, 99.55% okay.
+
+=head2 op/sprintf tests 129 and 130
+
+The op/sprintf tests 129 and 130 are known to fail on some platforms.
+Examples include any platform using sfio, and Compaq/Tandem's NonStop-UX.
+The failing platforms do not comply with the ANSI C Standard, line
+19ff on page 134 of ANSI X3.159 1989 to be exact. (They produce
+something other than "1" and "-1" when formatting 0.6 and -0.6 using
+the printf format "%.0f", most often they produce "0" and "-0".)
+
+=head2 Failure of Thread tests
+
+B<Note that support for 5.005-style threading remains experimental
+and practically unsupported.>
+
+The following tests are known to fail due to fundamental problems in
+the 5.005 threading implementation. These are not new failures--Perl
+5.005_0x has the same bugs, but didn't have these tests.
+
+ ext/List/Util/t/first 2
+ lib/autouse 4
+ ext/Thread/thr5005 19-20
+
+These failures are unlikely to get fixed.
+
+=head2 UNICOS
+
+=over 4
-=head2 Thread test failures
+=item *
-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.
+ext/POSIX/sigaction subtests 6 and 13 may fail.
-=head2 EBCDIC platforms not supported
+=item *
-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.
+lib/ExtUtils may spuriously claim that subtest 28 failed,
+which is interesting since the test only has 27 tests.
-=head2 In 64-bit HP-UX the lib/io_multihomed test may hang
+=item *
-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).
+Numerous numerical test failures
+
+ op/numconvert 209,210,217,218
+ op/override 7
+ ext/Time/HiRes/HiRes 9
+ lib/Math/BigInt/t/bigintpm 1145
+ lib/Math/Trig 25
+
+These tests fail because of yet unresolved floating point inaccuracies.
-=head2 NEXTSTEP 3.3 POSIX test failure
+=back
-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.
+=head2 UTS
-=head2 Tru64 (aka Digital UNIX, aka DEC OSF/1) lib/sdbm test failure with gcc
+There are a few known test failures, see L<perluts>.
-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.
+=head2 VMS
-=head2 UNICOS/mk CC failures during Configure run
+There is one known test failure with a default configuration:
-In UNICOS/mk the following errors may appear during the Configure run:
+ [.run]switches..........................FAILED on test 1
- 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".
+=head2 Win32
-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.
+In multi-CPU boxes there are some problems with the I/O buffering:
+some output may appear twice.
-=head2 Arrow operator and arrays
+=head2 Localising a Tied Variable Leaks Memory
-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:
+ use Tie::Hash;
+ tie my %tie_hash => 'Tie::StdHash';
- @x->[2]
- scalar(@x)->[2]
+ ...
-These expressions will get run-time errors in some future release of
-Perl.
+ local($tie_hash{Foo}) = 1; # leaks
-=head2 Windows 2000
+Code like the above is known to leak memory every time the local()
+is executed.
-Windows 2000 is known to fail test 22 in lib/open3.t (cause unknown at
-this time). That test passes under Windows NT.
+=head2 Localising Tied Arrays and Hashes Is Broken
-=head2 Experimental features
+ local %tied_array;
-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:
+doesn't work as one would expect: the old value is restored
+incorrectly.
-=over 4
+=head2 Self-tying of Arrays and Hashes Is Forbidden
-=item Threads
+Self-tying of arrays and hashes is broken in rather deep and
+hard-to-fix ways. As a stop-gap measure to avoid people from getting
+frustrated at the mysterious results (core dumps, most often) it is
+for now forbidden (you will get a fatal error even from an attempt).
-=item Unicode
+=head2 Building Extensions Can Fail Because Of Largefiles
-=item 64-bit support
+Some extensions like mod_perl are known to have issues with
+`largefiles', a change brought by Perl 5.6.0 in which file offsets
+default to 64 bits wide, where supported. Modules may fail to compile
+at all or compile and work incorrectly. Currently there is no good
+solution for the problem, but Configure now provides appropriate
+non-largefile ccflags, ldflags, libswanted, and libs in the %Config
+hash (e.g., $Config{ccflags_nolargefiles}) so the extensions that are
+having problems can try configuring themselves without the
+largefileness. This is admittedly not a clean solution, and the
+solution may not even work at all. One potential failure is whether
+one can (or, if one can, whether it's a good idea) link together at
+all binaries with different ideas about file offsets, all this is
+platform-dependent.
-=item Lvalue subroutines
+=head2 Unicode Support on EBCDIC Still Spotty
-=item Weak references
+Though mostly working, Unicode support still has problem spots on
+EBCDIC platforms. One such known spot are the C<\p{}> and C<\P{}>
+regular expression constructs for code points less than 256: the
+pP are testing for Unicode code points, not knowing about EBCDIC.
-=item The pseudo-hash data type
+=head2 The Compiler Suite Is Still Experimental
-=item The Compiler suite
+The compiler suite is slowly getting better but it continues to be
+highly experimental. Use in production environments is discouraged.
-=item Internal implementation of file globbing
+=head2 The Long Double Support Is Still Experimental
-=item The DB module
+The ability to configure Perl's numbers to use "long doubles",
+floating point numbers of hopefully better accuracy, is still
+experimental. The implementations of long doubles are not yet
+widespread and the existing implementations are not quite mature
+or standardised, therefore trying to support them is a rare
+and moving target. The gain of more precision may also be offset
+by slowdown in computations (more bits to move around, and the
+operations are more likely to be executed by less optimised
+libraries).
-=item The regular expression constructs C<(?{ code })> and C<(??{ code })>
+=head2 Seen In Perl 5.7 But Gone Now
-=back
+C<Time::Piece> (previously known as C<Time::Object>) was removed
+because it was felt that it didn't have enough value in it to be a
+core module. It is still a useful module, though, and is available
+from the CPAN.
-=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.
-There may also be information at http://www.perl.com/perl/, the Perl
-Home Page.
+If you find what you think is a bug, you might check the articles
+recently posted to the comp.lang.perl.misc newsgroup and the perl
+bug database at http://bugs.perl.org. There may also be
+information at http://www.perl.com/, the Perl Home Page.
If you believe you have an unreported bug, please run the B<perlbug>
program included with your release. Be sure to trim your bug down
to a tiny but sufficient test case. Your bug report, along with the
-output of C<perl -V>, will be sent off to perlbug@perl.com to be
+output of C<perl -V>, will be sent off to perlbug@perl.org to be
analysed by the Perl porting team.
=head1 SEE ALSO
=head1 HISTORY
-Written by Gurusamy Sarathy <F<gsar@activestate.com>>, with many
-contributions from The Perl Porters.
-
-Send omissions or corrections to <F<perlbug@perl.com>>.
+Written by Jarkko Hietaniemi <F<jhi@iki.fi>>.
=cut
https://perl5.git.perl.org / perl5.git / blobdiff