[ Index ]

PHP Cross Reference of Unnamed Project

title

Body

[close]

/se3-unattended/var/se3/unattended/install/linuxaux/opt/perl/lib/5.10.0/pod/ -> perl5100delta.pod (source)

   1  =encoding utf8
   2  
   3  =head1 NAME
   4  
   5  perldelta - what is new for perl 5.10.0
   6  
   7  =head1 DESCRIPTION
   8  
   9  This document describes the differences between the 5.8.8 release and
  10  the 5.10.0 release.
  11  
  12  Many of the bug fixes in 5.10.0 were already seen in the 5.8.X maintenance
  13  releases; they are not duplicated here and are documented in the set of
  14  man pages named perl58[1-8]?delta.
  15  
  16  =head1 Core Enhancements
  17  
  18  =head2 The C<feature> pragma
  19  
  20  The C<feature> pragma is used to enable new syntax that would break Perl's
  21  backwards-compatibility with older releases of the language. It's a lexical
  22  pragma, like C<strict> or C<warnings>.
  23  
  24  Currently the following new features are available: C<switch> (adds a
  25  switch statement), C<say> (adds a C<say> built-in function), and C<state>
  26  (adds a C<state> keyword for declaring "static" variables). Those
  27  features are described in their own sections of this document.
  28  
  29  The C<feature> pragma is also implicitly loaded when you require a minimal
  30  perl version (with the C<use VERSION> construct) greater than, or equal
  31  to, 5.9.5. See L<feature> for details.
  32  
  33  =head2 New B<-E> command-line switch
  34  
  35  B<-E> is equivalent to B<-e>, but it implicitly enables all
  36  optional features (like C<use feature ":5.10">).
  37  
  38  =head2 Defined-or operator
  39  
  40  A new operator C<//> (defined-or) has been implemented.
  41  The following expression:
  42  
  43      $a // $b
  44  
  45  is merely equivalent to
  46  
  47     defined $a ? $a : $b
  48  
  49  and the statement
  50  
  51     $c //= $d;
  52  
  53  can now be used instead of
  54  
  55     $c = $d unless defined $c;
  56  
  57  The C<//> operator has the same precedence and associativity as C<||>.
  58  Special care has been taken to ensure that this operator Do What You Mean
  59  while not breaking old code, but some edge cases involving the empty
  60  regular expression may now parse differently.  See L<perlop> for
  61  details.
  62  
  63  =head2 Switch and Smart Match operator
  64  
  65  Perl 5 now has a switch statement. It's available when C<use feature
  66  'switch'> is in effect. This feature introduces three new keywords,
  67  C<given>, C<when>, and C<default>:
  68  
  69      given ($foo) {
  70      when (/^abc/) { $abc = 1; }
  71      when (/^def/) { $def = 1; }
  72      when (/^xyz/) { $xyz = 1; }
  73      default { $nothing = 1; }
  74      }
  75  
  76  A more complete description of how Perl matches the switch variable
  77  against the C<when> conditions is given in L<perlsyn/"Switch statements">.
  78  
  79  This kind of match is called I<smart match>, and it's also possible to use
  80  it outside of switch statements, via the new C<~~> operator. See
  81  L<perlsyn/"Smart matching in detail">.
  82  
  83  This feature was contributed by Robin Houston.
  84  
  85  =head2 Regular expressions
  86  
  87  =over 4
  88  
  89  =item Recursive Patterns
  90  
  91  It is now possible to write recursive patterns without using the C<(??{})>
  92  construct. This new way is more efficient, and in many cases easier to
  93  read.
  94  
  95  Each capturing parenthesis can now be treated as an independent pattern
  96  that can be entered by using the C<(?PARNO)> syntax (C<PARNO> standing for
  97  "parenthesis number"). For example, the following pattern will match
  98  nested balanced angle brackets:
  99  
 100      /
 101       ^                      # start of line
 102       (                      # start capture buffer 1
 103      <                   #   match an opening angle bracket
 104      (?:                 #   match one of:
 105          (?>             #     don't backtrack over the inside of this group
 106          [^<>]+      #       one or more non angle brackets
 107          )               #     end non backtracking group
 108      |                   #     ... or ...
 109          (?1)            #     recurse to bracket 1 and try it again
 110      )*                  #   0 or more times.
 111      >                   #   match a closing angle bracket
 112       )                      # end capture buffer one
 113       $                      # end of line
 114      /x
 115  
 116  PCRE users should note that Perl's recursive regex feature allows
 117  backtracking into a recursed pattern, whereas in PCRE the recursion is
 118  atomic or "possessive" in nature.  As in the example above, you can
 119  add (?>) to control this selectively.  (Yves Orton)
 120  
 121  =item Named Capture Buffers
 122  
 123  It is now possible to name capturing parenthesis in a pattern and refer to
 124  the captured contents by name. The naming syntax is C<< (?<NAME>....) >>.
 125  It's possible to backreference to a named buffer with the C<< \k<NAME> >>
 126  syntax. In code, the new magical hashes C<%+> and C<%-> can be used to
 127  access the contents of the capture buffers.
 128  
 129  Thus, to replace all doubled chars with a single copy, one could write
 130  
 131      s/(?<letter>.)\k<letter>/$+{letter}/g
 132  
 133  Only buffers with defined contents will be "visible" in the C<%+> hash, so
 134  it's possible to do something like
 135  
 136      foreach my $name (keys %+) {
 137          print "content of buffer '$name' is $+{$name}\n";
 138      }
 139  
 140  The C<%-> hash is a bit more complete, since it will contain array refs
 141  holding values from all capture buffers similarly named, if there should
 142  be many of them.
 143  
 144  C<%+> and C<%-> are implemented as tied hashes through the new module
 145  C<Tie::Hash::NamedCapture>.
 146  
 147  Users exposed to the .NET regex engine will find that the perl
 148  implementation differs in that the numerical ordering of the buffers
 149  is sequential, and not "unnamed first, then named". Thus in the pattern
 150  
 151     /(A)(?<B>B)(C)(?<D>D)/
 152  
 153  $1 will be 'A', $2 will be 'B', $3 will be 'C' and $4 will be 'D' and not
 154  $1 is 'A', $2 is 'C' and $3 is 'B' and $4 is 'D' that a .NET programmer
 155  would expect. This is considered a feature. :-) (Yves Orton)
 156  
 157  =item Possessive Quantifiers
 158  
 159  Perl now supports the "possessive quantifier" syntax of the "atomic match"
 160  pattern. Basically a possessive quantifier matches as much as it can and never
 161  gives any back. Thus it can be used to control backtracking. The syntax is
 162  similar to non-greedy matching, except instead of using a '?' as the modifier
 163  the '+' is used. Thus C<?+>, C<*+>, C<++>, C<{min,max}+> are now legal
 164  quantifiers. (Yves Orton)
 165  
 166  =item Backtracking control verbs
 167  
 168  The regex engine now supports a number of special-purpose backtrack
 169  control verbs: (*THEN), (*PRUNE), (*MARK), (*SKIP), (*COMMIT), (*FAIL)
 170  and (*ACCEPT). See L<perlre> for their descriptions. (Yves Orton)
 171  
 172  =item Relative backreferences
 173  
 174  A new syntax C<\g{N}> or C<\gN> where "N" is a decimal integer allows a
 175  safer form of back-reference notation as well as allowing relative
 176  backreferences. This should make it easier to generate and embed patterns
 177  that contain backreferences. See L<perlre/"Capture buffers">. (Yves Orton)
 178  
 179  =item C<\K> escape
 180  
 181  The functionality of Jeff Pinyan's module Regexp::Keep has been added to
 182  the core. In regular expressions you can now use the special escape C<\K>
 183  as a way to do something like floating length positive lookbehind. It is
 184  also useful in substitutions like:
 185  
 186    s/(foo)bar/$1/g
 187  
 188  that can now be converted to
 189  
 190    s/foo\Kbar//g
 191  
 192  which is much more efficient. (Yves Orton)
 193  
 194  =item Vertical and horizontal whitespace, and linebreak
 195  
 196  Regular expressions now recognize the C<\v> and C<\h> escapes that match
 197  vertical and horizontal whitespace, respectively. C<\V> and C<\H>
 198  logically match their complements.
 199  
 200  C<\R> matches a generic linebreak, that is, vertical whitespace, plus
 201  the multi-character sequence C<"\x0D\x0A">.
 202  
 203  =back
 204  
 205  =head2 C<say()>
 206  
 207  say() is a new built-in, only available when C<use feature 'say'> is in
 208  effect, that is similar to print(), but that implicitly appends a newline
 209  to the printed string. See L<perlfunc/say>. (Robin Houston)
 210  
 211  =head2 Lexical C<$_>
 212  
 213  The default variable C<$_> can now be lexicalized, by declaring it like
 214  any other lexical variable, with a simple
 215  
 216      my $_;
 217  
 218  The operations that default on C<$_> will use the lexically-scoped
 219  version of C<$_> when it exists, instead of the global C<$_>.
 220  
 221  In a C<map> or a C<grep> block, if C<$_> was previously my'ed, then the
 222  C<$_> inside the block is lexical as well (and scoped to the block).
 223  
 224  In a scope where C<$_> has been lexicalized, you can still have access to
 225  the global version of C<$_> by using C<$::_>, or, more simply, by
 226  overriding the lexical declaration with C<our $_>. (Rafael Garcia-Suarez)
 227  
 228  =head2 The C<_> prototype
 229  
 230  A new prototype character has been added. C<_> is equivalent to C<$> but
 231  defaults to C<$_> if the corresponding argument isn't supplied. (both C<$>
 232  and C<_> denote a scalar). Due to the optional nature of the argument, you
 233  can only use it at the end of a prototype, or before a semicolon.
 234  
 235  This has a small incompatible consequence: the prototype() function has
 236  been adjusted to return C<_> for some built-ins in appropriate cases (for
 237  example, C<prototype('CORE::rmdir')>). (Rafael Garcia-Suarez)
 238  
 239  =head2 UNITCHECK blocks
 240  
 241  C<UNITCHECK>, a new special code block has been introduced, in addition to
 242  C<BEGIN>, C<CHECK>, C<INIT> and C<END>.
 243  
 244  C<CHECK> and C<INIT> blocks, while useful for some specialized purposes,
 245  are always executed at the transition between the compilation and the
 246  execution of the main program, and thus are useless whenever code is
 247  loaded at runtime. On the other hand, C<UNITCHECK> blocks are executed
 248  just after the unit which defined them has been compiled. See L<perlmod>
 249  for more information. (Alex Gough)
 250  
 251  =head2 New Pragma, C<mro>
 252  
 253  A new pragma, C<mro> (for Method Resolution Order) has been added. It
 254  permits to switch, on a per-class basis, the algorithm that perl uses to
 255  find inherited methods in case of a multiple inheritance hierarchy. The
 256  default MRO hasn't changed (DFS, for Depth First Search). Another MRO is
 257  available: the C3 algorithm. See L<mro> for more information.
 258  (Brandon Black)
 259  
 260  Note that, due to changes in the implementation of class hierarchy search,
 261  code that used to undef the C<*ISA> glob will most probably break. Anyway,
 262  undef'ing C<*ISA> had the side-effect of removing the magic on the @ISA
 263  array and should not have been done in the first place. Also, the
 264  cache C<*::ISA::CACHE::> no longer exists; to force reset the @ISA cache,
 265  you now need to use the C<mro> API, or more simply to assign to @ISA
 266  (e.g. with C<@ISA = @ISA>).
 267  
 268  =head2 readdir() may return a "short filename" on Windows
 269  
 270  The readdir() function may return a "short filename" when the long
 271  filename contains characters outside the ANSI codepage.  Similarly
 272  Cwd::cwd() may return a short directory name, and glob() may return short
 273  names as well.  On the NTFS file system these short names can always be
 274  represented in the ANSI codepage.  This will not be true for all other file
 275  system drivers; e.g. the FAT filesystem stores short filenames in the OEM
 276  codepage, so some files on FAT volumes remain unaccessible through the
 277  ANSI APIs.
 278  
 279  Similarly, $^X, @INC, and $ENV{PATH} are preprocessed at startup to make
 280  sure all paths are valid in the ANSI codepage (if possible).
 281  
 282  The Win32::GetLongPathName() function now returns the UTF-8 encoded
 283  correct long file name instead of using replacement characters to force
 284  the name into the ANSI codepage.  The new Win32::GetANSIPathName()
 285  function can be used to turn a long pathname into a short one only if the
 286  long one cannot be represented in the ANSI codepage.
 287  
 288  Many other functions in the C<Win32> module have been improved to accept
 289  UTF-8 encoded arguments.  Please see L<Win32> for details.
 290  
 291  =head2 readpipe() is now overridable
 292  
 293  The built-in function readpipe() is now overridable. Overriding it permits
 294  also to override its operator counterpart, C<qx//> (a.k.a. C<``>).
 295  Moreover, it now defaults to C<$_> if no argument is provided. (Rafael
 296  Garcia-Suarez)
 297  
 298  =head2 Default argument for readline()
 299  
 300  readline() now defaults to C<*ARGV> if no argument is provided. (Rafael
 301  Garcia-Suarez)
 302  
 303  =head2 state() variables
 304  
 305  A new class of variables has been introduced. State variables are similar
 306  to C<my> variables, but are declared with the C<state> keyword in place of
 307  C<my>. They're visible only in their lexical scope, but their value is
 308  persistent: unlike C<my> variables, they're not undefined at scope entry,
 309  but retain their previous value. (Rafael Garcia-Suarez, Nicholas Clark)
 310  
 311  To use state variables, one needs to enable them by using
 312  
 313      use feature 'state';
 314  
 315  or by using the C<-E> command-line switch in one-liners.
 316  See L<perlsub/"Persistent variables via state()">.
 317  
 318  =head2 Stacked filetest operators
 319  
 320  As a new form of syntactic sugar, it's now possible to stack up filetest
 321  operators. You can now write C<-f -w -x $file> in a row to mean
 322  C<-x $file && -w _ && -f _>. See L<perlfunc/-X>.
 323  
 324  =head2 UNIVERSAL::DOES()
 325  
 326  The C<UNIVERSAL> class has a new method, C<DOES()>. It has been added to
 327  solve semantic problems with the C<isa()> method. C<isa()> checks for
 328  inheritance, while C<DOES()> has been designed to be overridden when
 329  module authors use other types of relations between classes (in addition
 330  to inheritance). (chromatic)
 331  
 332  See L<< UNIVERSAL/"$obj->DOES( ROLE )" >>.
 333  
 334  =head2 Formats
 335  
 336  Formats were improved in several ways. A new field, C<^*>, can be used for
 337  variable-width, one-line-at-a-time text. Null characters are now handled
 338  correctly in picture lines. Using C<@#> and C<~~> together will now
 339  produce a compile-time error, as those format fields are incompatible.
 340  L<perlform> has been improved, and miscellaneous bugs fixed.
 341  
 342  =head2 Byte-order modifiers for pack() and unpack()
 343  
 344  There are two new byte-order modifiers, C<E<gt>> (big-endian) and C<E<lt>>
 345  (little-endian), that can be appended to most pack() and unpack() template
 346  characters and groups to force a certain byte-order for that type or group.
 347  See L<perlfunc/pack> and L<perlpacktut> for details.
 348  
 349  =head2 C<no VERSION>
 350  
 351  You can now use C<no> followed by a version number to specify that you
 352  want to use a version of perl older than the specified one.
 353  
 354  =head2 C<chdir>, C<chmod> and C<chown> on filehandles
 355  
 356  C<chdir>, C<chmod> and C<chown> can now work on filehandles as well as
 357  filenames, if the system supports respectively C<fchdir>, C<fchmod> and
 358  C<fchown>, thanks to a patch provided by Gisle Aas.
 359  
 360  =head2 OS groups
 361  
 362  C<$(> and C<$)> now return groups in the order where the OS returns them,
 363  thanks to Gisle Aas. This wasn't previously the case.
 364  
 365  =head2 Recursive sort subs
 366  
 367  You can now use recursive subroutines with sort(), thanks to Robin Houston.
 368  
 369  =head2 Exceptions in constant folding
 370  
 371  The constant folding routine is now wrapped in an exception handler, and
 372  if folding throws an exception (such as attempting to evaluate 0/0), perl
 373  now retains the current optree, rather than aborting the whole program.
 374  Without this change, programs would not compile if they had expressions that
 375  happened to generate exceptions, even though those expressions were in code
 376  that could never be reached at runtime. (Nicholas Clark, Dave Mitchell)
 377  
 378  =head2 Source filters in @INC
 379  
 380  It's possible to enhance the mechanism of subroutine hooks in @INC by
 381  adding a source filter on top of the filehandle opened and returned by the
 382  hook. This feature was planned a long time ago, but wasn't quite working
 383  until now. See L<perlfunc/require> for details. (Nicholas Clark)
 384  
 385  =head2 New internal variables
 386  
 387  =over 4
 388  
 389  =item C<${^RE_DEBUG_FLAGS}>
 390  
 391  This variable controls what debug flags are in effect for the regular
 392  expression engine when running under C<use re "debug">. See L<re> for
 393  details.
 394  
 395  =item C<${^CHILD_ERROR_NATIVE}>
 396  
 397  This variable gives the native status returned by the last pipe close,
 398  backtick command, successful call to wait() or waitpid(), or from the
 399  system() operator. See L<perlrun> for details. (Contributed by Gisle Aas.)
 400  
 401  =item C<${^RE_TRIE_MAXBUF}>
 402  
 403  See L</"Trie optimisation of literal string alternations">.
 404  
 405  =item C<${^WIN32_SLOPPY_STAT}>
 406  
 407  See L</"Sloppy stat on Windows">.
 408  
 409  =back
 410  
 411  =head2 Miscellaneous
 412  
 413  C<unpack()> now defaults to unpacking the C<$_> variable.
 414  
 415  C<mkdir()> without arguments now defaults to C<$_>.
 416  
 417  The internal dump output has been improved, so that non-printable characters
 418  such as newline and backspace are output in C<\x> notation, rather than
 419  octal.
 420  
 421  The B<-C> option can no longer be used on the C<#!> line. It wasn't
 422  working there anyway, since the standard streams are already set up
 423  at this point in the execution of the perl interpreter. You can use
 424  binmode() instead to get the desired behaviour.
 425  
 426  =head2 UCD 5.0.0
 427  
 428  The copy of the Unicode Character Database included in Perl 5 has
 429  been updated to version 5.0.0.
 430  
 431  =head2 MAD
 432  
 433  MAD, which stands for I<Miscellaneous Attribute Decoration>, is a
 434  still-in-development work leading to a Perl 5 to Perl 6 converter. To
 435  enable it, it's necessary to pass the argument C<-Dmad> to Configure. The
 436  obtained perl isn't binary compatible with a regular perl 5.10, and has
 437  space and speed penalties; moreover not all regression tests still pass
 438  with it. (Larry Wall, Nicholas Clark)
 439  
 440  =head2 kill() on Windows
 441  
 442  On Windows platforms, C<kill(-9, $pid)> now kills a process tree.
 443  (On UNIX, this delivers the signal to all processes in the same process
 444  group.)
 445  
 446  =head1 Incompatible Changes
 447  
 448  =head2 Packing and UTF-8 strings
 449  
 450  The semantics of pack() and unpack() regarding UTF-8-encoded data has been
 451  changed. Processing is now by default character per character instead of
 452  byte per byte on the underlying encoding. Notably, code that used things
 453  like C<pack("a*", $string)> to see through the encoding of string will now
 454  simply get back the original $string. Packed strings can also get upgraded
 455  during processing when you store upgraded characters. You can get the old
 456  behaviour by using C<use bytes>.
 457  
 458  To be consistent with pack(), the C<C0> in unpack() templates indicates
 459  that the data is to be processed in character mode, i.e. character by
 460  character; on the contrary, C<U0> in unpack() indicates UTF-8 mode, where
 461  the packed string is processed in its UTF-8-encoded Unicode form on a byte
 462  by byte basis. This is reversed with regard to perl 5.8.X, but now consistent
 463  between pack() and unpack().
 464  
 465  Moreover, C<C0> and C<U0> can also be used in pack() templates to specify
 466  respectively character and byte modes.
 467  
 468  C<C0> and C<U0> in the middle of a pack or unpack format now switch to the
 469  specified encoding mode, honoring parens grouping. Previously, parens were
 470  ignored.
 471  
 472  Also, there is a new pack() character format, C<W>, which is intended to
 473  replace the old C<C>. C<C> is kept for unsigned chars coded as bytes in
 474  the strings internal representation. C<W> represents unsigned (logical)
 475  character values, which can be greater than 255. It is therefore more
 476  robust when dealing with potentially UTF-8-encoded data (as C<C> will wrap
 477  values outside the range 0..255, and not respect the string encoding).
 478  
 479  In practice, that means that pack formats are now encoding-neutral, except
 480  C<C>.
 481  
 482  For consistency, C<A> in unpack() format now trims all Unicode whitespace
 483  from the end of the string. Before perl 5.9.2, it used to strip only the
 484  classical ASCII space characters.
 485  
 486  =head2 Byte/character count feature in unpack()
 487  
 488  A new unpack() template character, C<".">, returns the number of bytes or
 489  characters (depending on the selected encoding mode, see above) read so far.
 490  
 491  =head2 The C<$*> and C<$#> variables have been removed
 492  
 493  C<$*>, which was deprecated in favor of the C</s> and C</m> regexp
 494  modifiers, has been removed.
 495  
 496  The deprecated C<$#> variable (output format for numbers) has been
 497  removed.
 498  
 499  Two new severe warnings, C<$#/$* is no longer supported>, have been added.
 500  
 501  =head2 substr() lvalues are no longer fixed-length
 502  
 503  The lvalues returned by the three argument form of substr() used to be a
 504  "fixed length window" on the original string. In some cases this could
 505  cause surprising action at distance or other undefined behaviour. Now the
 506  length of the window adjusts itself to the length of the string assigned to
 507  it.
 508  
 509  =head2 Parsing of C<-f _>
 510  
 511  The identifier C<_> is now forced to be a bareword after a filetest
 512  operator. This solves a number of misparsing issues when a global C<_>
 513  subroutine is defined.
 514  
 515  =head2 C<:unique>
 516  
 517  The C<:unique> attribute has been made a no-op, since its current
 518  implementation was fundamentally flawed and not threadsafe.
 519  
 520  =head2 Effect of pragmas in eval
 521  
 522  The compile-time value of the C<%^H> hint variable can now propagate into
 523  eval("")uated code. This makes it more useful to implement lexical
 524  pragmas.
 525  
 526  As a side-effect of this, the overloaded-ness of constants now propagates
 527  into eval("").
 528  
 529  =head2 chdir FOO
 530  
 531  A bareword argument to chdir() is now recognized as a file handle.
 532  Earlier releases interpreted the bareword as a directory name.
 533  (Gisle Aas)
 534  
 535  =head2 Handling of .pmc files
 536  
 537  An old feature of perl was that before C<require> or C<use> look for a
 538  file with a F<.pm> extension, they will first look for a similar filename
 539  with a F<.pmc> extension. If this file is found, it will be loaded in
 540  place of any potentially existing file ending in a F<.pm> extension.
 541  
 542  Previously, F<.pmc> files were loaded only if more recent than the
 543  matching F<.pm> file. Starting with 5.9.4, they'll be always loaded if
 544  they exist.
 545  
 546  =head2 $^V is now a C<version> object instead of a v-string
 547  
 548  $^V can still be used with the C<%vd> format in printf, but any
 549  character-level operations will now access the string representation
 550  of the C<version> object and not the ordinals of a v-string.
 551  Expressions like C<< substr($^V, 0, 2) >> or C<< split //, $^V >>
 552  no longer work and must be rewritten.
 553  
 554  =head2 @- and @+ in patterns
 555  
 556  The special arrays C<@-> and C<@+> are no longer interpolated in regular
 557  expressions. (Sadahiro Tomoyuki)
 558  
 559  =head2 $AUTOLOAD can now be tainted
 560  
 561  If you call a subroutine by a tainted name, and if it defers to an
 562  AUTOLOAD function, then $AUTOLOAD will be (correctly) tainted.
 563  (Rick Delaney)
 564  
 565  =head2 Tainting and printf
 566  
 567  When perl is run under taint mode, C<printf()> and C<sprintf()> will now
 568  reject any tainted format argument. (Rafael Garcia-Suarez)
 569  
 570  =head2 undef and signal handlers
 571  
 572  Undefining or deleting a signal handler via C<undef $SIG{FOO}> is now
 573  equivalent to setting it to C<'DEFAULT'>. (Rafael Garcia-Suarez)
 574  
 575  =head2 strictures and dereferencing in defined()
 576  
 577  C<use strict 'refs'> was ignoring taking a hard reference in an argument
 578  to defined(), as in :
 579  
 580      use strict 'refs';
 581      my $x = 'foo';
 582      if (defined $$x) {...}
 583  
 584  This now correctly produces the run-time error C<Can't use string as a
 585  SCALAR ref while "strict refs" in use>.
 586  
 587  C<defined @$foo> and C<defined %$bar> are now also subject to C<strict
 588  'refs'> (that is, C<$foo> and C<$bar> shall be proper references there.)
 589  (C<defined(@foo)> and C<defined(%bar)> are discouraged constructs anyway.)
 590  (Nicholas Clark)
 591  
 592  =head2 C<(?p{})> has been removed
 593  
 594  The regular expression construct C<(?p{})>, which was deprecated in perl
 595  5.8, has been removed. Use C<(??{})> instead. (Rafael Garcia-Suarez)
 596  
 597  =head2 Pseudo-hashes have been removed
 598  
 599  Support for pseudo-hashes has been removed from Perl 5.9. (The C<fields>
 600  pragma remains here, but uses an alternate implementation.)
 601  
 602  =head2 Removal of the bytecode compiler and of perlcc
 603  
 604  C<perlcc>, the byteloader and the supporting modules (B::C, B::CC,
 605  B::Bytecode, etc.) are no longer distributed with the perl sources. Those
 606  experimental tools have never worked reliably, and, due to the lack of
 607  volunteers to keep them in line with the perl interpreter developments, it
 608  was decided to remove them instead of shipping a broken version of those.
 609  The last version of those modules can be found with perl 5.9.4.
 610  
 611  However the B compiler framework stays supported in the perl core, as with
 612  the more useful modules it has permitted (among others, B::Deparse and
 613  B::Concise).
 614  
 615  =head2 Removal of the JPL
 616  
 617  The JPL (Java-Perl Lingo) has been removed from the perl sources tarball.
 618  
 619  =head2 Recursive inheritance detected earlier
 620  
 621  Perl will now immediately throw an exception if you modify any package's
 622  C<@ISA> in such a way that it would cause recursive inheritance.
 623  
 624  Previously, the exception would not occur until Perl attempted to make
 625  use of the recursive inheritance while resolving a method or doing a
 626  C<$foo-E<gt>isa($bar)> lookup.
 627  
 628  =head1 Modules and Pragmata
 629  
 630  =head2 Upgrading individual core modules
 631  
 632  Even more core modules are now also available separately through the
 633  CPAN.  If you wish to update one of these modules, you don't need to
 634  wait for a new perl release.  From within the cpan shell, running the
 635  'r' command will report on modules with upgrades available.  See
 636  C<perldoc CPAN> for more information.
 637  
 638  =head2 Pragmata Changes
 639  
 640  =over 4
 641  
 642  =item C<feature>
 643  
 644  The new pragma C<feature> is used to enable new features that might break
 645  old code. See L</"The C<feature> pragma"> above.
 646  
 647  =item C<mro>
 648  
 649  This new pragma enables to change the algorithm used to resolve inherited
 650  methods. See L</"New Pragma, C<mro>"> above.
 651  
 652  =item Scoping of the C<sort> pragma
 653  
 654  The C<sort> pragma is now lexically scoped. Its effect used to be global.
 655  
 656  =item Scoping of C<bignum>, C<bigint>, C<bigrat>
 657  
 658  The three numeric pragmas C<bignum>, C<bigint> and C<bigrat> are now
 659  lexically scoped. (Tels)
 660  
 661  =item C<base>
 662  
 663  The C<base> pragma now warns if a class tries to inherit from itself.
 664  (Curtis "Ovid" Poe)
 665  
 666  =item C<strict> and C<warnings>
 667  
 668  C<strict> and C<warnings> will now complain loudly if they are loaded via
 669  incorrect casing (as in C<use Strict;>). (Johan Vromans)
 670  
 671  =item C<version>
 672  
 673  The C<version> module provides support for version objects.
 674  
 675  =item C<warnings>
 676  
 677  The C<warnings> pragma doesn't load C<Carp> anymore. That means that code
 678  that used C<Carp> routines without having loaded it at compile time might
 679  need to be adjusted; typically, the following (faulty) code won't work
 680  anymore, and will require parentheses to be added after the function name:
 681  
 682      use warnings;
 683      require Carp;
 684      Carp::confess 'argh';
 685  
 686  =item C<less>
 687  
 688  C<less> now does something useful (or at least it tries to). In fact, it
 689  has been turned into a lexical pragma. So, in your modules, you can now
 690  test whether your users have requested to use less CPU, or less memory,
 691  less magic, or maybe even less fat. See L<less> for more. (Joshua ben
 692  Jore)
 693  
 694  =back
 695  
 696  =head2 New modules
 697  
 698  =over 4
 699  
 700  =item *
 701  
 702  C<encoding::warnings>, by Audrey Tang, is a module to emit warnings
 703  whenever an ASCII character string containing high-bit bytes is implicitly
 704  converted into UTF-8. It's a lexical pragma since Perl 5.9.4; on older
 705  perls, its effect is global.
 706  
 707  =item *
 708  
 709  C<Module::CoreList>, by Richard Clamp, is a small handy module that tells
 710  you what versions of core modules ship with any versions of Perl 5. It
 711  comes with a command-line frontend, C<corelist>.
 712  
 713  =item *
 714  
 715  C<Math::BigInt::FastCalc> is an XS-enabled, and thus faster, version of
 716  C<Math::BigInt::Calc>.
 717  
 718  =item *
 719  
 720  C<Compress::Zlib> is an interface to the zlib compression library. It
 721  comes with a bundled version of zlib, so having a working zlib is not a
 722  prerequisite to install it. It's used by C<Archive::Tar> (see below).
 723  
 724  =item *
 725  
 726  C<IO::Zlib> is an C<IO::>-style interface to C<Compress::Zlib>.
 727  
 728  =item *
 729  
 730  C<Archive::Tar> is a module to manipulate C<tar> archives.
 731  
 732  =item *
 733  
 734  C<Digest::SHA> is a module used to calculate many types of SHA digests,
 735  has been included for SHA support in the CPAN module.
 736  
 737  =item *
 738  
 739  C<ExtUtils::CBuilder> and C<ExtUtils::ParseXS> have been added.
 740  
 741  =item *
 742  
 743  C<Hash::Util::FieldHash>, by Anno Siegel, has been added. This module
 744  provides support for I<field hashes>: hashes that maintain an association
 745  of a reference with a value, in a thread-safe garbage-collected way.
 746  Such hashes are useful to implement inside-out objects.
 747  
 748  =item *
 749  
 750  C<Module::Build>, by Ken Williams, has been added. It's an alternative to
 751  C<ExtUtils::MakeMaker> to build and install perl modules.
 752  
 753  =item *
 754  
 755  C<Module::Load>, by Jos Boumans, has been added. It provides a single
 756  interface to load Perl modules and F<.pl> files.
 757  
 758  =item *
 759  
 760  C<Module::Loaded>, by Jos Boumans, has been added. It's used to mark
 761  modules as loaded or unloaded.
 762  
 763  =item *
 764  
 765  C<Package::Constants>, by Jos Boumans, has been added. It's a simple
 766  helper to list all constants declared in a given package.
 767  
 768  =item *
 769  
 770  C<Win32API::File>, by Tye McQueen, has been added (for Windows builds).
 771  This module provides low-level access to Win32 system API calls for
 772  files/dirs.
 773  
 774  =item *
 775  
 776  C<Locale::Maketext::Simple>, needed by CPANPLUS, is a simple wrapper around
 777  C<Locale::Maketext::Lexicon>. Note that C<Locale::Maketext::Lexicon> isn't
 778  included in the perl core; the behaviour of C<Locale::Maketext::Simple>
 779  gracefully degrades when the later isn't present.
 780  
 781  =item *
 782  
 783  C<Params::Check> implements a generic input parsing/checking mechanism. It
 784  is used by CPANPLUS.
 785  
 786  =item *
 787  
 788  C<Term::UI> simplifies the task to ask questions at a terminal prompt.
 789  
 790  =item *
 791  
 792  C<Object::Accessor> provides an interface to create per-object accessors.
 793  
 794  =item *
 795  
 796  C<Module::Pluggable> is a simple framework to create modules that accept
 797  pluggable sub-modules.
 798  
 799  =item *
 800  
 801  C<Module::Load::Conditional> provides simple ways to query and possibly
 802  load installed modules.
 803  
 804  =item *
 805  
 806  C<Time::Piece> provides an object oriented interface to time functions,
 807  overriding the built-ins localtime() and gmtime().
 808  
 809  =item *
 810  
 811  C<IPC::Cmd> helps to find and run external commands, possibly
 812  interactively.
 813  
 814  =item *
 815  
 816  C<File::Fetch> provide a simple generic file fetching mechanism.
 817  
 818  =item *
 819  
 820  C<Log::Message> and C<Log::Message::Simple> are used by the log facility
 821  of C<CPANPLUS>.
 822  
 823  =item *
 824  
 825  C<Archive::Extract> is a generic archive extraction mechanism
 826  for F<.tar> (plain, gziped or bzipped) or F<.zip> files.
 827  
 828  =item *
 829  
 830  C<CPANPLUS> provides an API and a command-line tool to access the CPAN
 831  mirrors.
 832  
 833  =item *
 834  
 835  C<Pod::Escapes> provides utilities that are useful in decoding Pod
 836  EE<lt>...E<gt> sequences.
 837  
 838  =item *
 839  
 840  C<Pod::Simple> is now the backend for several of the Pod-related modules
 841  included with Perl.
 842  
 843  =back
 844  
 845  =head2 Selected Changes to Core Modules
 846  
 847  =over 4
 848  
 849  =item C<Attribute::Handlers>
 850  
 851  C<Attribute::Handlers> can now report the caller's file and line number.
 852  (David Feldman)
 853  
 854  All interpreted attributes are now passed as array references. (Damian
 855  Conway)
 856  
 857  =item C<B::Lint>
 858  
 859  C<B::Lint> is now based on C<Module::Pluggable>, and so can be extended
 860  with plugins. (Joshua ben Jore)
 861  
 862  =item C<B>
 863  
 864  It's now possible to access the lexical pragma hints (C<%^H>) by using the
 865  method B::COP::hints_hash(). It returns a C<B::RHE> object, which in turn
 866  can be used to get a hash reference via the method B::RHE::HASH(). (Joshua
 867  ben Jore)
 868  
 869  =item C<Thread>
 870  
 871  As the old 5005thread threading model has been removed, in favor of the
 872  ithreads scheme, the C<Thread> module is now a compatibility wrapper, to
 873  be used in old code only. It has been removed from the default list of
 874  dynamic extensions.
 875  
 876  =back
 877  
 878  =head1 Utility Changes
 879  
 880  =over 4
 881  
 882  =item perl -d
 883  
 884  The Perl debugger can now save all debugger commands for sourcing later;
 885  notably, it can now emulate stepping backwards, by restarting and
 886  rerunning all bar the last command from a saved command history.
 887  
 888  It can also display the parent inheritance tree of a given class, with the
 889  C<i> command.
 890  
 891  =item ptar
 892  
 893  C<ptar> is a pure perl implementation of C<tar> that comes with
 894  C<Archive::Tar>.
 895  
 896  =item ptardiff
 897  
 898  C<ptardiff> is a small utility used to generate a diff between the contents
 899  of a tar archive and a directory tree. Like C<ptar>, it comes with
 900  C<Archive::Tar>.
 901  
 902  =item shasum
 903  
 904  C<shasum> is a command-line utility, used to print or to check SHA
 905  digests. It comes with the new C<Digest::SHA> module.
 906  
 907  =item corelist
 908  
 909  The C<corelist> utility is now installed with perl (see L</"New modules">
 910  above).
 911  
 912  =item h2ph and h2xs
 913  
 914  C<h2ph> and C<h2xs> have been made more robust with regard to
 915  "modern" C code.
 916  
 917  C<h2xs> implements a new option C<--use-xsloader> to force use of
 918  C<XSLoader> even in backwards compatible modules.
 919  
 920  The handling of authors' names that had apostrophes has been fixed.
 921  
 922  Any enums with negative values are now skipped.
 923  
 924  =item perlivp
 925  
 926  C<perlivp> no longer checks for F<*.ph> files by default.  Use the new C<-a>
 927  option to run I<all> tests.
 928  
 929  =item find2perl
 930  
 931  C<find2perl> now assumes C<-print> as a default action. Previously, it
 932  needed to be specified explicitly.
 933  
 934  Several bugs have been fixed in C<find2perl>, regarding C<-exec> and
 935  C<-eval>. Also the options C<-path>, C<-ipath> and C<-iname> have been
 936  added.
 937  
 938  =item config_data
 939  
 940  C<config_data> is a new utility that comes with C<Module::Build>. It
 941  provides a command-line interface to the configuration of Perl modules
 942  that use Module::Build's framework of configurability (that is,
 943  C<*::ConfigData> modules that contain local configuration information for
 944  their parent modules.)
 945  
 946  =item cpanp
 947  
 948  C<cpanp>, the CPANPLUS shell, has been added. (C<cpanp-run-perl>, a
 949  helper for CPANPLUS operation, has been added too, but isn't intended for
 950  direct use).
 951  
 952  =item cpan2dist
 953  
 954  C<cpan2dist> is a new utility that comes with CPANPLUS. It's a tool to
 955  create distributions (or packages) from CPAN modules.
 956  
 957  =item pod2html
 958  
 959  The output of C<pod2html> has been enhanced to be more customizable via
 960  CSS. Some formatting problems were also corrected. (Jari Aalto)
 961  
 962  =back
 963  
 964  =head1 New Documentation
 965  
 966  The L<perlpragma> manpage documents how to write one's own lexical
 967  pragmas in pure Perl (something that is possible starting with 5.9.4).
 968  
 969  The new L<perlglossary> manpage is a glossary of terms used in the Perl
 970  documentation, technical and otherwise, kindly provided by O'Reilly Media,
 971  Inc.
 972  
 973  The L<perlreguts> manpage, courtesy of Yves Orton, describes internals of the
 974  Perl regular expression engine.
 975  
 976  The L<perlreapi> manpage describes the interface to the perl interpreter
 977  used to write pluggable regular expression engines (by Ævar Arnfjörð
 978  Bjarmason).
 979  
 980  The L<perlunitut> manpage is an tutorial for programming with Unicode and
 981  string encodings in Perl, courtesy of Juerd Waalboer.
 982  
 983  A new manual page, L<perlunifaq> (the Perl Unicode FAQ), has been added
 984  (Juerd Waalboer).
 985  
 986  The L<perlcommunity> manpage gives a description of the Perl community
 987  on the Internet and in real life. (Edgar "Trizor" Bering)
 988  
 989  The L<CORE> manual page documents the C<CORE::> namespace. (Tels)
 990  
 991  The long-existing feature of C</(?{...})/> regexps setting C<$_> and pos()
 992  is now documented.
 993  
 994  =head1 Performance Enhancements
 995  
 996  =head2 In-place sorting
 997  
 998  Sorting arrays in place (C<@a = sort @a>) is now optimized to avoid
 999  making a temporary copy of the array.
