=head1 NAME
-perldelta - what's new for perl5.006 (as of 5.005_54)
+perldelta - what's new for perl v5.6 (as of v5.005_61)
=head1 DESCRIPTION
+This is an unsupported alpha release, meant for intrepid Perl developers
+only. The included sources may not even build correctly on some platforms.
+Subscribing to perl5-porters is the best way to monitor and contribute
+to the progress of development releases (see www.perl.org for info).
+
This document describes differences between the 5.005 release and this one.
=head1 Incompatible Changes
=head2 Perl Source Incompatibilities
-None known at this time.
+TODO
=head2 C Source Incompatibilities
=item C<PERL_POLLUTE>
Release 5.005 grandfathered old global symbol names by providing preprocessor
-macros for extension source compatibility. As of release 5.006, these
+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> in order to get these definitions.
+compile perl with C<-DPERL_POLLUTE> to get these definitions. For
+extensions still using the old symbols, this option can be
+specified via MakeMaker:
+
+ perl Makefile.PL POLLUTE=1
+
+=item C<PERL_IMPLICIT_CONTEXT>
+
+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.
+
+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.
+
+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).
+
+PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built
+with one of -Dusethreads, -Dusemultiplicity, or both.
+
+See L<perlguts/"The Perl API"> for detailed information on the
+ramifications of building Perl using this option.
=item C<PERL_POLLUTE_MALLOC>
-Enabling the use of Perl's malloc in release 5.005 and earlier caused
+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 of these functions, since they used the
-same names by default.
+be usurped by the Perl versions, since by default they used the
+same names.
Besides causing problems on platforms that do not allow these functions to
be cleanly replaced, this also meant that the system versions could not
be called in programs that used Perl's malloc. Previous versions of Perl
-have allowed this behavior to be suppressed with the HIDEMYMALLOC and
+have allowed this behaviour to be suppressed with the HIDEMYMALLOC and
EMBEDMYMALLOC preprocessor definitions.
-As of release 5.006, Perl's malloc family of functions have default names
+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> in order to get the older behavior. HIDEMYMALLOC
-and EMBEDMYMALLOC have no effect, since the behavior they enabled is now
+C<-DPERL_POLLUTE_MALLOC> to get the older behaviour. HIDEMYMALLOC
+and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now
the default.
Note that these functions do B<not> constitute Perl's memory allocation API.
=item C<PL_na> and C<dTHR> Issues
The C<PL_na> global is now thread local, so a C<dTHR> declaration is needed
-in the scope in which it appears. XSUBs should handle this automatically,
+in the scope in which the global appears. XSUBs should handle this automatically,
but if you have used C<PL_na> in support functions, you either need to
change the C<PL_na> to a local variable (which is recommended), or put in
a C<dTHR>.
=item C<PATCHLEVEL> is now C<PERL_VERSION>
-The cpp macros C<PERL_REVISION>, C<PERL_VERSION> and C<PERL_SUBVERSION>
+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
+patchlevel, and subversion respectively. C<PERL_REVISION> had no
prior equivalent, while C<PERL_VERSION> and C<PERL_SUBVERSION> were
previously available as C<PATCHLEVEL> and C<SUBVERSION>.
-The new names cause less pollution of the cpp namespace, and reflect what
+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 patchlevel.h is explicitly
+the old names are still supported when F<patchlevel.h> is explicitly
included (as required before), so there is no source incompatibility
-due to the change.
+from the change.
=back
=head2 Binary Incompatibilities
-This release is not binary compatible with the 5.005 release and its
-maintenance versions.
+The default build of this release is binary compatible with the 5.005
+release or its maintenance versions.
+
+The usethreads or usemultiplicity builds are B<not> binary compatible
+with the corresponding builds in 5.005.
=head1 Core Changes
=head2 Lexically scoped warning categories
You can now control the granularity of warnings emitted by perl at a finer
-level using the C<use warning> pragma. See L<warning> for details.
+level using the C<use warnings> pragma. See L<warnings> and L<perllexwarn>
+for details.
=head2 Binary numbers supported
Binary numbers are now supported as literals, in s?printf formats, and
C<oct()>:
- $answer = 0b101010;
- printf "The answer is: %b\n", oct("0b101010");
+ $answer = 0b101010;
+ printf "The answer is: %b\n", oct("0b101010");
=head2 syswrite() ease-of-use
=head2 64-bit support
-Better 64-bit support -- but full support still a distant goal. One
-must Configure with -Duse64bits to get Configure to probe for the
-extent of 64-bit support. Depending on the platform (hints file) more
-or less 64-awareness becomes available. As of 5.005_54 at least
-somewhat 64-bit aware platforms are HP-UX 11 or better, Solaris 2.6 or
-better, IRIX 6.2 or better. Naturally 64-bit platforms like Digital
-UNIX and UNICOS also have 64-bit support.
+All platforms that have 64-bit integers either (a) natively as longs
+or ints (b) via special compiler flags (c) using long long are able to
+use "quads" (64-integers) as follows:
+
+=over 4
+
+=item constants in the code
+
+=item arguments to oct() and hex()
+
+=item arguments to print(), printf() and sprintf()
+
+=item pack() and unpack() "q" format
+
+=item in basic arithmetics
+
+=item vec() (but see the below note about bit arithmetics)
+
+=back
+
+Note that unless you have the case (a) you will have to configure
+and compile Perl using the -Duse64bits Configure flag.
+
+Unfortunately bit arithmetics (&, |, ^, ~, <<, >>) are not 64-bit clean.
+
+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.
+
+Note that in addition to requiring a proper file system to do this you
+may also need to adjust your per-process (or even your per-system)
+maximum filesize limits before running Perl scripts that try to handle
+large files, especially if you intend to write such files.
+
+Adjusting your file system/system limits is outside the scope of Perl.
+For process limits, you may try to increase the limits using your
+shell's limit/ulimit command before running Perl. The BSD::Resource
+extension (not included with the standard Perl distribution) may also
+be of use.
+
+(Large file support is also related to 64-bit support, for obvious reasons)
=head2 Better syntax checks on parenthesized unary operators
Expressions such as:
- print defined(&foo,&bar,&baz);
- print uc("foo","bar","baz");
- undef($foo,&bar);
+ print defined(&foo,&bar,&baz);
+ print uc("foo","bar","baz");
+ undef($foo,&bar);
-used to be accidentally allowed in earlier versions, and produced
-unpredictable behavior. Some of them produced ancillary warnings
-when used in this way, while others silently did the wrong thing.
+used to be accidentally allowed in earlier versions, and produced
+unpredictable behaviour. Some produced ancillary warnings
+when used in this way; others silently did the wrong thing.
The parenthesized forms of most unary operators that expect a single
-argument will now ensure that they are not called with more than one
-argument, making the above cases syntax errors. Note that the usual
-behavior of:
+argument now ensure that they are not called with more than one
+argument, making the cases shown above syntax errors. The usual
+behaviour of:
- print defined &foo, &bar, &baz;
- print uc "foo", "bar", "baz";
- undef $foo, &bar;
+ print defined &foo, &bar, &baz;
+ print uc "foo", "bar", "baz";
+ undef $foo, &bar;
remains unchanged. See L<perlop>.
+=head2 POSIX character class syntax [: :] supported
+
+For example to match alphabetic characters use /[[:alpha:]]/.
+See L<perlre> for details.
+
=head2 Improved C<qw//> operator
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 behavior of C<qw//> in scalar context stemming from
-the older implementation, which inherited the behavior from split().
+removes the confusing misbehaviour of C<qw//> in scalar context, which
+had inherited that behaviour from split().
Thus:
The new format type 'Z' is useful for packing and unpacking null-terminated
strings. See L<perlfunc/"pack">.
+=head2 pack() format modifier '!' supported
+
+The new format type modifier '!' is useful for packing and unpacking
+native shorts, ints, and longs. See L<perlfunc/"pack">.
+
+=head2 pack() and unpack() support counted strings
+
+The template character '#' can be used to specify a counted string
+type to be packed or unpacked. See L<perlfunc/"pack">.
+
+=head2 $^X variables may now have names longer than one character
+
+Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax
+error. Now variable names that begin with a control character may be
+arbitrarily long. However, for compatibility reasons, these variables
+I<must> be written with explicit braces, as C<${^XY}> for example.
+C<${^XYZ}> is synonymous with ${"\cXYZ"}. Variable names with more
+than one control character, such as C<${^XY^Z}>, are illegal.
+
+The old syntax has not changed. As before, `^X' may be either a
+literal control-X character or the two-character sequence `caret' plus
+`X'. When braces are omitted, the variable name stops after the
+control character. Thus C<"$^XYZ"> continues to be synonymous with
+C<$^X . "YZ"> as before.
+
+As before, lexical variables may not have names beginning with control
+characters. As before, variables whose names begin with a control
+character are always forced to be in package `main'. All such variables
+are reserved for future extensions, except those that begin with
+C<^_>, which may be used by user programs and are guaranteed not to
+acquire special meaning in any future version of Perl.
+
+=head2 C<use attrs> implicit in subroutine attributes
+
+Formerly, if you wanted to mark a subroutine as being a method call or
+as requiring an automatic lock() when it is entered, you had to declare
+that with a C<use attrs> pragma in the body of the subroutine.
+That can now be accomplished with a declaration syntax, like this:
+
+ sub mymethod : locked, method ;
+ ...
+ sub mymethod : locked, method {
+ ...
+ }
+
+F<AutoSplit.pm> and F<SelfLoader.pm> have been updated to keep the attributes
+with the stubs they provide. See L<attributes>.
+
=head1 Significant bug fixes
=head2 E<lt>HANDLEE<gt> on empty files
With C<$/> set to C<undef>, slurping an empty file returns a string of
-zero length (instead of C<undef>, as it used to) for the first time the
-HANDLE is read. Subsequent reads yield C<undef>.
+zero length (instead of C<undef>, as it used to) the first time the
+HANDLE is read. Further reads yield C<undef>.
This means that the following will append "foo" to an empty file (it used
-to not do anything before):
+to do nothing):
perl -0777 -pi -e 's/^/foo/' empty_file
-Note that the behavior of:
+The behaviour of:
perl -pi -e 's/^/foo/' empty_file
is unchanged (it continues to leave the file empty).
-=head2 pack() format modifier '_' supported
+=head2 C<eval '...'> improvements
-The new format type modifer '_' is useful for packing and unpacking
-native shorts, ints, and longs. See L<perlfunc/"pack">.
+Line numbers (as reflected by caller() and most diagnostics) within
+C<eval '...'> were often incorrect when here documents were involved.
+This has been corrected.
+
+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.
+
+Parsing of here documents used to be flawed when they appeared as
+the replacement expression in C<eval 's/.../.../e'>. This has
+been fixed.
+
+=head2 Automatic flushing of output buffers
+
+fork(), exec(), system(), qx//, and pipe open()s now flush buffers
+of all files opened for output when the operation
+was attempted. This mostly eliminates confusing
+buffering mishaps suffered by users unaware of how Perl internally
+handles I/O.
+
+=head2 Better diagnostics on meaningless filehandle operations
+
+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).
+
+=head2 Buffered data discarded from input filehandle when dup'ed.
+
+C<open(NEW, "E<lt>&OLD")> now discards any data that was previously
+read and buffered in C<OLD>. The next read operation on C<NEW> will
+return the same data as the corresponding operation on C<OLD>.
+Formerly, it would have returned the data from the start of the
+following disk block instead.
=head1 Supported Platforms
=item *
-Siemens BS200 is now supported.
+Siemens BS2000 is now supported under the POSIX Shell.
+
+=item *
+
+The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread
+extension.
+
+=item *
+
+GNU/Hurd is now supported.
=item *
-The Mach CThreads (NeXTstep) are now supported by the Thread extension.
+Rhapsody is now supported.
+
+=item *
+
+EPOC is is now supported (on Psion 5).
=back
=over 4
-=item op/io_const
+=item lib/attrs
+
+Compatibility tests for C<sub : attrs> vs the older C<use attrs>.
+
+=item lib/io_const
IO constants (SEEK_*, _IO*).
-
-=item op/io_dir
+
+=item lib/io_dir
Directory-related IO methods (new, read, close, rewind, tied delete).
-=item op/io_multihomed
+=item lib/io_multihomed
INET sockets with multi-homed hosts.
-=item op/io_poll
+=item lib/io_poll
IO poll().
-=item op/io_unix
+=item lib/io_unix
UNIX sockets.
+=item op/attrs
+
+Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>.
+
=item op/filetest
File test operators.
=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 ByteLoader
+
+The ByteLoader is a dedication extension to generate and run
+Perl bytecode. See L<ByteLoader>.
+
+=item B
+
+The Perl Compiler suite has been extensively reworked for this
+release.
+
+=item Devel::DProf
+
+Devel::DProf, a Perl source code profiler has been added.
+
=item Dumpvalue
Added Dumpvalue module provides screen dumps of Perl data.
=item Benchmark
-You can now run tests for I<x> seconds instead of guessing the right
-number of tests to run.
+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)".
+
+=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 Fcntl
More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for
-large (more than 4G) file access (the 64-bit support is not yet
+large (more than 4G) file access (64-bit support is not yet
working, though, so no need to get overly excited), Free/Net/OpenBSD
locking behaviour flags F_FLOCK, F_POSIX, Linux F_SHLCK, and
O_ACCMODE: the mask of O_RDONLY, O_WRONLY, and O_RDWR.
+=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 Math::BigInt
+
+The logical operations C<E<lt>E<lt>>, C<E<gt>E<gt>>, C<&>, C<|>,
+and C<~> are now supported on bigints.
+
=item Math::Complex
-
-The accessors methods Re, Im, arg, abs, rho, theta, methods can
-($z->Re()) now also act as mutators ($z->Re(3)).
+
+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) added,
-for example the great circle distance.
+A little bit of radial trigonometry (cylindrical and spherical),
+radial coordinate conversions, and the great circle distance were added.
+
+=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.
=item Time::Local
The timelocal() and timegm() functions used to silently return bogus
results when the date exceeded the machine's integer range. They
-consistently croak() if the date falls in an unsupported range.
+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.
+
+=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 utf8;>, to enable UTF-8 and Unicode support.
+C<use attrs> is now obsolescent, and is only provided for
+backward-compatibility. It's been replaced by the C<sub : attributes>
+syntax. See L<perlsub/"Subroutine Attributes"> and L<attributes>.
-Lexical warnings pragma, C<use warning;>, to control optional warnings.
+C<use utf8> to enable UTF-8 and Unicode support.
-C<use filetest;>, to control the behaviour of filetests (C<-r> C<-w> ...).
+C<use caller 'encoding'> allows modules to inherit pragmatic attributes
+from the caller's context. C<encoding> is currently the only supported
+attribute.
+
+Lexical warnings pragma, C<use warnings;>, to control optional warnings.
+
+C<use filetest> to control the behaviour of filetests (C<-r> C<-w> ...).
Currently only one subpragma implemented, "use filetest 'access';",
-that enables the use of access(2) or equivalent to check the
+that enables the use of access(2) or equivalent to check
permissions instead of using stat(2) as usual. This matters
-in filesystems where there are ACLs (access control lists), the
-stat(2) might lie, while access(2) knows better.
+in filesystems where there are ACLs (access control lists): the
+stat(2) might lie, but access(2) knows better.
=head1 Utility Changes
A tutorial that introduces the essentials of references.
+=item perltootc.pod
+
+A tutorial on managing class data for object modules.
+
=back
=head1 New Diagnostics
+=item "my sub" not yet implemented
+
+(F) Lexically scoped subroutines are not yet implemented. Don't try that
+yet.
+
+=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 /%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
+by Perl. This combination appears in an interpolated variable or a
C<'>-delimited regular expression.
-=item Unrecognized escape \\%c passed through
+=item Filehandle %s opened only for output
-(W) You used a backslash-character combination which is not recognized
-by Perl.
+(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 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 separator character %s in attribute list
+
+(F) Something other than a comma 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 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 Unrecognized escape \\%c passed through
+
+(W) You used a backslash-character combination which is not recognized
+by Perl.
+
+=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 defined(@array) is deprecated
+
+(D) defined() is not usually useful on arrays because it checks for an
+undefined I<scalar> value. If you want to see if the array is empty,
+just use C<if (@array) { # not empty }> for example.
+
+=item defined(%hash) is deprecated
+
+(D) defined() is not usually useful on hashes because it checks for an
+undefined I<scalar> value. If you want to see if the hash is empty,
+just use C<if (%hash) { # not empty }> for example.
+
+=item Invalid separator character %s in subroutine attribute list
+
+(F) Something other than a comma or whitespace was seen between the
+elements of a subroutine attribute list. If the previous attribute
+had a parenthesised parameter list, perhaps that list was terminated
+too soon.
+
+=item Unterminated attribute parameter in subroutine attribute list
+
+(F) The lexer saw an opening (left) parenthesis character while parsing a
+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 /%s/ should probably be written as "%s"
+
+(W) You have used a pattern where Perl expected to find a string,
+like in the first argument to C<join>. Perl will treat the true
+or false result of matching the pattern against $_ as the string,
+which is probably not what you had in mind.
+
+=item /%s/ should probably be written as "%s"
+
+(W) You have used a pattern where Perl expected to find a string,
+like in the first argument to C<join>. Perl will treat the true
+or false result of matching the pattern against $_ as the string,
+which is probably not what you had in mind.
+
=head1 Obsolete Diagnostics
Todo.
=head1 Configuration Changes
+=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 proxy protocol library, http://www.socks.nec.com/
+
=head1 BUGS
If you find what you think is a bug, you might check the headers of
-recently posted articles in the comp.lang.perl.misc newsgroup.
+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 believe you have an unreported bug, please run the B<perlbug>
-program included with your release. Make sure you trim your bug down
+program included with your release. Make 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 <F<perlbug@perl.com>> to be
+output of C<perl -V>, will be sent off to perlbug@perl.com to be
analysed by the Perl porting team.
=head1 SEE ALSO