pod/perldelta.pod

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