1000  
1001  Likewise, C<reverse sort ...> is now optimized to sort in reverse,
1002  avoiding the generation of a temporary intermediate list.
1003  
1004  =head2 Lexical array access
1005  
1006  Access to elements of lexical arrays via a numeric constant between 0 and
1007  255 is now faster. (This used to be only the case for global arrays.)
1008  
1009  =head2 XS-assisted SWASHGET
1010  
1011  Some pure-perl code that perl was using to retrieve Unicode properties and
1012  transliteration mappings has been reimplemented in XS.
1013  
1014  =head2 Constant subroutines
1015  
1016  The interpreter internals now support a far more memory efficient form of
1017  inlineable constants. Storing a reference to a constant value in a symbol
1018  table is equivalent to a full typeglob referencing a constant subroutine,
1019  but using about 400 bytes less memory. This proxy constant subroutine is
1020  automatically upgraded to a real typeglob with subroutine if necessary.
1021  The approach taken is analogous to the existing space optimisation for
1022  subroutine stub declarations, which are stored as plain scalars in place
1023  of the full typeglob.
1024  
1025  Several of the core modules have been converted to use this feature for
1026  their system dependent constants - as a result C<use POSIX;> now takes about
1027  200K less memory.
1028  
1029  =head2 C<PERL_DONT_CREATE_GVSV>
1030  
1031  The new compilation flag C<PERL_DONT_CREATE_GVSV>, introduced as an option
1032  in perl 5.8.8, is turned on by default in perl 5.9.3. It prevents perl
1033  from creating an empty scalar with every new typeglob. See L<perl588delta>
1034  for details.
1035  
1036  =head2 Weak references are cheaper
1037  
1038  Weak reference creation is now I<O(1)> rather than I<O(n)>, courtesy of
1039  Nicholas Clark. Weak reference deletion remains I<O(n)>, but if deletion only
1040  happens at program exit, it may be skipped completely.
1041  
1042  =head2 sort() enhancements
1043  
1044  Salvador Fandiño provided improvements to reduce the memory usage of C<sort>
1045  and to speed up some cases.
1046  
1047  =head2 Memory optimisations
1048  
1049  Several internal data structures (typeglobs, GVs, CVs, formats) have been
1050  restructured to use less memory. (Nicholas Clark)
1051  
1052  =head2 UTF-8 cache optimisation
1053  
1054  The UTF-8 caching code is now more efficient, and used more often.
1055  (Nicholas Clark)
1056  
1057  =head2 Sloppy stat on Windows
1058  
1059  On Windows, perl's stat() function normally opens the file to determine
1060  the link count and update attributes that may have been changed through
1061  hard links. Setting ${^WIN32_SLOPPY_STAT} to a true value speeds up
1062  stat() by not performing this operation. (Jan Dubois)
1063  
1064  =head2 Regular expressions optimisations
1065  
1066  =over 4
1067  
1068  =item Engine de-recursivised
1069  
1070  The regular expression engine is no longer recursive, meaning that
1071  patterns that used to overflow the stack will either die with useful
1072  explanations, or run to completion, which, since they were able to blow
1073  the stack before, will likely take a very long time to happen. If you were
1074  experiencing the occasional stack overflow (or segfault) and upgrade to
1075  discover that now perl apparently hangs instead, look for a degenerate
1076  regex. (Dave Mitchell)
1077  
1078  =item Single char char-classes treated as literals
1079  
1080  Classes of a single character are now treated the same as if the character
1081  had been used as a literal, meaning that code that uses char-classes as an
1082  escaping mechanism will see a speedup. (Yves Orton)
1083  
1084  =item Trie optimisation of literal string alternations
1085  
1086  Alternations, where possible, are optimised into more efficient matching
1087  structures. String literal alternations are merged into a trie and are
1088  matched simultaneously.  This means that instead of O(N) time for matching
1089  N alternations at a given point, the new code performs in O(1) time.
1090  A new special variable, ${^RE_TRIE_MAXBUF}, has been added to fine-tune
1091  this optimization. (Yves Orton)
1092  
1093  B<Note:> Much code exists that works around perl's historic poor
1094  performance on alternations. Often the tricks used to do so will disable
1095  the new optimisations. Hopefully the utility modules used for this purpose
1096  will be educated about these new optimisations.
1097  
1098  =item Aho-Corasick start-point optimisation
1099  
1100  When a pattern starts with a trie-able alternation and there aren't
1101  better optimisations available, the regex engine will use Aho-Corasick
1102  matching to find the start point. (Yves Orton)
1103  
1104  =back
1105  
1106  =head1 Installation and Configuration Improvements
1107  
1108  =head2 Configuration improvements
1109  
1110  =over 4
1111  
1112  =item C<-Dusesitecustomize>
1113  
1114  Run-time customization of @INC can be enabled by passing the
1115  C<-Dusesitecustomize> flag to Configure. When enabled, this will make perl
1116  run F<$sitelibexp/sitecustomize.pl> before anything else.  This script can
1117  then be set up to add additional entries to @INC.
1118  
1119  =item Relocatable installations
1120  
1121  There is now Configure support for creating a relocatable perl tree. If
1122  you Configure with C<-Duserelocatableinc>, then the paths in @INC (and
1123  everything else in %Config) can be optionally located via the path of the
1124  perl executable.
1125  
1126  That means that, if the string C<".../"> is found at the start of any
1127  path, it's substituted with the directory of $^X. So, the relocation can
1128  be configured on a per-directory basis, although the default with
1129  C<-Duserelocatableinc> is that everything is relocated. The initial
1130  install is done to the original configured prefix.
1131  
1132  =item strlcat() and strlcpy()
1133  
1134  The configuration process now detects whether strlcat() and strlcpy() are
1135  available.  When they are not available, perl's own version is used (from
1136  Russ Allbery's public domain implementation).  Various places in the perl
1137  interpreter now use them. (Steve Peters)
1138  
1139  =item C<d_pseudofork> and C<d_printf_format_null>
1140  
1141  A new configuration variable, available as C<$Config{d_pseudofork}> in
1142  the L<Config> module, has been added, to distinguish real fork() support
1143  from fake pseudofork used on Windows platforms.
1144  
1145  A new configuration variable, C<d_printf_format_null>, has been added, 
1146  to see if printf-like formats are allowed to be NULL.
1147  
1148  =item Configure help
1149  
1150  C<Configure -h> has been extended with the most commonly used options.
1151  
1152  =back
1153  
1154  =head2 Compilation improvements
1155  
1156  =over 4
1157  
1158  =item Parallel build
1159  
1160  Parallel makes should work properly now, although there may still be problems
1161  if C<make test> is instructed to run in parallel.
1162  
1163  =item Borland's compilers support
1164  
1165  Building with Borland's compilers on Win32 should work more smoothly. In
1166  particular Steve Hay has worked to side step many warnings emitted by their
1167  compilers and at least one C compiler internal error.
1168  
1169  =item Static build on Windows
1170  
1171  Perl extensions on Windows now can be statically built into the Perl DLL.
1172  
1173  Also, it's now possible to build a C<perl-static.exe> that doesn't depend
1174  on the Perl DLL on Win32. See the Win32 makefiles for details.
1175  (Vadim Konovalov)
1176  
1177  =item ppport.h files
1178  
1179  All F<ppport.h> files in the XS modules bundled with perl are now
1180  autogenerated at build time. (Marcus Holland-Moritz)
1181  
1182  =item C++ compatibility
1183  
1184  Efforts have been made to make perl and the core XS modules compilable
1185  with various C++ compilers (although the situation is not perfect with
1186  some of the compilers on some of the platforms tested.)
1187  
1188  =item Support for Microsoft 64-bit compiler
1189  
1190  Support for building perl with Microsoft's 64-bit compiler has been
1191  improved. (ActiveState)
1192  
1193  =item Visual C++
1194  
1195  Perl can now be compiled with Microsoft Visual C++ 2005 (and 2008 Beta 2).
1196  
1197  =item Win32 builds
1198  
1199  All win32 builds (MS-Win, WinCE) have been merged and cleaned up.
1200  
1201  =back
1202  
1203  =head2 Installation improvements
1204  
1205  =over 4
1206  
1207  =item Module auxiliary files
1208  
1209  README files and changelogs for CPAN modules bundled with perl are no
1210  longer installed.
1211  
1212  =back
1213  
1214  =head2 New Or Improved Platforms
1215  
1216  Perl has been reported to work on Symbian OS. See L<perlsymbian> for more
1217  information.
1218  
1219  Many improvements have been made towards making Perl work correctly on
1220  z/OS.
1221  
1222  Perl has been reported to work on DragonFlyBSD and MidnightBSD.
1223  
1224  Perl has also been reported to work on NexentaOS
1225  ( http://www.gnusolaris.org/ ).
1226  
1227  The VMS port has been improved. See L<perlvms>.
1228  
1229  Support for Cray XT4 Catamount/Qk has been added. See
1230  F<hints/catamount.sh> in the source code distribution for more
1231  information.
1232  
1233  Vendor patches have been merged for RedHat and Gentoo.
1234  
1235  DynaLoader::dl_unload_file() now works on Windows.
1236  
1237  =head1 Selected Bug Fixes
1238  
1239  =over 4
1240  
1241  =item strictures in regexp-eval blocks
1242  
1243  C<strict> wasn't in effect in regexp-eval blocks (C</(?{...})/>).
1244  
1245  =item Calling CORE::require()
1246  
1247  CORE::require() and CORE::do() were always parsed as require() and do()
1248  when they were overridden. This is now fixed.
1249  
1250  =item Subscripts of slices
1251  
1252  You can now use a non-arrowed form for chained subscripts after a list
1253  slice, like in:
1254  
1255      ({foo => "bar"})[0]{foo}
1256  
1257  This used to be a syntax error; a C<< -> >> was required.
1258  
1259  =item C<no warnings 'category'> works correctly with -w
1260  
1261  Previously when running with warnings enabled globally via C<-w>, selective
1262  disabling of specific warning categories would actually turn off all warnings.
1263  This is now fixed; now C<no warnings 'io';> will only turn off warnings in the
1264  C<io> class. Previously it would erroneously turn off all warnings.
1265  
1266  =item threads improvements
1267  
1268  Several memory leaks in ithreads were closed. Also, ithreads were made
1269  less memory-intensive.
1270  
1271  C<threads> is now a dual-life module, also available on CPAN. It has been
1272  expanded in many ways. A kill() method is available for thread signalling.
1273  One can get thread status, or the list of running or joinable threads.
1274  
1275  A new C<< threads->exit() >> method is used to exit from the application
1276  (this is the default for the main thread) or from the current thread only
1277  (this is the default for all other threads). On the other hand, the exit()
1278  built-in now always causes the whole application to terminate. (Jerry
1279  D. Hedden)
1280  
1281  =item chr() and negative values
1282  
1283  chr() on a negative value now gives C<\x{FFFD}>, the Unicode replacement
1284  character, unless when the C<bytes> pragma is in effect, where the low
1285  eight bits of the value are used.
1286  
1287  =item PERL5SHELL and tainting
1288  
1289  On Windows, the PERL5SHELL environment variable is now checked for
1290  taintedness. (Rafael Garcia-Suarez)
1291  
1292  =item Using *FILE{IO}
1293  
1294  C<stat()> and C<-X> filetests now treat *FILE{IO} filehandles like *FILE
1295  filehandles. (Steve Peters)
1296  
1297  =item Overloading and reblessing
1298  
1299  Overloading now works when references are reblessed into another class.
1300  Internally, this has been implemented by moving the flag for "overloading"
1301  from the reference to the referent, which logically is where it should
1302  always have been. (Nicholas Clark)
1303  
1304  =item Overloading and UTF-8
1305  
1306  A few bugs related to UTF-8 handling with objects that have
1307  stringification overloaded have been fixed. (Nicholas Clark)
1308  
1309  =item eval memory leaks fixed
1310  
1311  Traditionally, C<eval 'syntax error'> has leaked badly. Many (but not all)
1312  of these leaks have now been eliminated or reduced. (Dave Mitchell)
1313  
1314  =item Random device on Windows
1315  
1316  In previous versions, perl would read the file F</dev/urandom> if it
1317  existed when seeding its random number generator.  That file is unlikely
1318  to exist on Windows, and if it did would probably not contain appropriate
1319  data, so perl no longer tries to read it on Windows. (Alex Davies)
1320  
1321  =item PERLIO_DEBUG
1322  
1323  The C<PERLIO_DEBUG> environment variable no longer has any effect for
1324  setuid scripts and for scripts run with B<-T>.
1325  
1326  Moreover, with a thread-enabled perl, using C<PERLIO_DEBUG> could lead to
1327  an internal buffer overflow. This has been fixed.
1328  
1329  =item PerlIO::scalar and read-only scalars
1330  
1331  PerlIO::scalar will now prevent writing to read-only scalars. Moreover,
1332  seek() is now supported with PerlIO::scalar-based filehandles, the
1333  underlying string being zero-filled as needed. (Rafael, Jarkko Hietaniemi)
1334  
1335  =item study() and UTF-8
1336  
1337  study() never worked for UTF-8 strings, but could lead to false results.
1338  It's now a no-op on UTF-8 data. (Yves Orton)
1339  
1340  =item Critical signals
1341  
1342  The signals SIGILL, SIGBUS and SIGSEGV are now always delivered in an
1343  "unsafe" manner (contrary to other signals, that are deferred until the
1344  perl interpreter reaches a reasonably stable state; see
1345  L<perlipc/"Deferred Signals (Safe Signals)">). (Rafael)
1346  
1347  =item @INC-hook fix
1348  
1349  When a module or a file is loaded through an @INC-hook, and when this hook
1350  has set a filename entry in %INC, __FILE__ is now set for this module
1351  accordingly to the contents of that %INC entry. (Rafael)
1352  
1353  =item C<-t> switch fix
1354  
1355  The C<-w> and C<-t> switches can now be used together without messing
1356  up which categories of warnings are activated. (Rafael)
1357  
1358  =item Duping UTF-8 filehandles
1359  
1360  Duping a filehandle which has the C<:utf8> PerlIO layer set will now
1361  properly carry that layer on the duped filehandle. (Rafael)
1362  
1363  =item Localisation of hash elements
1364  
1365  Localizing a hash element whose key was given as a variable didn't work
1366  correctly if the variable was changed while the local() was in effect (as
1367  in C<local $h{$x}; ++$x>). (Bo Lindbergh)
1368  
1369  =back
1370  
1371  =head1 New or Changed Diagnostics
1372  
1373  =over 4
1374  
1375  =item Use of uninitialized value
1376  
1377  Perl will now try to tell you the name of the variable (if any) that was
1378  undefined.
1379  
1380  =item Deprecated use of my() in false conditional
1381  
1382  A new deprecation warning, I<Deprecated use of my() in false conditional>,
1383  has been added, to warn against the use of the dubious and deprecated
1384  construct
1385  
1386      my $x if 0;
1387  
1388  See L<perldiag>. Use C<state> variables instead.
1389  
1390  =item !=~ should be !~
1391  
1392  A new warning, C<!=~ should be !~>, is emitted to prevent this misspelling
1393  of the non-matching operator.
1394  
1395  =item Newline in left-justified string
1396  
1397  The warning I<Newline in left-justified string> has been removed.
1398  
1399  =item Too late for "-T" option
1400  
1401  The error I<Too late for "-T" option> has been reformulated to be more
1402  descriptive.
1403  
1404  =item "%s" variable %s masks earlier declaration
1405  
1406  This warning is now emitted in more consistent cases; in short, when one
1407  of the declarations involved is a C<my> variable:
1408  
1409      my $x;   my $x;    # warns
1410      my $x;  our $x;    # warns
1411      our $x;  my $x;    # warns
1412  
1413  On the other hand, the following:
1414  
1415      our $x; our $x;
1416  
1417  now gives a C<"our" variable %s redeclared> warning.
1418  
1419  =item readdir()/closedir()/etc. attempted on invalid dirhandle
1420  
1421  These new warnings are now emitted when a dirhandle is used but is
1422  either closed or not really a dirhandle.
1423  
1424  =item Opening dirhandle/filehandle %s also as a file/directory
1425  
1426  Two deprecation warnings have been added: (Rafael)
1427  
1428      Opening dirhandle %s also as a file
1429      Opening filehandle %s also as a directory
1430  
1431  =item Use of -P is deprecated
1432  
1433  Perl's command-line switch C<-P> is now deprecated.
1434  
1435  =item v-string in use/require is non-portable
1436  
1437  Perl will warn you against potential backwards compatibility problems with
1438  the C<use VERSION> syntax.
1439  
1440  =item perl -V
1441  
1442  C<perl -V> has several improvements, making it more useable from shell
1443  scripts to get the value of configuration variables. See L<perlrun> for
1444  details.
1445  
1446  =back
1447  
1448  =head1 Changed Internals
1449  
1450  In general, the source code of perl has been refactored, tidied up,
1451  and optimized in many places. Also, memory management and allocation
1452  has been improved in several points.
1453  
1454  When compiling the perl core with gcc, as many gcc warning flags are
1455  turned on as is possible on the platform.  (This quest for cleanliness
1456  doesn't extend to XS code because we cannot guarantee the tidiness of
1457  code we didn't write.)  Similar strictness flags have been added or
1458  tightened for various other C compilers.
1459  
1460  =head2 Reordering of SVt_* constants
1461  
1462  The relative ordering of constants that define the various types of C<SV>
1463  have changed; in particular, C<SVt_PVGV> has been moved before C<SVt_PVLV>,
1464  C<SVt_PVAV>, C<SVt_PVHV> and C<SVt_PVCV>.  This is unlikely to make any
1465  difference unless you have code that explicitly makes assumptions about that
1466  ordering. (The inheritance hierarchy of C<B::*> objects has been changed
1467  to reflect this.)
1468  
1469  =head2 Elimination of SVt_PVBM
1470  
1471  Related to this, the internal type C<SVt_PVBM> has been been removed. This
1472  dedicated type of C<SV> was used by the C<index> operator and parts of the
1473  regexp engine to facilitate fast Boyer-Moore matches. Its use internally has
1474  been replaced by C<SV>s of type C<SVt_PVGV>.
1475  
1476  =head2 New type SVt_BIND
1477  
1478  A new type C<SVt_BIND> has been added, in readiness for the project to
1479  implement Perl 6 on 5. There deliberately is no implementation yet, and
1480  they cannot yet be created or destroyed.
1481  
1482  =head2 Removal of CPP symbols
1483  
1484  The C preprocessor symbols C<PERL_PM_APIVERSION> and
1485  C<PERL_XS_APIVERSION>, which were supposed to give the version number of
1486  the oldest perl binary-compatible (resp. source-compatible) with the
1487  present one, were not used, and sometimes had misleading values. They have
1488  been removed.
1489  
1490  =head2 Less space is used by ops
1491  
1492  The C<BASEOP> structure now uses less space. The C<op_seq> field has been
1493  removed and replaced by a single bit bit-field C<op_opt>. C<op_type> is now 9
1494  bits long. (Consequently, the C<B::OP> class doesn't provide an C<seq>
1495  method anymore.)
1496  
1497  =head2 New parser
1498  
1499  perl's parser is now generated by bison (it used to be generated by
1500  byacc.) As a result, it seems to be a bit more robust.
1501  
1502  Also, Dave Mitchell improved the lexer debugging output under C<-DT>.
1503  
1504  =head2 Use of C<const>
1505  
1506  Andy Lester supplied many improvements to determine which function
1507  parameters and local variables could actually be declared C<const> to the C
1508  compiler. Steve Peters provided new C<*_set> macros and reworked the core to
1509  use these rather than assigning to macros in LVALUE context.
1510  
1511  =head2 Mathoms
1512  
1513  A new file, F<mathoms.c>, has been added. It contains functions that are
1514  no longer used in the perl core, but that remain available for binary or
1515  source compatibility reasons. However, those functions will not be
1516  compiled in if you add C<-DNO_MATHOMS> in the compiler flags.
1517  
1518  =head2 C<AvFLAGS> has been removed
1519  
1520  The C<AvFLAGS> macro has been removed.
1521  
1522  =head2 C<av_*> changes
1523  
1524  The C<av_*()> functions, used to manipulate arrays, no longer accept null
1525  C<AV*> parameters.
1526  
1527  =head2 $^H and %^H
1528  
1529  The implementation of the special variables $^H and %^H has changed, to
1530  allow implementing lexical pragmas in pure Perl.
1531  
1532  =head2 B:: modules inheritance changed
1533  
1534  The inheritance hierarchy of C<B::> modules has changed; C<B::NV> now
1535  inherits from C<B::SV> (it used to inherit from C<B::IV>).
1536  
1537  =head2 Anonymous hash and array constructors
1538  
1539  The anonymous hash and array constructors now take 1 op in the optree
1540  instead of 3, now that pp_anonhash and pp_anonlist return a reference to
1541  an hash/array when the op is flagged with OPf_SPECIAL. (Nicholas Clark)
1542  
1543  =head1 Known Problems
1544  
1545  There's still a remaining problem in the implementation of the lexical
1546  C<$_>: it doesn't work inside C</(?{...})/> blocks. (See the TODO test in
1547  F<t/op/mydef.t>.)
1548  
1549  Stacked filetest operators won't work when the C<filetest> pragma is in
1550  effect, because they rely on the stat() buffer C<_> being populated, and
1551  filetest bypasses stat().
1552  
1553  =head2 UTF-8 problems
1554  
1555  The handling of Unicode still is unclean in several places, where it's
1556  dependent on whether a string is internally flagged as UTF-8. This will
1557  be made more consistent in perl 5.12, but that won't be possible without
1558  a certain amount of backwards incompatibility.
1559  
1560  =head1 Platform Specific Problems
1561  
1562  When compiled with g++ and thread support on Linux, it's reported that the
1563  C<$!> stops working correctly. This is related to the fact that the glibc
1564  provides two strerror_r(3) implementation, and perl selects the wrong
1565  one.
1566  
1567  =head1 Reporting Bugs
1568  
1569  If you find what you think is a bug, you might check the articles
1570  recently posted to the comp.lang.perl.misc newsgroup and the perl
1571  bug database at http://rt.perl.org/rt3/ .  There may also be
1572  information at http://www.perl.org/ , the Perl Home Page.
1573  
1574  If you believe you have an unreported bug, please run the B<perlbug>
1575  program included with your release.  Be sure to trim your bug down
1576  to a tiny but sufficient test case.  Your bug report, along with the
1577  output of C<perl -V>, will be sent off to perlbug@perl.org to be
1578  analysed by the Perl porting team.
1579  
1580  =head1 SEE ALSO
1581  
1582  The F<Changes> file and the perl590delta to perl595delta man pages for
1583  exhaustive details on what changed.
1584  
1585  The F<INSTALL> file for how to build Perl.
1586  
1587  The F<README> file for general stuff.
1588  
1589  The F<Artistic> and F<Copying> files for copyright information.
1590  
1591  =cut


Generated: Tue Mar 17 22:47:18 2015 Cross-referenced by PHPXref 0.7.1