++ed by:

100 PAUSE users
209 non-PAUSE users.

Gurusamy Sarathy


perldelta - what's new for perl v5.6 (as of v5.005_61)


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.

Incompatible Changes

Perl Source Incompatibilities


C Source Incompatibilities


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 -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

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 sv_setsv(foo,bar) amounts to a macro invocation that actually translates to something like 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 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 "The Perl API" in perlguts for detailed information on the ramifications of building Perl using this option.


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.

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.

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 -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 not constitute Perl's memory allocation API. See "Memory Allocation" in perlguts for further information about that.

PL_na and dTHR Issues

The PL_na global is now thread local, so a dTHR declaration is needed in the scope in which the global appears. XSUBs should handle this automatically, but if you have used PL_na in support functions, you either need to change the PL_na to a local variable (which is recommended), or put in a dTHR.

Compatible C Source API Changes


The cpp macros PERL_REVISION, PERL_VERSION, and PERL_SUBVERSION are now available by default from perl.h, and reflect the base revision, patchlevel, and subversion respectively. PERL_REVISION had no prior equivalent, while PERL_VERSION and PERL_SUBVERSION were previously available as PATCHLEVEL and SUBVERSION.

The new names cause less pollution of the 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 included (as required before), so there is no source incompatibility from the change.

Binary Incompatibilities

The default build of this release is binary compatible with the 5.005 release or its maintenance versions.

The usethreads or usemultiplicity builds are not binary compatible with the corresponding builds in 5.005.

Core Changes

Unicode and UTF-8 support

Perl can optionally use UTF-8 as its internal representation for character strings. The use utf8 pragma enables this support in the current lexical scope. See utf8 for more information.

Lexically scoped warning categories

You can now control the granularity of warnings emitted by perl at a finer level using the use warning pragma. See warning and perllexwarn for details.

Binary numbers supported

Binary numbers are now supported as literals, in s?printf formats, and oct():

    $answer = 0b101010;
    printf "The answer is: %b\n", oct("0b101010");

syswrite() ease-of-use

The length argument of syswrite() is now optional.

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:

constants in the code
arguments to oct() and hex()
arguments to print(), printf() and sprintf()
pack() and unpack() "q" format
in basic arithmetics

Note that unless you have the case (a) you will have to configure and compile Perl using the -Duse64bits Configure flag.

Unfortunately, bit operations (&, <<, ...) and vec() do not work, they are limited to 32 bits.

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 (18446744073709551615 unsigned, -9223372036854775808...9223372036854775807 signed), they are silently promoted to floating point numbers, after which they will start losing precision (their lower digits).

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)

Better syntax checks on parenthesized unary operators

Expressions such as:

    print defined(&foo,&bar,&baz);
    print uc("foo","bar","baz");

used to be accidentally allowed in earlier versions, and produced unpredictable behaviour. Some produced ancillary warnings when used in this way; others silently did the wrong thing.

The parenthesized forms of most unary operators that expect a single argument now ensure that they are not called with more than one argument, making the cases shown above syntax errors. The usual behaviour of:

    print defined &foo, &bar, &baz;
    print uc "foo", "bar", "baz";
    undef $foo, &bar;

remains unchanged. See perlop.

POSIX character class syntax [: :] supported

For example to match alphabetic characters use /[[:alpha:]]/. See perlre for details.

Improved qw// operator

The qw// operator is now evaluated at compile time into a true list instead of being replaced with a run time call to split(). This removes the confusing misbehaviour of qw// in scalar context, which had inherited that behaviour from split().


    $foo = ($bar) = qw(a b c); print "$foo|$bar\n";

now correctly prints "3|a", instead of "2|a".

pack() format 'Z' supported

The new format type 'Z' is useful for packing and unpacking null-terminated strings. See "pack" in perlfunc.

pack() format modifier '!' supported

The new format type modifier '!' is useful for packing and unpacking native shorts, ints, and longs. See "pack" in perlfunc.

pack() and unpack() support counted strings

The template character '#' can be used to specify a counted string type to be packed or unpacked. See "pack" in perlfunc.

