=head1 NAME
-perldelta - what's new for perl v5.6 (as of v5.005_64)
+perldelta - what's new for perl v5.7.0
=head1 DESCRIPTION
-This is an unsupported alpha release, meant for intrepid Perl
-developers only. The included sources may not even build correctly on
-some platforms. Subscribing to perl5-porters is the best way to
-monitor and contribute to the progress of development releases (see
-http://www.hut.fi/~jhi/perl5-porters.html for info).
-
-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.7.0 release.
+
+=head1 Security Vulnerability Closed
+
+A potential security vulnerability in the optional suidperl component
+of Perl has been identified. suidperl is neither built nor installed
+by default. As of August the 20th, 2000, the only known vulnerable
+platform is Linux, most likely all Linux distributions. CERT and
+various vendors have been alerted about the vulnerability.
+
+The problem was caused by Perl trying to report a suspected security
+exploit attempt using an external program, /bin/mail. On Linux
+platforms the /bin/mail program had an undocumented feature which gave
+access to a root shell, resulting in a serious compromise instead of
+reporting the exploit attempt. If you don't have /bin/mail, or if you
+have 'safe setuid scripts', or if suidperl is not installed, you
+are safe.
+
+The exploit attempt reporting feature has been completely removed from
+the Perl 5.7.0 release, so that particular vulnerability isn't there
+anymore. However, further security vulnerabilities are,
+unfortunately, always possible. The suidperl code is being reviewed
+and if deemed too risky to continue to be supported, it may be
+completely removed from future releases. In any case, suidperl should
+only be used by security experts who know exactly what they are doing
+and why they are using suidperl instead of some other solution such as
+sudo (see http://www.courtesan.com/sudo/).
=head1 Incompatible Changes
-=head2 Perl Source Incompatibilities
-
-Beware that any new warnings that have been added or old ones
-that have been enhanced are B<not> considered incompatible changes.
-
-Since all new warnings must be explicitly requested via the C<-w>
-switch or the C<warnings> pragma, it is ultimately the programmer's
-responsibility to ensure that warnings are enabled judiciously.
-
=over 4
-=item CHECK is a new keyword
-
-In addition to C<BEGIN>, C<INIT>, C<END>, C<DESTROY> and C<AUTOLOAD>,
-subroutines named C<CHECK> are now special. These are queued up during
-compilation and behave similar to END blocks, except they are called at
-the end of compilation rather than at the end of execution. They cannot
-be called directly.
-
-=item Treatment of list slices of undef has changed
-
-When taking a slice of a literal list (as opposed to a slice of
-an array or hash), Perl used to return an empty list if the
-result happened to be composed of all undef values.
-
-The new behavior is to produce an empty list if (and only if)
-the original list was empty. Consider the following example:
-
- @a = (1,undef,undef,2)[2,1,2];
-
-The old behavior would have resulted in @a having no elements.
-The new behavior ensures it has three undefined elements.
-
-Note in particular that the behavior of slices of the following
-cases remains unchanged:
-
- @a = ()[1,2];
- @a = (getpwent)[7,0];
- @a = (anything_returning_empty_list())[2,1,2];
- @a = @b[2,1,2];
- @a = @c{'a','b','c'};
-
-See L<perldata>.
-
-=head2 Perl's version numbering has changed
-
-Beginning with Perl version 5.6, the version number convention has been
-changed to a "dotted integer" scheme that is more commonly found in open
-source projects.
-
-Maintenance versions of v5.6.0 will be released as v5.6.1, v5.6.2 etc.
-The next development series following v5.6 will be numbered v5.7.x,
-beginning with v5.7.0, and the next major production release following
-v5.6 will be v5.8.
-
-The English module now sets $PERL_VERSION to $^V (a string value) rather
-than C<$]> (a numeric value). (This is a potential incompatibility.
-Send us a report via perlbug if you are affected by this.)
-
-The v1.2.3 syntax is also now legal in Perl.
-See L<Support for strings represented as a vector of ordinals> for more on that.
-
-To cope with the new versioning system's use of at least three significant
-digits for each version component, the method used for incrementing the
-subversion number has also changed slightly. We assume that versions older
-than v5.6 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 amounts to a floating point
-value of 5.006_001).
-
-=item Literals of the form C<1.2.3> parse differently
-
-Previously, numeric literals with more than one dot in them were
-interpreted as a floating point number concatenated with one or more
-numbers. Such "numbers" are now parsed as strings composed of the
-specified ordinals.
-
-For example, C<print 97.98.99> used to output C<97.9899> in earlier
-versions, but now prints C<abc>.
-
-See L<Support for strings represented as a vector of ordinals> below.
-
-=item Possibly changed pseudo-random number generator
-
-In 5.005_0x and earlier, perl's rand() function used the C library
-rand(3) function. As of 5.005_52, Configure tests for drand48(),
-random(), and rand() (in that order) and picks the first one it finds.
-Perl programs that depend on reproducing a specific set of pseudo-random
-numbers will now likely produce different output. You can use
-C<sh Configure -Drandfunc=rand> to obtain the old behavior.
-
-=item Hashing function for hash keys has changed
-
-Perl hashes are not order preserving. The apparently random order
-encountered when iterating on the contents of a hash is determined
-by the hashing algorithm used. To improve the distribution of lower
-bits in the hashed value, the algorithm has changed slightly as of
-5.005_52. When iterating over hashes, this may yield a random order
-that is B<different> from that of previous versions.
-
-=item C<undef> fails on read only values
-
-Using the C<undef> operator on a readonly value (such as $1) has
-the same effect as assigning C<undef> to the readonly value--it
-throws an exception.
-
-=item Close-on-exec bit may be set on pipe and socket handles
-
-On systems that support a close-on-exec flag on filehandles, the
-flag will be set for any handles created by pipe(), socketpair(),
-socket(), and accept(), if that is warranted by the value of $^F
-that may be in effect. Earlier versions neglected to set the flag
-for handles created with these operators. See L<perlfunc/pipe>,
-L<perlfunc/socketpair>, L<perlfunc/socket>, L<perlfunc/accept>,
-and L<perlvar/$^F>.
-
-=item Writing C<"$$1"> to mean C<"${$}1"> is unsupported
-
-Perl 5.004 deprecated the interpretation of C<$$1> and
-similar within interpolated strings to mean C<$$ . "1">,
-but still allowed it.
-
-In Perl 5.6 and later, C<"$$1"> always means C<"${$1}">.
-
-=item delete(), values() and C<\(%h)> operate on aliases to values, not copies
-
-delete(), each(), values() and hashes in a list context return the actual
-values in the hash, instead of copies (as they used to in earlier
-versions). Typical idioms for using these constructs copy the
-returned values, but this can make a significant difference when
-creating references to the returned values.
-
-Keys in the hash are still returned as copies when iterating on
-a hash.
-
-=item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS
-
-vec() generates a run-time error if the BITS argument is not
-a valid power-of-two integer.
+=item *
-=item Text of some diagnostic output has changed
+Arrays now always interpolate into double-quoted strings:
+constructs like "foo@bar" now always assume C<@bar> is an array,
+whether or not the compiler has seen use of C<@bar>.
-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
+The semantics of bless(REF, REF) were unclear and until someone proves
+it to make some sense, it is forbidden.
-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
+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.
-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 obsolete chat2 library that should never have been allowed
+to escape the laboratory has been decommissioned.
- 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:
+lstat(FILEHANDLE) now gives a warning because the operation makes no sense.
+In future releases this may become a fatal error.
- print not((1,2,3)[0]);
+=item *
-The behavior remains unaffected when C<not> is not followed by parentheses.
+The long deprecated uppercase aliases for the string comparison
+operators (EQ, NE, LT, LE, GE, GT) have now been removed.
-=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>.
+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.
-=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 (say C<perl -V> and see what is
-your ivsize: if it is 8, you are 64-bit) , be warned that the
-semantics of all the bitwise numeric operators (& | ^ ~ << >>) have
-been changed. They used to be forced to be 32 bits wide, but now in
-the aforementioned platforms they are 64 bits wide. Most dramatically
-this affects the unary ~: what used to be 32 bits wide, is now 64 bits
-wide. If you depend on your integers being 32 bits wide, mask off the
-excess bits with C<& 0xffffffff>.
+The tr///C and tr///U features have been removed and will not return;
+the interface was a mistake. Sorry about that. For similar
+functionality, see pack('U0', ...) and pack('C0', ...).
=back
-=head2 C Source Incompatibilities
+=head1 Core Enhancements
=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, 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:
+C<perl -d:Module=arg,arg,arg> now works (previously one couldn't pass
+in multiple arguments.)
- perl Makefile.PL POLLUTE=1
+=item *
-=item C<PERL_IMPLICIT_CONTEXT>
+my __PACKAGE__ now works.
-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.
+=item *
-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.
+C<no Module;> now works even if there is no "sub unimport" in the Module.
-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.
+=item *
-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).
+The numerical comparison operators return C<undef> if either operand
+is a NaN. Previously the behaviour was unspecified.
-See L<perlguts/"The Perl API"> for detailed information on the
-ramifications of building Perl using this option.
+=item *
-=item C<PERL_POLLUTE_MALLOC>
+C<pack('U0a*', ...)> can now be used to force a string to UTF8.
-Enabling Perl's malloc in release 5.005 and earlier caused
-the namespace of system versions of the malloc family of functions to
-be usurped by the Perl versions, since by default they used the
-same names.
+=item *
-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.
+prototype(\&) is now available.
-As of release 5.6, Perl's malloc family of functions have default names
-distinct from the system versions. You need to explicitly compile perl with
-C<-DPERL_POLLUTE_MALLOC> to get the older behaviour. HIDEMYMALLOC
-and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now
-the default.
+=item *
-Note that these functions do B<not> constitute Perl's memory allocation API.
-See L<perlguts/"Memory Allocation"> for further information about that.
+There is now an UNTIE method.
=back
-=head2 Compatible C Source API Changes
+=head1 Modules and Pragmata
-=over
+=head2 New Modules
-=item C<PATCHLEVEL> is now C<PERL_VERSION>
+=over 4
-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.
+File::Temp allows one to create temporary files and directories in an
+easy, portable, and secure way.
-=item Support for C++ exceptions
+=item *
-change#3386, also needs perlguts documentation
-[TODO - Chip Salzenberg <chip@perlsupport.com>]
+Storable gives persistence to Perl data structures by allowing the
+storage and retrieval of Perl data to and from files in a fast and
+compact binary format.
=back
-=head2 Binary Incompatibilities
-
-In general, the default build of this release is expected to be binary
-compatible for extensions built with the 5.005 release or its maintenance
-versions. However, specific platforms may have broken binary compatibility
-due to changes in the defaults used in hints files. Therefore, please be
-sure to always check the platform-specific README files for any notes to
-the contrary.
-
-The usethreads or usemultiplicity builds are B<not> binary compatible
-with the corresponding builds in 5.005.
-
-On platforms that require an explicit list of exports (AIX, OS/2 and Windows,
-among others), purely internal symbols such as parser functions and the
-run time opcodes are not exported by default. Perl 5.005 used to export
-all functions irrespective of whether they were considered part of the
-public API or not.
-
-For the full list of public API functions, see L<perlapi>.
-
-=head1 Installation and Configuration Improvements
-
-=head2 -Dusethreads means something different
-
-WARNING: Support for threads continues to be an experimental feature.
-Interfaces and implementation are subject to sudden and drastic changes.
-
-The -Dusethreads flag now enables the experimental interpreter-based thread
-support by default. To get the flavor of experimental threads that was in
-5.005 instead, you need to ask for -Duse5005threads.
-
-As of v5.5.640, interpreter-threads support is still lacking a way to
-create new threads from Perl (i.e., C<use Thread;> will not work with
-interpreter threads). C<use Thread;> continues to be available when you
-ask for -Duse5005threads, bugs and all.
-
-=head2 New Configure flags
-
-The following new flags may be enabled on the Configure command line
-by running Configure with C<-Dflag>.
-
- usemultiplicity
- use5005threads
-
- use64bitint (equal to now deprecated 'use64bits')
- use64bitall
-
- uselongdouble
- usemorebits
- uselargefiles
- usesocks (only SOCKS v5 supported)
-
-=head2 Threadedness and 64-bitness now more daring
-
-The Configure options enabling the use of threads and the use of
-64-bitness are now more daring in the sense that they no more have an
-explicit list of operating systems of known threads/64-bit
-capabilities. In other words: if your operating system has the
-necessary APIs and datatypes, you should be able just to go ahead and
-use them, for threads by Configure -Dusethreads, and for 64 bits
-either explicitly by Configure -Duse64bitint or implicitly if your
-system has 64 bit wide datatypes. See also L<"64-bit support">.
-
-=head2 Long Doubles
-
-Some platforms have "long doubles", floating point numbers of even
-larger range than ordinary "doubles". To enable using long doubles for
-Perl's scalars, use -Duselongdouble.
-
-=head2 -Dusemorebits
-
-You can enable both -Duse64bitint and -Dlongdouble by -Dusemorebits.
-See also L<"64-bit support">.
-
-=head2 -Duselargefiles
-
-Some platforms support large files, files larger than two gigabytes.
-See L<"Large file support"> for more information.
-
-=head2 installusrbinperl
-
-You can use "Configure -Uinstallusrbinperl" which causes installperl
-to skip installing perl also as /usr/bin/perl. This is useful if you
-prefer not to modify /usr/bin for some reason or another but harmful
-because many scripts assume to find Perl in /usr/bin/perl.
-
-=head2 SOCKS support
-
-You can use "Configure -Dusesocks" which causes Perl to probe
-for the SOCKS (v5, not v4) proxy protocol library,
-http://www.socks.nec.com/
-
-=head2 C<-A> flag
-
-You can "post-edit" the Configure variables using the Configure C<-A>
-flag. The editing happens immediately after the platform specific
-hints files have been processed but before the actual configuration
-process starts. Run C<Configure -h> to find out the full C<-A> syntax.
-
-=head2 Enhanced Installation Directories
-
-The installation structure has been enriched to improve the support
-for maintaining multiple versions of perl, to provide locations for
-vendor-supplied modules, scripts, and manpages, and to ease maintenance
-of locally-added modules, scripts, and manpages. See the section on
-Installation Directories in the INSTALL file for complete details.
-For most users building and installing from source, the defaults should
-be fine.
-
-If you previously used C<Configure -Dsitelib> or C<-Dsitearch> to set
-special values for library directories, you might wish to consider using
-the new C<-Dsiteprefix> setting instead. Also, if you wish to re-use a
-config.sh file from an earlier version of perl, you should be sure to
-check that Configure makes sensible choices for the new directories.
-See INSTALL for complete details.
-
-=head1 Core Changes
-
-=head2 Unicode and UTF-8 support
-
-Perl can optionally use UTF-8 as its internal representation for character
-strings. The C<utf8> and C<bytes> pragmas are used to control this support
-in the current lexical scope. See L<perlunicode>, L<utf8> and L<bytes> for
-more information.
-
-=head2 Interpreter cloning, threads, and concurrency
-
-WARNING: This is an experimental feature in a pre-alpha state. Use
-at your own risk.
+=head2 Updated And Improved Modules and Pragmata
-Perl 5.005_63 introduces the beginnings of support for running multiple
-interpreters concurrently in different threads. In conjunction with
-the perl_clone() API call, which can be used to selectively duplicate
-the state of any given interpreter, it is possible to compile a
-piece of code once in an interpreter, clone that interpreter
-one or more times, and run all the resulting interpreters in distinct
-threads.
-
-On Windows, this feature is used to emulate fork() at the interpreter
-level. See L<perlfork>.
-
-This feature is still in evolution. It is eventually meant to be used
-to selectively clone a subroutine and data reachable from that
-subroutine in a separate interpreter and run the cloned subroutine
-in a separate thread. Since there is no shared data between the
-interpreters, little or no locking will be needed (unless parts of
-the symbol table are explicitly shared). This is obviously intended
-to be an easy-to-use replacement for the existing threads support.
-
-Support for cloning interpreters and interpreter concurrency can be
-enabled using the -Dusethreads Configure option (see win32/Makefile for
-how to enable it on Windows.) The resulting perl executable will be
-functionally identical to one that was built with -Dmultiplicity, but
-the perl_clone() API call will only be available in the former.
-
--Dusethreads enables, the cpp macros USE_ITHREADS by default, which enables
-Perl source code changes that provide a clear separation between the op tree
-and the data it operates with. The former is considered immutable, and can
-therefore be shared between an interpreter and all of its clones, while the
-latter is considered local to each interpreter, and is therefore copied for
-each clone.
-
-Note that building Perl with the -Dusemultiplicity Configure option
-is adequate if you wish to run multiple B<independent> interpreters
-concurrently in different threads. -Dusethreads only provides the
-additional functionality of the perl_clone() API call and other
-support for running B<cloned> interpreters concurrently.
-
-[XXX TODO - the Compiler backends may be broken when USE_ITHREADS is
-enabled.]
-
-=head2 Lexically scoped warning categories
-
-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.
-
-=head2 Lvalue subroutines
-
-WARNING: This is an experimental feature.
-
-change#4081
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>,
-Tuomas Lukka <lukka@iki.fi>)]
-
-=head2 "our" declarations
-
-An "our" declaration introduces a value that can be best understood
-as a lexically scoped symbolic alias to a global variable in the
-package that was current where the variable was declared. This is
-mostly useful as an alternative to the C<vars> pragma, but also provides
-the opportunity to introduce typing and other attributes for such
-variables. See L<perlfunc/our>.
-
-=head2 Support for strings represented as a vector of ordinals
-
-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>.
-
-Strings written in this form are also useful to represent version "numbers".
-It is easy to compare such version "numbers" (which are really just plain
-strings) using any of the usual string comparison operators C<eq>, C<ne>,
-C<lt>, C<gt>, etc., or perform bitwise string operations on them using C<|>,
-C<&>, etc.
-
-In conjunction with the new C<$^V> magic variable (which contains
-the perl version as a string), such literals can be used as a readable way
-to check if you're running a particular version of Perl:
-
- # this will parse in older versions of Perl also
- if ($^V and $^V gt v5.5.640) {
- # new features supported
- }
-
-C<require> and C<use> also have some special magic to support such literals.
-They will be interpreted as a version rather than as a module name:
-
- require v5.6.0; # croak if $^V lt v5.6.0
- use v5.6.0; # same, but croaks at compile-time
+=over 4
-Alternatively, the C<v> may be omitted if there is more than one dot:
+=item *
- require 5.6.0;
- use 5.6.0;
+The following independently supported modules have been updated to
+newer versions from CPAN: CGI, CPAN, DB_File, File::Spec, Getopt::Long,
+the podlators bundle, Pod::LaTeX, Pod::Parser, Term::ANSIColor, Test.
-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
+Bug fixes and minor enhancements have been applied to B::Deparse,
+Data::Dumper, IO::Poll, IO::Socket::INET, Math::BigFloat,
+Math::Complex, Math::Trig, Net::protoent, re, SelfLoader, Sys::SysLog,
+Test::Harness, Text::Wrap, UNIVERSAL.
-See L<perlop/"Strings of Character"> for additional information.
+=item *
-=head2 Weak references
+The attributes::reftype() now works on tied arguments.
-WARNING: This is an experimental feature.
+=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.
+AutoLoader can now be disabled with C<no AutoLoader;>,
-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 English module can now be used without the infamous performance
+hit by saying
-To use this feature, you need the WeakRef package from CPAN, which
-contains additional documentation.
+ use English '-no_performance_hit';
-change#3385, also need perlguts documentation
-[TODO - Tuomas Lukka <lukka@iki.fi>]
+(Assuming, of course, that one doesn't need the troublesome variables
+C<$`>, C<$&>, or C<$'>.) Also, introduce C<@LAST_MATCH_START> and
+C<@LAST_MATCH_END> English aliases for C<@-> and C<@+>.
-=head2 File globbing implemented internally
+=item *
-WARNING: This is currently an experimental feature. Interfaces and
-implementation are likely to change.
+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.
-Perl now uses the File::Glob implementation of the glob() operator
-automatically. This avoids using an external csh process and the
-problems associated with it.
+=item *
-=head2 Binary numbers supported
+File::Glob::glob() renamed to File::Glob::bsd_glob() to avoid
+prototype mismatch with CORE::glob().
-Binary numbers are now supported as literals, in s?printf formats, and
-C<oct()>:
+=item *
- $answer = 0b101010;
- printf "The answer is: %b\n", oct("0b101010");
+IPC::Open3 now allows the use of numeric file descriptors.
-=head2 Some arrows may be omitted in calls through references
+=item *
-Perl now allows the arrow to be omitted in many constructs
-involving subroutine calls through references. For example,
-C<$foo[10]-E<gt>('foo')> may now be written C<$foo[10]('foo')>.
-This is rather similar to how the arrow may be omitted from
-C<$foo[10]-E<gt>{'foo'}>. Note however, that the arrow is still
-required for C<foo(10)-E<gt>('bar')>.
+use lib now works identically to @INC. Removing directories
+with 'no lib' now works.
-=head2 exists() is supported on subroutine names
+=item *
-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.
+C<%INC> now localised in a Safe compartment so that use/require work.
-=head2 exists() and delete() are supported on array elements
+=item *
-The exists() and delete() builtins now work on simple arrays as well.
-The behavior is similar to that on hash elements.
+The Shell module now has an OO interface.
-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.
+=back
-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.
+=head1 Utility Changes
-See L<perlfunc/exists> and L<perlfunc/delete> for examples.
+=over 4
-=head2 syswrite() ease-of-use
+=item *
-The length argument of C<syswrite()> has become optional.
+The Emacs perl mode (emacs/cperl-mode.el) has been updated to version 4.31.
-=head2 File and directory handles can be autovivified
+=item *
-Similar to how constructs such as C<$x-E<gt>[0]> autovivify a reference,
-handle constructors (open(), opendir(), pipe(), socketpair(), sysopen(),
-socket(), and accept()) now autovivify a file or directory handle
-if the handle passed to them is an uninitialized scalar variable. This
-allows the constructs such as C<open(my $fh, ...)> and C<open(local $fh,...)>
-to be used to create filehandles that will conveniently be closed
-automatically when the scope ends, provided there are no other references
-to them. This largely eliminates the need for typeglobs when opening
-filehandles that must be passed around, as in the following example:
+Perlbug is now much more robust. It also sends the bug report to perl.org,
+not perl.com.
- sub myopen {
- open my $fh, "@_"
- or die "Can't open '@_': $!";
- return $fh;
- }
+=item *
- {
- my $f = myopen("</etc/motd");
- print <$f>;
- # $f implicitly closed here
- }
+The perlcc utility has been rewritten and its user interface (that is,
+command line) is much more like that of the UNIX C compiler, cc.
-[TODO - this idiom needs more pod penetration]
+=item *
-=head2 64-bit support
+The xsubpp utility for extension writers now understands POD
+documentation embedded in the *.xs files.
- NOTE: The Configure flags -Duselonglong and -Duse64bits
- have been deprecated. Use -Duse64bitint instead.
+=back
-Any platform that has 64-bit integers either (a) natively as longs or
-ints (b) via special compiler flags (c) using long long are able to
-use "quads" (64-integers) as follows:
+=head1 New Documentation
=over 4
=item *
-constants (decimal, hexadecimal, octal, binary) in the code
+perl56delta details the changes between the 5.005 release and the
+5.6.0 release.
=item *
-arguments to oct() and hex()
+perldebtut is a Perl debugging tutorial.
=item *
-arguments to print(), printf() and sprintf() (flag prefixes ll, L, q)
+perlebcdic contains considerations for running Perl on EBCDIC platforms.
+Note that unfortunately EBCDIC platforms that used to supported back in
+Perl 5.005 are still unsupported by Perl 5.7.0; the plan, however, is to
+bring them back to the fold.
=item *
-printed as such
+perlnewmod tells about writing and submitting a new module.
=item *
-pack() and unpack() "q" and "Q" formats
+perlposix-bc explains using Perl on the POSIX-BC platform
+(an EBCDIC mainframe platform).
=item *
-in basic arithmetics: + - * / % (NOTE: operating close to the limits
-of the integer values may produce surprising results)
+perlretut is a regular expression tutorial.
=item *
-in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced
-to be 32 bits wide.)
+perlrequick is a regular expressions quick-start guide.
+Yes, much quicker than perlretut.
=item *
-vec()
+perlutil explains the command line utilities packaged with the Perl
+distribution.
=back
-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 one does only as much as is
-required to get 64-bit integers into Perl (this may mean, for example,
-using "long longs") while your memory may still be limited to 2
-gigabytes (because your pointers most likely are 32-bit); the second
-one goes all the way by attempting to switch also longs (and pointers)
-being 64-bit. This may create an even more binary incompatible Perl
-than -Duse64bitint: the resulting executable may not run at all in a
-CPU-bit box, or you may have to reboot/reconfigure/rebuild your
-operating system to be 64-bit aware.
-
-Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint
-nor -Duse64bitall.
-
-Last but not least: note that due to Perl's habit of always using
-floating point numbers the quads are still not true integers.
-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 (their lower digits).
-
-=head2 Large file support
-
-If you have filesystems that support "large files" (files larger than
-2 gigabytes), you may now also be able to create and access them from
-Perl. You have to use Configure -Duselargefiles. Turning on the
-large file support turns on also the 64-bit support on many platforms.
-Beware that unless your filesystem also supports "sparse files" seeking
-to umpteen petabytes may be unadvisable.
-
-Note that in addition to requiring a proper file system to do large
-files you may also need to adjust your per-process (or your
-per-system, or per-process-group, or per-user-group) maximum filesize
-limits before running Perl scripts that try to handle large files,
-especially if you intend to write such files.
-
-Finally, in addition to your process/process group maximum filesize
-limits, you may have quota limits on your filesystems that stop you
-(your user id or your user group id) from using large files.
-
-Adjusting your process/user/group/file system/operating system limits
-is outside the scope of Perl core language. For process limits, you
-may try increasing the limits using your shell's limits/limit/ulimit
-command before running Perl. The BSD::Resource extension (not
-included with the standard Perl distribution) may also be of use, it
-offers the getrlimit/setrlimit interface that can be used to adjust
-process resource usage limits, including the maximum filesize limit.
+=head1 Performance Enhancements
-=head2 Long doubles
+=over 4
-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).
+=item *
-=head2 "more bits"
+map() that changes the size of the list should now work faster.
-You can "Configure -Dusemorebits" to turn on both the 64-bit support
-and the long double support.
+=item *
-=head2 Enhanced support for sort() subroutines
+sort() has been changed to use mergesort internally as opposed to the
+earlier quicksort. For very small lists this may result in slightly
+slower sorting times, but in general the speedup should be at least 20%.
+Additional bonuses are that the worst case behaviour of sort() is now
+better (in computer science terms it now runs in time O(N log N), as
+opposed to quicksorts 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).
-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>.
+=back
-For unprototyped sort subroutines, the historical behavior of passing
-the elements to be compared as the global variables $a and $b remains
-unchanged.
+=head1 Installation and Configuration Improvements
-=head2 Better syntax checks on parenthesized unary operators
+=head2 Generic Improvements
-Expressions such as:
+=over 4
- print defined(&foo,&bar,&baz);
- print uc("foo","bar","baz");
- undef($foo,&bar);
+=item *
-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.
+INSTALL now explains how you can configure perl to use 64-bit
+integers even on non-64-bit platforms.
-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:
+=item *
- print defined &foo, &bar, &baz;
- print uc "foo", "bar", "baz";
- undef $foo, &bar;
+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.
-remains unchanged. See L<perlop>.
+=item *
-=head2 POSIX character class syntax [: :] supported
+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.
-For example to match alphabetic characters use /[[:alpha:]]/.
-See L<perlre> for details.
+=item *
-=head2 Improved C<qw//> operator
+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.
-The C<qw//> operator is now evaluated at compile time into a true list
-instead of being replaced with a run time call to C<split()>. This
-removes the confusing misbehaviour of C<qw//> in scalar context, which
-had inherited that behaviour from split().
+=item *
-Thus:
+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.
- $foo = ($bar) = qw(a b c); print "$foo|$bar\n";
+=item *
-now correctly prints "3|a", instead of "2|a".
+If binary compatibility with the 5.005 release is not wanted, Configure
+no longer suggests including the 5.005 modules in @INC.
-=head2 pack() format 'Z' supported
+=item *
-The new format type 'Z' is useful for packing and unpacking null-terminated
-strings. See L<perlfunc/"pack">.
+Configure C<-S> can now run non-interactively.
-=head2 pack() format modifier '!' supported
+=item *
-The new format type modifier '!' is useful for packing and unpacking
-native shorts, ints, and longs. See L<perlfunc/"pack">.
+configure.gnu now works with options with whitespace in them.
-=head2 pack() and unpack() support counted strings
+=item *
-The template character '/' can be used to specify a counted string
-type to be packed or unpacked. See L<perlfunc/"pack">.
+installperl now outputs everything to STDERR.
-=head2 Comments in pack() templates
+=item *
-The '#' character in a template introduces a comment up to
-end of the line. This facilitates documentation of pack()
-templates.
+$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.)
-=head2 $^X variables may now have names longer than one character
+=back
-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.
+=head1 Selected Bug Fixes
-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.
+=over 4
-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.
+=item *
-=head2 C<use attrs> implicit in subroutine attributes
+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.
-Formerly, if you wanted to mark a subroutine as being a method call or
-as requiring an automatic lock() when it is entered, you had to declare
-that with a C<use attrs> pragma in the body of the subroutine.
-That can now be accomplished with declaration syntax, like this:
+=item *
- sub mymethod : locked method ;
- ...
- sub mymethod : locked method {
- ...
- }
+C<*foo{FORMAT}> now works.
- sub othermethod :locked :method ;
- ...
- sub othermethod :locked :method {
- ...
- }
+=item *
+Lexical warnings now propagating correctly between scopes.
-(Note how only the first C<:> is mandatory, and whitespace surrounding
-the C<:> is optional.)
+=item *
-F<AutoSplit.pm> and F<SelfLoader.pm> have been updated to keep the attributes
-with the stubs they provide. See L<attributes>.
+Line renumbering with eval and C<#line> now works.
-=head2 Regular expression improvements
+=item *
-change#2827,2373,2372,2365,1813,1800,4112,4158,4215,4301
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+Fixed numerous memory leaks, especially in eval "".
-=head2 Overloading improvements
+=item *
-change#2150
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+Modulus of unsigned numbers now works (4063328477 % 65535 used to
+return 27406, instead of 27047).
-=head2 open() with more than two arguments
+=item *
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+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.
-=head2 Support for interpolating named characters
+=item *
-change#4052
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+our() variables will not cause "will not stay shared" warnings.
-=head2 Experimental support for user-hooks in @INC
+=item *
-[TODO - Ken Fox <kfox@ford.com>]
+pack "Z" now correctly terminates the string with "\0".
-=head2 C<require> and C<do> may be overridden
+=item *
-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">.
+Fix password routines which in some shadow password platforms
+(e.g. HP-UX) caused getpwent() to return every other entry.
-=head2 New variable $^C reflects C<-c> switch
+=item *
-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>.
+printf() no longer resets the numeric locale to "C".
-=head2 New variable $^V contains Perl version in v5.6.0 format
+=item *
-C<$^V> contains the Perl version number as a string composed of
-characters whose ordinals match the version numbers, so that it may
-be used in string comparisons.
+C<q(a\\b)> now parses correctly as C<'a\\b'>.
-See C<Support for strings represented as a vector of ordinals> for an
-example.
+=item *
-=head2 Optional Y2K warnings
+Printing quads (64-bit integers) with printf/sprintf now works
+without the q L ll prefixes (assuming you are on a quad-capable platform).
-If Perl is built with the cpp macro C<PERL_Y2KWARN> defined,
-it emits optional warnings when concatenating the number 19
-with another number.
+=item *
-This behavior must be specifically enabled when running Configure.
-See F<INSTALL> and F<README.Y2K>.
+Regular expressions on references and overloaded scalars now work.
-=head1 Significant bug fixes
+=item *
-=head2 E<lt>HANDLEE<gt> on empty files
+scalar() now forces scalar context even when used in void context.
-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>.
+=item *
+
+sort() arguments are now compiled in the right wantarray context
+(they were accidentally using the context of the sort() itself).
-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
+Changed the POSIX character class C<[[:space:]]> to include the (very
+rare) vertical tab character. Added a new POSIX-ish character class
+C<[[:blank:]]> which stands for horizontal whitespace (currently,
+the space and the tab).
-The behaviour of:
+=item *
- perl -pi -e 's/^/foo/' empty_file
+$AUTOLOAD, sort(), lock(), and spawning subprocesses
+in multiple threads simultaneously are now thread-safe.
-is unchanged (it continues to leave the file empty).
+=item *
-=head2 C<eval '...'> improvements
+Allow read-only string on left hand side of non-modifying tr///.
-Line numbers (as reflected by caller() and most diagnostics) within
-C<eval '...'> were often incorrect when 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.
+Several Unicode fixes (but still not perfect).
-Parsing of here documents used to be flawed when they appeared as
-the replacement expression in C<eval 's/.../.../e'>. This has
-been fixed.
+=over 8
-=head2 All compilation errors are true errors
+=item *
-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.
+BOMs (byte order marks) in the beginning of Perl files
+(scripts, modules) should now be transparently skipped.
+UTF16 encoded Perl files should now be read correctly.
-The mechanism for reporting such errors has been reimplemented
-to queue compile-time errors and report them at the end of the
-compilation as true errors rather than as warnings. This fixes
-cases where error messages leaked through in the form of warnings
-when code was compiled at run time using C<eval STRING>, and
-also allows such errors to be reliably trapped using __DIE__ hooks.
+=item *
-=head2 Automatic flushing of output buffers
+The character tables have been updated to new Unicode 3.0 features.
-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 *
-=head2 Better diagnostics on meaningless filehandle operations
+chr() for values greater than 127 now create utf8 when under use
+utf8.
-Constructs such as C<open(E<lt>FHE<gt>)> and C<close(E<lt>FHE<gt>)>
-are compile time errors. Attempting to read from filehandles that
-were opened only for writing will now produce warnings (just as
-writing to read-only filehandles does).
+=item *
-=head2 Where possible, buffered data discarded from duped input filehandle
+Comparing with utf8 data does not magically upgrade non-utf8 data into
+utf8.
-C<open(NEW, "E<lt>&OLD")> now attempts to discard any data that
-was previously read and buffered in C<OLD> before duping the handle.
-On platforms where doing this is allowed, the next read operation
-on C<NEW> will return the same data as the corresponding operation
-on C<OLD>. Formerly, it would have returned the data from the start
-of the following disk block instead.
+=item *
-=head2 eof() has the same old magic as <>
+C<IsAlnum>, C<IsAlpha>, and C<IsWord> now match titlecase.
-C<eof()> would return true if no attempt to read from C<E<lt>E<gt>> had
-yet been made. C<eof()> has been changed to have a little magic of its
-own, it now opens the C<E<lt>E<gt>> files.
+=item *
-=head2 system(), backticks and pipe open now reflect exec() failure
+Concatenation with the C<.> operator or via variable interpolation,
+C<eq>, C<substr>, C<reverse>, C<quotemeta>, the C<x> operator,
+substitution with C<s///>, single-quoted UTF8, should now work--in
+theory.
-On Unix and similar platforms, system(), qx() and open(FOO, "cmd |")
-etc., are implemented via fork() and exec(). When the underlying
-exec() fails, earlier versions did not report the error properly,
-since the exec() happened to be in a different process.
+=item *
-The child process now communicates with the parent about the
-error in launching the external command, which allows these
-constructs to return with their usual error value and set $!.
+The C<tr///> operator now works I<slightly> better but is still rather
+broken. Note that the C<tr///CU> functionality has been removed (but
+see pack('U0', ...)).
-=head2 Implicitly closed filehandles are safer
+=item *
-Sometimes implicitly closed filehandles (as when they are localized,
-and Perl automatically closes them on exiting the scope) could
-inadvertently set $? or $!. This has been corrected.
+Zero entries were missing from the Unicode classes like C<IsDigit>.
-=head2 C<(\$)> prototype and C<$foo{a}>
+=back
-An scalar reference prototype now correctly allows a hash or
-array element in that slot.
+=item *
-=head2 Pseudo-hashes work better
+UNIVERSAL::isa no longer caches methods incorrectly. (This broke
+the Tk extension with 5.6.0.)
-Dereferencing some types of reference values in a pseudo-hash,
-such as C<$ph-E<gt>{foo}[1]>, was accidentally disallowed. This has
-been corrected.
+=back
-When applied to a pseudo-hash element, exists() now reports whether
-the specified value exists, not merely if the key is valid.
+=head2 Platform Specific Changes and Fixes
-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">.
+=over 4
-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>.
+BSDI 4.*
-=head2 C<goto &sub> and AUTOLOAD
+Perl now works on post-4.0 BSD/OSes.
-The C<goto &sub> construct works correctly when C<&sub> happens
-to be autoloaded.
+=item *
-=head2 C<-bareword> allowed under C<use integer>
+All BSDs
-The autoquoting of barewords preceded by C<-> did not work
-in prior versions when the C<integer> pragma was enabled.
-This has been fixed.
+Setting C<$0> now works (as much as possible; see perlvar for details).
-=head2 Boolean assignment operators are legal lvalues
+=item *
-Constructs such as C<($a ||= 2) += 1> are now allowed.
+Cygwin
-=head2 C<sort $coderef @foo> allowed
+Numerous updates; currently synchronised with Cygwin 1.1.4.
-sort() did not accept a subroutine reference as the comparison
-function in earlier versions. This is now permitted.
+=item *
-=head2 Failures in DESTROY()
+EPOC
-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.
+EPOC update after Perl 5.6.0. See README.epoc.
-=head2 Locale bugs fixed
+=item *
-printf() and sprintf() previously reset the numeric locale
-back to the default "C" locale. This has been fixed.
+FreeBSD 3.*
-Numbers formatted according to the local numeric locale
-(such as using a decimal comma instead of a decimal dot) caused
-"isn't numeric" warnings, even while the operations accessing
-those numbers produced correct results. The warnings are gone.
+Perl now works on post-3.0 FreeBSDs.
-=head2 Memory leaks
+=item *
-The C<eval 'return sub {...}'> construct could sometimes leak
-memory. This has been fixed.
+HP-UX
-Operations that aren't filehandle constructors used to leak memory
-when used on invalid filehandles. This has been fixed.
+README.hpux updated; C<Configure -Duse64bitall> now almost works.
-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
+IRIX
-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.
+Numerous compilation flag and hint enhancements; accidental mixing
+of 32-bit and 64-bit libraries (a doomed attempt) made much harder.
-=head2 Consistent numeric conversions
+=item *
-change#3378,3318
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+Linux
-=head2 Taint failures under C<-U>
+Long doubles should now work (see INSTALL).
-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
+MacOS Classic
-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.
+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.
-See L<CHECK blocks> for how to run things when the compile phase ends.
+=item *
-=head2 Potential to leak DATA filehandles
+MPE/iX
-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.
+MPE/iX update after Perl 5.6.0. See README.mpeix.
-This caveat is now better explained in the documentation.
-See L<perldata>.
+=item *
-=head2 Diagnostics follow STDERR
+NetBSD/sparc
-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>.
+Perl now works on NetBSD/sparc.
-=head2 Other fixes for better diagnostics
+=item *
-Line numbers are no longer suppressed (under most likely circumstances)
-during the global destruction phase.
+OS/2
-Diagnostics emitted from code running in threads other than the main
-thread are now accompanied by the thread ID.
+Now works with usethreads (see INSTALL).
-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 foo.
+Solaris
-Unrecognized alphabetic escapes encountered when parsing quote
-constructs now generate a warning, since they may take on new
-semantics in later versions of Perl.
+64-bitness using the Sun Workshop compiler now works.
-=head1 Performance enhancements
+=item *
-=head2 Simple sort() using { $a <=> $b } and the like are optimized
+Tru64 (aka Digital UNIX, aka DEC OSF/1)
-Many common sort() operations using a simple inlined block are now
-optimized for faster performance.
+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.
-=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.
+Unicos
-=head2 Method lookups optimized
+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.
-[TODO - Chip Salzenberg <chip@perlsupport.com>]
+=item *
-=head2 Faster mechanism to invoke XSUBs
+VMS
-change#4044,4125
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+chdir() now works better despite a CRT bug; now works with MULTIPLICITY
+(see INSTALL); now works with Perl's malloc.
-=head2 Perl_malloc() improvements
+=item *
-change#4237
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+Windows
-=head2 Faster subroutine calls
+=over 8
-Minor changes in how subroutine calls are handled internally
-provide marginal improvements in performance.
+=item *
-=head1 Platform specific changes
+accept() no longer leaks memory.
-=head2 Additional supported platforms
+=item *
-=over 4
+Better chdir() return value for a non-existent directory.
=item *
-VM/ESA is now supported.
+New %ENV entries now propagate to subprocesses.
=item *
-Siemens BS2000 is now supported under the POSIX Shell.
+$ENV{LIB} now used to search for libs under Visual C.
=item *
-The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread
-extension.
+A failed (pseudo)fork now returns undef and sets errno to EAGAIN.
=item *
-GNU/Hurd is now supported.
+Allow REG_EXPAND_SZ keys in the registry.
=item *
-Rhapsody is now supported.
+Can now send() from all threads, not just the first one.
=item *
-EPOC is is now supported (on Psion 5).
-
-=back
+Fake signal handling reenabled, bugs and all.
-=head2 DOS
+=item *
-=over 4
+Less stack reserved per thread so that more threads can run
+concurrently. (still 16M perl thread)
=item *
-Perl now works with djgpp 2.02 (and 2.03 alpha).
+C<File::Spec->tmpdir()> now prefers C:/temp over /tmp
+(works better when perl running as service).
=item *
-Environment variable names are not converted to uppercase any more.
+Better UNC path handling under ithreads.
=item *
-Wrong exit code from backticks now fixed.
+wait() and waitpid() now work much better.
=item *
-This port is still using its own builtin globbing.
+winsock handle leak fixed.
=back
-=head2 OS/2
-
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
-
-=head2 VMS
-
-[TODO - Charles Bailey <bailey@newman.upenn.edu>]
-
-=head2 Win32
-
-Site library searches failed to look for ".../site/5.XXX/lib"
-if ".../site/5.XXXYY/lib" wasn't found. This has been corrected.
-
-When given a pathname that consists only of a drivename, such
-as C<A:>, opendir() and stat() now use the current working
-directory for the drive rather than the drive root.
-
-The builtin XSUB functions in the Win32:: namespace are
-documented. See L<Win32>.
-
-$^X now contains the full path name of the running executable.
-
-A Win32::GetLongPathName() function is provided to complement
-Win32::GetFullPathName() and Win32::GetShortPathName(). See L<Win32>.
-
-POSIX::uname() is supported.
-
-system(1,...) now returns true process IDs rather than process
-handles. kill() accepts any real process id, rather than strictly
-return values from system(1,...).
-
-The C<Shell> module is supported.
-
-Rudimentary support for building under command.com in Windows 95
-has been added.
+=head1 New or Changed Diagnostics
-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.
+All regular expression compilation error messages are now hopefully
+easier to understand both because the error message now comes before
+the failed regex and because the point of failure is now clearly
+marked.
-The 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 put
-a C<use File::DosGlob;> in your program. For details and compatibility
-information, see L<File::Glob>.
+The various "opened only for", "on closed", "never opened" warnings
+drop the C<main::> prefix for filehandles in the C<main> package,
+for example C<STDIN> instead of <main::STDIN>.
-[TODO - GSAR]
+The "Unrecognized escape" warning has been extended to include C<\8>,
+C<\9>, and C<\_>. There is no need to escape any of the C<\w> characters.
-=head1 New tests
+=head1 Changed Internals
=over 4
-=item lib/attrs
-
-Compatibility tests for C<sub : attrs> vs the older C<use attrs>.
-
-=item lib/io_const
-
-IO constants (SEEK_*, _IO*).
-
-=item lib/io_dir
-
-Directory-related IO methods (new, read, close, rewind, tied delete).
-
-=item lib/io_multihomed
-
-INET sockets with multi-homed hosts.
-
-=item lib/io_poll
+=item *
-IO poll().
+perlapi.pod (a companion to perlguts) now attempts to document the
+internal API.
-=item lib/io_unix
+=item *
-UNIX sockets.
+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 op/attrs
+=item *
-Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>.
+Added rsignal(), whichsig(), do_join() to the publicised API.
-=item op/filetest
+=item *
-File test operators.
+Made possible to propagate customised exceptions via croak()ing.
-=item op/lex_assign
+=item *
-Verify operations that access pad objects (lexicals and temporaries).
+Added is_utf8_char(), is_utf8_string(), bytes_to_utf8(), and utf8_to_bytes().
-=item op/exists_sub
+=item *
-Verify C<exists &sub> operations.
+Now xsubs can have attributes just like subs.
=back
-=head1 Modules and Pragmata
-
-=head2 Modules
+=head1 Known Problems
-=over 4
-
-=item attributes
-
-While used internally by Perl as a pragma, this module also
-provides a way to fetch subroutine and variable attributes.
-See L<attributes>.
-
-=item B
+=head2 Unicode Support Still Far From Perfect
-The Perl Compiler suite has been extensively reworked for this
-release.
+We're working on it. Stay tuned.
-[TODO - Vishal Bhatia <vishal@gol.com>,
-Nick Ing-Simmons <nick@ni-s.u-net.com>]
+=head2 EBCDIC Still A Lost Platform
-=item ByteLoader
+The plan is to bring them back.
-The ByteLoader is a dedicated extension to generate and run
-Perl bytecode. See L<ByteLoader>.
+=head2 Building Extensions Can Fail Because Of Largefiles
-=item constant
+Certain extensions like mod_perl and BSD::Resource are known to have
+issues with `largefiles', a change brought by Perl 5.6.0 in which file
+offsets default to 64 bits wide, where supported. Modules may fail to
+compile at all or compile and work incorrectly. Currently there is no
+good solution for the problem, but Configure now provides appropriate
+non-largefile ccflags, ldflags, libswanted, and libs in the %Config
+hash (e.g., $Config{ccflags_nolargefiles}) so the extensions that are
+having problems can try configuring themselves without the
+largefileness. This is admittedly not a clean solution, and the
+solution may not even work at all. One potential failure is whether
+one can (or, if one can, whether it's a good idea) link together at
+all binaries with different ideas about file offsets, all this is
+platform-dependent.
-References can now be used.
+=head2 ftmp-posix subtest 6 fails in VMS
-The new version also allows a leading underscore in constant names, but
-disallows a double leading underscore (as in "__LINE__"). Some other names
-are disallowed or warned against, including BEGIN, END, etc. Some names
-which were forced into main:: used to fail silently in some cases; now they're
-fatal (outside of main::) and an optional warning (inside of main::).
-The ability to detect whether a constant had been set with a given name has
-been added.
+The test exposes a flushing bug in the VMS port of Perl, this failure
+as such can be ignored.
-See L<constant>.
+=head2 ftmp-security tests warn 'system possibly insecure'
-=item charnames
+Don't panic. Read INSTALL 'make test' section instead.
-change#4052
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
+=head2 Long Doubles Still Don't Work In Solaris
-=item Data::Dumper
+The experimental long double support is still very much so in Solaris.
+(Other platforms like Linux and Tru64 are beginning to solidify in this area.)
-A C<Maxdepth> setting can be specified to avoid venturing
-too deeply into deep data structures. See L<Data::Dumper>.
+=head2 Storable tests fail in some platforms
-Dumping C<qr//> objects works correctly.
-
-=item DB
+=over 4
-C<DB> is an experimental module that exposes a clean abstraction
-to Perl's debugging API.
+=item *
-=item DB_File
+Many Storable tests fail on AIX configured with 64 bit integers.
-DB_File can now be built with Berkeley DB versions 1, 2 or 3.
-See C<ext/DB_File/Changes>.
+So far unidentified problems break Storable in AIX if Perl is
+configured to use 64 bit integers. AIX in 32-bit mode works and
+other 64-bit platforms work with Storable.
-=item Devel::DProf
+=item *
-Devel::DProf, a Perl source code profiler has been added. See
-L<Devel::DProf> and L<dprofpp>.
+DOS DJGPP may hang when testing Storable.
-=item Dumpvalue
-
-The Dumpvalue module provides screen dumps of Perl data.
-
-=item Benchmark
-
-Overall, Benchmark results exhibit lower average error and better timing
-accuracy.
-
-You can now run tests for I<n> seconds instead of guessing the right
-number of tests to run: e.g. timethese(-5, ...) will run each
-code for at least 5 CPU seconds. Zero as the "number of repetitions"
-means "for at least 3 CPU seconds". The output format has also
-changed. For example:
-
- use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}})
-
-will now output something like this:
-
- Benchmark: running a, b, each for at least 5 CPU seconds...
- a: 5 wallclock secs ( 5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91/s (n=1156516)
- b: 4 wallclock secs ( 5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18/s (n=800686)
-
-New features: "each for at least N CPU seconds...", "wallclock secs",
-and the "@ operations/CPU second (n=operations)".
-
-timethese() now returns a reference to a hash of Benchmark objects containing
-the test results, keyed on the names of the tests.
-
-timethis() now returns the iterations field in the Benchmark result object
-instead of 0.
-
-timethese(), timethis(), and the new cmpthese() (see below) can also take
-a format specifier of 'none' to suppress output.
-
-A new function countit() is just like timeit() except that it takes a
-TIME instead of a COUNT.
-
-A new function cmpthese() prints a chart comparing the results of each test
-returned from a timethese() call. For each possible pair of tests, the
-percentage speed difference (iters/sec or seconds/iter) is shown.
-
-For other details, see L<Benchmark>.
-
-=item Devel::Peek
-
-The Devel::Peek module provides access to the internal representation
-of Perl variables and data. It is a data debugging tool for the XS programmer.
-
-=item English
-
-$PERL_VERSION now stands for C<$^V> (a string value) rather than for C<$]>
-(a numeric value).
-
-=item ExtUtils::MakeMaker
-
-change#4135, also needs docs in module pod
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
-
-=item Fcntl
-
-More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for
-large file (more than 4GB) access Note that the O_LARGEFILE is
-automatically/transparently added to sysopen() flags if large file
-support has been configured), Free/Net/OpenBSD locking behaviour flags
-F_FLOCK, F_POSIX, Linux F_SHLCK, and O_ACCMODE: the combined mask of
-O_RDONLY, O_WRONLY, and O_RDWR. The seek()/sysseek() constants
-SEEK_SET, SEEK_CUR, and SEEK_END are available via the C<:seek> tag.
-The chmod()/stat() S_IF* constants and S_IS* functions are available
-via the C<:mode> tag.
-
-
-=item File::Compare
-
-A compare_text() function has been added, which allows custom
-comparison functions. See L<File::Compare>.
-
-=item File::Find
-
-File::Find now works correctly when the wanted() function is either
-autoloaded or is a symbolic reference.
-
-A bug that caused File::Find to lose track of the working directory
-when pruning top-level directories has been fixed.
-
-File::Find now also supports several other options to control its
-behavior. It can follow symbolic links if the C<follow> option is
-specified. Enabling the C<no_chdir> option will make File::Find skip
-changing the current directory when walking directories. The C<untaint>
-flag can be useful when running with taint checks enabled.
-
-See L<File::Find>.
-
-=item File::Glob
-
-This extension implements BSD-style file globbing. By default,
-it will also be used for the internal implementation of the glob()
-operator. See L<File::Glob>.
-
-=item File::Spec
-
-New methods have been added to the File::Spec module: devnull() returns
-the name of the null device (/dev/null on Unix) and tmpdir() the name of
-the temp directory (normally /tmp on Unix). There are now also methods
-to convert between absolute and relative filenames: abs2rel() and
-rel2abs(). For compatibility with operating systems that specify volume
-names in file paths, the splitpath(), splitdir(), and catdir() methods
-have been added.
-
-=item File::Spec::Functions
-
-The new File::Spec::Functions modules provides a function interface
-to the File::Spec module. Allows shorthand
-
- $fullname = catfile($dir1, $dir2, $file);
-
-instead of
-
- $fullname = File::Spec->catfile($dir1, $dir2, $file);
-
-=item Getopt::Long
-
-Getopt::Long licensing has changed to allow the Perl Artistic License
-as well as the GPL. It used to be GPL only, which got in the way of
-non-GPL applications that wanted to use Getopt::Long.
-
-Getopt::Long encourages the use of Pod::Usage to produce help
-messages. For example:
-
- use Getopt::Long;
- use Pod::Usage;
- my $man = 0;
- my $help = 0;
- GetOptions('help|?' => \$help, man => \$man) or pod2usage(2);
- pod2usage(1) if $help;
- pod2usage(-exitstatus => 0, -verbose => 2) if $man;
-
- __END__
-
- =head1 NAME
-
- sample - Using GetOpt::Long and Pod::Usage
-
- =head1 SYNOPSIS
-
- sample [options] [file ...]
-
- Options:
- -help brief help message
- -man full documentation
-
- =head1 OPTIONS
-
- =over 8
-
- =item B<-help>
-
- Print a brief help message and exits.
-
- =item B<-man>
-
- Prints the manual page and exits.
-
- =back
-
- =head1 DESCRIPTION
-
- B<This program> will read the given input file(s) and do someting
- useful with the contents thereof.
-
- =cut
-
-See L<Pod::Usage> for details.
-
-A bug that prevented the non-option call-back E<lt>E<gt> from being
-specified as the first argument has been fixed.
-
-To specify the characters E<lt> and E<gt> as option starters, use
-E<gt>E<lt>. Note, however, that changing option starters is strongly
-deprecated.
-
-=item IO
-
-write() and syswrite() will now accept a single-argument
-form of the call, for consistency with Perl's syswrite().
-
-You can now create a TCP-based IO::Socket::INET without forcing
-a connect attempt. This allows you to configure its options
-(like making it non-blocking) and then call connect() manually.
-
-A bug that prevented the IO::Socket::protocol() accessor
-from ever returning the correct value has been corrected.
-
-=item JPL
-
-Java Perl Lingo is now distributed with Perl. See jpl/README
-for more information.
-
-=item lib
-
-C<use lib> now weeds out any trailing duplicate entries.
-C<no lib> removes all named entries.
-
-=item Math::BigInt
-
-The bitwise operations C<E<lt>E<lt>>, C<E<gt>E<gt>>, C<&>, C<|>,
-and C<~> are now supported on bigints.
-
-=item Math::Complex
-
-The accessor methods Re, Im, arg, abs, rho, and theta can now also
-act as mutators (accessor $z->Re(), mutator $z->Re(3)).
-
-=item Math::Trig
-
-A little bit of radial trigonometry (cylindrical and spherical),
-radial coordinate conversions, and the great circle distance were added.
-
-=item Pod::Parser, Pod::InputObjects
-
-Pod::Parser is a base class for parsing and selecting sections of
-pod documentation from an input stream. This module takes care of
-identifying pod paragraphs and commands in the input and hands off the
-parsed paragraphs and commands to user-defined methods which are free
-to interpret or translate them as they see fit.
-
-Pod::InputObjects defines some input objects needed by Pod::Parser, and
-for advanced users of Pod::Parser that need more about a command besides
-its name and text.
-
-As of release 5.6 of Perl, Pod::Parser is now the officially sanctioned
-"base parser code" recommended for use by all pod2xxx translators.
-Pod::Text (pod2text) and Pod::Man (pod2man) have already been converted
-to use Pod::Parser and efforts to convert Pod::HTML (pod2html) are already
-underway. For any questions or comments about pod parsing and translating
-issues and utilities, please use the pod-people@perl.org mailing list.
-
-For further information, please see L<Pod::Parser> and L<Pod::InputObjects>.
-
-=item Pod::Checker, podchecker
-
-This utility checks pod files for correct syntax, according to
-L<perlpod>. Obvious errors are flagged as such, while warnings are
-printed for mistakes that can be handled gracefully. The checklist is
-not complete yet. See L<Pod::Checker>.
-
-=item Pod::ParseUtils, Pod::Find
-
-These modules provide a set of gizmos that are useful mainly for pod
-translators. L<Pod::Find|Pod::Find> traverses directory structures and
-returns found pod files, along with their canonical names (like
-C<File::Spec::Unix>). L<Pod::ParseUtils|Pod::ParseUtils> contains
-B<Pod::List> (useful for storing pod list information), B<Pod::Hyperlink>
-(for parsing the contents of C<LE<gt>E<lt>> sequences) and B<Pod::Cache>
-(for caching information about pod files, e.g. link nodes).
-
-=item Pod::Select, podselect
-
-Pod::Select is a subclass of Pod::Parser which provides a function
-named "podselect()" to filter out user-specified sections of raw pod
-documentation from an input stream. podselect is a script that provides
-access to Pod::Select from other scripts to be used as a filter.
-See L<Pod::Select>.
-
-=item Pod::Usage, pod2usage
-
-Pod::Usage provides the function "pod2usage()" to print usage messages for
-a Perl script based on its embedded pod documentation. The pod2usage()
-function is generally useful to all script authors since it lets them
-write and maintain a single source (the pods) for documentation, thus
-removing the need to create and maintain redundant usage message text
-consisting of information already in the pods.
-
-There is also a pod2usage script which can be used from other kinds of
-scripts to print usage messages from pods (even for non-Perl scripts
-with pods embedded in comments).
-
-For details and examples, please see L<Pod::Usage>.
-
-=item Pod::Text and Pod::Man
-
-[TODO - Russ Allbery <rra@stanford.edu>]
-
-=item SDBM_File
-
-An EXISTS method has been added to this module (and sdbm_exists() has
-been added to the underlying sdbm library), so one can now call exists
-on an SDBM_File tied hash and get the correct result, rather than a
-runtime error.
-
-A bug that may have caused data loss when more than one disk block
-happens to be read from the database in a single FETCH() has been
-fixed.
-
-=item Sys::Syslog
-
-Sys::Syslog now uses XSUBs to access facilities from syslog.h so it
-no longer requires syslog.ph to exist.
-
-=item Sys::Hostname
-
-Sys::Hostname now uses XSUBs to call the C library's gethostname() or
-uname() if they exist.
-
-=item Time::Local
-
-The timelocal() and timegm() functions used to silently return bogus
-results when the date fell outside the machine's integer range. They
-now consistently croak() if the date falls in an unsupported range.
-
-=item Win32
-
-The error return value in list context has been changed for all functions
-that return a list of values. Previously these functions returned a list
-with a single element C<undef> if an error occurred. Now these functions
-return the empty list in these situations. This applies to the following
-functions:
-
- Win32::FsType
- Win32::GetOSVersion
-
-The remaining functions are unchanged and continue to return C<undef> on
-error even in list context.
-
-The Win32::SetLastError(ERROR) function has been added as a complement
-to the Win32::GetLastError() function.
-
-The new Win32::GetFullPathName(FILENAME) returns the full absolute
-pathname for FILENAME in scalar context. In list context it returns
-a two-element list containing the fully qualified directory name and
-the filename. See L<Win32>.
-
-=item DBM Filters
-
-A new feature called "DBM Filters" has been added to all the
-DBM modules--DB_File, GDBM_File, NDBM_File, ODBM_File, and SDBM_File.
-DBM Filters add four new methods to each DBM module:
-
- filter_store_key
- filter_store_value
- filter_fetch_key
- filter_fetch_value
-
-These can be used to filter key-value pairs before the pairs are
-written to the database or just after they are read from the database.
-See L<perldbmfilter> for further information.
-
-=back
-
-=head2 Pragmata
-
-C<use attrs> is now obsolete, and is only provided for
-backward-compatibility. It's been replaced by the C<sub : attributes>
-syntax. See L<perlsub/"Subroutine Attributes"> and L<attributes>.
-
-C<use utf8> to enable UTF-8 and Unicode support.
-
-Lexical warnings pragma, C<use warnings;>, to control optional warnings.
-See L<perllexwarn>.
-
-C<use filetest> to control the behaviour of filetests (C<-r> C<-w>
-...). Currently only one subpragma implemented, "use filetest
-'access';", that uses access(2) or equivalent to check permissions
-instead of using stat(2) as usual. This matters in filesystems
-where there are ACLs (access control lists): the stat(2) might lie,
-but access(2) knows better.
-
-=head1 Utility Changes
-
-=head2 h2ph
-
-[TODO - Kurt Starsinic <kstar@chapin.edu>]
-
-=head2 perlcc
-
-C<perlcc> now supports the C and Bytecode backends. By default,
-it generates output from the simple C backend rather than the
-optimized C backend.
-
-Support for non-Unix platforms has been improved.
-
-=head2 h2xs
-
-change#4232
-[TODO - Ilya Zakharevich <ilya@math.ohio-state.edu>]
-
-=head1 Documentation Changes
-
-=over 4
-
-=item perlapi.pod
-
-The official list of public Perl API functions.
-
-=item perlcompile.pod
-
-An introduction to using the Perl Compiler suite.
-
-=item perlfilter.pod
-
-An introduction to writing Perl source filters.
-
-=item perlhack.pod
-
-Some guidelines for hacking the Perl source code.
-
-=item perlintern.pod
-
-A list of internal functions in the Perl source code.
-(List is currently empty.)
-
-=item perlopentut.pod
-
-A tutorial on using open() effectively.
-
-=item perlreftut.pod
-
-A tutorial that introduces the essentials of references.
-
-=item perltootc.pod
-
-A tutorial on managing class data for object modules.
-
-=item perlunicode.pod
-
-An introduction to Unicode support features in Perl.
-
-=back
-
-=head1 New or Changed Diagnostics
-
-=over 4
-
-=item "%s" variable %s masks earlier declaration in same %s
-
-(W) A "my" or "our" variable has been redeclared in the current scope or statement,
-effectively eliminating all access to the previous instance. This is almost
-always a typographical error. Note that the earlier variable will still exist
-until the end of the scope or until all closure referents to it are
-destroyed.
-
-=item "my sub" not yet implemented
-
-(F) Lexically scoped subroutines are not yet implemented. Don't try that
-yet.
-
-=item "our" variable %s redeclared
-
-(W) You seem to have already declared the same global once before in the
-current lexical scope.
-
-=item '!' allowed only after types %s
-
-(F) The '!' is allowed in pack() and unpack() only after certain types.
-See L<perlfunc/pack>.
-
-=item / cannot take a count
-
-(F) You had an unpack template indicating a counted-length string,
-but you have also specified an explicit size for the string.
-See L<perlfunc/pack>.
-
-=item / must be followed by a, A or Z
-
-(F) You had an unpack template indicating a counted-length string,
-which must be followed by one of the letters a, A or Z
-to indicate what sort of string is to be unpacked.
-See L<perlfunc/pack>.
-
-=item / must be followed by a*, A* or Z*
-
-(F) You had a pack template indicating a counted-length string,
-Currently the only things that can have their length counted are a*, A* or Z*.
-See L<perlfunc/pack>.
-
-=item / must follow a numeric type
-
-(F) You had an unpack template that contained a '#',
-but this did not follow some numeric unpack specification.
-See L<perlfunc/pack>.
-
-=item /%s/: Unrecognized escape \\%c passed through
-
-(W) You used a backslash-character combination which is not recognized
-by Perl. This combination appears in an interpolated variable or a
-C<'>-delimited regular expression. The character was understood literally.
-
-=item /%s/: Unrecognized escape \\%c in character class passed through
-
-(W) You used a backslash-character combination which is not recognized
-by Perl inside character classes. The character was understood literally.
-
-=item /%s/ should probably be written as "%s"
-
-(W) You have used a pattern where Perl expected to find a string,
-as in the first argument to C<join>. Perl will treat the true
-or false result of matching the pattern against $_ as the string,
-which is probably not what you had in mind.
-
-=item %s() called too early to check prototype
-
-(W) You've called a function that has a prototype before the parser saw a
-definition or declaration for it, and Perl could not check that the call
-conforms to the prototype. You need to either add an early prototype
-declaration for the subroutine in question, or move the subroutine
-definition ahead of the call to get proper prototype checking. Alternatively,
-if you are certain that you're calling the function correctly, you may put
-an ampersand before the name to avoid the warning. See L<perlsub>.
-
-=item %s argument is not a HASH or ARRAY element
-
-(F) The argument to exists() must be a hash or array element, such as:
-
- $foo{$bar}
- $ref->[12]->["susie"]
-
-=item %s argument is not a HASH or ARRAY element or slice
-
-(F) The argument to delete() must be either a hash or array element, such as:
-
- $foo{$bar}
- $ref->[12]->["susie"]
-
-or a hash or array slice, such as:
-
- @foo[$bar, $baz, $xyzzy]
- @{$ref->[12]}{"susie", "queue"}
-
-=item %s argument is not a subroutine name
-
-(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 %s package attribute may clash with future reserved word: %s
-
-(W) A lowercase attribute name was used that had a package-specific handler.
-That name might have a meaning to Perl itself some day, even though it
-doesn't yet. Perhaps you should use a mixed-case attribute name, instead.
-See L<attributes>.
-
-=item (in cleanup) %s
-
-(W) This prefix usually indicates that a DESTROY() method raised
-the indicated exception. Since destructors are usually called by
-the system at arbitrary points during execution, and often a vast
-number of times, the warning is issued only once for any number
-of failures that would otherwise result in the same message being
-repeated.
-
-Failure of user callbacks dispatched using the C<G_KEEPERR> flag
-could also result in this warning. See L<perlcall/G_KEEPERR>.
-
-=item <> should be quotes
-
-(F) You wrote C<require E<lt>fileE<gt>> when you should have written
-C<require 'file'>.
-
-=item Attempt to join self
-
-(F) You tried to join a thread from within itself, which is an
-impossible task. You may be joining the wrong thread, or you may
-need to move the join() to some other thread.
-
-=item Bad evalled substitution pattern
-
-(F) You've used the /e switch to evaluate the replacement for a
-substitution, but perl found a syntax error in the code to evaluate,
-most likely an unexpected right brace '}'.
-
-=item Bad realloc() ignored
-
-(S) An internal routine called realloc() on something that had never been
-malloc()ed in the first place. Mandatory, but can be disabled by
-setting environment variable C<PERL_BADFREE> to 1.
-
-=item Bareword found in conditional
-
-(W) The compiler found a bareword where it expected a conditional,
-which often indicates that an || or && was parsed as part of the
-last argument of the previous construct, for example:
-
- open FOO || die;
-
-It may also indicate a misspelled constant that has been interpreted
-as a bareword:
-
- use constant TYPO => 1;
- if (TYOP) { print "foo" }
-
-The C<strict> pragma is useful in avoiding such errors.
-
-=item Binary number > 0b11111111111111111111111111111111 non-portable
-
-(W) The binary number you specified is larger than 2**32-1
-(4294967295) and therefore non-portable between systems. See
-L<perlport> for more on portability concerns.
-
-=item Bit vector size > 32 non-portable
-
-(W) Using bit vector sizes larger than 32 is non-portable.
-
-=item Buffer overflow in prime_env_iter: %s
-
-(W) A warning peculiar to VMS. While Perl was preparing to iterate over
-%ENV, it encountered a logical name or symbol definition which was too long,
-so it was truncated to the string shown.
-
-=item Can't check filesystem of script "%s"
-
-(P) For some reason you can't check the filesystem of the script for nosuid.
-
-=item Can't declare class for non-scalar %s in "%s"
-
-(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 Can't declare %s in "%s"
-
-(F) Only scalar, array, and hash variables may be declared as "my" or
-"our" variables. They must have ordinary identifiers as names.
-
-=item Can't ignore signal CHLD, forcing to default
-
-(W) Perl has detected that it is being run with the SIGCHLD signal
-(sometimes known as SIGCLD) disabled. Since disabling this signal
-will interfere with proper determination of exit status of child
-processes, Perl has reset the signal to its default value.
-This situation typically indicates that the parent program under
-which Perl may be running (e.g. cron) is being very careless.
-
-=item Can't modify non-lvalue subroutine call
-
-(F) Subroutines meant to be used in lvalue context should be declared as
-such, see L<perlsub/"Lvalue subroutines">.
-
-=item Can't read CRTL environ
-
-(S) A warning peculiar to VMS. Perl tried to read an element of %ENV
-from the CRTL's internal environment array and discovered the array was
-missing. You need to figure out where your CRTL misplaced its environ
-or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not searched.
-
-=item Can't remove %s: %s, skipping file
-
-(S) You requested an inplace edit without creating a backup file. Perl
-was unable to remove the original file to replace it with the modified
-file. The file was left unmodified.
-
-=item Can't return %s from lvalue subroutine
-
-(F) Perl detected an attempt to return illegal lvalues (such
-as temporary or readonly values) from a subroutine used as an lvalue.
-This is not allowed.
-
-=item Can't weaken a nonreference
-
-(F) You attempted to weaken something that was not a reference. Only
-references can be weakened.
-
-=item Character class [:%s:] unknown
-
-(F) The class in the character class [: :] syntax is unknown.
-See L<perlre>.
-
-=item Character class syntax [%s] belongs inside character classes
-
-(W) The character class constructs [: :], [= =], and [. .] go
-I<inside> character classes, the [] are part of the construct,
-for example: /[012[:alpha:]345]/. Note that [= =] and [. .]
-are not currently implemented; they are simply placeholders for
-future extensions.
-
-=item Constant is not %s reference
-
-(F) A constant value (perhaps declared using the C<use constant> pragma)
-is being dereferenced, but it amounts to the wrong type of reference. The
-message indicates the type of reference that was expected. This usually
-indicates a syntax error in dereferencing the constant value.
-See L<perlsub/"Constant Functions"> and L<constant>.
-
-=item constant(%s): %%^H is not localized
-
-(F) When setting compile-time-lexicalized hash %^H one should set the
-corresponding bit of $^H as well.
-
-=item constant(%s): %s
-
-(F) Compile-time-substitutions (such as overloaded constants and
-character names) were not correctly set up.
-
-=item defined(@array) is deprecated
-
-(D) defined() is not usually useful on arrays because it checks for an
-undefined I<scalar> value. If you want to see if the array is empty,
-just use C<if (@array) { # not empty }> for example.
-
-=item defined(%hash) is deprecated
-
-(D) defined() is not usually useful on hashes because it checks for an
-undefined I<scalar> value. If you want to see if the hash is empty,
-just use C<if (%hash) { # not empty }> for example.
-
-=item Did not produce a valid header
-
-See Server error.
-
-=item Did you mean "local" instead of "our"?
-
-(W) Remember that "our" does not localize the declared global variable.
-You have declared it again in the same lexical scope, which seems superfluous.
-
-=item Document contains no data
-
-See Server error.
-
-=item entering effective %s failed
-
-(F) While under the C<use filetest> pragma, switching the real and
-effective uids or gids failed.
-
-=item false [] range "%s" in regexp
-
-(W) A character class range must start and end at a literal character, not
-another character class like C<\d> or C<[:alpha:]>. The "-" in your false
-range is interpreted as a literal "-". Consider quoting the "-", "\-".
-See L<perlre>.
-
-=item Filehandle %s opened only for output
-
-(W) You tried to read from a filehandle opened only for writing. If you
-intended it to be a read/write filehandle, you needed to open it with
-"+E<lt>" or "+E<gt>" or "+E<gt>E<gt>" instead of with "E<lt>" or nothing. If
-you intended only to read from the file, use "E<lt>". See
-L<perlfunc/open>.
-
-=item flock() on closed filehandle %s
-
-(W) The filehandle you're attempting to flock() got itself closed some
-time before now. Check your logic flow. flock() operates on filehandles.
-Are you attempting to call flock() on a dirhandle by the same name?
-
-=item Global symbol "%s" requires explicit package name
-
-(F) You've said "use strict vars", which indicates that all variables
-must either be lexically scoped (using "my"), declared beforehand using
-"our", or explicitly qualified to say which package the global variable
-is in (using "::").
-
-=item Hexadecimal number > 0xffffffff non-portable
-
-(W) The hexadecimal number you specified is larger than 2**32-1
-(4294967295) and therefore non-portable between systems. See
-L<perlport> for more on portability concerns.
-
-=item Ill-formed CRTL environ value "%s"
-
-(W) A warning peculiar to VMS. Perl tried to read the CRTL's internal
-environ array, and encountered an element without the C<=> delimiter
-used to spearate keys from values. The element is ignored.
-
-=item Ill-formed message in prime_env_iter: |%s|
-
-(W) A warning peculiar to VMS. Perl tried to read a logical name
-or CLI symbol definition when preparing to iterate over %ENV, and
-didn't see the expected delimiter between key and value, so the
-line was ignored.
-
-=item Illegal binary digit %s
-
-(F) You used a digit other than 0 or 1 in a binary number.
-
-=item Illegal binary digit %s ignored
-
-(W) You may have tried to use a digit other than 0 or 1 in a binary number.
-Interpretation of the binary number stopped before the offending digit.
-
-=item Illegal number of bits in vec
-
-(F) The number of bits in vec() (the third argument) must be a power of
-two from 1 to 32 (or 64, if your platform supports that).
-
-=item Integer overflow in %s number
-
-(W) The hexadecimal, octal or binary number you have specified either
-as a literal or as an argument to hex() or oct() is too big for your
-architecture, and has been converted to a floating point number. On a
-32-bit architecture the largest hexadecimal, octal or binary number
-representable without overflow is 0xFFFFFFFF, 037777777777, or
-0b11111111111111111111111111111111 respectively. Note that Perl
-transparently promotes all numbers to a floating point representation
-internally--subject to loss of precision errors in subsequent
-operations.
-
-=item Invalid %s attribute: %s
-
-The indicated attribute for a subroutine or variable was not recognized
-by Perl or by a user-supplied handler. See L<attributes>.
-
-=item Invalid %s attributes: %s
-
-The indicated attributes for a subroutine or variable were not recognized
-by Perl or by a user-supplied handler. See L<attributes>.
-
-=item invalid [] range "%s" in regexp
-
-The offending range is now explicitly displayed.
-
-=item Invalid separator character %s in attribute list
-
-(F) Something other than a colon or whitespace was seen between the
-elements of an attribute list. If the previous attribute
-had a parenthesised parameter list, perhaps that list was terminated
-too soon. See L<attributes>.
-
-=item Invalid separator character %s in subroutine attribute list
-
-(F) Something other than a colon or whitespace was seen between the
-elements of a subroutine attribute list. If the previous attribute
-had a parenthesised parameter list, perhaps that list was terminated
-too soon.
-
-=item leaving effective %s failed
-
-(F) While under the C<use filetest> pragma, switching the real and
-effective uids or gids failed.
-
-=item Lvalue subs returning %s not implemented yet
-
-(F) Due to limitations in the current implementation, array and hash
-values cannot be returned in subroutines used in lvalue context.
-See L<perlsub/"Lvalue subroutines">.
-
-=item Method %s not permitted
-
-See Server error.
-
-=item Missing %sbrace%s on \N{}
-
-(F) Wrong syntax of character name literal C<\N{charname}> within
-double-quotish context.
-
-=item Missing command in piped open
-
-(W) You used the C<open(FH, "| command")> or C<open(FH, "command |")>
-construction, but the command was missing or blank.
-
-=item Missing name in "my sub"
-
-(F) The reserved syntax for lexically scoped subroutines requires that they
-have a name with which they can be found.
-
-=item No %s specified for -%c
-
-(F) The indicated command line switch needs a mandatory argument, but
-you haven't specified one.
-
-=item No package name allowed for variable %s in "our"
-
-(F) Fully qualified variable names are not allowed in "our" declarations,
-because that doesn't make much sense under existing semantics. Such
-syntax is reserved for future extensions.
-
-=item No space allowed after -%c
-
-(F) The argument to the indicated command line switch must follow immediately
-after the switch, without intervening spaces.
-
-=item no UTC offset information; assuming local time is UTC
-
-(S) A warning peculiar to VMS. Perl was unable to find the local
-timezone offset, so it's assuming that local system time is equivalent
-to UTC. If it's not, define the logical name F<SYS$TIMEZONE_DIFFERENTIAL>
-to translate to the number of seconds which need to be added to UTC to
-get local time.
-
-=item Octal number > 037777777777 non-portable
-
-(W) The octal number you specified is larger than 2**32-1 (4294967295)
-and therefore non-portable between systems. See L<perlport> for more
-on portability concerns.
-
-See also L<perlport> for writing portable code.
-
-=item panic: del_backref
-
-(P) Failed an internal consistency check while trying to reset a weak
-reference.
-
-=item panic: kid popen errno read
-
-(F) forked child returned an incomprehensible message about its errno.
-
-=item panic: magic_killbackrefs
-
-(P) Failed an internal consistency check while trying to reset all weak
-references to an object.
-
-=item Parentheses missing around "%s" list
-
-(W) You said something like
-
- my $foo, $bar = @_;
-
-when you meant
-
- my ($foo, $bar) = @_;
-
-Remember that "my", "our", and "local" bind tighter than comma.
-
-=item Possible Y2K bug: %s
-
-(W) You are concatenating the number 19 with another number, which
-could be a potential Year 2000 problem.
-
-=item Premature end of script headers
-
-See Server error.
-
-=item Repeat count in pack overflows
-
-(F) You can't specify a repeat count so large that it overflows
-your signed integers. See L<perlfunc/pack>.
-
-=item Repeat count in unpack overflows
-
-(F) You can't specify a repeat count so large that it overflows
-your signed integers. See L<perlfunc/unpack>.
-
-=item realloc() of freed memory ignored
-
-(S) An internal routine called realloc() on something that had already
-been freed.
-
-=item Reference is already weak
-
-(W) You have attempted to weaken a reference that is already weak.
-Doing so has no effect.
-
-=item setpgrp can't take arguments
-
-(F) Your system has the setpgrp() from BSD 4.2, which takes no arguments,
-unlike POSIX setpgid(), which takes a process ID and process group ID.
-
-=item Strange *+?{} on zero-length expression
-
-(W) You applied a regular expression quantifier in a place where it
-makes no sense, such as on a zero-width assertion.
-Try putting the quantifier inside the assertion instead. For example,
-the way to match "abc" provided that it is followed by three
-repetitions of "xyz" is C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>.
-
-=item switching effective %s is not implemented
-
-(F) While under the C<use filetest> pragma, we cannot switch the
-real and effective uids or gids.
-
-=item This Perl can't reset CRTL environ elements (%s)
-
-=item This Perl can't set CRTL environ elements (%s=%s)
-
-(W) Warnings peculiar to VMS. You tried to change or delete an element
-of the CRTL's internal environ array, but your copy of Perl wasn't
-built with a CRTL that contained the setenv() function. You'll need to
-rebuild Perl with a CRTL that does, or redefine F<PERL_ENV_TABLES> (see
-L<perlvms>) so that the environ array isn't the target of the change to
-%ENV which produced the warning.
-
-=item Unknown open() mode '%s'
-
-(F) The second argument of 3-argument open() is not among the list
-of valid modes: C<E<lt>>, C<E<gt>>, C<E<gt>E<gt>>, C<+E<lt>>,
-C<+E<gt>>, C<+E<gt>E<gt>>, C<-|>, C<|E<45>>.
-
-=item Unknown process %x sent message to prime_env_iter: %s
-
-(P) An error peculiar to VMS. Perl was reading values for %ENV before
-iterating over it, and someone else stuck a message in the stream of
-data Perl expected. Someone's very confused, or perhaps trying to
-subvert Perl's population of %ENV for nefarious purposes.
-
-=item Unrecognized escape \\%c passed through
-
-(W) You used a backslash-character combination which is not recognized
-by Perl. The character was understood literally.
-
-=item Unterminated attribute parameter in attribute list
-
-(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>.
-
-=item Unterminated attribute list
-
-(F) The lexer found something other than a simple identifier at the start
-of an attribute, and it wasn't a semicolon or the start of a
-block. Perhaps you terminated the parameter list of the previous attribute
-too soon. See L<attributes>.
-
-=item Unterminated attribute parameter in subroutine attribute list
-
-(F) The lexer saw an opening (left) parenthesis character while parsing a
-subroutine attribute list, but the matching closing (right) parenthesis
-character was not found. You may need to add (or remove) a backslash
-character to get your parentheses to balance.
-
-=item Unterminated subroutine attribute list
-
-(F) The lexer found something other than a simple identifier at the start
-of a subroutine attribute, and it wasn't a semicolon or the start of a
-block. Perhaps you terminated the parameter list of the previous attribute
-too soon.
-
-=item Value of CLI symbol "%s" too long
-
-(W) A warning peculiar to VMS. Perl tried to read the value of an %ENV
-element from a CLI symbol table, and found a resultant string longer
-than 1024 characters. The return value has been truncated to 1024
-characters.
-
-=item Version number must be a constant number
-
-(P) The attempt to translate a C<use Module n.n LIST> statement into
-its equivalent C<BEGIN> block found an internal inconsistency with
-the version number.
-
-=back
-
-=head1 Obsolete Diagnostics
-
-=over 4
-
-=item Character class syntax [: :] is reserved for future extensions
-
-(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 ":\]".
-
-=item Ill-formed logical name |%s| in prime_env_iter
-
-(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.
-
-=item Probable precedence problem on %s
-
-(W) The compiler found a bareword where it expected a conditional,
-which often indicates that an || or && was parsed as part of the
-last argument of the previous construct, for example:
-
- open FOO || die;
-
-=item regexp too big
-
-(F) The current implementation of regular expressions uses shorts as
-address offsets within a string. Unfortunately this means that if
-the regular expression compiles to longer than 32767, it'll blow up.
-Usually when you want a regular expression this big, there is a better
-way to do it with multiple statements. See L<perlre>.
-
-=item Use of "$$<digit>" to mean "${$}<digit>" is deprecated
+=item *
-(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.
+st-06compat fails in UNICOS and UNICOS/mk.
-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.
+This means that you cannot read old (pre-Storable-0.7) Storable images
+made in other platforms.
=back
-=head1 BUGS
+=head1 Reporting Bugs
-If you find what you think is a bug, you might check the
-articles recently posted to the comp.lang.perl.misc newsgroup.
-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/perl/, the Perl Home Page.
If you believe you have an unreported bug, please run the B<perlbug>
-program included with your release. Make sure to trim your bug down
+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.
+Written by Jarkko Hietaniemi <F<jhi@iki.fi>>, with many contributions
+from The Perl Porters and Perl Users submitting feedback and patches.
-Send omissions or corrections to <F<perlbug@perl.com>>.
+Send omissions or corrections to <F<perlbug@perl.org>>.
=cut
https://perl5.git.perl.org / perl5.git / blobdiff