pod/perldelta.pod

   1 =head1 NAME
   2
   3 perldelta - what's new for perl v5.6 (as of v5.005_61)
   4
   5 =head1 DESCRIPTION
   6
   7 This is an unsupported alpha release, meant for intrepid Perl developers
   8 only.  The included sources may not even build correctly on some platforms.
   9 Subscribing to perl5-porters is the best way to monitor and contribute
  10 to the progress of development releases (see www.perl.org for info).
  11
  12 This document describes differences between the 5.005 release and this one.
  13
  14 =head1 Incompatible Changes
  15
  16 =head2 Perl Source Incompatibilities
  17
  18 TODO
  19
  20 =head2 C Source Incompatibilities
  21
  22 =over 4
  23
  24 =item C<PERL_POLLUTE>
  25
  26 Release 5.005 grandfathered old global symbol names by providing preprocessor
  27 macros for extension source compatibility.  As of release 5.6, these
  28 preprocessor definitions are not available by default.  You need to explicitly
  29 compile perl with C<-DPERL_POLLUTE> to get these definitions.  For
  30 extensions still using the old symbols, this option can be
  31 specified via MakeMaker:
  32
  33     perl Makefile.PL POLLUTE=1
  34
  35 =item C<PERL_IMPLICIT_CONTEXT>
  36
  37 This new build option provides a set of macros for all API functions
  38 such that an implicit interpreter/thread context argument is passed to
  39 every API function.  As a result of this, something like C<sv_setsv(foo,bar)>
  40 amounts to a macro invocation that actually translates to something like
  41 C<Perl_sv_setsv(my_perl,foo,bar)>.  While this is generally expected
  42 to not have any significant source compatibility issues, the difference
  43 between a macro and a real function call will need to be considered.
  44
  45 This means that there B<is> a source compatibility issue as a result of
  46 this if your extensions attempt to use pointers to any of the Perl API
  47 functions.
  48
  49 Note that the above issue is not relevant to the default build of
  50 Perl, whose interfaces continue to match those of prior versions
  51 (but subject to the other options described here).
  52
  53 PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built
  54 with one of -Dusethreads, -Dusemultiplicity, or both.
  55
  56 See L<perlguts/"The Perl API"> for detailed information on the
  57 ramifications of building Perl using this option.
  58
  59 =item C<PERL_POLLUTE_MALLOC>
  60
  61 Enabling Perl's malloc in release 5.005 and earlier caused
  62 the namespace of system versions of the malloc family of functions to
  63 be usurped by the Perl versions, since by default they used the
  64 same names.
  65
  66 Besides causing problems on platforms that do not allow these functions to
  67 be cleanly replaced, this also meant that the system versions could not
  68 be called in programs that used Perl's malloc.  Previous versions of Perl
  69 have allowed this behaviour to be suppressed with the HIDEMYMALLOC and
  70 EMBEDMYMALLOC preprocessor definitions.
  71
  72 As of release 5.6, Perl's malloc family of functions have default names
  73 distinct from the system versions.  You need to explicitly compile perl with
  74 C<-DPERL_POLLUTE_MALLOC> to get the older behaviour.  HIDEMYMALLOC
  75 and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now
  76 the default.
  77
  78 Note that these functions do B<not> constitute Perl's memory allocation API.
  79 See L<perlguts/"Memory Allocation"> for further information about that.
  80
  81 =item C<PL_na> and C<dTHR> Issues
  82
  83 The C<PL_na> global is now thread local, so a C<dTHR> declaration is needed
  84 in the scope in which the global appears.  XSUBs should handle this automatically,
  85 but if you have used C<PL_na> in support functions, you either need to
  86 change the C<PL_na> to a local variable (which is recommended), or put in
  87 a C<dTHR>.
  88
  89 =back
  90
  91 =head2 Compatible C Source API Changes
  92
  93 =over
  94
  95 =item C<PATCHLEVEL> is now C<PERL_VERSION>
  96
  97 The cpp macros C<PERL_REVISION>, C<PERL_VERSION>, and C<PERL_SUBVERSION>
  98 are now available by default from perl.h, and reflect the base revision,
  99 patchlevel, and subversion respectively.  C<PERL_REVISION> had no
 100 prior equivalent, while C<PERL_VERSION> and C<PERL_SUBVERSION> were
 101 previously available as C<PATCHLEVEL> and C<SUBVERSION>.
 102
 103 The new names cause less pollution of the B<cpp> namespace and reflect what
 104 the numbers have come to stand for in common practice.  For compatibility,
 105 the old names are still supported when F<patchlevel.h> is explicitly
 106 included (as required before), so there is no source incompatibility
 107 from the change.
 108
 109 =back
 110
 111 =head2 Binary Incompatibilities
 112
 113 The default build of this release is binary compatible with the 5.005
 114 release or its maintenance versions.
 115
 116 The usethreads or usemultiplicity builds are B<not> binary compatible
 117 with the corresponding builds in 5.005.
 118
 119 =head1 Core Changes
 120
 121 =head2 Unicode and UTF-8 support
 122
 123 Perl can optionally use UTF-8 as its internal representation for character
 124 strings.  The C<use utf8> pragma enables this support in the current lexical
 125 scope.  See L<utf8> for more information.
 126
 127 =head2 Lexically scoped warning categories
 128
 129 You can now control the granularity of warnings emitted by perl at a finer
 130 level using the C<use warning> pragma.  See L<warning> and L<perllexwarn>
 131 for details.
 132
 133 =head2 Binary numbers supported
 134
 135 Binary numbers are now supported as literals, in s?printf formats, and
 136 C<oct()>:
 137
 138     $answer = 0b101010;
 139     printf "The answer is: %b\n", oct("0b101010");
 140
 141 =head2 syswrite() ease-of-use
 142
 143 The length argument of C<syswrite()> is now optional.
 144
 145 =head2 64-bit support
 146
 147 All platforms that have 64-bit integers either (a) natively as longs
 148 or ints (b) via special compiler flags (c) using long long are able to
 149 use "quads" (64-integers) as follows:
 150
 151 =over 4
 152
 153 =item constants in the code
 154
 155 =item arguments to oct() and hex()
 156
 157 =item arguments to print(), printf() and sprintf()
 158
 159 =item pack() and unpack() "q" format
 160
 161 =item in basic arithmetics
 162
 163 =item vec() (but see the below note about bit arithmetics)
 164
 165 =back
 166
 167 Note that unless you have the case (a) you will have to configure
 168 and compile Perl using the -Duse64bits Configure flag.
 169
 170 Unfortunately bit arithmetics (&, |, ^, ~, <<, >>) are not 64-bit clean.
 171
 172 Last but not least: note that due to Perl's habit of always using
 173 floating point numbers the quads are still not true integers.
 174 When quads overflow their limits (0...18_446_744_073_709_551_615 unsigned,
 175 -9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they
 176 are silently promoted to floating point numbers, after which they will
 177 start losing precision (their lower digits).
 178
 179 =head2 Large file support
 180
 181 If you have filesystems that support "large files" (files larger than
 182 2 gigabytes), you may now also be able to create and access them from Perl.
 183
 184 Note that in addition to requiring a proper file system to do this you
 185 may also need to adjust your per-process (or even your per-system)
 186 maximum filesize limits before running Perl scripts that try to handle
 187 large files, especially if you intend to write such files.
 188
 189 Adjusting your file system/system limits is outside the scope of Perl.
 190 For process limits, you may try to increase the limits using your
 191 shell's limit/ulimit command before running Perl.  The BSD::Resource
 192 extension (not included with the standard Perl distribution) may also
 193 be of use.
 194
 195 (Large file support is also related to 64-bit support, for obvious reasons)
 196
 197 =head2 Better syntax checks on parenthesized unary operators
 198
 199 Expressions such as:
 200
 201     print defined(&foo,&bar,&baz);
 202     print uc("foo","bar","baz");
 203     undef($foo,&bar);
 204
 205 used to be accidentally allowed in earlier versions, and produced
 206 unpredictable behaviour.  Some produced ancillary warnings
 207 when used in this way; others silently did the wrong thing.
 208
 209 The parenthesized forms of most unary operators that expect a single
 210 argument now ensure that they are not called with more than one
 211 argument, making the cases shown above syntax errors.  The usual
 212 behaviour of:
 213
 214     print defined &foo, &bar, &baz;
 215     print uc "foo", "bar", "baz";
 216     undef $foo, &bar;
 217
 218 remains unchanged.  See L<perlop>.
 219
 220 =head2 POSIX character class syntax [: :] supported
 221
 222 For example to match alphabetic characters use /[[:alpha:]]/.
 223 See L<perlre> for details.
 224
 225 =head2 Improved C<qw//> operator
 226
 227 The C<qw//> operator is now evaluated at compile time into a true list
 228 instead of being replaced with a run time call to C<split()>.  This
 229 removes the confusing misbehaviour of C<qw//> in scalar context, which
 230 had inherited that behaviour from split().
 231
 232 Thus:
 233
 234     $foo = ($bar) = qw(a b c); print "$foo|$bar\n";
 235
 236 now correctly prints "3|a", instead of "2|a".
 237
 238 =head2 pack() format 'Z' supported
 239
 240 The new format type 'Z' is useful for packing and unpacking null-terminated
 241 strings.  See L<perlfunc/"pack">.
 242
 243 =head2 pack() format modifier '!' supported
 244
 245 The new format type modifier '!' is useful for packing and unpacking
 246 native shorts, ints, and longs.  See L<perlfunc/"pack">.
 247
 248 =head2 pack() and unpack() support counted strings
 249
 250 The template character '#' can be used to specify a counted string
 251 type to be packed or unpacked.  See L<perlfunc/"pack">.
 252
 253 =head2 $^X variables may now have names longer than one character
 254
 255 Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax
 256 error.  Now variable names that begin with a control character may be
 257 arbitrarily long.  However, for compatibility reasons, these variables
 258 I<must> be written with explicit braces, as C<${^XY}> for example.
 259 C<${^XYZ}> is synonymous with ${"\cXYZ"}.  Variable names with more
 260 than one control character, such as C<${^XY^Z}>, are illegal.
 261
 262 The old syntax has not changed.  As before, `^X' may be either a
 263 literal control-X character or the two-character sequence `caret' plus
 264 `X'.  When braces are omitted, the variable name stops after the
 265 control character.  Thus C<"$^XYZ"> continues to be synonymous with
 266 C<$^X . "YZ"> as before.
 267
 268 As before, lexical variables may not have names beginning with control
 269 characters.  As before, variables whose names begin with a control
 270 character are always forced to be in package `main'.  All such variables
 271 are reserved for future extensions, except those that begin with
 272 C<^_>, which may be used by user programs and is guaranteed not to
 273 acquire special meaning in any future version of Perl.
 274
 275 =head1 Significant bug fixes
 276
 277 =head2 E<lt>HANDLEE<gt> on empty files
 278
 279 With C<$/> set to C<undef>, slurping an empty file returns a string of
 280 zero length (instead of C<undef>, as it used to) the first time the
 281 HANDLE is read.  Further reads yield C<undef>.
 282
 283 This means that the following will append "foo" to an empty file (it used
 284 to do nothing):
 285
 286     perl -0777 -pi -e 's/^/foo/' empty_file
 287
 288 The behaviour of:
 289
 290     perl -pi -e 's/^/foo/' empty_file
 291
 292 is unchanged (it continues to leave the file empty).
 293
 294 =head2 C<eval '...'> improvements
 295
 296 Line numbers (as reflected by caller() and most diagnostics) within
 297 C<eval '...'> were often incorrect when here documents were involved.
 298 This has been corrected.
 299
 300 Lexical lookups for variables appearing in C<eval '...'> within
 301 functions that were themselves called within an C<eval '...'> were
 302 searching the wrong place for lexicals.  The lexical search now
 303 correctly ends at the subroutine's block boundary.
 304
 305 Parsing of here documents used to be flawed when they appeared as
 306 the replacement expression in C<eval 's/.../.../e'>.  This has
 307 been fixed.
 308
 309 =head2 Automatic flushing of output buffers
 310
 311 fork(), exec(), system(), qx//, and pipe open()s now flush buffers
 312 of all files opened for output when the operation
 313 was attempted.  This mostly eliminates confusing
 314 buffering mishaps suffered by users unaware of how Perl internally
 315 handles I/O.
 316
 317 =head2 Better diagnostics on meaningless filehandle operations
 318
 319 Constructs such as C<open(E<lt>FHE<gt>)> and C<close(E<lt>FHE<gt>)>
 320 are compile time errors.  Attempting to read from filehandles that
 321 were opened only for writing will now produce warnings (just as
 322 writing to read-only filehandles does).
 323
 324 =head2 Buffered data discarded from input filehandle when dup'ed.
 325
 326 C<open(NEW, "E<lt>&OLD")> now discards any data that was previously
 327 read and buffered in C<OLD>.  The next read operation on C<NEW> will
 328 return the same data as the corresponding operation on C<OLD>.
 329 Formerly, it would have returned the data from the start of the
 330 following disk block instead.
 331
 332 =head1 Supported Platforms
 333
 334 =over 4
 335
 336 =item *
 337
 338 VM/ESA is now supported.
 339
 340 =item *
 341
 342 Siemens BS2000 is now supported under the POSIX Shell.
 343
 344 =item *
 345
 346 The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread
 347 extension.
 348
 349 =item *
 350
 351 GNU/Hurd is now supported.
 352
 353 =item *
 354
 355 Rhapsody is now supported.
 356
 357 =item *
 358
 359 EPOC is is now supported (on Psion 5).
 360
 361 =back
 362
 363 =head1 New tests
 364
 365 =over 4
 366
 367 =item   op/io_const
 368
 369 IO constants (SEEK_*, _IO*).
 370
 371 =item   op/io_dir
 372
 373 Directory-related IO methods (new, read, close, rewind, tied delete).
 374
 375 =item   op/io_multihomed
 376
 377 INET sockets with multi-homed hosts.
 378
 379 =item   op/io_poll
 380
 381 IO poll().
 382
 383 =item   op/io_unix
 384
 385 UNIX sockets.
 386
 387 =item   op/filetest
 388
 389 File test operators.
 390
 391 =item   op/lex_assign
 392
 393 Verify operations that access pad objects (lexicals and temporaries).
 394
 395 =back
 396
 397 =head1 Modules and Pragmata
 398
 399 =head2 Modules
 400
 401 =over 4
 402
 403 =item ByteLoader
 404
 405 The ByteLoader is a dedication extension to generate and run
 406 Perl bytecode.  See L<ByteLoader>.
 407
 408 =item B
 409
 410 The Perl Compiler suite has been extensively reworked for this
 411 release.
 412
 413 =item Devel::DProf
 414
 415 Devel::DProf, a Perl source code profiler has been added.
 416
 417 =item Dumpvalue
 418
 419 Added Dumpvalue module provides screen dumps of Perl data.
 420
 421 =item Benchmark
 422
 423 You can now run tests for I<n> seconds instead of guessing the right
 424 number of tests to run: e.g. timethese(-5, ...) will run each
 425 code for at least 5 CPU seconds.  Zero as the "number of repetitions"
 426 means "for at least 3 CPU seconds".  The output format has also
 427 changed.  For example:
 428
 429 use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}})
 430
 431 will now output something like this:
 432
 433 Benchmark: running a, b, each for at least 5 CPU seconds...
 434          a:  5 wallclock secs ( 5.77 usr +  0.00 sys =  5.77 CPU) @ 200551.91/s (n=1156516)
 435          b:  4 wallclock secs ( 5.00 usr +  0.02 sys =  5.02 CPU) @ 159605.18/s (n=800686)
 436
 437 New features: "each for at least N CPU seconds...", "wallclock secs",
 438 and the "@ operations/CPU second (n=operations)".
 439
 440 =item Devel::Peek
 441
 442 The Devel::Peek module provides access to the internal representation
 443 of Perl variables and data.  It is a data debugging tool for the XS programmer.
 444
 445 =item Fcntl
 446
 447 More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for
 448 large (more than 4G) file access (64-bit support is not yet
 449 working, though, so no need to get overly excited), Free/Net/OpenBSD
 450 locking behaviour flags F_FLOCK, F_POSIX, Linux F_SHLCK, and
 451 O_ACCMODE: the mask of O_RDONLY, O_WRONLY, and O_RDWR.
 452
 453 =item File::Spec
 454
 455 New methods have been added to the File::Spec module: devnull() returns
 456 the name of the null device (/dev/null on Unix) and tmpdir() the name of
 457 the temp directory (normally /tmp on Unix).  There are now also methods
 458 to convert between absolute and relative filenames: abs2rel() and
 459 rel2abs().  For compatibility with operating systems that specify volume
 460 names in file paths, the splitpath(), splitdir(), and catdir() methods
 461 have been added.
 462
 463 =item File::Spec::Functions
 464
 465 The new File::Spec::Functions modules provides a function interface
 466 to the File::Spec module.  Allows shorthand
 467
 468     $fullname = catfile($dir1, $dir2, $file);
 469
 470 instead of
 471
 472     $fullname = File::Spec->catfile($dir1, $dir2, $file);
 473
 474 =item Math::BigInt
 475
 476 The logical operations C<E<lt>E<lt>>, C<E<gt>E<gt>>, C<&>, C<|>,
 477 and C<~> are now supported on bigints.
 478
 479 =item Math::Complex
 480
 481 The accessor methods Re, Im, arg, abs, rho, and theta can now also
 482 act as mutators (accessor $z->Re(), mutator $z->Re(3)).
 483
 484 =item Math::Trig
 485
 486 A little bit of radial trigonometry (cylindrical and spherical),
 487 radial coordinate conversions, and the great circle distance were added.
 488
 489 =item SDBM_File
 490
 491 An EXISTS method has been added to this module (and sdbm_exists() has
 492 been added to the underlying sdbm library), so one can now call exists
 493 on an SDBM_File tied hash and get the correct result, rather than a
 494 runtime error.
 495
 496 =item Time::Local
 497
 498 The timelocal() and timegm() functions used to silently return bogus
 499 results when the date exceeded the machine's integer range.  They
 500 now consistently croak() if the date falls in an unsupported range.
 501
 502 =item Win32
 503
 504 The error return value in list context has been changed for all functions
 505 that return a list of values.  Previously these functions returned a list
 506 with a single element C<undef> if an error occurred.  Now these functions
 507 return the empty list in these situations.  This applies to the following
 508 functions:
 509
 510     Win32::FsType
 511     Win32::GetOSVersion
 512
 513 The remaining functions are unchanged and continue to return C<undef> on
 514 error even in list context.
 515
 516 The Win32::SetLastError(ERROR) function has been added as a complement
 517 to the Win32::GetLastError() function.
 518
 519 The new Win32::GetFullPathName(FILENAME) returns the full absolute
 520 pathname for FILENAME in scalar context.  In list context it returns
 521 a two-element list containing the fully qualified directory name and
 522 the filename.
 523
 524 =item DBM Filters
 525
 526 A new feature called "DBM Filters" has been added to all the
 527 DBM modules--DB_File, GDBM_File, NDBM_File, ODBM_File, and SDBM_File.
 528 DBM Filters add four new methods to each DBM module:
 529
 530     filter_store_key
 531     filter_store_value
 532     filter_fetch_key
 533     filter_fetch_value
 534
 535 These can be used to filter key-value pairs before the pairs are
 536 written to the database or just after they are read from the database.
 537 See L<perldbmfilter> for further information.
 538
 539 =back
 540
 541 =head2 Pragmata
 542
 543 C<use utf8> to enable UTF-8 and Unicode support.
 544
 545 C<use caller 'encoding'> allows modules to inherit pragmatic attributes
 546 from the caller's context.  C<encoding> is currently the only supported
 547 attribute.
 548
 549 Lexical warnings pragma, C<use warning;>, to control optional warnings.
 550
 551 C<use filetest> to control the behaviour of filetests (C<-r> C<-w> ...).
 552 Currently only one subpragma implemented, "use filetest 'access';",
 553 that enables the use of access(2) or equivalent to check
 554 permissions instead of using stat(2) as usual.  This matters
 555 in filesystems where there are ACLs (access control lists): the
 556 stat(2) might lie, but access(2) knows better.
 557
 558 =head1 Utility Changes
 559
 560 Todo.
 561
 562 =head1 Documentation Changes
 563
 564 =over 4
 565
 566 =item perlopentut.pod
 567
 568 A tutorial on using open() effectively.
 569
 570 =item perlreftut.pod
 571
 572 A tutorial that introduces the essentials of references.
 573
 574 =item perltootc.pod
 575
 576 A tutorial on managing class data for object modules.
 577
 578 =back
 579
 580 =head1 New Diagnostics
 581
 582 =item /%s/: Unrecognized escape \\%c passed through
 583
 584 (W) You used a backslash-character combination which is not recognized
 585 by Perl.  This combination appears in an interpolated variable or a
 586 C<'>-delimited regular expression.
 587
 588 =item Filehandle %s opened only for output
 589
 590 (W) You tried to read from a filehandle opened only for writing.  If you
 591 intended it to be a read-write filehandle, you needed to open it with
 592 "+E<lt>" or "+E<gt>" or "+E<gt>E<gt>" instead of with "E<lt>" or nothing.  If
 593 you intended only to read from the file, use "E<lt>".  See
 594 L<perlfunc/open>.
 595
 596 =item Missing command in piped open
 597
 598 (W) You used the C<open(FH, "| command")> or C<open(FH, "command |")>
 599 construction, but the command was missing or blank.
 600
 601 =item Unrecognized escape \\%c passed through
 602
 603 (W) You used a backslash-character combination which is not recognized
 604 by Perl.
 605
 606 =item defined(@array) is deprecated
 607
 608 (D) defined() is not usually useful on arrays because it checks for an
 609 undefined I<scalar> value.  If you want to see if the array is empty,
 610 just use C<if (@array) { # not empty }> for example.
 611
 612 =item defined(%hash) is deprecated
 613
 614 (D) defined() is not usually useful on hashes because it checks for an
 615 undefined I<scalar> value.  If you want to see if the hash is empty,
 616 just use C<if (%hash) { # not empty }> for example.
 617
 618 =head1 Obsolete Diagnostics
 619
 620 Todo.
 621
 622 =head1 Configuration Changes
 623
 624 =head2 installusrbinperl
 625
 626 You can use "Configure -Uinstallusrbinperl" which causes installperl
 627 to skip installing perl also as /usr/bin/perl.  This is useful if you
 628 prefer not to modify /usr/bin for some reason or another but harmful
 629 because many scripts assume to find Perl in /usr/bin/perl.
 630
 631 =head2 SOCKS support
 632
 633 You can use "Configure -Dusesocks" which causes Perl to probe
 634 for the SOCKS proxy protocol library, http://www.socks.nec.com/
 635
 636 =head1 BUGS
 637
 638 If you find what you think is a bug, you might check the headers of
 639 articles recently posted to the comp.lang.perl.misc newsgroup.
 640 There may also be information at http://www.perl.com/perl/, the Perl
 641 Home Page.
 642
 643 If you believe you have an unreported bug, please run the B<perlbug>
 644 program included with your release.  Make sure to trim your bug down
 645 to a tiny but sufficient test case.  Your bug report, along with the
 646 output of C<perl -V>, will be sent off to perlbug@perl.com to be
 647 analysed by the Perl porting team.
 648
 649 =head1 SEE ALSO
 650
 651 The F<Changes> file for exhaustive details on what changed.
 652
 653 The F<INSTALL> file for how to build Perl.
 654
 655 The F<README> file for general stuff.
 656
 657 The F<Artistic> and F<Copying> files for copyright information.
 658
 659 =head1 HISTORY
 660
 661 Written by Gurusamy Sarathy <F<gsar@umich.edu>>, with many contributions
 662 from The Perl Porters.
 663
 664 Send omissions or corrections to <F<perlbug@perl.com>>.
 665
 666 =cut