[Summary view] [Print] [Text view]

   1  =head1 NAME
   2  
   3  perl58delta - what is new for perl v5.8.0
   4  
   5  =head1 DESCRIPTION
   6  
   7  This document describes differences between the 5.6.0 release and
   8  the 5.8.0 release.
   9  
  10  Many of the bug fixes in 5.8.0 were already seen in the 5.6.1
  11  maintenance release since the two releases were kept closely
  12  coordinated (while 5.8.0 was still called 5.7.something).
  13  
  14  Changes that were integrated into the 5.6.1 release are marked C<[561]>.
  15  Many of these changes have been further developed since 5.6.1 was released,
  16  those are marked C<[561+]>.
  17  
  18  You can see the list of changes in the 5.6.1 release (both from the
  19  5.005_03 release and the 5.6.0 release) by reading L<perl561delta>.
  20  
  21  =head1 Highlights In 5.8.0
  22  
  23  =over 4
  24  
  25  =item *
  26  
  27  Better Unicode support
  28  
  29  =item *
  30  
  31  New IO Implementation
  32  
  33  =item *
  34  
  35  New Thread Implementation
  36  
  37  =item *
  38  
  39  Better Numeric Accuracy
  40  
  41  =item *
  42  
  43  Safe Signals
  44  
  45  =item *
  46  
  47  Many New Modules
  48  
  49  =item *
  50  
  51  More Extensive Regression Testing
  52  
  53  =back
  54  
  55  =head1 Incompatible Changes
  56  
  57  =head2 Binary Incompatibility
  58  
  59  B<Perl 5.8 is not binary compatible with earlier releases of Perl.>
  60  
  61  B<You have to recompile your XS modules.>
  62  
  63  (Pure Perl modules should continue to work.)
  64  
  65  The major reason for the discontinuity is the new IO architecture
  66  called PerlIO.  PerlIO is the default configuration because without
  67  it many new features of Perl 5.8 cannot be used.  In other words:
  68  you just have to recompile your modules containing XS code, sorry
  69  about that.
  70  
  71  In future releases of Perl, non-PerlIO aware XS modules may become
  72  completely unsupported.  This shouldn't be too difficult for module
  73  authors, however: PerlIO has been designed as a drop-in replacement
  74  (at the source code level) for the stdio interface.
  75  
  76  Depending on your platform, there are also other reasons why
  77  we decided to break binary compatibility, please read on.
  78  
  79  =head2 64-bit platforms and malloc
  80  
  81  If your pointers are 64 bits wide, the Perl malloc is no longer being
  82  used because it does not work well with 8-byte pointers.  Also,
  83  usually the system mallocs on such platforms are much better optimized
  84  for such large memory models than the Perl malloc.  Some memory-hungry
  85  Perl applications like the PDL don't work well with Perl's malloc.
  86  Finally, other applications than Perl (such as mod_perl) tend to prefer
  87  the system malloc.  Such platforms include Alpha and 64-bit HPPA,
  88  MIPS, PPC, and Sparc.
  89  
  90  =head2 AIX Dynaloading
  91  
  92  The AIX dynaloading now uses in AIX releases 4.3 and newer the native
  93  dlopen interface of AIX instead of the old emulated interface.  This
  94  change will probably break backward compatibility with compiled
  95  modules.  The change was made to make Perl more compliant with other
  96  applications like mod_perl which are using the AIX native interface.
  97  
  98  =head2 Attributes for C<my> variables now handled at run-time
  99  
 100  The C<my EXPR : ATTRS> syntax now applies variable attributes at
 101  run-time.  (Subroutine and C<our> variables still get attributes applied
 102  at compile-time.)  See L<attributes> for additional details.  In particular,
 103  however, this allows variable attributes to be useful for C<tie> interfaces,
 104  which was a deficiency of earlier releases.  Note that the new semantics
 105  doesn't work with the Attribute::Handlers module (as of version 0.76).
 106  
 107  =head2 Socket Extension Dynamic in VMS
 108  
 109  The Socket extension is now dynamically loaded instead of being
 110  statically built in.  This may or may not be a problem with ancient
 111  TCP/IP stacks of VMS: we do not know since we weren't able to test
 112  Perl in such configurations.
 113  
 114  =head2 IEEE-format Floating Point Default on OpenVMS Alpha
 115  
 116  Perl now uses IEEE format (T_FLOAT) as the default internal floating
 117  point format on OpenVMS Alpha, potentially breaking binary compatibility
 118  with external libraries or existing data.  G_FLOAT is still available as
 119  a configuration option.  The default on VAX (D_FLOAT) has not changed.
 120  
 121  =head2 New Unicode Semantics (no more C<use utf8>, almost)
 122  
 123  Previously in Perl 5.6 to use Unicode one would say "use utf8" and
 124  then the operations (like string concatenation) were Unicode-aware
 125  in that lexical scope.
 126  
 127  This was found to be an inconvenient interface, and in Perl 5.8 the
 128  Unicode model has completely changed: now the "Unicodeness" is bound
 129  to the data itself, and for most of the time "use utf8" is not needed
 130  at all.  The only remaining use of "use utf8" is when the Perl script
 131  itself has been written in the UTF-8 encoding of Unicode.  (UTF-8 has
 132  not been made the default since there are many Perl scripts out there
 133  that are using various national eight-bit character sets, which would
 134  be illegal in UTF-8.)
 135  
 136  See L<perluniintro> for the explanation of the current model,
 137  and L<utf8> for the current use of the utf8 pragma.
 138  
 139  =head2 New Unicode Properties
 140  
 141  Unicode I<scripts> are now supported. Scripts are similar to (and superior
 142  to) Unicode I<blocks>. The difference between scripts and blocks is that
 143  scripts are the glyphs used by a language or a group of languages, while
 144  the blocks are more artificial groupings of (mostly) 256 characters based
 145  on the Unicode numbering.
 146  
 147  In general, scripts are more inclusive, but not universally so. For
 148  example, while the script C<Latin> includes all the Latin characters and
 149  their various diacritic-adorned versions, it does not include the various
 150  punctuation or digits (since they are not solely C<Latin>).
 151  
 152  A number of other properties are now supported, including C<\p{L&}>,
 153  C<\p{Any}> C<\p{Assigned}>, C<\p{Unassigned}>, C<\p{Blank}> [561] and
 154  C<\p{SpacePerl}> [561] (along with their C<\P{...}> versions, of course).
 155  See L<perlunicode> for details, and more additions.
 156  
 157  The C<In> or C<Is> prefix to names used with the C<\p{...}> and C<\P{...}>
 158  are now almost always optional. The only exception is that a C<In> prefix
 159  is required to signify a Unicode block when a block name conflicts with a
 160  script name. For example, C<\p{Tibetan}> refers to the script, while
 161  C<\p{InTibetan}> refers to the block. When there is no name conflict, you
 162  can omit the C<In> from the block name (e.g. C<\p{BraillePatterns}>), but
 163  to be safe, it's probably best to always use the C<In>).
 164  
 165  =head2 REF(...) Instead Of SCALAR(...)
 166  
 167  A reference to a reference now stringifies as "REF(0x81485ec)" instead
 168  of "SCALAR(0x81485ec)" in order to be more consistent with the return
 169  value of ref().
 170  
 171  =head2 pack/unpack D/F recycled
 172  
 173  The undocumented pack/unpack template letters D/F have been recycled
 174  for better use: now they stand for long double (if supported by the
 175  platform) and NV (Perl internal floating point type).  (They used
 176  to be aliases for d/f, but you never knew that.)
 177  
 178  =head2 glob() now returns filenames in alphabetical order
 179  
 180  The list of filenames from glob() (or <...>) is now by default sorted
 181  alphabetically to be csh-compliant (which is what happened before
 182  in most UNIX platforms).  (bsd_glob() does still sort platform
 183  natively, ASCII or EBCDIC, unless GLOB_ALPHASORT is specified.) [561]
 184  
 185  =head2 Deprecations
 186  
 187  =over 4
 188  
 189  =item *
 190  
 191  The semantics of bless(REF, REF) were unclear and until someone proves
 192  it to make some sense, it is forbidden.
 193  
 194  =item *
 195  
 196  The obsolete chat2 library that should never have been allowed
 197  to escape the laboratory has been decommissioned.
 198  
 199  =item *
 200  
 201  Using chdir("") or chdir(undef) instead of explicit chdir() is
 202  doubtful.  A failure (think chdir(some_function()) can lead into
 203  unintended chdir() to the home directory, therefore this behaviour
 204  is deprecated.
 205  
 206  =item *
 207  
 208  The builtin dump() function has probably outlived most of its
 209  usefulness.  The core-dumping functionality will remain in future
 210  available as an explicit call to C<CORE::dump()>, but in future
 211  releases the behaviour of an unqualified C<dump()> call may change.
 212  
 213  =item *
 214  
 215  The very dusty examples in the eg/ directory have been removed.
 216  Suggestions for new shiny examples welcome but the main issue is that
 217  the examples need to be documented, tested and (most importantly)
 218  maintained.
 219  
 220  =item *
 221  
 222  The (bogus) escape sequences \8 and \9 now give an optional warning
 223  ("Unrecognized escape passed through").  There is no need to \-escape
 224  any C<\w> character.
 225  
 226  =item *
 227  
 228  The *glob{FILEHANDLE} is deprecated, use *glob{IO} instead.
 229  
 230  =item *
 231  
 232  The C<package;> syntax (C<package> without an argument) has been
 233  deprecated.  Its semantics were never that clear and its
 234  implementation even less so.  If you have used that feature to
 235  disallow all but fully qualified variables, C<use strict;> instead.
 236  
 237  =item *
 238  
 239  The unimplemented POSIX regex features [[.cc.]] and [[=c=]] are still
 240  recognised but now cause fatal errors.  The previous behaviour of
 241  ignoring them by default and warning if requested was unacceptable
 242  since it, in a way, falsely promised that the features could be used.
 243  
 244  =item *
 245  
 246  In future releases, non-PerlIO aware XS modules may become completely
 247  unsupported.  Since PerlIO is a drop-in replacement for stdio at the
 248  source code level, this shouldn't be that drastic a change.
 249  
 250  =item *
 251  
 252  Previous versions of perl and some readings of some sections of Camel
 253  III implied that the C<:raw> "discipline" was the inverse of C<:crlf>.
 254  Turning off "clrfness" is no longer enough to make a stream truly
 255  binary. So the PerlIO C<:raw> layer (or "discipline", to use the Camel
 256  book's older terminology) is now formally defined as being equivalent
 257  to binmode(FH) - which is in turn defined as doing whatever is
 258  necessary to pass each byte as-is without any translation.  In
 259  particular binmode(FH) - and hence C<:raw> - will now turn off both
 260  CRLF and UTF-8 translation and remove other layers (e.g. :encoding())
 261  which would modify byte stream.
 262  
 263  =item *
 264  
 265  The current user-visible implementation of pseudo-hashes (the weird
 266  use of the first array element) is deprecated starting from Perl 5.8.0
 267  and will be removed in Perl 5.10.0, and the feature will be
 268  implemented differently.  Not only is the current interface rather
 269  ugly, but the current implementation slows down normal array and hash
 270  use quite noticeably. The C<fields> pragma interface will remain
 271  available.  The I<restricted hashes> interface is expected to
 272  be the replacement interface (see L<Hash::Util>).  If your existing
 273  programs depends on the underlying implementation, consider using
 274  L<Class::PseudoHash> from CPAN.
 275  
 276  =item *
 277  
 278  The syntaxes C<< @a->[...] >> and  C<< %h->{...} >> have now been deprecated.
 279  
 280  =item *
 281  
 282  After years of trying, suidperl is considered to be too complex to
 283  ever be considered truly secure.  The suidperl functionality is likely
 284  to be removed in a future release.
 285  
 286  =item *
 287  
 288  The 5.005 threads model (module C<Thread>) is deprecated and expected
 289  to be removed in Perl 5.10.  Multithreaded code should be migrated to
 290  the new ithreads model (see L<threads>, L<threads::shared> and
 291  L<perlthrtut>).
 292  
 293  =item *
 294  
 295  The long deprecated uppercase aliases for the string comparison
 296  operators (EQ, NE, LT, LE, GE, GT) have now been removed.
 297  
 298  =item *
 299  
 300  The tr///C and tr///U features have been removed and will not return;
 301  the interface was a mistake.  Sorry about that.  For similar
 302  functionality, see pack('U0', ...) and pack('C0', ...). [561]
 303  
 304  =item *
 305  
 306  Earlier Perls treated "sub foo (@bar)" as equivalent to "sub foo (@)".
 307  The prototypes are now checked better at compile-time for invalid
 308  syntax.  An optional warning is generated ("Illegal character in
 309  prototype...")  but this may be upgraded to a fatal error in a future
 310  release.
 311  
 312  =item *
 313  
 314  The C<exec LIST> and C<system LIST> operations now produce warnings on
 315  tainted data and in some future release they will produce fatal errors.
 316  
 317  =item *
 318  
 319  The existing behaviour when localising tied arrays and hashes is wrong,
 320  and will be changed in a future release, so do not rely on the existing
 321  behaviour. See L<"Localising Tied Arrays and Hashes Is Broken">.
 322  
 323  =back
 324  
 325  =head1 Core Enhancements
 326  
 327  =head2 Unicode Overhaul
 328  
 329  Unicode in general should be now much more usable than in Perl 5.6.0
 330  (or even in 5.6.1).  Unicode can be used in hash keys, Unicode in
 331  regular expressions should work now, Unicode in tr/// should work now,
 332  Unicode in I/O should work now.  See L<perluniintro> for introduction
 333  and L<perlunicode> for details.
 334  
 335  =over 4
 336  
 337  =item *
 338  
 339  The Unicode Character Database coming with Perl has been upgraded
 340  to Unicode 3.2.0.  For more information, see http://www.unicode.org/ .
 341  [561+] (5.6.1 has UCD 3.0.1.)
 342  
 343  =item *
 344  
 345  For developers interested in enhancing Perl's Unicode capabilities:
 346  almost all the UCD files are included with the Perl distribution in
 347  the F<lib/unicore> subdirectory.  The most notable omission, for space
 348  considerations, is the Unihan database.
 349  
 350  =item *
 351  
 352  The properties \p{Blank} and \p{SpacePerl} have been added. "Blank" is like
 353  C isblank(), that is, it contains only "horizontal whitespace" (the space
 354  character is, the newline isn't), and the "SpacePerl" is the Unicode
 355  equivalent of C<\s> (\p{Space} isn't, since that includes the vertical
 356  tabulator character, whereas C<\s> doesn't.)
 357  
 358  See "New Unicode Properties" earlier in this document for additional
 359  information on changes with Unicode properties.
 360  
 361  =back
 362  
 363  =head2 PerlIO is Now The Default
 364  
 365  =over 4
 366  
 367  =item *
 368  
 369  IO is now by default done via PerlIO rather than system's "stdio".
 370  PerlIO allows "layers" to be "pushed" onto a file handle to alter the
 371  handle's behaviour.  Layers can be specified at open time via 3-arg
 372  form of open:
 373  
 374     open($fh,'>:crlf :utf8', $path) || ...
 375  
 376  or on already opened handles via extended C<binmode>:
 377  
 378     binmode($fh,':encoding(iso-8859-7)');
 379  
 380  The built-in layers are: unix (low level read/write), stdio (as in
 381  previous Perls), perlio (re-implementation of stdio buffering in a
 382  portable manner), crlf (does CRLF <=> "\n" translation as on Win32,
 383  but available on any platform).  A mmap layer may be available if
 384  platform supports it (mostly UNIXes).
 385  
 386  Layers to be applied by default may be specified via the 'open' pragma.
 387  
 388  See L</"Installation and Configuration Improvements"> for the effects
 389  of PerlIO on your architecture name.
 390  
 391  =item *
 392  
 393  If your platform supports fork(), you can use the list form of C<open>
 394  for pipes.  For example:
 395  
 396      open KID_PS, "-|", "ps", "aux" or die $!;
 397  
 398  forks the ps(1) command (without spawning a shell, as there are more
 399  than three arguments to open()), and reads its standard output via the
 400  C<KID_PS> filehandle.  See L<perlipc>.
 401  
 402  =item *
 403  
 404  File handles can be marked as accepting Perl's internal encoding of Unicode
 405  (UTF-8 or UTF-EBCDIC depending on platform) by a pseudo layer ":utf8" :
 406  
 407     open($fh,">:utf8","Uni.txt");
 408  
 409  Note for EBCDIC users: the pseudo layer ":utf8" is erroneously named
 410  for you since it's not UTF-8 what you will be getting but instead
 411  UTF-EBCDIC.  See L<perlunicode>, L<utf8>, and
 412  http://www.unicode.org/unicode/reports/tr16/ for more information.
 413  In future releases this naming may change.  See L<perluniintro>
 414  for more information about UTF-8.
 415  
 416  =item *
 417  
 418  If your environment variables (LC_ALL, LC_CTYPE, LANG) look like you
 419  want to use UTF-8 (any of the variables match C</utf-?8/i>), your
 420  STDIN, STDOUT, STDERR handles and the default open layer (see L<open>)
 421  are marked as UTF-8.  (This feature, like other new features that
 422  combine Unicode and I/O, work only if you are using PerlIO, but that's
 423  the default.)
 424  
 425  Note that after this Perl really does assume that everything is UTF-8:
 426  for example if some input handle is not, Perl will probably very soon
 427  complain about the input data like this "Malformed UTF-8 ..." since
 428  any old eight-bit data is not legal UTF-8.
 429  
 430  Note for code authors: if you want to enable your users to use UTF-8
 431  as their default encoding  but in your code still have eight-bit I/O streams
 432  (such as images or zip files), you need to explicitly open() or binmode()
 433  with C<:bytes> (see L<perlfunc/open> and L<perlfunc/binmode>), or you
 434  can just use C<binmode(FH)> (nice for pre-5.8.0 backward compatibility).
 435  
 436  =item *
 437  
 438  File handles can translate character encodings from/to Perl's internal
 439  Unicode form on read/write via the ":encoding()" layer.
 440  
 441  =item *
 442  
 443  File handles can be opened to "in memory" files held in Perl scalars via:
 444  
 445     open($fh,'>', \$variable) || ...
 446  
 447  =item *
 448  
 449  Anonymous temporary files are available without need to
 450  'use FileHandle' or other module via
 451  
 452     open($fh,"+>", undef) || ...
 453  
 454  That is a literal undef, not an undefined value.
 455  
 456  =back
 457  
 458  =head2 ithreads
 459  
 460  The new interpreter threads ("ithreads" for short) implementation of
 461  multithreading, by Arthur Bergman, replaces the old "5.005 threads"
 462  implementation.  In the ithreads model any data sharing between
 463  threads must be explicit, as opposed to the model where data sharing
 464  was implicit.  See L<threads> and L<threads::shared>, and
 465  L<perlthrtut>.
 466  
 467  As a part of the ithreads implementation Perl will also use
 468  any necessary and detectable reentrant libc interfaces.
 469  
 470  =head2 Restricted Hashes
 471  
 472  A restricted hash is restricted to a certain set of keys, no keys
 473  outside the set can be added.  Also individual keys can be restricted
 474  so that the key cannot be deleted and the value cannot be changed.
 475  No new syntax is involved: the Hash::Util module is the interface.
 476  
 477  =head2 Safe Signals
 478  
 479  Perl used to be fragile in that signals arriving at inopportune moments
 480  could corrupt Perl's internal state.  Now Perl postpones handling of
 481  signals until it's safe (between opcodes).
 482  
 483  This change may have surprising side effects because signals no longer
 484  interrupt Perl instantly.  Perl will now first finish whatever it was
 485  doing, like finishing an internal operation (like sort()) or an
 486  external operation (like an I/O operation), and only then look at any
 487  arrived signals (and before starting the next operation).  No more corrupt
 488  internal state since the current operation is always finished first,
 489  but the signal may take more time to get heard.  Note that breaking
 490  out from potentially blocking operations should still work, though.
 491  
 492  =head2 Understanding of Numbers
 493  
 494  In general a lot of fixing has happened in the area of Perl's
 495  understanding of numbers, both integer and floating point.  Since in
 496  many systems the standard number parsing functions like C<strtoul()>
 497  and C<atof()> seem to have bugs, Perl tries to work around their
 498  deficiencies.  This results hopefully in more accurate numbers.
 499  
 500  Perl now tries internally to use integer values in numeric conversions
 501  and basic arithmetics (+ - * /) if the arguments are integers, and
 502  tries also to keep the results stored internally as integers.
 503  This change leads to often slightly faster and always less lossy
 504  arithmetics. (Previously Perl always preferred floating point numbers
 505  in its math.)
 506  
 507  =head2 Arrays now always interpolate into double-quoted strings [561]
 508  
 509  In double-quoted strings, arrays now interpolate, no matter what.  The
 510  behavior in earlier versions of perl 5 was that arrays would interpolate
 511  into strings if the array had been mentioned before the string was
 512  compiled, and otherwise Perl would raise a fatal compile-time error.
 513  In versions 5.000 through 5.003, the error was
 514  
 515          Literal @example now requires backslash
 516  
 517  In versions 5.004_01 through 5.6.0, the error was
 518  
 519          In string, @example now must be written as \@example
 520  
 521  The idea here was to get people into the habit of writing
 522  C<"fred\@example.com"> when they wanted a literal C<@> sign, just as
 523  they have always written C<"Give me back my \$5"> when they wanted a
 524  literal C<$> sign.
 525  
 526  Starting with 5.6.1, when Perl now sees an C<@> sign in a
 527  double-quoted string, it I<always> attempts to interpolate an array,
 528  regardless of whether or not the array has been used or declared
 529  already.  The fatal error has been downgraded to an optional warning:
 530  
 531          Possible unintended interpolation of @example in string
 532  
 533  This warns you that C<"fred@example.com"> is going to turn into
 534  C<fred.com> if you don't backslash the C<@>.
 535  See http://www.plover.com/~mjd/perl/at-error.html for more details
 536  about the history here.
 537  
 538  =head2 Miscellaneous Changes
 539  
 540  =over 4
 541  
 542  =item *
 543  
 544  AUTOLOAD is now lvaluable, meaning that you can add the :lvalue attribute
 545  to AUTOLOAD subroutines and you can assign to the AUTOLOAD return value.
 546  
 547  =item *
 548  
 549  The $Config{byteorder} (and corresponding BYTEORDER in config.h) was
 550  previously wrong in platforms if sizeof(long) was 4, but sizeof(IV)
 551  was 8.  The byteorder was only sizeof(long) bytes long (1234 or 4321),
 552  but now it is correctly sizeof(IV) bytes long, (12345678 or 87654321).
 553  (This problem didn't affect Windows platforms.)
 554  
 555  Also, $Config{byteorder} is now computed dynamically--this is more
 556  robust with "fat binaries" where an executable image contains binaries
 557  for more than one binary platform, and when cross-compiling.
 558  
 559  =item *
 560  
 561  C<perl -d:Module=arg,arg,arg> now works (previously one couldn't pass
 562  in multiple arguments.)
 563  
 564  =item *
 565  
 566  C<do> followed by a bareword now ensures that this bareword isn't
 567  a keyword (to avoid a bug where C<do q(foo.pl)> tried to call a
 568  subroutine called C<q>).  This means that for example instead of
 569  C<do format()> you must write C<do &format()>.
 570  
 571  =item *
 572  
 573  The builtin dump() now gives an optional warning
 574  C<dump() better written as CORE::dump()>,
 575  meaning that by default C<dump(...)> is resolved as the builtin
 576  dump() which dumps core and aborts, not as (possibly) user-defined
 577  C<sub dump>.  To call the latter, qualify the call as C<&dump(...)>.
 578  (The whole dump() feature is to considered deprecated, and possibly
 579  removed/changed in future releases.)
 580  
 581  =item *
 582  
 583  chomp() and chop() are now overridable.  Note, however, that their
 584  prototype (as given by C<prototype("CORE::chomp")> is undefined,
 585  because it cannot be expressed and therefore one cannot really write
 586  replacements to override these builtins.
 587  
 588  =item *
 589  
 590  END blocks are now run even if you exit/die in a BEGIN block.
 591  Internally, the execution of END blocks is now controlled by
 592  PL_exit_flags & PERL_EXIT_DESTRUCT_END. This enables the new
 593  behaviour for Perl embedders. This will default in 5.10. See
 594  L<perlembed>.
 595  
 596  =item *
 597  
 598  Formats now support zero-padded decimal fields.
 599  
 600  =item *
 601  
 602  Although "you shouldn't do that", it was possible to write code that
 603  depends on Perl's hashed key order (Data::Dumper does this).  The new
 604  algorithm "One-at-a-Time" produces a different hashed key order.
 605  More details are in L</"Performance Enhancements">.
 606  
 607  =item *
 608  
 609  lstat(FILEHANDLE) now gives a warning because the operation makes no sense.
 610  In future releases this may become a fatal error.
 611  
 612  =item *
 613  
 614  Spurious syntax errors generated in certain situations, when glob()
 615  caused File::Glob to be loaded for the first time, have been fixed. [561]
 616  
 617  =item *
 618  
 619  Lvalue subroutines can now return C<undef> in list context.  However,
 620  the lvalue subroutine feature still remains experimental.  [561+]
 621  
 622  =item *
 623  
 624  A lost warning "Can't declare ... dereference in my" has been
 625  restored (Perl had it earlier but it became lost in later releases.)
 626  
 627  =item *
 628  
 629  A new special regular expression variable has been introduced:
 630  C<$^N>, which contains the most-recently closed group (submatch).
 631  
 632  =item *
 633  
 634  C<no Module;> does not produce an error even if Module does not have an
 635  unimport() method.  This parallels the behavior of C<use> vis-a-vis
 636  C<import>. [561]
 637  
 638  =item *
 639  
 640  The numerical comparison operators return C<undef> if either operand
 641  is a NaN.  Previously the behaviour was unspecified.
 642  
 643  =item *
 644  
 645  C<our> can now have an experimental optional attribute C<unique> that
 646  affects how global variables are shared among multiple interpreters,
 647  see L<perlfunc/our>.
 648  
 649  =item *
 650  
 651  The following builtin functions are now overridable: each(), keys(),
 652  pop(), push(), shift(), splice(), unshift(). [561]
 653  
 654  =item *
 655  
 656  C<pack() / unpack()> can now group template letters with C<()> and then
 657  apply repetition/count modifiers on the groups.
 658  
 659  =item *
 660  
 661  C<pack() / unpack()> can now process the Perl internal numeric types:
 662  IVs, UVs, NVs-- and also long doubles, if supported by the platform.
 663  The template letters are C<j>, C<J>, C<F>, and C<D>.
 664  
 665  =item *
 666  
 667  C<pack('U0a*', ...)> can now be used to force a string to UTF-8.
 668  
 669  =item *
 670  
 671  my __PACKAGE__ $obj now works. [561]
 672  
 673  =item *
 674  
 675  POSIX::sleep() now returns the number of I<unslept> seconds
 676  (as the POSIX standard says), as opposed to CORE::sleep() which
 677  returns the number of slept seconds.
 678  
 679  =item *
 680  
 681  printf() and sprintf() now support parameter reordering using the
 682  C<%\d+\$> and C<*\d+\$> syntaxes.  For example
 683  
 684      printf "%2\$s %1\$s\n", "foo", "bar";
 685  
 686  will print "bar foo\n".  This feature helps in writing
 687  internationalised software, and in general when the order
 688  of the parameters can vary.
 689  
 690  =item *
 691  
 692  The (\&) prototype now works properly. [561]
 693  
 694  =item *
 695  
 696  prototype(\[$@%&]) is now available to implicitly create references
 697  (useful for example if you want to emulate the tie() interface).
 698  
 699  =item *
 700  
 701  A new command-line option, C<-t> is available.  It is the
 702  little brother of C<-T>: instead of dying on taint violations,
 703  lexical warnings are given.  B<This is only meant as a temporary
 704  debugging aid while securing the code of old legacy applications.
 705  This is not a substitute for -T.>
 706  
 707  =item *
 708  
 709  In other taint news, the C<exec LIST> and C<system LIST> have now been
 710  considered too risky (think C<exec @ARGV>: it can start any program
 711  with any arguments), and now the said forms cause a warning under
 712  lexical warnings.  You should carefully launder the arguments to
 713  guarantee their validity.  In future releases of Perl the forms will
 714  become fatal errors so consider starting laundering now.
 715  
 716  =item *
 717  
 718  Tied hash interfaces are now required to have the EXISTS and DELETE
 719  methods (either own or inherited).
 720  
 721  =item *
 722  
 723  If tr/// is just counting characters, it doesn't attempt to
 724  modify its target.
 725  
 726  =item *
 727  
 728  untie() will now call an UNTIE() hook if it exists.  See L<perltie>
 729  for details. [561]
 730  
 731  =item *
 732  
 733  L<utime> now supports C<utime undef, undef, @files> to change the
 734  file timestamps to the current time.
 735  
 736  =item *
 737  
 738  The rules for allowing underscores (underbars) in numeric constants
 739  have been relaxed and simplified: now you can have an underscore
 740  simply B<between digits>.
 741  
 742  =item *
 743  
 744  Rather than relying on C's argv[0] (which may not contain a full pathname)
 745  where possible $^X is now set by asking the operating system.
 746  (eg by reading F</proc/self/exe> on Linux, F</proc/curproc/file> on FreeBSD)
 747  
 748  =item *
 749  
 750  A new variable, C<${^TAINT}>, indicates whether taint mode is enabled.
 751  
 752  =item *
 753  
 754  You can now override the readline() builtin, and this overrides also
 755  the <FILEHANDLE> angle bracket operator.
 756  
 757  =item *
 758  
 759  The command-line options -s and -F are now recognized on the shebang
 760  (#!) line.
 761  
 762  =item *
 763  
 764  Use of the C</c> match modifier without an accompanying C</g> modifier
 765  elicits a new warning: C<Use of /c modifier is meaningless without /g>.
 766  
 767  Use of C</c> in substitutions, even with C</g>, elicits
 768  C<Use of /c modifier is meaningless in s///>.
 769  
 770  Use of C</g> with C<split> elicits C<Use of /g modifier is meaningless
 771  in split>.
 772  
 773  =item *
 774  
 775  Support for the C<CLONE> special subroutine had been added.
 776  With ithreads, when a new thread is created, all Perl data is cloned,
 777  however non-Perl data cannot be cloned automatically.  In C<CLONE> you
 778  can do whatever you need to do, like for example handle the cloning of
 779  non-Perl data, if necessary.  C<CLONE> will be executed once for every
 780  package that has it defined or inherited.  It will be called in the
 781  context of the new thread, so all modifications are made in the new area.
 782  
 783  See L<perlmod>
 784  
 785  =back
 786  
 787  =head1 Modules and Pragmata
 788  
 789  =head2 New Modules and Pragmata
 790  
 791  =over 4
 792  
 793  =item *
 794  
 795  C<Attribute::Handlers>, originally by Damian Conway and now maintained
 796  by Arthur Bergman, allows a class to define attribute handlers.
 797  
 798      package MyPack;
 799      use Attribute::Handlers;
 800      sub Wolf :ATTR(SCALAR) { print "howl!\n" }
 801  
 802      # later, in some package using or inheriting from MyPack...
 803  
 804      my MyPack $Fluffy : Wolf; # the attribute handler Wolf will be called
 805  
 806  Both variables and routines can have attribute handlers.  Handlers can
 807  be specific to type (SCALAR, ARRAY, HASH, or CODE), or specific to the
 808  exact compilation phase (BEGIN, CHECK, INIT, or END).
 809  See L<Attribute::Handlers>.
 810  
 811  =item *
 812  
 813  C<B::Concise>, by Stephen McCamant, is a new compiler backend for
 814  walking the Perl syntax tree, printing concise info about ops.
 815  The output is highly customisable.  See L<B::Concise>. [561+]
 816  
 817  =item *
 818  
 819  The new bignum, bigint, and bigrat pragmas, by Tels, implement
 820  transparent bignum support (using the Math::BigInt, Math::BigFloat,
 821  and Math::BigRat backends).
 822  
 823  =item *
 824  
 825  C<Class::ISA>, by Sean Burke, is a module for reporting the search
 826  path for a class's ISA tree.  See L<Class::ISA>.
 827  
 828  =item *
 829  
 830  C<Cwd> now has a split personality: if possible, an XS extension is
 831  used, (this will hopefully be faster, more secure, and more robust)
 832  but if not possible, the familiar Perl implementation is used.
 833  
 834  =item *
 835  
 836  C<Devel::PPPort>, originally by Kenneth Albanowski and now
 837  maintained by Paul Marquess, has been added.  It is primarily used
 838  by C<h2xs> to enhance portability of XS modules between different
 839  versions of Perl.  See L<Devel::PPPort>.
 840  
 841  =item *
 842  
 843  C<Digest>, frontend module for calculating digests (checksums), from
 844  Gisle Aas, has been added.  See L<Digest>.
 845  
 846  =item *
 847  
 848  C<Digest::MD5> for calculating MD5 digests (checksums) as defined in
 849  RFC 1321, from Gisle Aas, has been added.  See L<Digest::MD5>.
 850  
 851      use Digest::MD5 'md5_hex';
 852  
 853      $digest = md5_hex("Thirsty Camel");
 854  
 855      print $digest, "\n"; # 01d19d9d2045e005c3f1b80e8b164de1
 856  
 857  NOTE: the C<MD5> backward compatibility module is deliberately not
 858  included since its further use is discouraged.
 859  
 860  See also L<PerlIO::via::QuotedPrint>.
 861  
 862  =item *
 863  
 864  C<Encode>, originally by Nick Ing-Simmons and now maintained by Dan
 865  Kogai, provides a mechanism to translate between different character
 866  encodings.  Support for Unicode, ISO-8859-1, and ASCII are compiled in
 867  to the module.  Several other encodings (like the rest of the
 868  ISO-8859, CP*/Win*, Mac, KOI8-R, three variants EBCDIC, Chinese,
 869  Japanese, and Korean encodings) are included and can be loaded at
 870  runtime.  (For space considerations, the largest Chinese encodings
 871  have been separated into their own CPAN module, Encode::HanExtra,
 872  which Encode will use if available).  See L<Encode>.
 873  
 874  Any encoding supported by Encode module is also available to the
 875  ":encoding()" layer if PerlIO is used.
 876  
 877  =item *
 878  
 879  C<Hash::Util> is the interface to the new I<restricted hashes>
 880  feature.  (Implemented by Jeffrey Friedl, Nick Ing-Simmons, and
 881  Michael Schwern.)  See L<Hash::Util>.
 882  
 883  =item *
 884  
 885  C<I18N::Langinfo> can be used to query locale information.
 886  See L<I18N::Langinfo>.
 887  
 888  =item *
 889  
 890  C<I18N::LangTags>, by Sean Burke, has functions for dealing with
 891  RFC3066-style language tags.  See L<I18N::LangTags>.
 892  
 893  =item *
 894  
 895  C<ExtUtils::Constant>, by Nicholas Clark, is a new tool for extension
 896  writers for generating XS code to import C header constants.
 897  See L<ExtUtils::Constant>.
 898  
 899  =item *
 900  
 901  C<Filter::Simple>, by Damian Conway, is an easy-to-use frontend to
 902  Filter::Util::Call.  See L<Filter::Simple>.
 903  
 904      # in MyFilter.pm:
 905  
 906      package MyFilter;
 907  
 908      use Filter::Simple sub {
 909          while (my ($from, $to) = splice @_, 0, 2) {
 910                  s/$from/$to/g;
 911          }
 912      };
 913  
 914      1;
 915  
 916      # in user's code:
 917  
 918      use MyFilter qr/red/ => 'green';
 919  
 920      print "red\n";   # this code is filtered, will print "green\n"
 921      print "bored\n"; # this code is filtered, will print "bogreen\n"
 922  
 923      no MyFilter;
 924  
 925      print "red\n";   # this code is not filtered, will print "red\n"
 926  
 927  =item *
 928  
 929  C<File::Temp>, by Tim Jenness, allows one to create temporary files
 930  and directories in an easy, portable, and secure way.  See L<File::Temp>.
 931  [561+]
 932  
 933  =item *
 934  
 935  C<Filter::Util::Call>, by Paul Marquess, provides you with the
 936  framework to write I<source filters> in Perl.  For most uses, the
 937  frontend Filter::Simple is to be preferred.  See L<Filter::Util::Call>.
 938  
 939  =item *
 940  
 941  C<if>, by Ilya Zakharevich, is a new pragma for conditional inclusion
 942  of modules.
 943  
 944  =item *
 945  
 946  L<libnet>, by Graham Barr, is a collection of perl5 modules related
 947  to network programming.  See L<Net::FTP>, L<Net::NNTP>, L<Net::Ping>
 948  (not part of libnet, but related), L<Net::POP3>, L<Net::SMTP>,
 949  and L<Net::Time>.
 950  
 951  Perl installation leaves libnet unconfigured; use F<libnetcfg>
 952  to configure it.
 953  
 954  =item *
 955  
 956  C<List::Util>, by Graham Barr, is a selection of general-utility
 957  list subroutines, such as sum(), min(), first(), and shuffle().
 958  See L<List::Util>.
 959  
 960  =item *
 961  
 962  C<Locale::Constants>, C<Locale::Country>, C<Locale::Currency>
 963  C<Locale::Language>, and L<Locale::Script>, by Neil Bowers, have
 964  been added.  They provide the codes for various locale standards, such
 965  as "fr" for France, "usd" for US Dollar, and "ja" for Japanese.
 966  
 967      use Locale::Country;
 968  
 969      $country = code2country('jp');               # $country gets 'Japan'
 970      $code    = country2code('Norway');           # $code gets 'no'
 971  
 972  See L<Locale::Constants>, L<Locale::Country>, L<Locale::Currency>,
 973  and L<Locale::Language>.
 974  
 975  =item *
 976  
 977  C<Locale::Maketext>, by Sean Burke, is a localization framework.  See
 978  L<Locale::Maketext>, and L<Locale::Maketext::TPJ13>.  The latter is an
 979  article about software localization, originally published in The Perl
 980  Journal #13, and republished here with kind permission.
 981  
 982  =item *
 983  
 984  C<Math::BigRat> for big rational numbers, to accompany Math::BigInt and
 985  Math::BigFloat, from Tels.  See L<Math::BigRat>.
 986  
 987  =item *
 988  
 989  C<Memoize> can make your functions faster by trading space for time,
 990  from Mark-Jason Dominus.  See L<Memoize>.
 991  
 992  =item *
 993  
 994  C<MIME::Base64>, by Gisle Aas, allows you to encode data in base64,
 995  as defined in RFC 2045 - I<MIME (Multipurpose Internet Mail
 996  Extensions)>.
 997  
 998      use MIME::Base64;
 999  
1000      $encoded = encode_base64('Aladdin:open sesame');
1001      $decoded = decode_base64($encoded);
1002  
1003      print $encoded, "\n"; # "QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
1004  
1005  See L<MIME::Base64>.
1006  
1007  =item *
1008  
1009  C<MIME::QuotedPrint>, by Gisle Aas, allows you to encode data
1010  in quoted-printable encoding, as defined in RFC 2045 - I<MIME
1011  (Multipurpose Internet Mail Extensions)>.
1012  
1013      use MIME::QuotedPrint;
1014  
1015      $encoded = encode_qp("\xDE\xAD\xBE\xEF");
1016      $decoded = decode_qp($encoded);
1017  
1018      print $encoded, "\n"; # "=DE=AD=BE=EF\n"
1019      print $decoded, "\n"; # "\xDE\xAD\xBE\xEF\n"
1020  
1021  See also L<PerlIO::via::QuotedPrint>.
1022  
1023  =item *
1024  
1025  C<NEXT>, by Damian Conway, is a pseudo-class for method redispatch.
1026  See L<NEXT>.
1027  
1028  =item *
1029  
1030  C<open> is a new pragma for setting the default I/O layers
1031  for open().
1032  
1033  =item *
1034  
1035  C<PerlIO::scalar>, by Nick Ing-Simmons, provides the implementation
1036  of IO to "in memory" Perl scalars as discussed above.  It also serves
1037  as an example of a loadable PerlIO layer.  Other future possibilities
1038  include PerlIO::Array and PerlIO::Code.  See L<PerlIO::scalar>.
1039  
1040  =item *
1041  
1042  C<PerlIO::via>, by Nick Ing-Simmons, acts as a PerlIO layer and wraps
1043  PerlIO layer functionality provided by a class (typically implemented
1044  in Perl code).
1045  
1046  =item *
1047  
1048  C<PerlIO::via::QuotedPrint>, by Elizabeth Mattijsen, is an example
1049  of a C<PerlIO::via> class:
1050  
1051      use PerlIO::via::QuotedPrint;
1052      open($fh,">:via(QuotedPrint)",$path);
1053  
1054  This will automatically convert everything output to C<$fh> to
1055  Quoted-Printable.  See L<PerlIO::via> and L<PerlIO::via::QuotedPrint>.
1056  
1057  =item *
1058  
1059  C<Pod::ParseLink>, by Russ Allbery, has been added,
1060  to parse LZ<><> links in pods as described in the new
1061  perlpodspec.
1062  
1063  =item *
1064  
1065  C<Pod::Text::Overstrike>, by Joe Smith, has been added.
1066  It converts POD data to formatted overstrike text.
1067  See L<Pod::Text::Overstrike>. [561+]
1068  
1069  =item *
1070  
1071  C<Scalar::Util> is a selection of general-utility scalar subroutines,
1072  such as blessed(), reftype(), and tainted().  See L<Scalar::Util>.
1073  
1074  =item *
1075  
1076  C<sort> is a new pragma for controlling the behaviour of sort().
1077  
1078  =item *
1079  
1080  C<Storable> gives persistence to Perl data structures by allowing the
1081  storage and retrieval of Perl data to and from files in a fast and
1082  compact binary format.  Because in effect Storable does serialisation
1083  of Perl data structures, with it you can also clone deep, hierarchical
1084  datastructures.  Storable was originally created by Raphael Manfredi,
1085  but it is now maintained by Abhijit Menon-Sen.  Storable has been
1086  enhanced to understand the two new hash features, Unicode keys and
1087  restricted hashes.  See L<Storable>.
1088  
1089  =item *
1090  
1091  C<Switch>, by Damian Conway, has been added.  Just by saying
1092  
1093      use Switch;
1094  
1095  you have C<switch> and C<case> available in Perl.
1096  
1097      use Switch;
1098  
1099      switch ($val) {
1100  
1101          case 1        { print "number 1" }
1102          case "a"    { print "string a" }
1103          case [1..10,42]    { print "number in list" }
1104          case (@array)    { print "number in list" }
1105          case /\w+/    { print "pattern" }
1106          case qr/\w+/    { print "pattern" }
1107          case (%hash)    { print "entry in hash" }
1108          case (\%hash)    { print "entry in hash" }
1109          case (\&sub)    { print "arg to subroutine" }
1110          else        { print "previous case not true" }
1111      }
1112  
1113  See L<Switch>.
1114  
1115  =item *
1116  
1117  C<Test::More>, by Michael Schwern, is yet another framework for writing
1118  test scripts, more extensive than Test::Simple.  See L<Test::More>.
1119  
1120  =item *
1121  
1122  C<Test::Simple>, by Michael Schwern, has basic utilities for writing
1123  tests.   See L<Test::Simple>.
1124  
1125  =item *
1126  
1127  C<Text::Balanced>, by Damian Conway, has been added, for extracting
1128  delimited text sequences from strings.
1129  
1130      use Text::Balanced 'extract_delimited';
1131  
1132      ($a, $b) = extract_delimited("'never say never', he never said", "'", '');
1133  
1134  $a will be "'never say never'", $b will be ', he never said'.
1135  
1136  In addition to extract_delimited(), there are also extract_bracketed(),
1137  extract_quotelike(), extract_codeblock(), extract_variable(),
1138  extract_tagged(), extract_multiple(), gen_delimited_pat(), and
1139  gen_extract_tagged().  With these, you can implement rather advanced
1140  parsing algorithms.  See L<Text::Balanced>.
1141  
1142  =item *
1143  
1144  C<threads>, by Arthur Bergman, is an interface to interpreter threads.
1145  Interpreter threads (ithreads) is the new thread model introduced in
1146  Perl 5.6 but only available as an internal interface for extension
1147  writers (and for Win32 Perl for C<fork()> emulation).  See L<threads>,
1148  L<threads::shared>, and L<perlthrtut>.
1149  
1150  =item *
1151  
1152  C<threads::shared>, by Arthur Bergman, allows data sharing for
1153  interpreter threads.  See L<threads::shared>.
1154  
1155  =item *
1156  
1157  C<Tie::File>, by Mark-Jason Dominus, associates a Perl array with the
1158  lines of a file.  See L<Tie::File>.
1159  
1160  =item *
1161  
1162  C<Tie::Memoize>, by Ilya Zakharevich, provides on-demand loaded hashes.
1163  See L<Tie::Memoize>.
1164  
1165  =item *
1166  
1167  C<Tie::RefHash::Nestable>, by Edward Avis, allows storing hash
1168  references (unlike the standard Tie::RefHash)  The module is contained
1169  within Tie::RefHash.  See L<Tie::RefHash>.
1170  
1171  =item *
1172  
1173  C<Time::HiRes>, by Douglas E. Wegscheid, provides high resolution
1174  timing (ualarm, usleep, and gettimeofday).  See L<Time::HiRes>.
1175  
1176  =item *
1177  
1178  C<Unicode::UCD> offers a querying interface to the Unicode Character
1179  Database.  See L<Unicode::UCD>.
1180  
1181  =item *
1182  
1183  C<Unicode::Collate>, by SADAHIRO Tomoyuki, implements the UCA
1184  (Unicode Collation Algorithm) for sorting Unicode strings.
1185  See L<Unicode::Collate>.
1186  
1187  =item *
1188  
1189  C<Unicode::Normalize>, by SADAHIRO Tomoyuki, implements the various
1190  Unicode normalization forms.  See L<Unicode::Normalize>.
1191  
1192  =item *
1193  
1194  C<XS::APItest>, by Tim Jenness, is a test extension that exercises XS
1195  APIs.  Currently only C<printf()> is tested: how to output various
1196  basic data types from XS.
1197  
1198  =item *
1199  
1200  C<XS::Typemap>, by Tim Jenness, is a test extension that exercises
1201  XS typemaps.  Nothing gets installed, but the code is worth studying
1202  for extension writers.
1203  
1204  =back
1205  
1206  =head2 Updated And Improved Modules and Pragmata
1207  
1208  =over 4
1209  
1210  =item *
1211  
1212  The following independently supported modules have been updated to the
1213  newest versions from CPAN: CGI, CPAN, DB_File, File::Spec, File::Temp,
1214  Getopt::Long, Math::BigFloat, Math::BigInt, the podlators bundle
1215  (Pod::Man, Pod::Text), Pod::LaTeX [561+], Pod::Parser, Storable,
1216  Term::ANSIColor, Test, Text-Tabs+Wrap.
1217  
1218  =item *
1219  
1220  attributes::reftype() now works on tied arguments.
1221  
1222  =item *
1223  
1224  AutoLoader can now be disabled with C<no AutoLoader;>.
1225  
1226  =item *
1227  
1228  B::Deparse has been significantly enhanced by Robin Houston.  It can
1229  now deparse almost all of the standard test suite (so that the tests
1230  still succeed).  There is a make target "test.deparse" for trying this
1231  out.
1232  
1233  =item *
1234  
1235  Carp now has better interface documentation, and the @CARP_NOT
1236  interface has been added to get optional control over where errors
1237  are reported independently of @ISA, by Ben Tilly.
1238  
1239  =item *
1240  
1241  Class::Struct can now define the classes in compile time.
1242  
1243  =item *
1244  
1245  Class::Struct now assigns the array/hash element if the accessor
1246  is called with an array/hash element as the B<sole> argument.
1247  
1248  =item *
1249  
1250  The return value of Cwd::fastcwd() is now tainted.
1251  
1252  =item *
1253  
1254  Data::Dumper now has an option to sort hashes.
1255  
1256  =item *
1257  
1258  Data::Dumper now has an option to dump code references
1259  using B::Deparse.
1260  
1261  =item *
1262  
1263  DB_File now supports newer Berkeley DB versions, among
1264  other improvements.
1265  
1266  =item *
1267  
1268  Devel::Peek now has an interface for the Perl memory statistics
1269  (this works only if you are using perl's malloc, and if you have
1270  compiled with debugging).
1271  
1272  =item *
1273  
1274  The English module can now be used without the infamous performance
1275  hit by saying
1276  
1277      use English '-no_match_vars';
1278  
1279  (Assuming, of course, that you don't need the troublesome variables
1280  C<$`>, C<$&>, or C<$'>.)  Also, introduced C<@LAST_MATCH_START> and
1281  C<@LAST_MATCH_END> English aliases for C<@-> and C<@+>.
1282  
1283  =item *
1284  
1285  ExtUtils::MakeMaker has been significantly cleaned up and fixed.
1286  The enhanced version has also been backported to earlier releases
1287  of Perl and submitted to CPAN so that the earlier releases can
1288  enjoy the fixes.
1289  
1290  =item *
1291  
1292  The arguments of WriteMakefile() in Makefile.PL are now checked
1293  for sanity much more carefully than before.  This may cause new
1294  warnings when modules are being installed.  See L<ExtUtils::MakeMaker>
1295  for more details.
1296  
1297  =item *
1298  
1299  ExtUtils::MakeMaker now uses File::Spec internally, which hopefully
1300  leads to better portability.
1301  
1302  =item *
1303  
1304  Fcntl, Socket, and Sys::Syslog have been rewritten by Nicholas Clark
1305  to use the new-style constant dispatch section (see L<ExtUtils::Constant>).
1306  This means that they will be more robust and hopefully faster.
1307  
1308  =item *
1309  
1310  File::Find now chdir()s correctly when chasing symbolic links. [561]
1311  
1312  =item *
1313  
1314  File::Find now has pre- and post-processing callbacks.  It also
1315  correctly changes directories when chasing symbolic links.  Callbacks
1316  (naughtily) exiting with "next;" instead of "return;" now work.
1317  
1318  =item *
1319  
1320  File::Find is now (again) reentrant.  It also has been made
1321  more portable.
1322  
1323  =item *
1324  
1325  The warnings issued by File::Find now belong to their own category.
1326  You can enable/disable them with C<use/no warnings 'File::Find';>.
1327  
1328  =item *
1329  
1330  File::Glob::glob() has been renamed to File::Glob::bsd_glob()
1331  because the name clashes with the builtin glob().  The older
1332  name is still available for compatibility, but is deprecated. [561]
1333  
1334  =item *
1335  
1336  File::Glob now supports C<GLOB_LIMIT> constant to limit the size of
1337  the returned list of filenames.
1338  
1339  =item *
1340  
1341  IPC::Open3 now allows the use of numeric file descriptors.
1342  
1343  =item *
1344  
1345  IO::Socket now has an atmark() method, which returns true if the socket
1346  is positioned at the out-of-band mark.  The method is also exportable
1347  as a sockatmark() function.
1348  
1349  =item *
1350  
1351  IO::Socket::INET failed to open the specified port if the service name
1352  was not known.  It now correctly uses the supplied port number as is. [561]
1353  
1354  =item *
1355  
1356  IO::Socket::INET has support for the ReusePort option (if your
1357  platform supports it).  The Reuse option now has an alias, ReuseAddr.
1358  For clarity, you may want to prefer ReuseAddr.
1359  
1360  =item *
1361  
1362  IO::Socket::INET now supports a value of zero for C<LocalPort>
1363  (usually meaning that the operating system will make one up.)
1364  
1365  =item *
1366  
1367  'use lib' now works identically to @INC.  Removing directories
1368  with 'no lib' now works.
1369  
1370  =item *
1371  
1372  Math::BigFloat and Math::BigInt have undergone a full rewrite by Tels.
1373  They are now magnitudes faster, and they support various bignum
1374  libraries such as GMP and PARI as their backends.
1375  
1376  =item *
1377  
1378  Math::Complex handles inf, NaN etc., better.
1379  
1380  =item *
1381  
1382  Net::Ping has been considerably enhanced by Rob Brown: multihoming is
1383  now supported, Win32 functionality is better, there is now time
1384  measuring functionality (optionally high-resolution using
1385  Time::HiRes), and there is now "external" protocol which uses
1386  Net::Ping::External module which runs your external ping utility and
1387  parses the output.  A version of Net::Ping::External is available in
1388  CPAN.
1389  
1390  Note that some of the Net::Ping tests are disabled when running
1391  under the Perl distribution since one cannot assume one or more
1392  of the following: enabled echo port at localhost, full Internet
1393  connectivity, or sympathetic firewalls.  You can set the environment
1394  variable PERL_TEST_Net_Ping to "1" (one) before running the Perl test
1395  suite to enable all the Net::Ping tests.
1396  
1397  =item *
1398  
1399  POSIX::sigaction() is now much more flexible and robust.
1400  You can now install coderef handlers, 'DEFAULT', and 'IGNORE'
1401  handlers, installing new handlers was not atomic.
1402  
1403  =item *
1404  
1405  In Safe, C<%INC> is now localised in a Safe compartment so that
1406  use/require work.
1407  
1408  =item *
1409  
1410  In SDBM_File on dosish platforms, some keys went missing because of
1411  lack of support for files with "holes".  A workaround for the problem
1412  has been added.
1413  
1414  =item *
1415  
1416  In Search::Dict one can now have a pre-processing hook for the
1417  lines being searched.
1418  
1419  =item *
1420  
1421  The Shell module now has an OO interface.
1422  
1423  =item *
1424  
1425  In Sys::Syslog there is now a failover mechanism that will go
1426  through alternative connection mechanisms until the message
1427  is successfully logged.
1428  
1429  =item *
1430  
1431  The Test module has been significantly enhanced.
1432  
1433  =item *
1434  
1435  Time::Local::timelocal() does not handle fractional seconds anymore.
1436  The rationale is that neither does localtime(), and timelocal() and
1437  localtime() are supposed to be inverses of each other.
1438  
1439  =item *
1440  
1441  The vars pragma now supports declaring fully qualified variables.
1442  (Something that C<our()> does not and will not support.)
1443  
1444  =item *
1445  
1446  The C<utf8::> name space (as in the pragma) provides various
1447  Perl-callable functions to provide low level access to Perl's
1448  internal Unicode representation.  At the moment only length()
1449  has been implemented.
1450  
1451  =back
1452  
1453  =head1 Utility Changes
1454  
1455  =over 4
1456  
1457  =item *
1458  
1459  Emacs perl mode (emacs/cperl-mode.el) has been updated to version
1460  4.31.
1461  
1462  =item *
1463  
1464  F<emacs/e2ctags.pl> is now much faster.
1465  
1466  =item *
1467  
1468  C<enc2xs> is a tool for people adding their own encodings to the
1469  Encode module.
1470  
1471  =item *
1472  
1473  C<h2ph> now supports C trigraphs.
1474  
1475  =item *
1476  
1477  C<h2xs> now produces a template README.
1478  
1479  =item *
1480  
1481  C<h2xs> now uses C<Devel::PPPort> for better portability between
1482  different versions of Perl.
1483  
1484  =item *
1485  
1486  C<h2xs> uses the new L<ExtUtils::Constant|ExtUtils::Constant> module
1487  which will affect newly created extensions that define constants.
1488  Since the new code is more correct (if you have two constants where the
1489  first one is a prefix of the second one, the first constant B<never>
1490  got defined), less lossy (it uses integers for integer constant,
1491  as opposed to the old code that used floating point numbers even for
1492  integer constants), and slightly faster, you might want to consider
1493  regenerating your extension code (the new scheme makes regenerating
1494  easy).  L<h2xs> now also supports C trigraphs.
1495  
1496  =item *
1497  
1498  C<libnetcfg> has been added to configure libnet.
1499  
1500  =item *
1501  
1502  C<perlbug> is now much more robust.  It also sends the bug report to
1503  perl.org, not perl.com.
1504  
1505  =item *
1506  
1507  C<perlcc> has been rewritten and its user interface (that is,
1508  command line) is much more like that of the UNIX C compiler, cc.
1509  (The perlbc tools has been removed.  Use C<perlcc -B> instead.)
1510  B<Note that perlcc is still considered very experimental and
1511  unsupported.> [561]
1512  
1513  =item *
1514  
1515  C<perlivp> is a new Installation Verification Procedure utility
1516  for running any time after installing Perl.
1517  
1518  =item *
1519  
1520  C<piconv> is an implementation of the character conversion utility
1521  C<iconv>, demonstrating the new Encode module.
1522  
1523  =item *
1524  
1525  C<pod2html> now allows specifying a cache directory.
1526  
1527  =item *
1528  
1529  C<pod2html> now produces XHTML 1.0.
1530  
1531  =item *
1532  
1533  C<pod2html> now understands POD written using different line endings
1534  (PC-like CRLF versus UNIX-like LF versus MacClassic-like CR).
1535  
1536  =item *
1537  
1538  C<s2p> has been completely rewritten in Perl.  (It is in fact a full
1539  implementation of sed in Perl: you can use the sed functionality by
1540  using the C<psed> utility.)
1541  
1542  =item *
1543  
1544  C<xsubpp> now understands POD documentation embedded in the *.xs
1545  files. [561]
1546  
1547  =item *
1548  
1549  C<xsubpp> now supports the OUT keyword.
1550  
1551  =back
1552  
1553  =head1 New Documentation
1554  
1555  =over 4
1556  
1557  =item *
1558  
1559  perl56delta details the changes between the 5.005 release and the
1560  5.6.0 release.
1561  
1562  =item *
1563  
1564  perlclib documents the internal replacements for standard C library
1565  functions.  (Interesting only for extension writers and Perl core
1566  hackers.) [561+]
1567  
1568  =item *
1569  
1570  perldebtut is a Perl debugging tutorial. [561+]
1571  
1572  =item *
1573  
1574  perlebcdic contains considerations for running Perl on EBCDIC
1575  platforms. [561+]
1576  
1577  =item *
1578  
1579  perlintro is a gentle introduction to Perl.
1580  
1581  =item *
1582  
1583  perliol documents the internals of PerlIO with layers.
1584  
1585  =item *
1586  
1587  perlmodstyle is a style guide for writing modules.
1588  
1589  =item *
1590  
1591  perlnewmod tells about writing and submitting a new module. [561+]
1592  
1593  =item *
1594  
1595  perlpacktut is a pack() tutorial.
1596  
1597  =item *
1598  
1599  perlpod has been rewritten to be clearer and to record the best
1600  practices gathered over the years.
1601  
1602  =item *
1603  
1604  perlpodspec is a more formal specification of the pod format,
1605  mainly of interest for writers of pod applications, not to
1606  people writing in pod.
1607  
1608  =item *
1609  
1610  perlretut is a regular expression tutorial. [561+]
1611  
1612  =item *
1613  
1614  perlrequick is a regular expressions quick-start guide.
1615  Yes, much quicker than perlretut. [561]
1616  
1617  =item *
1618  
1619  perltodo has been updated.
1620  
1621  =item *
1622  
1623  perltootc has been renamed as perltooc (to not to conflict
1624  with perltoot in filesystems restricted to "8.3" names).
1625  
1626  =item *
1627  
1628  perluniintro is an introduction to using Unicode in Perl.
1629  (perlunicode is more of a detailed reference and background
1630  information)
1631  
1632  =item *
1633  
1634  perlutil explains the command line utilities packaged with the Perl
1635  distribution. [561+]
1636  
1637  =back
1638  
1639  The following platform-specific documents are available before
1640  the installation as README.I<platform>, and after the installation
1641  as perlI<platform>:
1642  
1643      perlaix perlamiga perlapollo perlbeos perlbs2000
1644      perlce perlcygwin perldgux perldos perlepoc perlfreebsd perlhpux
1645      perlhurd perlirix perlmachten perlmacos perlmint perlmpeix
1646      perlnetware perlos2 perlos390 perlplan9 perlqnx perlsolaris
1647      perltru64 perluts perlvmesa perlvms perlvos perlwin32
1648  
1649  These documents usually detail one or more of the following subjects:
1650  configuring, building, testing, installing, and sometimes also using
1651  Perl on the said platform.
1652  
1653  Eastern Asian Perl users are now welcomed in their own languages:
1654  README.jp (Japanese), README.ko (Korean), README.cn (simplified
1655  Chinese) and README.tw (traditional Chinese), which are written in
1656  normal pod but encoded in EUC-JP, EUC-KR, EUC-CN and Big5.  These
1657  will get installed as
1658  
1659     perljp perlko perlcn perltw
1660  
1661  =over 4
1662  
1663  =item *
1664  
1665  The documentation for the POSIX-BC platform is called "BS2000", to avoid
1666  confusion with the Perl POSIX module.
1667  
1668  =item *
1669  
1670  The documentation for the WinCE platform is called perlce (README.ce
1671  in the source code kit), to avoid confusion with the perlwin32
1672  documentation on 8.3-restricted filesystems.
1673  
1674  =back
1675  
1676  =head1 Performance Enhancements
1677  
1678  =over 4
1679  
1680  =item *
1681  
1682  map() could get pathologically slow when the result list it generates
1683  is larger than the source list.  The performance has been improved for
1684  common scenarios. [561]
1685  
1686  =item *
1687  
1688  sort() is also fully reentrant, in the sense that the sort function
1689  can itself call sort().  This did not work reliably in previous
1690  releases. [561]
1691  
1692  =item *
1693  
1694  sort() has been changed to use primarily mergesort internally as
1695  opposed to the earlier quicksort.  For very small lists this may
1696  result in slightly slower sorting times, but in general the speedup
1697  should be at least 20%.  Additional bonuses are that the worst case
1698  behaviour of sort() is now better (in computer science terms it now
1699  runs in time O(N log N), as opposed to quicksort's Theta(N**2)
1700  worst-case run time behaviour), and that sort() is now stable
1701  (meaning that elements with identical keys will stay ordered as they
1702  were before the sort).  See the C<sort> pragma for information.
1703  
1704  The story in more detail: suppose you want to serve yourself a little
1705  slice of Pi.
1706  
1707      @digits = ( 3,1,4,1,5,9 );
1708  
1709  A numerical sort of the digits will yield (1,1,3,4,5,9), as expected.
1710  Which C<1> comes first is hard to know, since one C<1> looks pretty
1711  much like any other.  You can regard this as totally trivial,
1712  or somewhat profound.  However, if you just want to sort the even
1713  digits ahead of the odd ones, then what will
1714  
1715      sort { ($a % 2) <=> ($b % 2) } @digits;
1716  
1717  yield?  The only even digit, C<4>, will come first.  But how about
1718  the odd numbers, which all compare equal?  With the quicksort algorithm
1719  used to implement Perl 5.6 and earlier, the order of ties is left up
1720  to the sort.  So, as you add more and more digits of Pi, the order
1721  in which the sorted even and odd digits appear will change.
1722  and, for sufficiently large slices of Pi, the quicksort algorithm
1723  in Perl 5.8 won't return the same results even if reinvoked with the
1724  same input.  The justification for this rests with quicksort's
1725  worst case behavior.  If you run
1726  
1727     sort { $a <=> $b } ( 1 .. $N , 1 .. $N );
1728  
1729  (something you might approximate if you wanted to merge two sorted
1730  arrays using sort), doubling $N doesn't just double the quicksort time,
1731  it I<quadruples> it.  Quicksort has a worst case run time that can
1732  grow like N**2, so-called I<quadratic> behaviour, and it can happen
1733  on patterns that may well arise in normal use.  You won't notice this
1734  for small arrays, but you I<will> notice it with larger arrays,
1735  and you may not live long enough for the sort to complete on arrays
1736  of a million elements.  So the 5.8 quicksort scrambles large arrays
1737  before sorting them, as a statistical defence against quadratic behaviour.
1738  But that means if you sort the same large array twice, ties may be
1739  broken in different ways.
1740  
1741  Because of the unpredictability of tie-breaking order, and the quadratic
1742  worst-case behaviour, quicksort was I<almost> replaced completely with
1743  a stable mergesort.  I<Stable> means that ties are broken to preserve
1744  the original order of appearance in the input array.  So
1745  
1746      sort { ($a % 2) <=> ($b % 2) } (3,1,4,1,5,9);
1747  
1748  will yield (4,3,1,1,5,9), guaranteed.  The even and odd numbers
1749  appear in the output in the same order they appeared in the input.
1750  Mergesort has worst case O(N log N) behaviour, the best value
1751  attainable.  And, ironically, this mergesort does particularly
1752  well where quicksort goes quadratic:  mergesort sorts (1..$N, 1..$N)
1753  in O(N) time.  But quicksort was rescued at the last moment because
1754  it is faster than mergesort on certain inputs and platforms.
1755  For example, if you really I<don't> care about the order of even
1756  and odd digits, quicksort will run in O(N) time; it's very good
1757  at sorting many repetitions of a small number of distinct elements.
1758  The quicksort divide and conquer strategy works well on platforms
1759  with relatively small, very fast, caches.  Eventually, the problem gets
1760  whittled down to one that fits in the cache, from which point it
1761  benefits from the increased memory speed.
1762  
1763  Quicksort was rescued by implementing a sort pragma to control aspects
1764  of the sort.  The B<stable> subpragma forces stable behaviour,
1765  regardless of algorithm.  The B<_quicksort> and B<_mergesort>
1766  subpragmas are heavy-handed ways to select the underlying implementation.
1767  The leading C<_> is a reminder that these subpragmas may not survive
1768  beyond 5.8.  More appropriate mechanisms for selecting the implementation
1769  exist, but they wouldn't have arrived in time to save quicksort.
1770  
1771  =item *
1772  
1773  Hashes now use Bob Jenkins "One-at-a-Time" hashing key algorithm
1774  ( http://burtleburtle.net/bob/hash/doobs.html ).  This algorithm is
1775  reasonably fast while producing a much better spread of values than
1776  the old hashing algorithm (originally by Chris Torek, later tweaked by
1777  Ilya Zakharevich).  Hash values output from the algorithm on a hash of
1778  all 3-char printable ASCII keys comes much closer to passing the
1779  DIEHARD random number generation tests.  According to perlbench, this
1780  change has not affected the overall speed of Perl.
1781  
1782  =item *
1783  
1784  unshift() should now be noticeably faster.
1785  
1786  =back
1787  
1788  =head1 Installation and Configuration Improvements
1789  
1790  =head2 Generic Improvements
1791  
1792  =over 4
1793  
1794  =item *
1795  
1796  INSTALL now explains how you can configure Perl to use 64-bit
1797  integers even on non-64-bit platforms.
1798  
1799  =item *
1800  
1801  Policy.sh policy change: if you are reusing a Policy.sh file
1802  (see INSTALL) and you use Configure -Dprefix=/foo/bar and in the old
1803  Policy $prefix eq $siteprefix and $prefix eq $vendorprefix, all of
1804  them will now be changed to the new prefix, /foo/bar.  (Previously
1805  only $prefix changed.)  If you do not like this new behaviour,
1806  specify prefix, siteprefix, and vendorprefix explicitly.
1807  
1808  =item *
1809  
1810  A new optional location for Perl libraries, otherlibdirs, is available.
1811  It can be used for example for vendor add-ons without disturbing Perl's
1812  own library directories.
1813  
1814  =item *
1815  
1816  In many platforms, the vendor-supplied 'cc' is too stripped-down to
1817  build Perl (basically, 'cc' doesn't do ANSI C).  If this seems
1818  to be the case and 'cc' does not seem to be the GNU C compiler
1819  'gcc', an automatic attempt is made to find and use 'gcc' instead.
1820  
1821  =item *
1822  
1823  gcc needs to closely track the operating system release to avoid
1824  build problems. If Configure finds that gcc was built for a different
1825  operating system release than is running, it now gives a clearly visible
1826  warning that there may be trouble ahead.
1827  
1828  =item *
1829  
1830  Since Perl 5.8 is not binary-compatible with previous releases
1831  of Perl, Configure no longer suggests including the 5.005
1832  modules in @INC.
1833  
1834  =item *
1835  
1836  Configure C<-S> can now run non-interactively. [561]
1837  
1838  =item *
1839  
1840  Configure support for pdp11-style memory models has been removed due
1841  to obsolescence. [561]
1842  
1843  =item *
1844  
1845  configure.gnu now works with options with whitespace in them.
1846  
1847  =item *
1848  
1849  installperl now outputs everything to STDERR.
1850  
1851  =item *
1852  
1853  Because PerlIO is now the default on most platforms, "-perlio" doesn't
1854  get appended to the $Config{archname} (also known as $^O) anymore.
1855  Instead, if you explicitly choose not to use perlio (Configure command
1856  line option -Uuseperlio), you will get "-stdio" appended.
1857  
1858  =item *
1859  
1860  Another change related to the architecture name is that "-64all"
1861  (-Duse64bitall, or "maximally 64-bit") is appended only if your
1862  pointers are 64 bits wide.  (To be exact, the use64bitall is ignored.)
1863  
1864  =item *
1865  
1866  In AFS installations, one can configure the root of the AFS to be
1867  somewhere else than the default F</afs> by using the Configure
1868  parameter C<-Dafsroot=/some/where/else>.
1869  
1870  =item *
1871  
1872  APPLLIB_EXP, a lesser-known configuration-time definition, has been
1873  documented.  It can be used to prepend site-specific directories
1874  to Perl's default search path (@INC); see INSTALL for information.
1875  
1876  =item *
1877  
1878  The version of Berkeley DB used when the Perl (and, presumably, the
1879  DB_File extension) was built is now available as
1880  C<@Config{qw(db_version_major db_version_minor db_version_patch)}>
1881  from Perl and as C<DB_VERSION_MAJOR_CFG DB_VERSION_MINOR_CFG
1882  DB_VERSION_PATCH_CFG> from C.
1883  
1884  =item *
1885  
1886  Building Berkeley DB3 for compatibility modes for DB, NDBM, and ODBM
1887  has been documented in INSTALL.
1888  
1889  =item *
1890  
1891  If you have CPAN access (either network or a local copy such as a
1892  CD-ROM) you can during specify extra modules to Configure to build and
1893  install with Perl using the -Dextras=...  option.  See INSTALL for
1894  more details.
1895  
1896  =item *
1897  
1898  In addition to config.over, a new override file, config.arch, is
1899  available.  This file is supposed to be used by hints file writers
1900  for architecture-wide changes (as opposed to config.over which is
1901  for site-wide changes).
1902  
1903  =item *
1904  
1905  If your file system supports symbolic links, you can build Perl outside
1906  of the source directory by
1907  
1908      mkdir perl/build/directory
1909      cd perl/build/directory
1910      sh /path/to/perl/source/Configure -Dmksymlinks ...
1911  
1912  This will create in perl/build/directory a tree of symbolic links
1913  pointing to files in /path/to/perl/source.  The original files are left
1914  unaffected.  After Configure has finished, you can just say
1915  
1916      make all test
1917  
1918  and Perl will be built and tested, all in perl/build/directory.
1919  [561]
1920  
1921  =item *
1922  
1923  For Perl developers, several new make targets for profiling
1924  and debugging have been added; see L<perlhack>.
1925  
1926  =over 8
1927  
1928  =item *
1929  
1930  Use of the F<gprof> tool to profile Perl has been documented in
1931  L<perlhack>.  There is a make target called "perl.gprof" for
1932  generating a gprofiled Perl executable.
1933  
1934  =item *
1935  
1936  If you have GCC 3, there is a make target called "perl.gcov" for
1937  creating a gcoved Perl executable for coverage analysis.  See
1938  L<perlhack>.
1939  
1940  =item *
1941  
1942  If you are on IRIX or Tru64 platforms, new profiling/debugging options
1943  have been added; see L<perlhack> for more information about pixie and
1944  Third Degree.
1945  
1946  =back
1947  
1948  =item *
1949  
1950  Guidelines of how to construct minimal Perl installations have
1951  been added to INSTALL.
1952  
1953  =item *
1954  
1955  The Thread extension is now not built at all under ithreads
1956  (C<Configure -Duseithreads>) because it wouldn't work anyway (the
1957  Thread extension requires being Configured with C<-Duse5005threads>).
1958  
1959  B<Note that the 5.005 threads are unsupported and deprecated: if you
1960  have code written for the old threads you should migrate it to the
1961  new ithreads model.>
1962  
1963  =item *
1964  
1965  The Gconvert macro ($Config{d_Gconvert}) used by perl for stringifying
1966  floating-point numbers is now more picky about using sprintf %.*g
1967  rules for the conversion.  Some platforms that used to use gcvt may
1968  now resort to the slower sprintf.
1969  
1970  =item *
1971  
1972  The obsolete method of making a special (e.g., debugging) flavor
1973  of perl by saying
1974  
1975      make LIBPERL=libperld.a
1976  
1977  has been removed. Use -DDEBUGGING instead.
1978  
1979  =back
1980  
1981  =head2 New Or Improved Platforms
1982  
1983  For the list of platforms known to support Perl,
1984  see L<perlport/"Supported Platforms">.
1985  
1986  =over 4
1987  
1988  =item *
1989  
1990  AIX dynamic loading should be now better supported.
1991  
1992  =item *
1993  
1994  AIX should now work better with gcc, threads, and 64-bitness.  Also the
1995  long doubles support in AIX should be better now.  See L<perlaix>.
1996  
1997  =item *
1998  
1999  AtheOS ( http://www.atheos.cx/ ) is a new platform.
2000  
2001  =item *
2002  
2003  BeOS has been reclaimed.
2004  
2005  =item *
2006  
2007  The DG/UX platform now supports 5.005-style threads.
2008  See L<perldgux>.
2009  
2010  =item *
2011  
2012  The DYNIX/ptx platform (also known as dynixptx) is supported at or
2013  near osvers 4.5.2.
2014  
2015  =item *
2016  
2017  EBCDIC platforms (z/OS (also known as OS/390), POSIX-BC, and VM/ESA)
2018  have been regained.  Many test suite tests still fail and the
2019  co-existence of Unicode and EBCDIC isn't quite settled, but the
2020  situation is much better than with Perl 5.6.  See L<perlos390>,
2021  L<perlbs2000> (for POSIX-BC), and L<perlvmesa> for more information.
2022  
2023  =item *
2024  
2025  Building perl with -Duseithreads or -Duse5005threads now works under
2026  HP-UX 10.20 (previously it only worked under 10.30 or later). You will
2027  need a thread library package installed. See README.hpux. [561]
2028  
2029  =item *
2030  
2031  Mac OS Classic is now supported in the mainstream source package
2032  (MacPerl has of course been available since perl 5.004 but now the
2033  source code bases of standard Perl and MacPerl have been synchronised)
2034  [561]
2035  
2036  =item *
2037  
2038  Mac OS X (or Darwin) should now be able to build Perl even on HFS+
2039  filesystems.  (The case-insensitivity used to confuse the Perl build
2040  process.)
2041  
2042  =item *
2043  
2044  NCR MP-RAS is now supported. [561]
2045  
2046  =item *
2047  
2048  All the NetBSD specific patches (except for the installation
2049  specific ones) have been merged back to the main distribution.
2050  
2051  =item *
2052  
2053  NetWare from Novell is now supported.  See L<perlnetware>.
2054  
2055  =item *
2056  
2057  NonStop-UX is now supported. [561]
2058  
2059  =item *
2060  
2061  NEC SUPER-UX is now supported.
2062  
2063  =item *
2064  
2065  All the OpenBSD specific patches (except for the installation
2066  specific ones) have been merged back to the main distribution.
2067  
2068  =item *
2069  
2070  Perl has been tested with the GNU pth userlevel thread package
2071  ( http://www.gnu.org/software/pth/pth.html ).  All thread tests
2072  of Perl now work, but not without adding some yield()s to the tests,
2073  so while pth (and other userlevel thread implementations) can be
2074  considered to be "working" with Perl ithreads, keep in mind the
2075  possible non-preemptability of the underlying thread implementation.
2076  
2077  =item *
2078  
2079  Stratus VOS is now supported using Perl's native build method
2080  (Configure).  This is the recommended method to build Perl on
2081  VOS.  The older methods, which build miniperl, are still
2082  available.  See L<perlvos>. [561+]
2083  
2084  =item *
2085  
2086  The Amdahl UTS UNIX mainframe platform is now supported. [561]
2087  
2088  =item *
2089  
2090  WinCE is now supported.  See L<perlce>.
2091  
2092  =item *
2093  
2094  z/OS (formerly known as OS/390, formerly known as MVS OE) now has
2095  support for dynamic loading.  This is not selected by default,
2096  however, you must specify -Dusedl in the arguments of Configure. [561]
2097  
2098  =back
2099  
2100  =head1 Selected Bug Fixes
2101  
2102  Numerous memory leaks and uninitialized memory accesses have been
2103  hunted down.  Most importantly, anonymous subs used to leak quite
2104  a bit. [561]
2105  
2106  =over 4
2107  
2108  =item *
2109  
2110  The autouse pragma didn't work for Multi::Part::Function::Names.
2111  
2112  =item *
2113  
2114  caller() could cause core dumps in certain situations.  Carp was
2115  sometimes affected by this problem.  In particular, caller() now
2116  returns a subroutine name of C<(unknown)> for subroutines that have
2117  been removed from the symbol table.
2118  
2119  =item *
2120  
2121  chop(@list) in list context returned the characters chopped in
2122  reverse order.  This has been reversed to be in the right order. [561]
2123  
2124  =item *
2125  
2126  Configure no longer includes the DBM libraries (dbm, gdbm, db, ndbm)
2127  when building the Perl binary.  The only exception to this is SunOS 4.x,
2128  which needs them. [561]
2129  
2130  =item *
2131  
2132  The behaviour of non-decimal but numeric string constants such as
2133  "0x23" was platform-dependent: in some platforms that was seen as 35,
2134  in some as 0, in some as a floating point number (don't ask).  This
2135  was caused by Perl's using the operating system libraries in a situation
2136  where the result of the string to number conversion is undefined: now
2137  Perl consistently handles such strings as zero in numeric contexts.
2138  
2139  =item *
2140  
2141  Several debugger fixes: exit code now reflects the script exit code,
2142  condition C<"0"> now treated correctly, the C<d> command now checks
2143  line number, C<$.> no longer gets corrupted, and all debugger output
2144  now goes correctly to the socket if RemotePort is set. [561]
2145  
2146  =item *
2147  
2148  The debugger (perl5db.pl) has been modified to present a more
2149  consistent commands interface, via (CommandSet=580).  perl5db.t was
2150  also added to test the changes, and as a placeholder for further tests.
2151  
2152  See L<perldebug>.
2153  
2154  =item *
2155  
2156  The debugger has a new C<dumpDepth> option to control the maximum
2157  depth to which nested structures are dumped.  The C<x> command has
2158  been extended so that C<x N EXPR> dumps out the value of I<EXPR> to a
2159  depth of at most I<N> levels.
2160  
2161  =item *
2162  
2163  The debugger can now show lexical variables if you have the CPAN
2164  module PadWalker installed.
2165  
2166  =item *
2167  
2168  The order of DESTROYs has been made more predictable.
2169  
2170  =item *
2171  
2172  Perl 5.6.0 could emit spurious warnings about redefinition of
2173  dl_error() when statically building extensions into perl.
2174  This has been corrected. [561]
2175  
2176  =item *
2177  
2178  L<dprofpp> -R didn't work.
2179  
2180  =item *
2181  
2182  C<*foo{FORMAT}> now works.
2183  
2184  =item *
2185  
2186  Infinity is now recognized as a number.
2187  
2188  =item *
2189  
2190  UNIVERSAL::isa no longer caches methods incorrectly.  (This broke
2191  the Tk extension with 5.6.0.) [561]
2192  
2193  =item *
2194  
2195  Lexicals I: lexicals outside an eval "" weren't resolved
2196  correctly inside a subroutine definition inside the eval "" if they
2197  were not already referenced in the top level of the eval""ed code.
2198  
2199  =item *
2200  
2201  Lexicals II: lexicals leaked at file scope into subroutines that
2202  were declared before the lexicals.
2203  
2204  =item *
2205  
2206  Lexical warnings now propagating correctly between scopes
2207  and into C<eval "...">.
2208  
2209  =item *
2210  
2211  C<use warnings qw(FATAL all)> did not work as intended.  This has been
2212  corrected. [561]
2213  
2214  =item *
2215  
2216  warnings::enabled() now reports the state of $^W correctly if the caller
2217  isn't using lexical warnings. [561]
2218  
2219  =item *
2220  
2221  Line renumbering with eval and C<#line> now works. [561]
2222  
2223  =item *
2224  
2225  Fixed numerous memory leaks, especially in eval "".
2226  
2227  =item *
2228  
2229  Localised tied variables no longer leak memory
2230  
2231      use Tie::Hash;
2232      tie my %tied_hash => 'Tie::StdHash';
2233  
2234      ...
2235  
2236      # Used to leak memory every time local() was called;
2237      # in a loop, this added up.
2238      local($tied_hash{Foo}) = 1;
2239  
2240  =item *
2241  
2242  Localised hash elements (and %ENV) are correctly unlocalised to not
2243  exist, if they didn't before they were localised.
2244  
2245  
2246      use Tie::Hash;
2247      tie my %tied_hash => 'Tie::StdHash';
2248  
2249      ...
2250  
2251      # Nothing has set the FOO element so far
2252  
2253      { local $tied_hash{FOO} = 'Bar' }
2254  
2255      # This used to print, but not now.
2256      print "exists!\n" if exists $tied_hash{FOO};
2257  
2258  As a side effect of this fix, tied hash interfaces B<must> define
2259  the EXISTS and DELETE methods.
2260  
2261  =item *
2262  
2263  mkdir() now ignores trailing slashes in the directory name,
2264  as mandated by POSIX.
2265  
2266  =item *
2267  
2268  Some versions of glibc have a broken modfl().  This affects builds
2269  with C<-Duselongdouble>.  This version of Perl detects this brokenness
2270  and has a workaround for it.  The glibc release 2.2.2 is known to have
2271  fixed the modfl() bug.
2272  
2273  =item *
2274  
2275  Modulus of unsigned numbers now works (4063328477 % 65535 used to
2276  return 27406, instead of 27047). [561]
2277  
2278  =item *
2279  
2280  Some "not a number" warnings introduced in 5.6.0 eliminated to be
2281  more compatible with 5.005.  Infinity is now recognised as a number. [561]
2282  
2283  =item *
2284  
2285  Numeric conversions did not recognize changes in the string value
2286  properly in certain circumstances. [561]
2287  
2288  =item *
2289  
2290  Attributes (such as :shared) didn't work with our().
2291  
2292  =item *
2293  
2294  our() variables will not cause bogus "Variable will not stay shared"
2295  warnings. [561]
2296  
2297  =item *
2298  
2299  "our" variables of the same name declared in two sibling blocks
2300  resulted in bogus warnings about "redeclaration" of the variables.
2301  The problem has been corrected. [561]
2302  
2303  =item *
2304  
2305  pack "Z" now correctly terminates the string with "\0".
2306  
2307  =item *
2308  
2309  Fix password routines which in some shadow password platforms
2310  (e.g. HP-UX) caused getpwent() to return every other entry.
2311  
2312  =item *
2313  
2314  The PERL5OPT environment variable (for passing command line arguments
2315  to Perl) didn't work for more than a single group of options. [561]
2316  
2317  =item *
2318  
2319  PERL5OPT with embedded spaces didn't work.
2320  
2321  =item *
2322  
2323  printf() no longer resets the numeric locale to "C".
2324  
2325  =item *
2326  
2327  C<qw(a\\b)> now parses correctly as C<'a\\b'>: that is, as three
2328  characters, not four. [561]
2329  
2330  =item *
2331  
2332  pos() did not return the correct value within s///ge in earlier
2333  versions.  This is now handled correctly. [561]
2334  
2335  =item *
2336  
2337  Printing quads (64-bit integers) with printf/sprintf now works
2338  without the q L ll prefixes (assuming you are on a quad-capable platform).
2339  
2340  =item *
2341  
2342  Regular expressions on references and overloaded scalars now work. [561+]
2343  
2344  =item *
2345  
2346  Right-hand side magic (GMAGIC) could in many cases such as string
2347  concatenation be invoked too many times.
2348  
2349  =item *
2350  
2351  scalar() now forces scalar context even when used in void context.
2352  
2353  =item *
2354  
2355  SOCKS support is now much more robust.
2356  
2357  =item *
2358  
2359  sort() arguments are now compiled in the right wantarray context
2360  (they were accidentally using the context of the sort() itself).
2361  The comparison block is now run in scalar context, and the arguments
2362  to be sorted are always provided list context. [561]
2363  
2364  =item *
2365  
2366  Changed the POSIX character class C<[[:space:]]> to include the (very
2367  rarely used) vertical tab character.  Added a new POSIX-ish character
2368  class C<[[:blank:]]> which stands for horizontal whitespace
2369  (currently, the space and the tab).
2370  
2371  =item *
2372  
2373  The tainting behaviour of sprintf() has been rationalized.  It does
2374  not taint the result of floating point formats anymore, making the
2375  behaviour consistent with that of string interpolation. [561]
2376  
2377  =item *
2378  
2379  Some cases of inconsistent taint propagation (such as within hash
2380  values) have been fixed.
2381  
2382  =item *
2383  
2384  The RE engine found in Perl 5.6.0 accidentally pessimised certain kinds
2385  of simple pattern matches.  These are now handled better. [561]
2386  
2387  =item *
2388  
2389  Regular expression debug output (whether through C<use re 'debug'>
2390  or via C<-Dr>) now looks better. [561]
2391  
2392  =item *
2393  
2394  Multi-line matches like C<"a\nxb\n" =~ /(?!\A)x/m> were flawed.  The
2395  bug has been fixed. [561]
2396  
2397  =item *
2398  
2399  Use of $& could trigger a core dump under some situations.  This
2400  is now avoided. [561]
2401  
2402  =item *
2403  
2404  The regular expression captured submatches ($1, $2, ...) are now
2405  more consistently unset if the match fails, instead of leaving false
2406  data lying around in them. [561]
2407  
2408  =item *
2409  
2410  readline() on files opened in "slurp" mode could return an extra
2411  "" (blank line) at the end in certain situations.  This has been
2412  corrected. [561]
2413  
2414  =item *
2415  
2416  Autovivification of symbolic references of special variables described
2417  in L<perlvar> (as in C<${$num}>) was accidentally disabled.  This works
2418  again now. [561]
2419  
2420  =item *
2421  
2422  Sys::Syslog ignored the C<LOG_AUTH> constant.
2423  
2424  =item *
2425  
2426  $AUTOLOAD, sort(), lock(), and spawning subprocesses
2427  in multiple threads simultaneously are now thread-safe.
2428  
2429  =item *
2430  
2431  Tie::Array's SPLICE method was broken.
2432  
2433  =item *
2434  
2435  Allow a read-only string on the left-hand side of a non-modifying tr///.
2436  
2437  =item *
2438  
2439  If C<STDERR> is tied, warnings caused by C<warn> and C<die> now
2440  correctly pass to it.
2441  
2442  =item *
2443  
2444  Several Unicode fixes.
2445  
2446  =over 8
2447  
2448  =item *
2449  
2450  BOMs (byte order marks) at the beginning of Perl files
2451  (scripts, modules) should now be transparently skipped.
2452  UTF-16 and UCS-2 encoded Perl files should now be read correctly.
2453  
2454  =item *
2455  
2456  The character tables have been updated to Unicode 3.2.0.
2457  
2458  =item *
2459  
2460  Comparing with utf8 data does not magically upgrade non-utf8 data
2461  into utf8.  (This was a problem for example if you were mixing data
2462  from I/O and Unicode data: your output might have got magically encoded
2463  as UTF-8.)
2464  
2465  =item *
2466  
2467  Generating illegal Unicode code points such as U+FFFE, or the UTF-16
2468  surrogates, now also generates an optional warning.
2469  
2470  =item *
2471  
2472  C<IsAlnum>, C<IsAlpha>, and C<IsWord> now match titlecase.
2473  
2474  =item *
2475  
2476  Concatenation with the C<.> operator or via variable interpolation,
2477  C<eq>, C<substr>, C<reverse>, C<quotemeta>, the C<x> operator,
2478  substitution with C<s///>, single-quoted UTF-8, should now work.
2479  
2480  =item *
2481  
2482  The C<tr///> operator now works.  Note that the C<tr///CU>
2483  functionality has been removed (but see pack('U0', ...)).
2484  
2485  =item *
2486  
2487  C<eval "v200"> now works.
2488  
2489  =item *
2490  
2491  Perl 5.6.0 parsed m/\x{ab}/ incorrectly, leading to spurious warnings.
2492  This has been corrected. [561]
2493  
2494  =item *
2495  
2496  Zero entries were missing from the Unicode classes such as C<IsDigit>.
2497  
2498  =back
2499  
2500  =item *
2501  
2502  Large unsigned numbers (those above 2**31) could sometimes lose their
2503  unsignedness, causing bogus results in arithmetic operations. [561]
2504  
2505  =item *
2506  
2507  The Perl parser has been stress tested using both random input and
2508  Markov chain input and the few found crashes and lockups have been
2509  fixed.
2510  
2511  =back
2512  
2513  =head2 Platform Specific Changes and Fixes
2514  
2515  =over 4
2516  
2517  =item *
2518  
2519  BSDI 4.*
2520  
2521  Perl now works on post-4.0 BSD/OSes.
2522  
2523  =item *
2524  
2525  All BSDs
2526  
2527  Setting C<$0> now works (as much as possible; see L<perlvar> for details).
2528  
2529  =item *
2530  
2531  Cygwin
2532  
2533  Numerous updates; currently synchronised with Cygwin 1.3.10.
2534  
2535  =item *
2536  
2537  Previously DYNIX/ptx had problems in its Configure probe for non-blocking I/O.
2538  
2539  =item *
2540  
2541  EPOC
2542  
2543  EPOC now better supported.  See README.epoc. [561]
2544  
2545  =item *
2546  
2547  FreeBSD 3.*
2548  
2549  Perl now works on post-3.0 FreeBSDs.
2550  
2551  =item *
2552  
2553  HP-UX
2554  
2555  README.hpux updated; C<Configure -Duse64bitall> now works;
2556  now uses HP-UX malloc instead of Perl malloc.
2557  
2558  =item *
2559  
2560  IRIX
2561  
2562  Numerous compilation flag and hint enhancements; accidental mixing
2563  of 32-bit and 64-bit libraries (a doomed attempt) made much harder.
2564  
2565  =item *
2566  
2567  Linux
2568  
2569  =over 8
2570  
2571  =item *
2572  
2573  Long doubles should now work (see INSTALL). [561]
2574  
2575  =item *
2576  
2577  Linux previously had problems related to sockaddrlen when using
2578  accept(), recvfrom() (in Perl: recv()), getpeername(), and
2579  getsockname().
2580  
2581  =back
2582  
2583  =item *
2584  
2585  Mac OS Classic
2586  
2587  Compilation of the standard Perl distribution in Mac OS Classic should
2588  now work if you have the Metrowerks development environment and the
2589  missing Mac-specific toolkit bits.  Contact the macperl mailing list
2590  for details.
2591  
2592  =item *
2593  
2594  MPE/iX
2595  
2596  MPE/iX update after Perl 5.6.0.  See README.mpeix. [561]
2597  
2598  =item *
2599  
2600  NetBSD/threads: try installing the GNU pth (should be in the
2601  packages collection, or http://www.gnu.org/software/pth/),
2602  and Configure with -Duseithreads.
2603  
2604  =item *
2605  
2606  NetBSD/sparc
2607  
2608  Perl now works on NetBSD/sparc.
2609  
2610  =item *
2611  
2612  OS/2
2613  
2614  Now works with usethreads (see INSTALL). [561]
2615  
2616  =item *
2617  
2618  Solaris
2619  
2620  64-bitness using the Sun Workshop compiler now works.
2621  
2622  =item *
2623  
2624  Stratus VOS
2625  
2626  The native build method requires at least VOS Release 14.5.0
2627  and GNU C++/GNU Tools 2.0.1 or later.  The Perl pack function
2628  now maps overflowed values to +infinity and underflowed values
2629  to -infinity.
2630  
2631  =item *
2632  
2633  Tru64 (aka Digital UNIX, aka DEC OSF/1)
2634  
2635  The operating system version letter now recorded in $Config{osvers}.
2636  Allow compiling with gcc (previously explicitly forbidden).  Compiling
2637  with gcc still not recommended because buggy code results, even with
2638  gcc 2.95.2.
2639  
2640  =item *
2641  
2642  Unicos
2643  
2644  Fixed various alignment problems that lead into core dumps either
2645  during build or later; no longer dies on math errors at runtime;
2646  now using full quad integers (64 bits), previously was using
2647  only 46 bit integers for speed.
2648  
2649  =item *
2650  
2651  VMS
2652  
2653  See L</"Socket Extension Dynamic in VMS"> and L</"IEEE-format Floating Point
2654  Default on OpenVMS Alpha"> for important changes not otherwise listed here.
2655  
2656  chdir() now works better despite a CRT bug; now works with MULTIPLICITY
2657  (see INSTALL); now works with Perl's malloc.
2658  
2659  The tainting of C<%ENV> elements via C<keys> or C<values> was previously
2660  unimplemented.  It now works as documented.
2661  
2662  The C<waitpid> emulation has been improved.  The worst bug (now fixed)
2663  was that a pid of -1 would cause a wildcard search of all processes on
2664  the system.
2665  
2666  POSIX-style signals are now emulated much better on VMS versions prior
2667  to 7.0.
2668  
2669  The C<system> function and backticks operator have improved
2670  functionality and better error handling. [561]
2671  
2672  File access tests now use current process privileges rather than the
2673  user's default privileges, which could sometimes result in a mismatch
2674  between reported access and actual access.  This improvement is only
2675  available on VMS v6.0 and later.
2676  
2677  There is a new C<kill> implementation based on C<sys$sigprc> that allows
2678  older VMS systems (pre-7.0) to use C<kill> to send signals rather than
2679  simply force exit.  This implementation also allows later systems to
2680  call C<kill> from within a signal handler.
2681  
2682  Iterative logical name translations are now limited to 10 iterations in
2683  imitation of SHOW LOGICAL and other OpenVMS facilities.
2684  
2685  =item *
2686  
2687  Windows
2688  
2689  =over 8
2690  
2691  =item *
2692  
2693  Signal handling now works better than it used to.  It is now implemented
2694  using a Windows message loop, and is therefore less prone to random
2695  crashes.
2696  
2697  =item *
2698  
2699  fork() emulation is now more robust, but still continues to have a few
2700  esoteric bugs and caveats.  See L<perlfork> for details. [561+]
2701  
2702  =item *
2703  
2704  A failed (pseudo)fork now returns undef and sets errno to EAGAIN. [561]
2705  
2706  =item *
2707  
2708  The following modules now work on Windows:
2709  
2710      ExtUtils::Embed         [561]
2711      IO::Pipe
2712      IO::Poll
2713      Net::Ping
2714  
2715  =item *
2716  
2717  IO::File::new_tmpfile() is no longer limited to 32767 invocations
2718  per-process.
2719  
2720  =item *
2721  
2722  Better chdir() return value for a non-existent directory.
2723  
2724  =item *
2725  
2726  Compiling perl using the 64-bit Platform SDK tools is now supported.
2727  
2728  =item *
2729  
2730  The Win32::SetChildShowWindow() builtin can be used to control the
2731  visibility of windows created by child processes.  See L<Win32> for
2732  details.
2733  
2734  =item *
2735  
2736  Non-blocking waits for child processes (or pseudo-processes) are
2737  supported via C<waitpid($pid, &POSIX::WNOHANG)>.
2738  
2739  =item *
2740  
2741  The behavior of system() with multiple arguments has been rationalized.
2742  Each unquoted argument will be automatically quoted to protect whitespace,
2743  and any existing whitespace in the arguments will be preserved.  This
2744  improves the portability of system(@args) by avoiding the need for
2745  Windows C<cmd> shell specific quoting in perl programs.
2746  
2747  Note that this means that some scripts that may have relied on earlier
2748  buggy behavior may no longer work correctly.  For example,
2749  C<system("nmake /nologo", @args)> will now attempt to run the file
2750  C<nmake /nologo> and will fail when such a file isn't found.
2751  On the other hand, perl will now execute code such as
2752  C<system("c:/Program Files/MyApp/foo.exe", @args)> correctly.
2753  
2754  =item *
2755  
2756  The perl header files no longer suppress common warnings from the
2757  Microsoft Visual C++ compiler.  This means that additional warnings may
2758  now show up when compiling XS code.
2759  
2760  =item *
2761  
2762  Borland C++ v5.5 is now a supported compiler that can build Perl.
2763  However, the generated binaries continue to be incompatible with those
2764  generated by the other supported compilers (GCC and Visual C++). [561]
2765  
2766  =item *
2767  
2768  Duping socket handles with open(F, ">&MYSOCK") now works under Windows 9x.
2769  [561]
2770  
2771  =item *
2772  
2773  Current directory entries in %ENV are now correctly propagated to child
2774  processes. [561]
2775  
2776  =item *
2777  
2778  New %ENV entries now propagate to subprocesses. [561]
2779  
2780  =item *
2781  
2782  Win32::GetCwd() correctly returns C:\ instead of C: when at the drive root.
2783  Other bugs in chdir() and Cwd::cwd() have also been fixed. [561]
2784  
2785  =item *
2786  
2787  The makefiles now default to the features enabled in ActiveState ActivePerl
2788  (a popular Win32 binary distribution). [561]
2789  
2790  =item *
2791  
2792  HTML files will now be installed in c:\perl\html instead of
2793  c:\perl\lib\pod\html
2794  
2795  =item *
2796  
2797  REG_EXPAND_SZ keys are now allowed in registry settings used by perl. [561]
2798  
2799  =item *
2800  
2801  Can now send() from all threads, not just the first one. [561]
2802  
2803  =item *
2804  
2805  ExtUtils::MakeMaker now uses $ENV{LIB} to search for libraries. [561]
2806  
2807  =item *
2808  
2809  Less stack reserved per thread so that more threads can run
2810  concurrently. (Still 16M per thread.) [561]
2811  
2812  =item *
2813  
2814  C<< File::Spec->tmpdir() >> now prefers C:/temp over /tmp
2815  (works better when perl is running as service).
2816  
2817  =item *
2818  
2819  Better UNC path handling under ithreads. [561]
2820  
2821  =item *
2822  
2823  wait(), waitpid(), and backticks now return the correct exit status
2824  under Windows 9x. [561]
2825  
2826  =item *
2827  
2828  A socket handle leak in accept() has been fixed. [561]
2829  
2830  =back
2831  
2832  =back
2833  
2834  =head1 New or Changed Diagnostics
2835  
2836  Please see L<perldiag> for more details.
2837  
2838  =over 4
2839  
2840  =item *
2841  
2842  Ambiguous range in the transliteration operator (like a-z-9) now
2843  gives a warning.
2844  
2845  =item *
2846  
2847  chdir("") and chdir(undef) now give a deprecation warning because they
2848  cause a possible unintentional chdir to the home directory.
2849  Say chdir() if you really mean that.
2850  
2851  =item *
2852  
2853  Two new debugging options have been added: if you have compiled your
2854  Perl with debugging, you can use the -DT [561] and -DR options to trace
2855  tokenising and to add reference counts to displaying variables,
2856  respectively.
2857  
2858  =item *
2859  
2860  The lexical warnings category "deprecated" is no longer a sub-category
2861  of the "syntax" category. It is now a top-level category in its own
2862  right.
2863  
2864  =item *
2865  
2866  Unadorned dump() will now give a warning suggesting to
2867  use explicit CORE::dump() if that's what really is meant.
2868  
2869  =item *
2870  
2871  The "Unrecognized escape" warning has been extended to include C<\8>,
2872  C<\9>, and C<\_>.  There is no need to escape any of the C<\w> characters.
2873  
2874  =item *
2875  
2876  All regular expression compilation error messages are now hopefully
2877  easier to understand both because the error message now comes before
2878  the failed regex and because the point of failure is now clearly
2879  marked by a C<E<lt>-- HERE> marker.
2880  
2881  =item *
2882  
2883  Various I/O (and socket) functions like binmode(), close(), and so
2884  forth now more consistently warn if they are used illogically either
2885  on a yet unopened or on an already closed filehandle (or socket).
2886  
2887  =item *
2888  
2889  Using lstat() on a filehandle now gives a warning.  (It's a non-sensical
2890  thing to do.)
2891  
2892  =item *
2893  
2894  The C<-M> and C<-m> options now warn if you didn't supply the module name.
2895  
2896  =item *
2897  
2898  If you in C<use> specify a required minimum version, modules matching
2899  the name and but not defining a $VERSION will cause a fatal failure.
2900  
2901  =item *
2902  
2903  Using negative offset for vec() in lvalue context is now a warnable offense.
2904  
2905  =item *
2906  
2907  Odd number of arguments to overload::constant now elicits a warning.
2908  
2909  =item *
2910  
2911  Odd number of elements in anonymous hash now elicits a warning.
2912  
2913  =item *
2914  
2915  The various "opened only for", "on closed", "never opened" warnings
2916  drop the C<main::> prefix for filehandles in the C<main> package,
2917  for example C<STDIN> instead of C<main::STDIN>.
2918  
2919  =item *
2920  
2921  Subroutine prototypes are now checked more carefully, you may
2922  get warnings for example if you have used non-prototype characters.
2923  
2924  =item *
2925  
2926  If an attempt to use a (non-blessed) reference as an array index
2927  is made, a warning is given.
2928  
2929  =item *
2930  
2931  C<push @a;> and C<unshift @a;> (with no values to push or unshift)
2932  now give a warning.  This may be a problem for generated and eval'ed
2933  code.
2934  
2935  =item *
2936  
2937  If you try to L<perlfunc/pack> a number less than 0 or larger than 255
2938  using the C<"C"> format you will get an optional warning.  Similarly
2939  for the C<"c"> format and a number less than -128 or more than 127.
2940  
2941  =item *
2942  
2943  pack C<P> format now demands an explicit size.
2944  
2945  =item *
2946  
2947  unpack C<w> now warns of unterminated compressed integers.
2948  
2949  =item *
2950  
2951  Warnings relating to the use of PerlIO have been added.
2952  
2953  =item *
2954  
2955  Certain regex modifiers such as C<(?o)> make sense only if applied to
2956  the entire regex.  You will get an optional warning if you try to do
2957  otherwise.
2958  
2959  =item *
2960  
2961  Variable length lookbehind has not yet been implemented, trying to
2962  use it will tell that.
2963  
2964  =item *
2965  
2966  Using arrays or hashes as references (e.g. C<< %foo->{bar} >>
2967  has been deprecated for a while.  Now you will get an optional warning.
2968  
2969  =item *
2970  
2971  Warnings relating to the use of the new restricted hashes feature
2972  have been added.
2973  
2974  =item *
2975  
2976  Self-ties of arrays and hashes are not supported and fatal errors
2977  will happen even at an attempt to do so.
2978  
2979  =item *
2980  
2981  Using C<sort> in scalar context now issues an optional warning.
2982  This didn't do anything useful, as the sort was not performed.
2983  
2984  =item *
2985  
2986  Using the /g modifier in split() is meaningless and will cause a warning.
2987  
2988  =item *
2989  
2990  Using splice() past the end of an array now causes a warning.
2991  
2992  =item *
2993  
2994  Malformed Unicode encodings (UTF-8 and UTF-16) cause a lot of warnings,
2995  as does trying to use UTF-16 surrogates (which are unimplemented).
2996  
2997  =item *
2998  
2999  Trying to use Unicode characters on an I/O stream without marking the
3000  stream's encoding (using open() or binmode()) will cause "Wide character"
3001  warnings.
3002  
3003  =item *
3004  
3005  Use of v-strings in use/require causes a (backward) portability warning.
3006  
3007  =item *
3008  
3009  Warnings relating to the use interpreter threads and their shared data
3010  have been added.
3011  
3012  =back
3013  
3014  =head1 Changed Internals
3015  
3016  =over 4
3017  
3018  =item *
3019  
3020  PerlIO is now the default.
3021  
3022  =item *
3023  
3024  perlapi.pod (a companion to perlguts) now attempts to document the
3025  internal API.
3026  
3027  =item *
3028  
3029  You can now build a really minimal perl called microperl.
3030  Building microperl does not require even running Configure;
3031  C<make -f Makefile.micro> should be enough.  Beware: microperl makes
3032  many assumptions, some of which may be too bold; the resulting
3033  executable may crash or otherwise misbehave in wondrous ways.
3034  For careful hackers only.
3035  
3036  =item *
3037  
3038  Added rsignal(), whichsig(), do_join(), op_clear, op_null,
3039  ptr_table_clear(), ptr_table_free(), sv_setref_uv(), and several UTF-8
3040  interfaces to the publicised API.  For the full list of the available
3041  APIs see L<perlapi>.
3042  
3043  =item *
3044  
3045  Made possible to propagate customised exceptions via croak()ing.
3046  
3047  =item *
3048  
3049  Now xsubs can have attributes just like subs.  (Well, at least the
3050  built-in attributes.)
3051  
3052  =item *
3053  
3054  dTHR and djSP have been obsoleted; the former removed (because it's
3055  a no-op) and the latter replaced with dSP.
3056  
3057  =item *
3058  
3059  PERL_OBJECT has been completely removed.
3060  
3061  =item *
3062  
3063  The MAGIC constants (e.g. C<'P'>) have been macrofied
3064  (e.g. C<PERL_MAGIC_TIED>) for better source code readability
3065  and maintainability.
3066  
3067  =item *
3068  
3069  The regex compiler now maintains a structure that identifies nodes in
3070  the compiled bytecode with the corresponding syntactic features of the
3071  original regex expression.  The information is attached to the new
3072  C<offsets> member of the C<struct regexp>. See L<perldebguts> for more
3073  complete information.
3074  
3075  =item *
3076  
3077  The C code has been made much more C<gcc -Wall> clean.  Some warning
3078  messages still remain in some platforms, so if you are compiling with
3079  gcc you may see some warnings about dubious practices.  The warnings
3080  are being worked on.
3081  
3082  =item *
3083  
3084  F<perly.c>, F<sv.c>, and F<sv.h> have now been extensively commented.
3085  
3086  =item *
3087  
3088  Documentation on how to use the Perl source repository has been added
3089  to F<Porting/repository.pod>.
3090  
3091  =item *
3092  
3093  There are now several profiling make targets.
3094  
3095  =back
3096  
3097  =head1 Security Vulnerability Closed [561]
3098  
3099  (This change was already made in 5.7.0 but bears repeating here.)
3100  (5.7.0 came out before 5.6.1: the development branch 5.7 released
3101  earlier than the maintenance branch 5.6)
3102  
3103  A potential security vulnerability in the optional suidperl component
3104  of Perl was identified in August 2000.  suidperl is neither built nor
3105  installed by default.  As of November 2001 the only known vulnerable
3106  platform is Linux, most likely all Linux distributions.  CERT and
3107  various vendors and distributors have been alerted about the vulnerability.
3108  See http://www.cpan.org/src/5.0/sperl-2000-08-05/sperl-2000-08-05.txt
3109  for more information.
3110  
3111  The problem was caused by Perl trying to report a suspected security
3112  exploit attempt using an external program, /bin/mail.  On Linux
3113  platforms the /bin/mail program had an undocumented feature which
3114  when combined with suidperl gave access to a root shell, resulting in
3115  a serious compromise instead of reporting the exploit attempt.  If you
3116  don't have /bin/mail, or if you have 'safe setuid scripts', or if
3117  suidperl is not installed, you are safe.
3118  
3119  The exploit attempt reporting feature has been completely removed from
3120  Perl 5.8.0 (and the maintenance release 5.6.1, and it was removed also
3121  from all the Perl 5.7 releases), so that particular vulnerability
3122  isn't there anymore.  However, further security vulnerabilities are,
3123  unfortunately, always possible.  The suidperl functionality is most
3124  probably going to be removed in Perl 5.10.  In any case, suidperl
3125  should only be used by security experts who know exactly what they are
3126  doing and why they are using suidperl instead of some other solution
3127  such as sudo ( see http://www.courtesan.com/sudo/ ).
3128  
3129  =head1 New Tests
3130  
3131  Several new tests have been added, especially for the F<lib> and
3132  F<ext> subsections.  There are now about 69 000 individual tests
3133  (spread over about 700 test scripts), in the regression suite (5.6.1
3134  has about 11 700 tests, in 258 test scripts)  The exact numbers depend
3135  on the platform and Perl configuration used.  Many of the new tests
3136  are of course introduced by the new modules, but still in general Perl
3137  is now more thoroughly tested.
3138  
3139  Because of the large number of tests, running the regression suite
3140  will take considerably longer time than it used to: expect the suite
3141  to take up to 4-5 times longer to run than in perl 5.6.  On a really
3142  fast machine you can hope to finish the suite in about 6-8 minutes
3143  (wallclock time).
3144  
3145  The tests are now reported in a different order than in earlier Perls.
3146  (This happens because the test scripts from under t/lib have been moved
3147  to be closer to the library/extension they are testing.)
3148  
3149  =head1 Known Problems
3150  
3151  =head2 The Compiler Suite Is Still Very Experimental
3152  
3153  The compiler suite is slowly getting better but it continues to be
3154  highly experimental.  Use in production environments is discouraged.
3155  
3156  =head2 Localising Tied Arrays and Hashes Is Broken
3157  
3158      local %tied_array;
3159  
3160  doesn't work as one would expect: the old value is restored
3161  incorrectly.  This will be changed in a future release, but we don't
3162  know yet what the new semantics will exactly be.  In any case, the
3163  change will break existing code that relies on the current
3164  (ill-defined) semantics, so just avoid doing this in general.
3165  
3166  =head2 Building Extensions Can Fail Because Of Largefiles
3167  
3168  Some extensions like mod_perl are known to have issues with
3169  `largefiles', a change brought by Perl 5.6.0 in which file offsets
3170  default to 64 bits wide, where supported.  Modules may fail to compile
3171  at all, or they may compile and work incorrectly.  Currently, there
3172  is no good solution for the problem, but Configure now provides
3173  appropriate non-largefile ccflags, ldflags, libswanted, and libs
3174  in the %Config hash (e.g., $Config{ccflags_nolargefiles}) so the
3175  extensions that are having problems can try configuring themselves
3176  without the largefileness.  This is admittedly not a clean solution,
3177  and the solution may not even work at all.  One potential failure is
3178  whether one can (or, if one can, whether it's a good idea to) link
3179  together at all binaries with different ideas about file offsets;
3180  all this is platform-dependent.
3181  
3182  =head2 Modifying $_ Inside for(..)
3183  
3184     for (1..5) { $_++ }
3185  
3186  works without complaint.  It shouldn't.  (You should be able to
3187  modify only lvalue elements inside the loops.)  You can see the
3188  correct behaviour by replacing the 1..5 with 1, 2, 3, 4, 5.
3189  
3190  =head2 mod_perl 1.26 Doesn't Build With Threaded Perl
3191  
3192  Use mod_perl 1.27 or higher.
3193  
3194  =head2 lib/ftmp-security tests warn 'system possibly insecure'
3195  
3196  Don't panic.  Read the 'make test' section of INSTALL instead.
3197  
3198  =head2 libwww-perl (LWP) fails base/date #51
3199  
3200  Use libwww-perl 5.65 or later.
3201  
3202  =head2 PDL failing some tests
3203  
3204  Use PDL 2.3.4 or later.
3205  
3206  =head2 Perl_get_sv
3207  
3208  You may get errors like 'Undefined symbol "Perl_get_sv"' or "can't
3209  resolve symbol 'Perl_get_sv'", or the symbol may be "Perl_sv_2pv".
3210  This probably means that you are trying to use an older shared Perl
3211  library (or extensions linked with such) with Perl 5.8.0 executable.
3212  Perl used to have such a subroutine, but that is no more the case.
3213  Check your shared library path, and any shared Perl libraries in those
3214  directories.
3215  
3216  Sometimes this problem may also indicate a partial Perl 5.8.0
3217  installation, see L</"Mac OS X dyld undefined symbols"> for an
3218  example and how to deal with it.
3219  
3220  =head2 Self-tying Problems
3221  
3222  Self-tying of arrays and hashes is broken in rather deep and
3223  hard-to-fix ways.  As a stop-gap measure to avoid people from getting
3224  frustrated at the mysterious results (core dumps, most often), it is
3225  forbidden for now (you will get a fatal error even from an attempt).
3226  
3227  A change to self-tying of globs has caused them to be recursively
3228  referenced (see: L<perlobj/"Two-Phased Garbage Collection">).  You
3229  will now need an explicit untie to destroy a self-tied glob.  This
3230  behaviour may be fixed at a later date.
3231  
3232  Self-tying of scalars and IO thingies works.
3233  
3234  =head2 ext/threads/t/libc
3235  
3236  If this test fails, it indicates that your libc (C library) is not
3237  threadsafe.  This particular test stress tests the localtime() call to
3238  find out whether it is threadsafe.  See L<perlthrtut> for more information.
3239  
3240  =head2 Failure of Thread (5.005-style) tests
3241  
3242  B<Note that support for 5.005-style threading is deprecated,
3243  experimental and practically unsupported.  In 5.10, it is expected
3244  to be removed.  You should migrate your code to ithreads.>
3245  
3246  The following tests are known to fail due to fundamental problems in
3247  the 5.005 threading implementation. These are not new failures--Perl
3248  5.005_0x has the same bugs, but didn't have these tests.
3249  
3250   ../ext/B/t/xref.t                    255 65280    14   12  85.71%  3-14
3251   ../ext/List/Util/t/first.t           255 65280     7    4  57.14%  2 5-7
3252   ../lib/English.t                       2   512    54    2   3.70%  2-3
3253   ../lib/FileCache.t                                 5    1  20.00%  5
3254   ../lib/Filter/Simple/t/data.t                      6    3  50.00%  1-3
3255   ../lib/Filter/Simple/t/filter_only.                9    3  33.33%  1-2 5
3256   ../lib/Math/BigInt/t/bare_mbf.t                 1627    4   0.25%  8 11 1626-1627
3257   ../lib/Math/BigInt/t/bigfltpm.t                 1629    4   0.25%  10 13 1628-
3258                                                                      1629
3259   ../lib/Math/BigInt/t/sub_mbf.t                  1633    4   0.24%  8 11 1632-1633
3260   ../lib/Math/BigInt/t/with_sub.t                 1628    4   0.25%  9 12 1627-1628
3261   ../lib/Tie/File/t/31_autodefer.t     255 65280    65   32  49.23%  34-65
3262   ../lib/autouse.t                                  10    1  10.00%  4
3263   op/flip.t                                         15    1   6.67%  15
3264  
3265  These failures are unlikely to get fixed as 5.005-style threads
3266  are considered fundamentally broken.  (Basically what happens is that
3267  competing threads can corrupt shared global state, one good example
3268  being regular expression engine's state.)
3269  
3270  =head2 Timing problems
3271  
3272  The following tests may fail intermittently because of timing
3273  problems, for example if the system is heavily loaded.
3274  
3275      t/op/alarm.t
3276      ext/Time/HiRes/HiRes.t
3277      lib/Benchmark.t
3278      lib/Memoize/t/expmod_t.t
3279      lib/Memoize/t/speed.t
3280  
3281  In case of failure please try running them manually, for example
3282  
3283      ./perl -Ilib ext/Time/HiRes/HiRes.t
3284  
3285  =head2 Tied/Magical Array/Hash Elements Do Not Autovivify
3286  
3287  For normal arrays C<$foo = \$bar[1]> will assign C<undef> to
3288  C<$bar[1]> (assuming that it didn't exist before), but for
3289  tied/magical arrays and hashes such autovivification does not happen
3290  because there is currently no way to catch the reference creation.
3291  The same problem affects slicing over non-existent indices/keys of
3292  a tied/magical array/hash.
3293  
3294  =head2 Unicode in package/class and subroutine names does not work
3295  
3296  One can have Unicode in identifier names, but not in package/class or
3297  subroutine names.  While some limited functionality towards this does
3298  exist as of Perl 5.8.0, that is more accidental than designed; use of
3299  Unicode for the said purposes is unsupported.
3300  
3301  One reason of this unfinishedness is its (currently) inherent
3302  unportability: since both package names and subroutine names may
3303  need to be mapped to file and directory names, the Unicode capability
3304  of the filesystem becomes important-- and there unfortunately aren't
3305  portable answers.
3306  
3307  =head1 Platform Specific Problems
3308  
3309  =head2 AIX
3310  
3311  =over 4
3312  
3313  =item *
3314  
3315  If using the AIX native make command, instead of just "make" issue
3316  "make all".  In some setups the former has been known to spuriously
3317  also try to run "make install".  Alternatively, you may want to use
3318  GNU make.
3319  
3320  =item *
3321  
3322  In AIX 4.2, Perl extensions that use C++ functions that use statics
3323  may have problems in that the statics are not getting initialized.
3324  In newer AIX releases, this has been solved by linking Perl with
3325  the libC_r library, but unfortunately in AIX 4.2 the said library
3326  has an obscure bug where the various functions related to time
3327  (such as time() and gettimeofday()) return broken values, and
3328  therefore in AIX 4.2 Perl is not linked against libC_r.
3329  
3330  =item *
3331  
3332  vac 5.0.0.0 May Produce Buggy Code For Perl
3333  
3334  The AIX C compiler vac version 5.0.0.0 may produce buggy code,
3335  resulting in a few random tests failing when run as part of "make
3336  test", but when the failing tests are run by hand, they succeed.
3337  We suggest upgrading to at least vac version 5.0.1.0, that has been
3338  known to compile Perl correctly.  "lslpp -L|grep vac.C" will tell
3339  you the vac version.  See README.aix.
3340  
3341  =item *
3342  
3343  If building threaded Perl, you may get compilation warning from pp_sys.c:
3344  
3345    "pp_sys.c", line 4651.39: 1506-280 (W) Function argument assignment between types "unsigned char*" and "const void*" is not allowed.
3346  
3347  This is harmless; it is caused by the getnetbyaddr() and getnetbyaddr_r()
3348  having slightly different types for their first argument.
3349  
3350  =back
3351  
3352  =head2 Alpha systems with old gccs fail several tests
3353  
3354  If you see op/pack, op/pat, op/regexp, or ext/Storable tests failing
3355  in a Linux/alpha or *BSD/Alpha, it's probably time to upgrade your gcc.
3356  gccs prior to 2.95.3 are definitely not good enough, and gcc 3.1 may
3357  be even better.  (RedHat Linux/alpha with gcc 3.1 reported no problems,
3358  as did Linux 2.4.18 with gcc 2.95.4.)  (In Tru64, it is preferable to
3359  use the bundled C compiler.)
3360  
3361  =head2 AmigaOS
3362  
3363  Perl 5.8.0 doesn't build in AmigaOS.  It broke at some point during
3364  the ithreads work and we could not find Amiga experts to unbreak the
3365  problems.  Perl 5.6.1 still works for AmigaOS (as does the 5.7.2
3366  development release).
3367  
3368  =head2 BeOS
3369  
3370  The following tests fail on 5.8.0 Perl in BeOS Personal 5.03:
3371  
3372   t/op/lfs............................FAILED at test 17
3373   t/op/magic..........................FAILED at test 24
3374   ext/Fcntl/t/syslfs..................FAILED at test 17
3375   ext/File/Glob/t/basic...............FAILED at test 3
3376   ext/POSIX/t/sigaction...............FAILED at test 13
3377   ext/POSIX/t/waitpid.................FAILED at test 1
3378  
3379  See L<perlbeos> (README.beos) for more details.
3380  
3381  =head2 Cygwin "unable to remap"
3382  
3383  For example when building the Tk extension for Cygwin,
3384  you may get an error message saying "unable to remap".
3385  This is known problem with Cygwin, and a workaround is
3386  detailed in here: http://sources.redhat.com/ml/cygwin/2001-12/msg00894.html
3387  
3388  =head2 Cygwin ndbm tests fail on FAT
3389  
3390  One can build but not install (or test the build of) the NDBM_File
3391  on FAT filesystems.  Installation (or build) on NTFS works fine.
3392  If one attempts the test on a FAT install (or build) the following
3393  failures are expected:
3394  
3395   ../ext/NDBM_File/ndbm.t       13  3328    71   59  83.10%  1-2 4 16-71
3396   ../ext/ODBM_File/odbm.t      255 65280    ??   ??       %  ??
3397   ../lib/AnyDBM_File.t           2   512    12    2  16.67%  1 4
3398   ../lib/Memoize/t/errors.t      0   139    11    5  45.45%  7-11
3399   ../lib/Memoize/t/tie_ndbm.t   13  3328     4    4 100.00%  1-4
3400   run/fresh_perl.t                          97    1   1.03%  91
3401  
3402  NDBM_File fails and ODBM_File just coredumps.
3403  
3404  If you intend to run only on FAT (or if using AnyDBM_File on FAT),
3405  run Configure with the -Ui_ndbm and -Ui_dbm options to prevent
3406  NDBM_File and ODBM_File being built.
3407  
3408  =head2 DJGPP Failures
3409  
3410   t/op/stat............................FAILED at test 29
3411   lib/File/Find/t/find.................FAILED at test 1
3412   lib/File/Find/t/taint................FAILED at test 1
3413   lib/h2xs.............................FAILED at test 15
3414   lib/Pod/t/eol........................FAILED at test 1
3415   lib/Test/Harness/t/strap-analyze.....FAILED at test 8
3416   lib/Test/Harness/t/test-harness......FAILED at test 23
3417   lib/Test/Simple/t/exit...............FAILED at test 1
3418  
3419  The above failures are known as of 5.8.0 with native builds with long
3420  filenames, but there are a few more if running under dosemu because of
3421  limitations (and maybe bugs) of dosemu:
3422  
3423   t/comp/cpp...........................FAILED at test 3
3424   t/op/inccode.........................(crash)
3425  
3426  and a few lib/ExtUtils tests, and several hundred Encode/t/Aliases.t
3427  failures that work fine with long filenames.  So you really might
3428  prefer native builds and long filenames.
3429  
3430  =head2 FreeBSD built with ithreads coredumps reading large directories
3431  
3432  This is a known bug in FreeBSD 4.5's readdir_r(), it has been fixed in
3433  FreeBSD 4.6 (see L<perlfreebsd> (README.freebsd)).
3434  
3435  =head2 FreeBSD Failing locale Test 117 For ISO 8859-15 Locales
3436  
3437  The ISO 8859-15 locales may fail the locale test 117 in FreeBSD.
3438  This is caused by the characters \xFF (y with diaeresis) and \xBE
3439  (Y with diaeresis) not behaving correctly when being matched
3440  case-insensitively.  Apparently this problem has been fixed in
3441  the latest FreeBSD releases.
3442  ( http://www.freebsd.org/cgi/query-pr.cgi?pr=34308 )
3443  
3444  =head2 IRIX fails ext/List/Util/t/shuffle.t or Digest::MD5
3445  
3446  IRIX with MIPSpro 7.3.1.2m or 7.3.1.3m compiler may fail the List::Util
3447  test ext/List/Util/t/shuffle.t by dumping core.  This seems to be
3448  a compiler error since if compiled with gcc no core dump ensues, and
3449  no failures have been seen on the said test on any other platform.
3450  
3451  Similarly, building the Digest::MD5 extension has been
3452  known to fail with "*** Termination code 139 (bu21)".
3453  
3454  The cure is to drop optimization level (Configure -Doptimize=-O2).
3455  
3456  =head2 HP-UX lib/posix Subtest 9 Fails When LP64-Configured
3457  
3458  If perl is configured with -Duse64bitall, the successful result of the
3459  subtest 10 of lib/posix may arrive before the successful result of the
3460  subtest 9, which confuses the test harness so much that it thinks the
3461  subtest 9 failed.
3462  
3463  =head2 Linux with glibc 2.2.5 fails t/op/int subtest #6 with -Duse64bitint
3464  
3465  This is a known bug in the glibc 2.2.5 with long long integers.
3466  ( http://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=65612 )
3467  
3468  =head2 Linux With Sfio Fails op/misc Test 48
3469  
3470  No known fix.
3471  
3472  =head2 Mac OS X
3473  
3474  Please remember to set your environment variable LC_ALL to "C"
3475  (setenv LC_ALL C) before running "make test" to avoid a lot of
3476  warnings about the broken locales of Mac OS X.
3477  
3478  The following tests are known to fail in Mac OS X 10.1.5 because of
3479  buggy (old) implementations of Berkeley DB included in Mac OS X:
3480  
3481   Failed Test                 Stat Wstat Total Fail  Failed  List of Failed
3482   -------------------------------------------------------------------------
3483   ../ext/DB_File/t/db-btree.t    0    11    ??   ??       %  ??
3484   ../ext/DB_File/t/db-recno.t              149    3   2.01%  61 63 65
3485  
3486  If you are building on a UFS partition, you will also probably see
3487  t/op/stat.t subtest #9 fail.  This is caused by Darwin's UFS not
3488  supporting inode change time.
3489  
3490  Also the ext/POSIX/t/posix.t subtest #10 fails but it is skipped for
3491  now because the failure is Apple's fault, not Perl's (blocked signals
3492  are lost).
3493  
3494  If you Configure with ithreads, ext/threads/t/libc.t will fail. Again,
3495  this is not Perl's fault-- the libc of Mac OS X is not threadsafe
3496  (in this particular test, the localtime() call is found to be
3497  threadunsafe.)
3498  
3499  =head2 Mac OS X dyld undefined symbols
3500  
3501  If after installing Perl 5.8.0 you are getting warnings about missing
3502  symbols, for example
3503  
3504      dyld: perl Undefined symbols
3505      _perl_sv_2pv
3506      _perl_get_sv
3507  
3508  you probably have an old pre-Perl-5.8.0 installation (or parts of one)
3509  in /Library/Perl (the undefined symbols used to exist in pre-5.8.0 Perls).
3510  It seems that for some reason "make install" doesn't always completely
3511  overwrite the files in /Library/Perl.  You can move the old Perl
3512  shared library out of the way like this:
3513  
3514      cd /Library/Perl/darwin/CORE
3515      mv libperl.dylib libperlold.dylib
3516  
3517  and then reissue "make install".  Note that the above of course is
3518  extremely disruptive for anything using the /usr/local/bin/perl.
3519  If that doesn't help, you may have to try removing all the .bundle
3520  files from beneath /Library/Perl, and again "make install"-ing.
3521  
3522  =head2 OS/2 Test Failures
3523  
3524  The following tests are known to fail on OS/2 (for clarity
3525  only the failures are shown, not the full error messages):
3526  
3527   ../lib/ExtUtils/t/Mkbootstrap.t    1   256    18    1   5.56%  8
3528   ../lib/ExtUtils/t/Packlist.t       1   256    34    1   2.94%  17
3529   ../lib/ExtUtils/t/basic.t          1   256    17    1   5.88%  14
3530   lib/os2_process.t                  2   512   227    2   0.88%  174 209
3531   lib/os2_process_kid.t                        227    2   0.88%  174 209
3532   lib/rx_cmprt.t                   255 65280    18    3  16.67%  16-18
3533  
3534  =head2 op/sprintf tests 91, 129, and 130
3535  
3536  The op/sprintf tests 91, 129, and 130 are known to fail on some platforms.
3537  Examples include any platform using sfio, and Compaq/Tandem's NonStop-UX.
3538  
3539  Test 91 is known to fail on QNX6 (nto), because C<sprintf '%e',0>
3540  incorrectly produces C<0.000000e+0> instead of C<0.000000e+00>.
3541  
3542  For tests 129 and 130, the failing platforms do not comply with
3543  the ANSI C Standard: lines 19ff on page 134 of ANSI X3.159 1989, to
3544  be exact.  (They produce something other than "1" and "-1" when
3545  formatting 0.6 and -0.6 using the printf format "%.0f"; most often,
3546  they produce "0" and "-0".)
3547  
3548  =head2 SCO
3549  
3550  The socketpair tests are known to be unhappy in SCO 3.2v5.0.4:
3551  
3552   ext/Socket/socketpair.t...............FAILED tests 15-45
3553  
3554  =head2 Solaris 2.5
3555  
3556  In case you are still using Solaris 2.5 (aka SunOS 5.5), you may
3557  experience failures (the test core dumping) in lib/locale.t.
3558  The suggested cure is to upgrade your Solaris.
3559  
3560  =head2 Solaris x86 Fails Tests With -Duse64bitint
3561  
3562  The following tests are known to fail in Solaris x86 with Perl
3563  configured to use 64 bit integers:
3564  
3565   ext/Data/Dumper/t/dumper.............FAILED at test 268
3566   ext/Devel/Peek/Peek..................FAILED at test 7
3567  
3568  =head2 SUPER-UX (NEC SX)
3569  
3570  The following tests are known to fail on SUPER-UX:
3571  
3572   op/64bitint...........................FAILED tests 29-30, 32-33, 35-36
3573   op/arith..............................FAILED tests 128-130
3574   op/pack...............................FAILED tests 25-5625
3575   op/pow................................
3576   op/taint..............................# msgsnd failed
3577   ../ext/IO/lib/IO/t/io_poll............FAILED tests 3-4
3578   ../ext/IPC/SysV/ipcsysv...............FAILED tests 2, 5-6
3579   ../ext/IPC/SysV/t/msg.................FAILED tests 2, 4-6
3580   ../ext/Socket/socketpair..............FAILED tests 12
3581   ../lib/IPC/SysV.......................FAILED tests 2, 5-6
3582   ../lib/warnings.......................FAILED tests 115-116, 118-119
3583  
3584  The op/pack failure ("Cannot compress negative numbers at op/pack.t line 126")
3585  is serious but as of yet unsolved.  It points at some problems with the
3586  signedness handling of the C compiler, as do the 64bitint, arith, and pow
3587  failures.  Most of the rest point at problems with SysV IPC.
3588  
3589  =head2 Term::ReadKey not working on Win32
3590  
3591  Use Term::ReadKey 2.20 or later.
3592  
3593  =head2 UNICOS/mk
3594  
3595  =over 4
3596  
3597  =item *
3598  
3599  During Configure, the test
3600  
3601      Guessing which symbols your C compiler and preprocessor define...
3602  
3603  will probably fail with error messages like
3604  
3605      CC-20 cc: ERROR File = try.c, Line = 3
3606        The identifier "bad" is undefined.
3607  
3608        bad switch yylook 79bad switch yylook 79bad switch yylook 79bad switch yylook 79#ifdef A29K
3609        ^
3610  
3611      CC-65 cc: ERROR File = try.c, Line = 3
3612        A semicolon is expected at this point.
3613  
3614  This is caused by a bug in the awk utility of UNICOS/mk.  You can ignore
3615  the error, but it does cause a slight problem: you cannot fully
3616  benefit from the h2ph utility (see L<h2ph>) that can be used to
3617  convert C headers to Perl libraries, mainly used to be able to access
3618  from Perl the constants defined using C preprocessor, cpp.  Because of
3619  the above error, parts of the converted headers will be invisible.
3620  Luckily, these days the need for h2ph is rare.
3621  
3622  =item *
3623  
3624  If building Perl with interpreter threads (ithreads), the
3625  getgrent(), getgrnam(), and getgrgid() functions cannot return the
3626  list of the group members due to a bug in the multithreaded support of
3627  UNICOS/mk.  What this means is that in list context the functions will
3628  return only three values, not four.
3629  
3630  =back
3631  
3632  =head2 UTS
3633  
3634  There are a few known test failures, see L<perluts> (README.uts).
3635  
3636  =head2 VOS (Stratus)
3637  
3638  When Perl is built using the native build process on VOS Release
3639  14.5.0 and GNU C++/GNU Tools 2.0.1, all attempted tests either
3640  pass or result in TODO (ignored) failures.
3641  
3642  =head2 VMS
3643  
3644  There should be no reported test failures with a default configuration,
3645  though there are a number of tests marked TODO that point to areas
3646  needing further debugging and/or porting work.
3647  
3648  =head2 Win32
3649  
3650  In multi-CPU boxes, there are some problems with the I/O buffering:
3651  some output may appear twice.
3652  
3653  =head2 XML::Parser not working
3654  
3655  Use XML::Parser 2.31 or later.
3656  
3657  =head2 z/OS (OS/390)
3658  
3659  z/OS has rather many test failures but the situation is actually much
3660  better than it was in 5.6.0; it's just that so many new modules and
3661  tests have been added.
3662  
3663   Failed Test                   Stat Wstat Total Fail  Failed  List of Failed
3664   ---------------------------------------------------------------------------
3665   ../ext/Data/Dumper/t/dumper.t              357    8   2.24%  311 314 325 327
3666                                                                331 333 337 339
3667   ../ext/IO/lib/IO/t/io_unix.t                 5    4  80.00%  2-5
3668   ../ext/Storable/t/downgrade.t   12  3072   169   12   7.10%  14-15 46-47 78-79
3669                                                                110-111 150 161
3670   ../lib/ExtUtils/t/Constant.t   121 30976    48   48 100.00%  1-48
3671   ../lib/ExtUtils/t/Embed.t                    9    9 100.00%  1-9
3672   op/pat.t                                   922    7   0.76%  665 776 785 832-
3673                                                                834 845
3674   op/sprintf.t                               224    3   1.34%  98 100 136
3675   op/tr.t                                     97    5   5.15%  63 71-74
3676   uni/fold.t                                 780    6   0.77%  61 169 196 661
3677                                                                710-711
3678  
3679  The failures in dumper.t and downgrade.t are problems in the tests,
3680  those in io_unix and sprintf are problems in the USS (UDP sockets and
3681  printf formats).  The pat, tr, and fold failures are genuine Perl
3682  problems caused by EBCDIC (and in the pat and fold cases, combining
3683  that with Unicode).  The Constant and Embed are probably problems in
3684  the tests (since they test Perl's ability to build extensions, and
3685  that seems to be working reasonably well.)
3686  
3687  =head2 Unicode Support on EBCDIC Still Spotty
3688  
3689  Though mostly working, Unicode support still has problem spots on
3690  EBCDIC platforms.  One such known spot are the C<\p{}> and C<\P{}>
3691  regular expression constructs for code points less than 256: the
3692  C<pP> are testing for Unicode code points, not knowing about EBCDIC.
3693  
3694  =head2 Seen In Perl 5.7 But Gone Now
3695  
3696  C<Time::Piece> (previously known as C<Time::Object>) was removed
3697  because it was felt that it didn't have enough value in it to be a
3698  core module.  It is still a useful module, though, and is available
3699  from the CPAN.
3700  
3701  Perl 5.8 unfortunately does not build anymore on AmigaOS; this broke
3702  accidentally at some point.  Since there are not that many Amiga
3703  developers available, we could not get this fixed and tested in time
3704  for 5.8.0.  Perl 5.6.1 still works for AmigaOS (as does the 5.7.2
3705  development release).
3706  
3707  The C<PerlIO::Scalar> and C<PerlIO::Via> (capitalised) were renamed as
3708  C<PerlIO::scalar> and C<PerlIO::via> (all lowercase) just before 5.8.0.
3709  The main rationale was to have all core PerlIO layers to have all
3710  lowercase names.  The "plugins" are named as usual, for example
3711  C<PerlIO::via::QuotedPrint>.
3712  
3713  The C<threads::shared::queue> and C<threads::shared::semaphore> were
3714  renamed as C<Thread::Queue> and C<Thread::Semaphore> just before 5.8.0.
3715  The main rationale was to have thread modules to obey normal naming,
3716  C<Thread::> (the C<threads> and C<threads::shared> themselves are
3717  more pragma-like, they affect compile-time, so they stay lowercase).
3718  
3719  =head1 Reporting Bugs
3720  
3721  If you find what you think is a bug, you might check the articles
3722  recently posted to the comp.lang.perl.misc newsgroup and the perl
3723  bug database at http://bugs.perl.org/ .  There may also be
3724  information at http://www.perl.com/ , the Perl Home Page.
3725  
3726  If you believe you have an unreported bug, please run the B<perlbug>
3727  program included with your release.  Be sure to trim your bug down
3728  to a tiny but sufficient test case.  Your bug report, along with the
3729  output of C<perl -V>, will be sent off to perlbug@perl.org to be
3730  analysed by the Perl porting team.
3731  
3732  =head1 SEE ALSO
3733  
3734  The F<Changes> file for exhaustive details on what changed.
3735  
3736  The F<INSTALL> file for how to build Perl.
3737  
3738  The F<README> file for general stuff.
3739  
3740  The F<Artistic> and F<Copying> files for copyright information.
3741  
3742  =head1 HISTORY
3743  
3744  Written by Jarkko Hietaniemi <F<jhi@iki.fi>>.
3745  
3746  =cut