$^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 must be written with explicit braces, as ${^XY} for example. ${^XYZ} is synonymous with ${"\cXYZ"}. Variable names with more than one control character, such as ${^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 "$^XYZ" continues to be synonymous with $^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 ^_, which may be used by user programs and is guaranteed not to acquire special meaning in any future version of Perl.

Significant bug fixes

<HANDLE> on empty files

With $/ set to undef, slurping an empty file returns a string of zero length (instead of undef, as it used to) the first time the HANDLE is read. Further reads yield undef.

This means that the following will append "foo" to an empty file (it used to do nothing):

    perl -0777 -pi -e 's/^/foo/' empty_file

The behaviour of:

    perl -pi -e 's/^/foo/' empty_file

is unchanged (it continues to leave the file empty).

eval '...' improvements

Line numbers (as reflected by caller() and most diagnostics) within eval '...' were often incorrect when here documents were involved. This has been corrected.

Lexical lookups for variables appearing in eval '...' within functions that were themselves called within an 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 eval 's/.../.../e'. This has been fixed.

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.

Better diagnostics on meaningless filehandle operations

Constructs such as open(<FH>) and close(<FH>) are compile time errors. Attempting to read from filehandles that were opened only for writing will now produce warnings (just as writing to read-only filehandles does).

Buffered data discarded from input filehandle when dup'ed.

open(NEW, "<&OLD") now discards any data that was previously read and buffered in OLD. The next read operation on NEW will return the same data as the corresponding operation on OLD. Formerly, it would have returned the data from the start of the following disk block instead.

Supported Platforms

  • VM/ESA is now supported.

  • Siemens BS2000 is now supported under the POSIX Shell.

  • The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread extension.

  • GNU/Hurd is now supported.

  • Rhapsody is now supported.

  • EPOC is is now supported (on Psion 5).

New tests


IO constants (SEEK_*, _IO*).


Directory-related IO methods (new, read, close, rewind, tied delete).


INET sockets with multi-homed hosts.


IO poll().


UNIX sockets.


File test operators.


Verify operations that access pad objects (lexicals and temporaries).

Modules and Pragmata



The ByteLoader is a dedication extension to generate and run Perl bytecode. See ByteLoader.


The Perl Compiler suite has been extensively reworked for this release.


Devel::DProf, a Perl source code profiler has been added.


Added Dumpvalue module provides screen dumps of Perl data.


You can now run tests for 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)".


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.


More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for large (more than 4G) file access (64-bit support is not yet working, though, so no need to get overly excited), Free/Net/OpenBSD locking behaviour flags F_FLOCK, F_POSIX, Linux F_SHLCK, and O_ACCMODE: the mask of O_RDONLY, O_WRONLY, and O_RDWR.


New methods have been added to the File::Spec module: devnull() returns the name of the null device (/dev/null on Unix) and tmpdir() the name of the temp directory (normally /tmp on Unix). There are now also methods to convert between absolute and relative filenames: abs2rel() and rel2abs(). For compatibility with operating systems that specify volume names in file paths, the splitpath(), splitdir(), and catdir() methods have been added.


The 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);

The logical operations <<, >>, &, |, and ~ are now supported on bigints.


The accessor methods Re, Im, arg, abs, rho, and theta can now also act as mutators (accessor $z->Re(), mutator $z->Re(3)).


A little bit of radial trigonometry (cylindrical and spherical), radial coordinate conversions, and the great circle distance were added.


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.


The timelocal() and timegm() functions used to silently return bogus results when the date exceeded the machine's integer range. They now consistently croak() if the date falls in an unsupported range.


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 undef if an error occurred. Now these functions return the empty list in these situations. This applies to the following functions:


The remaining functions are unchanged and continue to return 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.

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:


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 perldbmfilter for further information.


use utf8 to enable UTF-8 and Unicode support.

use caller 'encoding' allows modules to inherit pragmatic attributes from the caller's context. encoding is currently the only supported attribute.

Lexical warnings pragma, use warning;, to control optional warnings.

use filetest to control the behaviour of filetests (-r -w ...). Currently only one subpragma implemented, "use filetest 'access';", that enables the use of access(2) or equivalent to check permissions instead of using stat(2) as usual. This matters in filesystems where there are ACLs (access control lists): the stat(2) might lie, but access(2) knows better.

Utility Changes


Documentation Changes


A tutorial on using open() effectively.


A tutorial that introduces the essentials of references.


A tutorial on managing class data for object modules.

New Diagnostics

/%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 '-delimited regular expression.

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 "+<" or "+>" or "+>>" instead of with "<" or nothing. If you intended only to read from the file, use "<". See "open" in perlfunc.

Missing command in piped open

(W) You used the open(FH, "| command") or open(FH, "command |") construction, but the command was missing or blank.

Unrecognized escape \\%c passed through

(W) You used a backslash-character combination which is not recognized by Perl.

defined(@array) is deprecated

(D) defined() is not usually useful on arrays because it checks for an undefined scalar value. If you want to see if the array is empty, just use if (@array) { # not empty } for example.

defined(%hash) is deprecated

(D) defined() is not usually useful on hashes because it checks for an undefined scalar value. If you want to see if the hash is empty, just use if (%hash) { # not empty } for example.

Obsolete Diagnostics


Configuration Changes


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.

SOCKS support

You can use "Configure -Dusesocks" which causes Perl to probe for the SOCKS proxy protocol library, http://www.socks.nec.com/


If you find what you think is a bug, you might check the headers of 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 perlbug 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 perl -V, will be sent off to perlbug@perl.com to be analysed by the Perl porting team.


The Changes file for exhaustive details on what changed.

The INSTALL file for how to build Perl.

The README file for general stuff.

The Artistic and Copying files for copyright information.


Written by Gurusamy Sarathy <gsar@umich.edu>, with many contributions from The Perl Porters.

Send omissions or corrections to <perlbug@perl.com>.

2 POD Errors

The following errors were encountered while parsing the POD:

Around line 581:

'=item' outside of any '=over'

Around line 617:

You forgot a '=back' before '=head1'