1=head1 NAME 2 3perldelta - what's new for perl v5.6.x 4 5=head1 DESCRIPTION 6 7This document describes differences between the 5.005 release and the 5.6.1 8release. 9 10=head1 Summary of changes between 5.6.0 and 5.6.1 11 12This section contains a summary of the changes between the 5.6.0 release 13and the 5.6.1 release. More details about the changes mentioned here 14may be found in the F<Changes> files that accompany the Perl source 15distribution. See L<perlhack> for pointers to online resources where you 16can inspect the individual patches described by these changes. 17 18=head2 Security Issues 19 20suidperl will not run /bin/mail anymore, because some platforms have 21a /bin/mail that is vulnerable to buffer overflow attacks. 22 23Note that suidperl is neither built nor installed by default in 24any recent version of perl. Use of suidperl is highly discouraged. 25If you think you need it, try alternatives such as sudo first. 26See http://www.courtesan.com/sudo/. 27 28=head2 Core bug fixes 29 30This is not an exhaustive list. It is intended to cover only the 31significant user-visible changes. 32 33=over 34 35=item C<UNIVERSAL::isa()> 36 37A bug in the caching mechanism used by C<UNIVERSAL::isa()> that affected 38base.pm has been fixed. The bug has existed since the 5.005 releases, 39but wasn't tickled by base.pm in those releases. 40 41=item Memory leaks 42 43Various cases of memory leaks and attempts to access uninitialized memory 44have been cured. See L</"Known Problems"> below for further issues. 45 46=item Numeric conversions 47 48Numeric conversions did not recognize changes in the string value 49properly in certain circumstances. 50 51In other situations, large unsigned numbers (those above 2**31) could 52sometimes lose their unsignedness, causing bogus results in arithmetic 53operations. 54 55Integer modulus on large unsigned integers sometimes returned 56incorrect values. 57 58Perl 5.6.0 generated "not a number" warnings on certain conversions where 59previous versions didn't. 60 61These problems have all been rectified. 62 63Infinity is now recognized as a number. 64 65=item qw(a\\b) 66 67In Perl 5.6.0, qw(a\\b) produced a string with two backslashes instead 68of one, in a departure from the behavior in previous versions. The 69older behavior has been reinstated. 70 71=item caller() 72 73caller() could cause core dumps in certain situations. Carp was sometimes 74affected by this problem. 75 76=item Bugs in regular expressions 77 78Pattern matches on overloaded values are now handled correctly. 79 80Perl 5.6.0 parsed m/\x{ab}/ incorrectly, leading to spurious warnings. 81This has been corrected. 82 83The RE engine found in Perl 5.6.0 accidentally pessimised certain kinds 84of simple pattern matches. These are now handled better. 85 86Regular expression debug output (whether through C<use re 'debug'> 87or via C<-Dr>) now looks better. 88 89Multi-line matches like C<"a\nxb\n" =~ /(?!\A)x/m> were flawed. The 90bug has been fixed. 91 92Use of $& could trigger a core dump under some situations. This 93is now avoided. 94 95Match variables $1 et al., weren't being unset when a pattern match 96was backtracking, and the anomaly showed up inside C</...(?{ ... }).../> 97etc. These variables are now tracked correctly. 98 99pos() did not return the correct value within s///ge in earlier 100versions. This is now handled correctly. 101 102=item "slurp" mode 103 104readline() on files opened in "slurp" mode could return an extra "" at 105the end in certain situations. This has been corrected. 106 107=item Autovivification of symbolic references to special variables 108 109Autovivification of symbolic references of special variables described 110in L<perlvar> (as in C<${$num}>) was accidentally disabled. This works 111again now. 112 113=item Lexical warnings 114 115Lexical warnings now propagate correctly into C<eval "...">. 116 117C<use warnings qw(FATAL all)> did not work as intended. This has been 118corrected. 119 120Lexical warnings could leak into other scopes in some situations. 121This is now fixed. 122 123warnings::enabled() now reports the state of $^W correctly if the caller 124isn't using lexical warnings. 125 126=item Spurious warnings and errors 127 128Perl 5.6.0 could emit spurious warnings about redefinition of dl_error() 129when statically building extensions into perl. This has been corrected. 130 131"our" variables could result in bogus "Variable will not stay shared" 132warnings. This is now fixed. 133 134"our" variables of the same name declared in two sibling blocks 135resulted in bogus warnings about "redeclaration" of the variables. 136The problem has been corrected. 137 138=item glob() 139 140Compatibility of the builtin glob() with old csh-based glob has been 141improved with the addition of GLOB_ALPHASORT option. See C<File::Glob>. 142 143File::Glob::glob() has been renamed to File::Glob::bsd_glob() 144because the name clashes with the builtin glob(). The older 145name is still available for compatibility, but is deprecated. 146 147Spurious syntax errors generated in certain situations, when glob() 148caused File::Glob to be loaded for the first time, have been fixed. 149 150=item Tainting 151 152Some cases of inconsistent taint propagation (such as within hash 153values) have been fixed. 154 155The tainting behavior of sprintf() has been rationalized. It does 156not taint the result of floating point formats anymore, making the 157behavior consistent with that of string interpolation. 158 159=item sort() 160 161Arguments to sort() weren't being provided the right wantarray() context. 162The comparison block is now run in scalar context, and the arguments to 163be sorted are always provided list context. 164 165sort() is also fully reentrant, in the sense that the sort function 166can itself call sort(). This did not work reliably in previous releases. 167 168=item #line directives 169 170#line directives now work correctly when they appear at the very 171beginning of C<eval "...">. 172 173=item Subroutine prototypes 174 175The (\&) prototype now works properly. 176 177=item map() 178 179map() could get pathologically slow when the result list it generates 180is larger than the source list. The performance has been improved for 181common scenarios. 182 183=item Debugger 184 185Debugger exit code now reflects the script exit code. 186 187Condition C<"0"> in breakpoints is now treated correctly. 188 189The C<d> command now checks the line number. 190 191C<$.> is no longer corrupted by the debugger. 192 193All debugger output now correctly goes to the socket if RemotePort 194is set. 195 196=item PERL5OPT 197 198PERL5OPT can be set to more than one switch group. Previously, 199it used to be limited to one group of options only. 200 201=item chop() 202 203chop(@list) in list context returned the characters chopped in reverse 204order. This has been reversed to be in the right order. 205 206=item Unicode support 207 208Unicode support has seen a large number of incremental improvements, 209but continues to be highly experimental. It is not expected to be 210fully supported in the 5.6.x maintenance releases. 211 212substr(), join(), repeat(), reverse(), quotemeta() and string 213concatenation were all handling Unicode strings incorrectly in 214Perl 5.6.0. This has been corrected. 215 216Support for C<tr///CU> and C<tr///UC> etc., have been removed since 217we realized the interface is broken. For similar functionality, 218see L<perlfunc/pack>. 219 220The Unicode Character Database has been updated to version 3.0.1 221with additions made available to the public as of August 30, 2000. 222 223The Unicode character classes \p{Blank} and \p{SpacePerl} have been 224added. "Blank" is like C isblank(), that is, it contains only 225"horizontal whitespace" (the space character is, the newline isn't), 226and the "SpacePerl" is the Unicode equivalent of C<\s> (\p{Space} 227isn't, since that includes the vertical tabulator character, whereas 228C<\s> doesn't.) 229 230If you are experimenting with Unicode support in perl, the development 231versions of Perl may have more to offer. In particular, I/O layers 232are now available in the development track, but not in the maintenance 233track, primarily to do backward compatibility issues. Unicode support 234is also evolving rapidly on a daily basis in the development track--the 235maintenance track only reflects the most conservative of these changes. 236 237=item 64-bit support 238 239Support for 64-bit platforms has been improved, but continues to be 240experimental. The level of support varies greatly among platforms. 241 242=item Compiler 243 244The B Compiler and its various backends have had many incremental 245improvements, but they continue to remain highly experimental. Use in 246production environments is discouraged. 247 248The perlcc tool has been rewritten so that the user interface is much 249more like that of a C compiler. 250 251The perlbc tools has been removed. Use C<perlcc -B> instead. 252 253=item Lvalue subroutines 254 255There have been various bugfixes to support lvalue subroutines better. 256However, the feature still remains experimental. 257 258=item IO::Socket 259 260IO::Socket::INET failed to open the specified port if the service 261name was not known. It now correctly uses the supplied port number 262as is. 263 264=item File::Find 265 266File::Find now chdir()s correctly when chasing symbolic links. 267 268=item xsubpp 269 270xsubpp now tolerates embedded POD sections. 271 272=item C<no Module;> 273 274C<no Module;> does not produce an error even if Module does not have an 275unimport() method. This parallels the behavior of C<use> vis-a-vis 276C<import>. 277 278=item Tests 279 280A large number of tests have been added. 281 282=back 283 284=head2 Core features 285 286untie() will now call an UNTIE() hook if it exists. See L<perltie> 287for details. 288 289The C<-DT> command line switch outputs copious tokenizing information. 290See L<perlrun>. 291 292Arrays are now always interpolated in double-quotish strings. Previously, 293C<"foo@bar.com"> used to be a fatal error at compile time, if an array 294C<@bar> was not used or declared. This transitional behavior was 295intended to help migrate perl4 code, and is deemed to be no longer useful. 296See L</"Arrays now always interpolate into double-quoted strings">. 297 298keys(), each(), pop(), push(), shift(), splice() and unshift() 299can all be overridden now. 300 301C<my __PACKAGE__ $obj> now does the expected thing. 302 303=head2 Configuration issues 304 305On some systems (IRIX and Solaris among them) the system malloc is demonstrably 306better. While the defaults haven't been changed in order to retain binary 307compatibility with earlier releases, you may be better off building perl 308with C<Configure -Uusemymalloc ...> as discussed in the F<INSTALL> file. 309 310C<Configure> has been enhanced in various ways: 311 312=over 313 314=item * 315 316Minimizes use of temporary files. 317 318=item * 319 320By default, does not link perl with libraries not used by it, such as 321the various dbm libraries. SunOS 4.x hints preserve behavior on that 322platform. 323 324=item * 325 326Support for pdp11-style memory models has been removed due to obsolescence. 327 328=item * 329 330Building outside the source tree is supported on systems that have 331symbolic links. This is done by running 332 333 sh /path/to/source/Configure -Dmksymlinks ... 334 make all test install 335 336in a directory other than the perl source directory. See F<INSTALL>. 337 338=item * 339 340C<Configure -S> can be run non-interactively. 341 342=back 343 344=head2 Documentation 345 346README.aix, README.solaris and README.macos have been added. README.posix-bc 347has been renamed to README.bs2000. These are installed as L<perlaix>, 348L<perlsolaris>, L<perlmacos>, and L<perlbs2000> respectively. 349 350The following pod documents are brand new: 351 352 perlclib Internal replacements for standard C library functions 353 perldebtut Perl debugging tutorial 354 perlebcdic Considerations for running Perl on EBCDIC platforms 355 perlnewmod Perl modules: preparing a new module for distribution 356 perlrequick Perl regular expressions quick start 357 perlretut Perl regular expressions tutorial 358 perlutil utilities packaged with the Perl distribution 359 360The F<INSTALL> file has been expanded to cover various issues, such as 36164-bit support. 362 363A longer list of contributors has been added to the source distribution. 364See the file C<AUTHORS>. 365 366Numerous other changes have been made to the included documentation and FAQs. 367 368=head2 Bundled modules 369 370The following modules have been added. 371 372=over 373 374=item B::Concise 375 376Walks Perl syntax tree, printing concise info about ops. See L<B::Concise>. 377 378=item File::Temp 379 380Returns name and handle of a temporary file safely. See L<File::Temp>. 381 382=item Pod::LaTeX 383 384Converts Pod data to formatted LaTeX. See L<Pod::LaTeX>. 385 386=item Pod::Text::Overstrike 387 388Converts POD data to formatted overstrike text. See L<Pod::Text::Overstrike>. 389 390=back 391 392The following modules have been upgraded. 393 394=over 395 396=item CGI 397 398CGI v2.752 is now included. 399 400=item CPAN 401 402CPAN v1.59_54 is now included. 403 404=item Class::Struct 405 406Various bugfixes have been added. 407 408=item DB_File 409 410DB_File v1.75 supports newer Berkeley DB versions, among other 411improvements. 412 413=item Devel::Peek 414 415Devel::Peek has been enhanced to support dumping of memory statistics, 416when perl is built with the included malloc(). 417 418=item File::Find 419 420File::Find now supports pre and post-processing of the files in order 421to sort() them, etc. 422 423=item Getopt::Long 424 425Getopt::Long v2.25 is included. 426 427=item IO::Poll 428 429Various bug fixes have been included. 430 431=item IPC::Open3 432 433IPC::Open3 allows use of numeric file descriptors. 434 435=item Math::BigFloat 436 437The fmod() function supports modulus operations. Various bug fixes 438have also been included. 439 440=item Math::Complex 441 442Math::Complex handles inf, NaN etc., better. 443 444=item Net::Ping 445 446ping() could fail on odd number of data bytes, and when the echo service 447isn't running. This has been corrected. 448 449=item Opcode 450 451A memory leak has been fixed. 452 453=item Pod::Parser 454 455Version 1.13 of the Pod::Parser suite is included. 456 457=item Pod::Text 458 459Pod::Text and related modules have been upgraded to the versions 460in podlators suite v2.08. 461 462=item SDBM_File 463 464On dosish platforms, some keys went missing because of lack of support for 465files with "holes". A workaround for the problem has been added. 466 467=item Sys::Syslog 468 469Various bug fixes have been included. 470 471=item Tie::RefHash 472 473Now supports Tie::RefHash::Nestable to automagically tie hashref values. 474 475=item Tie::SubstrHash 476 477Various bug fixes have been included. 478 479=back 480 481=head2 Platform-specific improvements 482 483The following new ports are now available. 484 485=over 486 487=item NCR MP-RAS 488 489=item NonStop-UX 490 491=back 492 493Perl now builds under Amdahl UTS. 494 495Perl has also been verified to build under Amiga OS. 496 497Support for EPOC has been much improved. See README.epoc. 498 499Building perl with -Duseithreads or -Duse5005threads now works 500under HP-UX 10.20 (previously it only worked under 10.30 or later). 501You will need a thread library package installed. See README.hpux. 502 503Long doubles should now work under Linux. 504 505MacOS Classic is now supported in the mainstream source package. 506See README.macos. 507 508Support for MPE/iX has been updated. See README.mpeix. 509 510Support for OS/2 has been improved. See C<os2/Changes> and README.os2. 511 512Dynamic loading on z/OS (formerly OS/390) has been improved. See 513README.os390. 514 515Support for VMS has seen many incremental improvements, including 516better support for operators like backticks and system(), and better 517%ENV handling. See C<README.vms> and L<perlvms>. 518 519Support for Stratus VOS has been improved. See C<vos/Changes> and README.vos. 520 521Support for Windows has been improved. 522 523=over 524 525=item * 526 527fork() emulation has been improved in various ways, but still continues 528to be experimental. See L<perlfork> for known bugs and caveats. 529 530=item * 531 532%SIG has been enabled under USE_ITHREADS, but its use is completely 533unsupported under all configurations. 534 535=item * 536 537Borland C++ v5.5 is now a supported compiler that can build Perl. 538However, the generated binaries continue to be incompatible with those 539generated by the other supported compilers (GCC and Visual C++). 540 541=item * 542 543Non-blocking waits for child processes (or pseudo-processes) are 544supported via C<waitpid($pid, &POSIX::WNOHANG)>. 545 546=item * 547 548A memory leak in accept() has been fixed. 549 550=item * 551 552wait(), waitpid() and backticks now return the correct exit status under 553Windows 9x. 554 555=item * 556 557Trailing new %ENV entries weren't propagated to child processes. This 558is now fixed. 559 560=item * 561 562Current directory entries in %ENV are now correctly propagated to child 563processes. 564 565=item * 566 567Duping socket handles with open(F, ">&MYSOCK") now works under Windows 9x. 568 569=item * 570 571The makefiles now provide a single switch to bulk-enable all the features 572enabled in ActiveState ActivePerl (a popular binary distribution). 573 574=item * 575 576Win32::GetCwd() correctly returns C:\ instead of C: when at the drive root. 577Other bugs in chdir() and Cwd::cwd() have also been fixed. 578 579=item * 580 581fork() correctly returns undef and sets EAGAIN when it runs out of 582pseudo-process handles. 583 584=item * 585 586ExtUtils::MakeMaker now uses $ENV{LIB} to search for libraries. 587 588=item * 589 590UNC path handling is better when perl is built to support fork(). 591 592=item * 593 594A handle leak in socket handling has been fixed. 595 596=item * 597 598send() works from within a pseudo-process. 599 600=back 601 602Unless specifically qualified otherwise, the remainder of this document 603covers changes between the 5.005 and 5.6.0 releases. 604 605=head1 Core Enhancements 606 607=head2 Interpreter cloning, threads, and concurrency 608 609Perl 5.6.0 introduces the beginnings of support for running multiple 610interpreters concurrently in different threads. In conjunction with 611the perl_clone() API call, which can be used to selectively duplicate 612the state of any given interpreter, it is possible to compile a 613piece of code once in an interpreter, clone that interpreter 614one or more times, and run all the resulting interpreters in distinct 615threads. 616 617On the Windows platform, this feature is used to emulate fork() at the 618interpreter level. See L<perlfork> for details about that. 619 620This feature is still in evolution. It is eventually meant to be used 621to selectively clone a subroutine and data reachable from that 622subroutine in a separate interpreter and run the cloned subroutine 623in a separate thread. Since there is no shared data between the 624interpreters, little or no locking will be needed (unless parts of 625the symbol table are explicitly shared). This is obviously intended 626to be an easy-to-use replacement for the existing threads support. 627 628Support for cloning interpreters and interpreter concurrency can be 629enabled using the -Dusethreads Configure option (see win32/Makefile for 630how to enable it on Windows.) The resulting perl executable will be 631functionally identical to one that was built with -Dmultiplicity, but 632the perl_clone() API call will only be available in the former. 633 634-Dusethreads enables the cpp macro USE_ITHREADS by default, which in turn 635enables Perl source code changes that provide a clear separation between 636the op tree and the data it operates with. The former is immutable, and 637can therefore be shared between an interpreter and all of its clones, 638while the latter is considered local to each interpreter, and is therefore 639copied for each clone. 640 641Note that building Perl with the -Dusemultiplicity Configure option 642is adequate if you wish to run multiple B<independent> interpreters 643concurrently in different threads. -Dusethreads only provides the 644additional functionality of the perl_clone() API call and other 645support for running B<cloned> interpreters concurrently. 646 647 NOTE: This is an experimental feature. Implementation details are 648 subject to change. 649 650=head2 Lexically scoped warning categories 651 652You can now control the granularity of warnings emitted by perl at a finer 653level using the C<use warnings> pragma. L<warnings> and L<perllexwarn> 654have copious documentation on this feature. 655 656=head2 Unicode and UTF-8 support 657 658Perl now uses UTF-8 as its internal representation for character 659strings. The C<utf8> and C<bytes> pragmas are used to control this support 660in the current lexical scope. See L<perlunicode>, L<utf8> and L<bytes> for 661more information. 662 663This feature is expected to evolve quickly to support some form of I/O 664disciplines that can be used to specify the kind of input and output data 665(bytes or characters). Until that happens, additional modules from CPAN 666will be needed to complete the toolkit for dealing with Unicode. 667 668 NOTE: This should be considered an experimental feature. Implementation 669 details are subject to change. 670 671=head2 Support for interpolating named characters 672 673The new C<\N> escape interpolates named characters within strings. 674For example, C<"Hi! \N{WHITE SMILING FACE}"> evaluates to a string 675with a Unicode smiley face at the end. 676 677=head2 "our" declarations 678 679An "our" declaration introduces a value that can be best understood 680as a lexically scoped symbolic alias to a global variable in the 681package that was current where the variable was declared. This is 682mostly useful as an alternative to the C<vars> pragma, but also provides 683the opportunity to introduce typing and other attributes for such 684variables. See L<perlfunc/our>. 685 686=head2 Support for strings represented as a vector of ordinals 687 688Literals of the form C<v1.2.3.4> are now parsed as a string composed 689of characters with the specified ordinals. This is an alternative, more 690readable way to construct (possibly Unicode) strings instead of 691interpolating characters, as in C<"\x{1}\x{2}\x{3}\x{4}">. The leading 692C<v> may be omitted if there are more than two ordinals, so C<1.2.3> is 693parsed the same as C<v1.2.3>. 694 695Strings written in this form are also useful to represent version "numbers". 696It is easy to compare such version "numbers" (which are really just plain 697strings) using any of the usual string comparison operators C<eq>, C<ne>, 698C<lt>, C<gt>, etc., or perform bitwise string operations on them using C<|>, 699C<&>, etc. 700 701In conjunction with the new C<$^V> magic variable (which contains 702the perl version as a string), such literals can be used as a readable way 703to check if you're running a particular version of Perl: 704 705 # this will parse in older versions of Perl also 706 if ($^V and $^V gt v5.6.0) { 707 # new features supported 708 } 709 710C<require> and C<use> also have some special magic to support such literals. 711They will be interpreted as a version rather than as a module name: 712 713 require v5.6.0; # croak if $^V lt v5.6.0 714 use v5.6.0; # same, but croaks at compile-time 715 716Alternatively, the C<v> may be omitted if there is more than one dot: 717 718 require 5.6.0; 719 use 5.6.0; 720 721Also, C<sprintf> and C<printf> support the Perl-specific format flag C<%v> 722to print ordinals of characters in arbitrary strings: 723 724 printf "v%vd", $^V; # prints current version, such as "v5.5.650" 725 printf "%*vX", ":", $addr; # formats IPv6 address 726 printf "%*vb", " ", $bits; # displays bitstring 727 728See L<perldata/"Scalar value constructors"> for additional information. 729 730=head2 Improved Perl version numbering system 731 732Beginning with Perl version 5.6.0, the version number convention has been 733changed to a "dotted integer" scheme that is more commonly found in open 734source projects. 735 736Maintenance versions of v5.6.0 will be released as v5.6.1, v5.6.2 etc. 737The next development series following v5.6.0 will be numbered v5.7.x, 738beginning with v5.7.0, and the next major production release following 739v5.6.0 will be v5.8.0. 740 741The English module now sets $PERL_VERSION to $^V (a string value) rather 742than C<$]> (a numeric value). (This is a potential incompatibility. 743Send us a report via perlbug if you are affected by this.) 744 745The v1.2.3 syntax is also now legal in Perl. 746See L<Support for strings represented as a vector of ordinals> for more on that. 747 748To cope with the new versioning system's use of at least three significant 749digits for each version component, the method used for incrementing the 750subversion number has also changed slightly. We assume that versions older 751than v5.6.0 have been incrementing the subversion component in multiples of 75210. Versions after v5.6.0 will increment them by 1. Thus, using the new 753notation, 5.005_03 is the "same" as v5.5.30, and the first maintenance 754version following v5.6.0 will be v5.6.1 (which should be read as being 755equivalent to a floating point value of 5.006_001 in the older format, 756stored in C<$]>). 757 758=head2 New syntax for declaring subroutine attributes 759 760Formerly, if you wanted to mark a subroutine as being a method call or 761as requiring an automatic lock() when it is entered, you had to declare 762that with a C<use attrs> pragma in the body of the subroutine. 763That can now be accomplished with declaration syntax, like this: 764 765 sub mymethod : locked method ; 766 ... 767 sub mymethod : locked method { 768 ... 769 } 770 771 sub othermethod :locked :method ; 772 ... 773 sub othermethod :locked :method { 774 ... 775 } 776 777 778(Note how only the first C<:> is mandatory, and whitespace surrounding 779the C<:> is optional.) 780 781F<AutoSplit.pm> and F<SelfLoader.pm> have been updated to keep the attributes 782with the stubs they provide. See L<attributes>. 783 784=head2 File and directory handles can be autovivified 785 786Similar to how constructs such as C<< $x->[0] >> autovivify a reference, 787handle constructors (open(), opendir(), pipe(), socketpair(), sysopen(), 788socket(), and accept()) now autovivify a file or directory handle 789if the handle passed to them is an uninitialized scalar variable. This 790allows the constructs such as C<open(my $fh, ...)> and C<open(local $fh,...)> 791to be used to create filehandles that will conveniently be closed 792automatically when the scope ends, provided there are no other references 793to them. This largely eliminates the need for typeglobs when opening 794filehandles that must be passed around, as in the following example: 795 796 sub myopen { 797 open my $fh, "@_" 798 or die "Can't open '@_': $!"; 799 return $fh; 800 } 801 802 { 803 my $f = myopen("</etc/motd"); 804 print <$f>; 805 # $f implicitly closed here 806 } 807 808=head2 open() with more than two arguments 809 810If open() is passed three arguments instead of two, the second argument 811is used as the mode and the third argument is taken to be the file name. 812This is primarily useful for protecting against unintended magic behavior 813of the traditional two-argument form. See L<perlfunc/open>. 814 815=head2 64-bit support 816 817Any platform that has 64-bit integers either 818 819 (1) natively as longs or ints 820 (2) via special compiler flags 821 (3) using long long or int64_t 822 823is able to use "quads" (64-bit integers) as follows: 824 825=over 4 826 827=item * 828 829constants (decimal, hexadecimal, octal, binary) in the code 830 831=item * 832 833arguments to oct() and hex() 834 835=item * 836 837arguments to print(), printf() and sprintf() (flag prefixes ll, L, q) 838 839=item * 840 841printed as such 842 843=item * 844 845pack() and unpack() "q" and "Q" formats 846 847=item * 848 849in basic arithmetics: + - * / % (NOTE: operating close to the limits 850of the integer values may produce surprising results) 851 852=item * 853 854in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced 855to be 32 bits wide but now operate on the full native width.) 856 857=item * 858 859vec() 860 861=back 862 863Note that unless you have the case (a) you will have to configure 864and compile Perl using the -Duse64bitint Configure flag. 865 866 NOTE: The Configure flags -Duselonglong and -Duse64bits have been 867 deprecated. Use -Duse64bitint instead. 868 869There are actually two modes of 64-bitness: the first one is achieved 870using Configure -Duse64bitint and the second one using Configure 871-Duse64bitall. The difference is that the first one is minimal and 872the second one maximal. The first works in more places than the second. 873 874The C<use64bitint> does only as much as is required to get 64-bit 875integers into Perl (this may mean, for example, using "long longs") 876while your memory may still be limited to 2 gigabytes (because your 877pointers could still be 32-bit). Note that the name C<64bitint> does 878not imply that your C compiler will be using 64-bit C<int>s (it might, 879but it doesn't have to): the C<use64bitint> means that you will be 880able to have 64 bits wide scalar values. 881 882The C<use64bitall> goes all the way by attempting to switch also 883integers (if it can), longs (and pointers) to being 64-bit. This may 884create an even more binary incompatible Perl than -Duse64bitint: the 885resulting executable may not run at all in a 32-bit box, or you may 886have to reboot/reconfigure/rebuild your operating system to be 64-bit 887aware. 888 889Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint 890nor -Duse64bitall. 891 892Last but not least: note that due to Perl's habit of always using 893floating point numbers, the quads are still not true integers. 894When quads overflow their limits (0...18_446_744_073_709_551_615 unsigned, 895-9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they 896are silently promoted to floating point numbers, after which they will 897start losing precision (in their lower digits). 898 899 NOTE: 64-bit support is still experimental on most platforms. 900 Existing support only covers the LP64 data model. In particular, the 901 LLP64 data model is not yet supported. 64-bit libraries and system 902 APIs on many platforms have not stabilized--your mileage may vary. 903 904=head2 Large file support 905 906If you have filesystems that support "large files" (files larger than 9072 gigabytes), you may now also be able to create and access them from 908Perl. 909 910 NOTE: The default action is to enable large file support, if 911 available on the platform. 912 913If the large file support is on, and you have a Fcntl constant 914O_LARGEFILE, the O_LARGEFILE is automatically added to the flags 915of sysopen(). 916 917Beware that unless your filesystem also supports "sparse files" seeking 918to umpteen petabytes may be inadvisable. 919 920Note that in addition to requiring a proper file system to do large 921files you may also need to adjust your per-process (or your 922per-system, or per-process-group, or per-user-group) maximum filesize 923limits before running Perl scripts that try to handle large files, 924especially if you intend to write such files. 925 926Finally, in addition to your process/process group maximum filesize 927limits, you may have quota limits on your filesystems that stop you 928(your user id or your user group id) from using large files. 929 930Adjusting your process/user/group/file system/operating system limits 931is outside the scope of Perl core language. For process limits, you 932may try increasing the limits using your shell's limits/limit/ulimit 933command before running Perl. The BSD::Resource extension (not 934included with the standard Perl distribution) may also be of use, it 935offers the getrlimit/setrlimit interface that can be used to adjust 936process resource usage limits, including the maximum filesize limit. 937 938=head2 Long doubles 939 940In some systems you may be able to use long doubles to enhance the 941range and precision of your double precision floating point numbers 942(that is, Perl's numbers). Use Configure -Duselongdouble to enable 943this support (if it is available). 944 945=head2 "more bits" 946 947You can "Configure -Dusemorebits" to turn on both the 64-bit support 948and the long double support. 949 950=head2 Enhanced support for sort() subroutines 951 952Perl subroutines with a prototype of C<($$)>, and XSUBs in general, can 953now be used as sort subroutines. In either case, the two elements to 954be compared are passed as normal parameters in @_. See L<perlfunc/sort>. 955 956For unprototyped sort subroutines, the historical behavior of passing 957the elements to be compared as the global variables $a and $b remains 958unchanged. 959 960=head2 C<sort $coderef @foo> allowed 961 962sort() did not accept a subroutine reference as the comparison 963function in earlier versions. This is now permitted. 964 965=head2 File globbing implemented internally 966 967Perl now uses the File::Glob implementation of the glob() operator 968automatically. This avoids using an external csh process and the 969problems associated with it. 970 971 NOTE: This is currently an experimental feature. Interfaces and 972 implementation are subject to change. 973 974=head2 Support for CHECK blocks 975 976In addition to C<BEGIN>, C<INIT>, C<END>, C<DESTROY> and C<AUTOLOAD>, 977subroutines named C<CHECK> are now special. These are queued up during 978compilation and behave similar to END blocks, except they are called at 979the end of compilation rather than at the end of execution. They cannot 980be called directly. 981 982=head2 POSIX character class syntax [: :] supported 983 984For example to match alphabetic characters use /[[:alpha:]]/. 985See L<perlre> for details. 986 987=head2 Better pseudo-random number generator 988 989In 5.005_0x and earlier, perl's rand() function used the C library 990rand(3) function. As of 5.005_52, Configure tests for drand48(), 991random(), and rand() (in that order) and picks the first one it finds. 992 993These changes should result in better random numbers from rand(). 994 995=head2 Improved C<qw//> operator 996 997The C<qw//> operator is now evaluated at compile time into a true list 998instead of being replaced with a run time call to C<split()>. This 999removes the confusing misbehaviour of C<qw//> in scalar context, which 1000had inherited that behaviour from split(). 1001 1002Thus: 1003 1004 $foo = ($bar) = qw(a b c); print "$foo|$bar\n"; 1005 1006now correctly prints "3|a", instead of "2|a". 1007 1008=head2 Better worst-case behavior of hashes 1009 1010Small changes in the hashing algorithm have been implemented in 1011order to improve the distribution of lower order bits in the 1012hashed value. This is expected to yield better performance on 1013keys that are repeated sequences. 1014 1015=head2 pack() format 'Z' supported 1016 1017The new format type 'Z' is useful for packing and unpacking null-terminated 1018strings. See L<perlfunc/"pack">. 1019 1020=head2 pack() format modifier '!' supported 1021 1022The new format type modifier '!' is useful for packing and unpacking 1023native shorts, ints, and longs. See L<perlfunc/"pack">. 1024 1025=head2 pack() and unpack() support counted strings 1026 1027The template character '/' can be used to specify a counted string 1028type to be packed or unpacked. See L<perlfunc/"pack">. 1029 1030=head2 Comments in pack() templates 1031 1032The '#' character in a template introduces a comment up to 1033end of the line. This facilitates documentation of pack() 1034templates. 1035 1036=head2 Weak references 1037 1038In previous versions of Perl, you couldn't cache objects so as 1039to allow them to be deleted if the last reference from outside 1040the cache is deleted. The reference in the cache would hold a 1041reference count on the object and the objects would never be 1042destroyed. 1043 1044Another familiar problem is with circular references. When an 1045object references itself, its reference count would never go 1046down to zero, and it would not get destroyed until the program 1047is about to exit. 1048 1049Weak references solve this by allowing you to "weaken" any 1050reference, that is, make it not count towards the reference count. 1051When the last non-weak reference to an object is deleted, the object 1052is destroyed and all the weak references to the object are 1053automatically undef-ed. 1054 1055To use this feature, you need the WeakRef package from CPAN, which 1056contains additional documentation. 1057 1058 NOTE: This is an experimental feature. Details are subject to change. 1059 1060=head2 Binary numbers supported 1061 1062Binary numbers are now supported as literals, in s?printf formats, and 1063C<oct()>: 1064 1065 $answer = 0b101010; 1066 printf "The answer is: %b\n", oct("0b101010"); 1067 1068=head2 Lvalue subroutines 1069 1070Subroutines can now return modifiable lvalues. 1071See L<perlsub/"Lvalue subroutines">. 1072 1073 NOTE: This is an experimental feature. Details are subject to change. 1074 1075=head2 Some arrows may be omitted in calls through references 1076 1077Perl now allows the arrow to be omitted in many constructs 1078involving subroutine calls through references. For example, 1079C<< $foo[10]->('foo') >> may now be written C<$foo[10]('foo')>. 1080This is rather similar to how the arrow may be omitted from 1081C<< $foo[10]->{'foo'} >>. Note however, that the arrow is still 1082required for C<< foo(10)->('bar') >>. 1083 1084=head2 Boolean assignment operators are legal lvalues 1085 1086Constructs such as C<($a ||= 2) += 1> are now allowed. 1087 1088=head2 exists() is supported on subroutine names 1089 1090The exists() builtin now works on subroutine names. A subroutine 1091is considered to exist if it has been declared (even if implicitly). 1092See L<perlfunc/exists> for examples. 1093 1094=head2 exists() and delete() are supported on array elements 1095 1096The exists() and delete() builtins now work on simple arrays as well. 1097The behavior is similar to that on hash elements. 1098 1099exists() can be used to check whether an array element has been 1100initialized. This avoids autovivifying array elements that don't exist. 1101If the array is tied, the EXISTS() method in the corresponding tied 1102package will be invoked. 1103 1104delete() may be used to remove an element from the array and return 1105it. The array element at that position returns to its uninitialized 1106state, so that testing for the same element with exists() will return 1107false. If the element happens to be the one at the end, the size of 1108the array also shrinks up to the highest element that tests true for 1109exists(), or 0 if none such is found. If the array is tied, the DELETE() 1110method in the corresponding tied package will be invoked. 1111 1112See L<perlfunc/exists> and L<perlfunc/delete> for examples. 1113 1114=head2 Pseudo-hashes work better 1115 1116Dereferencing some types of reference values in a pseudo-hash, 1117such as C<< $ph->{foo}[1] >>, was accidentally disallowed. This has 1118been corrected. 1119 1120When applied to a pseudo-hash element, exists() now reports whether 1121the specified value exists, not merely if the key is valid. 1122 1123delete() now works on pseudo-hashes. When given a pseudo-hash element 1124or slice it deletes the values corresponding to the keys (but not the keys 1125themselves). See L<perlref/"Pseudo-hashes: Using an array as a hash">. 1126 1127Pseudo-hash slices with constant keys are now optimized to array lookups 1128at compile-time. 1129 1130List assignments to pseudo-hash slices are now supported. 1131 1132The C<fields> pragma now provides ways to create pseudo-hashes, via 1133fields::new() and fields::phash(). See L<fields>. 1134 1135 NOTE: The pseudo-hash data type continues to be experimental. 1136 Limiting oneself to the interface elements provided by the 1137 fields pragma will provide protection from any future changes. 1138 1139=head2 Automatic flushing of output buffers 1140 1141fork(), exec(), system(), qx//, and pipe open()s now flush buffers 1142of all files opened for output when the operation was attempted. This 1143mostly eliminates confusing buffering mishaps suffered by users unaware 1144of how Perl internally handles I/O. 1145 1146This is not supported on some platforms like Solaris where a suitably 1147correct implementation of fflush(NULL) isn't available. 1148 1149=head2 Better diagnostics on meaningless filehandle operations 1150 1151Constructs such as C<< open(<FH>) >> and C<< close(<FH>) >> 1152are compile time errors. Attempting to read from filehandles that 1153were opened only for writing will now produce warnings (just as 1154writing to read-only filehandles does). 1155 1156=head2 Where possible, buffered data discarded from duped input filehandle 1157 1158C<< open(NEW, "<&OLD") >> now attempts to discard any data that 1159was previously read and buffered in C<OLD> before duping the handle. 1160On platforms where doing this is allowed, the next read operation 1161on C<NEW> will return the same data as the corresponding operation 1162on C<OLD>. Formerly, it would have returned the data from the start 1163of the following disk block instead. 1164 1165=head2 eof() has the same old magic as <> 1166 1167C<eof()> would return true if no attempt to read from C<< <> >> had 1168yet been made. C<eof()> has been changed to have a little magic of its 1169own, it now opens the C<< <> >> files. 1170 1171=head2 binmode() can be used to set :crlf and :raw modes 1172 1173binmode() now accepts a second argument that specifies a discipline 1174for the handle in question. The two pseudo-disciplines ":raw" and 1175":crlf" are currently supported on DOS-derivative platforms. 1176See L<perlfunc/"binmode"> and L<open>. 1177 1178=head2 C<-T> filetest recognizes UTF-8 encoded files as "text" 1179 1180The algorithm used for the C<-T> filetest has been enhanced to 1181correctly identify UTF-8 content as "text". 1182 1183=head2 system(), backticks and pipe open now reflect exec() failure 1184 1185On Unix and similar platforms, system(), qx() and open(FOO, "cmd |") 1186etc., are implemented via fork() and exec(). When the underlying 1187exec() fails, earlier versions did not report the error properly, 1188since the exec() happened to be in a different process. 1189 1190The child process now communicates with the parent about the 1191error in launching the external command, which allows these 1192constructs to return with their usual error value and set $!. 1193 1194=head2 Improved diagnostics 1195 1196Line numbers are no longer suppressed (under most likely circumstances) 1197during the global destruction phase. 1198 1199Diagnostics emitted from code running in threads other than the main 1200thread are now accompanied by the thread ID. 1201 1202Embedded null characters in diagnostics now actually show up. They 1203used to truncate the message in prior versions. 1204 1205$foo::a and $foo::b are now exempt from "possible typo" warnings only 1206if sort() is encountered in package C<foo>. 1207 1208Unrecognized alphabetic escapes encountered when parsing quote 1209constructs now generate a warning, since they may take on new 1210semantics in later versions of Perl. 1211 1212Many diagnostics now report the internal operation in which the warning 1213was provoked, like so: 1214 1215 Use of uninitialized value in concatenation (.) at (eval 1) line 1. 1216 Use of uninitialized value in print at (eval 1) line 1. 1217 1218Diagnostics that occur within eval may also report the file and line 1219number where the eval is located, in addition to the eval sequence 1220number and the line number within the evaluated text itself. For 1221example: 1222 1223 Not enough arguments for scalar at (eval 4)[newlib/perl5db.pl:1411] line 2, at EOF 1224 1225=head2 Diagnostics follow STDERR 1226 1227Diagnostic output now goes to whichever file the C<STDERR> handle 1228is pointing at, instead of always going to the underlying C runtime 1229library's C<stderr>. 1230 1231=head2 More consistent close-on-exec behavior 1232 1233On systems that support a close-on-exec flag on filehandles, the 1234flag is now set for any handles created by pipe(), socketpair(), 1235socket(), and accept(), if that is warranted by the value of $^F 1236that may be in effect. Earlier versions neglected to set the flag 1237for handles created with these operators. See L<perlfunc/pipe>, 1238L<perlfunc/socketpair>, L<perlfunc/socket>, L<perlfunc/accept>, 1239and L<perlvar/$^F>. 1240 1241=head2 syswrite() ease-of-use 1242 1243The length argument of C<syswrite()> has become optional. 1244 1245=head2 Better syntax checks on parenthesized unary operators 1246 1247Expressions such as: 1248 1249 print defined(&foo,&bar,&baz); 1250 print uc("foo","bar","baz"); 1251 undef($foo,&bar); 1252 1253used to be accidentally allowed in earlier versions, and produced 1254unpredictable behaviour. Some produced ancillary warnings 1255when used in this way; others silently did the wrong thing. 1256 1257The parenthesized forms of most unary operators that expect a single 1258argument now ensure that they are not called with more than one 1259argument, making the cases shown above syntax errors. The usual 1260behaviour of: 1261 1262 print defined &foo, &bar, &baz; 1263 print uc "foo", "bar", "baz"; 1264 undef $foo, &bar; 1265 1266remains unchanged. See L<perlop>. 1267 1268=head2 Bit operators support full native integer width 1269 1270The bit operators (& | ^ ~ << >>) now operate on the full native 1271integral width (the exact size of which is available in $Config{ivsize}). 1272For example, if your platform is either natively 64-bit or if Perl 1273has been configured to use 64-bit integers, these operations apply 1274to 8 bytes (as opposed to 4 bytes on 32-bit platforms). 1275For portability, be sure to mask off the excess bits in the result of 1276unary C<~>, e.g., C<~$x & 0xffffffff>. 1277 1278=head2 Improved security features 1279 1280More potentially unsafe operations taint their results for improved 1281security. 1282 1283The C<passwd> and C<shell> fields returned by the getpwent(), getpwnam(), 1284and getpwuid() are now tainted, because the user can affect their own 1285encrypted password and login shell. 1286 1287The variable modified by shmread(), and messages returned by msgrcv() 1288(and its object-oriented interface IPC::SysV::Msg::rcv) are also tainted, 1289because other untrusted processes can modify messages and shared memory 1290segments for their own nefarious purposes. 1291 1292=head2 More functional bareword prototype (*) 1293 1294Bareword prototypes have been rationalized to enable them to be used 1295to override builtins that accept barewords and interpret them in 1296a special way, such as C<require> or C<do>. 1297 1298Arguments prototyped as C<*> will now be visible within the subroutine 1299as either a simple scalar or as a reference to a typeglob. 1300See L<perlsub/Prototypes>. 1301 1302=head2 C<require> and C<do> may be overridden 1303 1304C<require> and C<do 'file'> operations may be overridden locally 1305by importing subroutines of the same name into the current package 1306(or globally by importing them into the CORE::GLOBAL:: namespace). 1307Overriding C<require> will also affect C<use>, provided the override 1308is visible at compile-time. 1309See L<perlsub/"Overriding Built-in Functions">. 1310 1311=head2 $^X variables may now have names longer than one character 1312 1313Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax 1314error. Now variable names that begin with a control character may be 1315arbitrarily long. However, for compatibility reasons, these variables 1316I<must> be written with explicit braces, as C<${^XY}> for example. 1317C<${^XYZ}> is synonymous with ${"\cXYZ"}. Variable names with more 1318than one control character, such as C<${^XY^Z}>, are illegal. 1319 1320The old syntax has not changed. As before, `^X' may be either a 1321literal control-X character or the two-character sequence `caret' plus 1322`X'. When braces are omitted, the variable name stops after the 1323control character. Thus C<"$^XYZ"> continues to be synonymous with 1324C<$^X . "YZ"> as before. 1325 1326As before, lexical variables may not have names beginning with control 1327characters. As before, variables whose names begin with a control 1328character are always forced to be in package `main'. All such variables 1329are reserved for future extensions, except those that begin with 1330C<^_>, which may be used by user programs and are guaranteed not to 1331acquire special meaning in any future version of Perl. 1332 1333=head2 New variable $^C reflects C<-c> switch 1334 1335C<$^C> has a boolean value that reflects whether perl is being run 1336in compile-only mode (i.e. via the C<-c> switch). Since 1337BEGIN blocks are executed under such conditions, this variable 1338enables perl code to determine whether actions that make sense 1339only during normal running are warranted. See L<perlvar>. 1340 1341=head2 New variable $^V contains Perl version as a string 1342 1343C<$^V> contains the Perl version number as a string composed of 1344characters whose ordinals match the version numbers, i.e. v5.6.0. 1345This may be used in string comparisons. 1346 1347See C<Support for strings represented as a vector of ordinals> for an 1348example. 1349 1350=head2 Optional Y2K warnings 1351 1352If Perl is built with the cpp macro C<PERL_Y2KWARN> defined, 1353it emits optional warnings when concatenating the number 19 1354with another number. 1355 1356This behavior must be specifically enabled when running Configure. 1357See F<INSTALL> and F<README.Y2K>. 1358 1359=head2 Arrays now always interpolate into double-quoted strings 1360 1361In double-quoted strings, arrays now interpolate, no matter what. The 1362behavior in earlier versions of perl 5 was that arrays would interpolate 1363into strings if the array had been mentioned before the string was 1364compiled, and otherwise Perl would raise a fatal compile-time error. 1365In versions 5.000 through 5.003, the error was 1366 1367 Literal @example now requires backslash 1368 1369In versions 5.004_01 through 5.6.0, the error was 1370 1371 In string, @example now must be written as \@example 1372 1373The idea here was to get people into the habit of writing 1374C<"fred\@example.com"> when they wanted a literal C<@> sign, just as 1375they have always written C<"Give me back my \$5"> when they wanted a 1376literal C<$> sign. 1377 1378Starting with 5.6.1, when Perl now sees an C<@> sign in a 1379double-quoted string, it I<always> attempts to interpolate an array, 1380regardless of whether or not the array has been used or declared 1381already. The fatal error has been downgraded to an optional warning: 1382 1383 Possible unintended interpolation of @example in string 1384 1385This warns you that C<"fred@example.com"> is going to turn into 1386C<fred.com> if you don't backslash the C<@>. 1387See http://www.plover.com/~mjd/perl/at-error.html for more details 1388about the history here. 1389 1390=head1 Modules and Pragmata 1391 1392=head2 Modules 1393 1394=over 4 1395 1396=item attributes 1397 1398While used internally by Perl as a pragma, this module also 1399provides a way to fetch subroutine and variable attributes. 1400See L<attributes>. 1401 1402=item B 1403 1404The Perl Compiler suite has been extensively reworked for this 1405release. More of the standard Perl testsuite passes when run 1406under the Compiler, but there is still a significant way to 1407go to achieve production quality compiled executables. 1408 1409 NOTE: The Compiler suite remains highly experimental. The 1410 generated code may not be correct, even when it manages to execute 1411 without errors. 1412 1413=item Benchmark 1414 1415Overall, Benchmark results exhibit lower average error and better timing 1416accuracy. 1417 1418You can now run tests for I<n> seconds instead of guessing the right 1419number of tests to run: e.g., timethese(-5, ...) will run each 1420code for at least 5 CPU seconds. Zero as the "number of repetitions" 1421means "for at least 3 CPU seconds". The output format has also 1422changed. For example: 1423 1424 use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}}) 1425 1426will now output something like this: 1427 1428 Benchmark: running a, b, each for at least 5 CPU seconds... 1429 a: 5 wallclock secs ( 5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91/s (n=1156516) 1430 b: 4 wallclock secs ( 5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18/s (n=800686) 1431 1432New features: "each for at least N CPU seconds...", "wallclock secs", 1433and the "@ operations/CPU second (n=operations)". 1434 1435timethese() now returns a reference to a hash of Benchmark objects containing 1436the test results, keyed on the names of the tests. 1437 1438timethis() now returns the iterations field in the Benchmark result object 1439instead of 0. 1440 1441timethese(), timethis(), and the new cmpthese() (see below) can also take 1442a format specifier of 'none' to suppress output. 1443 1444A new function countit() is just like timeit() except that it takes a 1445TIME instead of a COUNT. 1446 1447A new function cmpthese() prints a chart comparing the results of each test 1448returned from a timethese() call. For each possible pair of tests, the 1449percentage speed difference (iters/sec or seconds/iter) is shown. 1450 1451For other details, see L<Benchmark>. 1452 1453=item ByteLoader 1454 1455The ByteLoader is a dedicated extension to generate and run 1456Perl bytecode. See L<ByteLoader>. 1457 1458=item constant 1459 1460References can now be used. 1461 1462The new version also allows a leading underscore in constant names, but 1463disallows a double leading underscore (as in "__LINE__"). Some other names 1464are disallowed or warned against, including BEGIN, END, etc. Some names 1465which were forced into main:: used to fail silently in some cases; now they're 1466fatal (outside of main::) and an optional warning (inside of main::). 1467The ability to detect whether a constant had been set with a given name has 1468been added. 1469 1470See L<constant>. 1471 1472=item charnames 1473 1474This pragma implements the C<\N> string escape. See L<charnames>. 1475 1476=item Data::Dumper 1477 1478A C<Maxdepth> setting can be specified to avoid venturing 1479too deeply into deep data structures. See L<Data::Dumper>. 1480 1481The XSUB implementation of Dump() is now automatically called if the 1482C<Useqq> setting is not in use. 1483 1484Dumping C<qr//> objects works correctly. 1485 1486=item DB 1487 1488C<DB> is an experimental module that exposes a clean abstraction 1489to Perl's debugging API. 1490 1491=item DB_File 1492 1493DB_File can now be built with Berkeley DB versions 1, 2 or 3. 1494See C<ext/DB_File/Changes>. 1495 1496=item Devel::DProf 1497 1498Devel::DProf, a Perl source code profiler has been added. See 1499L<Devel::DProf> and L<dprofpp>. 1500 1501=item Devel::Peek 1502 1503The Devel::Peek module provides access to the internal representation 1504of Perl variables and data. It is a data debugging tool for the XS programmer. 1505 1506=item Dumpvalue 1507 1508The Dumpvalue module provides screen dumps of Perl data. 1509 1510=item DynaLoader 1511 1512DynaLoader now supports a dl_unload_file() function on platforms that 1513support unloading shared objects using dlclose(). 1514 1515Perl can also optionally arrange to unload all extension shared objects 1516loaded by Perl. To enable this, build Perl with the Configure option 1517C<-Accflags=-DDL_UNLOAD_ALL_AT_EXIT>. (This maybe useful if you are 1518using Apache with mod_perl.) 1519 1520=item English 1521 1522$PERL_VERSION now stands for C<$^V> (a string value) rather than for C<$]> 1523(a numeric value). 1524 1525=item Env 1526 1527Env now supports accessing environment variables like PATH as array 1528variables. 1529 1530=item Fcntl 1531 1532More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for 1533large file (more than 4GB) access (NOTE: the O_LARGEFILE is 1534automatically added to sysopen() flags if large file support has been 1535configured, as is the default), Free/Net/OpenBSD locking behaviour 1536flags F_FLOCK, F_POSIX, Linux F_SHLCK, and O_ACCMODE: the combined 1537mask of O_RDONLY, O_WRONLY, and O_RDWR. The seek()/sysseek() 1538constants SEEK_SET, SEEK_CUR, and SEEK_END are available via the 1539C<:seek> tag. The chmod()/stat() S_IF* constants and S_IS* functions 1540are available via the C<:mode> tag. 1541 1542=item File::Compare 1543 1544A compare_text() function has been added, which allows custom 1545comparison functions. See L<File::Compare>. 1546 1547=item File::Find 1548 1549File::Find now works correctly when the wanted() function is either 1550autoloaded or is a symbolic reference. 1551 1552A bug that caused File::Find to lose track of the working directory 1553when pruning top-level directories has been fixed. 1554 1555File::Find now also supports several other options to control its 1556behavior. It can follow symbolic links if the C<follow> option is 1557specified. Enabling the C<no_chdir> option will make File::Find skip 1558changing the current directory when walking directories. The C<untaint> 1559flag can be useful when running with taint checks enabled. 1560 1561See L<File::Find>. 1562 1563=item File::Glob 1564 1565This extension implements BSD-style file globbing. By default, 1566it will also be used for the internal implementation of the glob() 1567operator. See L<File::Glob>. 1568 1569=item File::Spec 1570 1571New methods have been added to the File::Spec module: devnull() returns 1572the name of the null device (/dev/null on Unix) and tmpdir() the name of 1573the temp directory (normally /tmp on Unix). There are now also methods 1574to convert between absolute and relative filenames: abs2rel() and 1575rel2abs(). For compatibility with operating systems that specify volume 1576names in file paths, the splitpath(), splitdir(), and catdir() methods 1577have been added. 1578 1579=item File::Spec::Functions 1580 1581The new File::Spec::Functions modules provides a function interface 1582to the File::Spec module. Allows shorthand 1583 1584 $fullname = catfile($dir1, $dir2, $file); 1585 1586instead of 1587 1588 $fullname = File::Spec->catfile($dir1, $dir2, $file); 1589 1590=item Getopt::Long 1591 1592Getopt::Long licensing has changed to allow the Perl Artistic License 1593as well as the GPL. It used to be GPL only, which got in the way of 1594non-GPL applications that wanted to use Getopt::Long. 1595 1596Getopt::Long encourages the use of Pod::Usage to produce help 1597messages. For example: 1598 1599 use Getopt::Long; 1600 use Pod::Usage; 1601 my $man = 0; 1602 my $help = 0; 1603 GetOptions('help|?' => \$help, man => \$man) or pod2usage(2); 1604 pod2usage(1) if $help; 1605 pod2usage(-exitstatus => 0, -verbose => 2) if $man; 1606 1607 __END__ 1608 1609 =head1 NAME 1610 1611 sample - Using GetOpt::Long and Pod::Usage 1612 1613 =head1 SYNOPSIS 1614 1615 sample [options] [file ...] 1616 1617 Options: 1618 -help brief help message 1619 -man full documentation 1620 1621 =head1 OPTIONS 1622 1623 =over 8 1624 1625 =item B<-help> 1626 1627 Print a brief help message and exits. 1628 1629 =item B<-man> 1630 1631 Prints the manual page and exits. 1632 1633 =back 1634 1635 =head1 DESCRIPTION 1636 1637 B<This program> will read the given input file(s) and do something 1638 useful with the contents thereof. 1639 1640 =cut 1641 1642See L<Pod::Usage> for details. 1643 1644A bug that prevented the non-option call-back <> from being 1645specified as the first argument has been fixed. 1646 1647To specify the characters < and > as option starters, use ><. Note, 1648however, that changing option starters is strongly deprecated. 1649 1650=item IO 1651 1652write() and syswrite() will now accept a single-argument 1653form of the call, for consistency with Perl's syswrite(). 1654 1655You can now create a TCP-based IO::Socket::INET without forcing 1656a connect attempt. This allows you to configure its options 1657(like making it non-blocking) and then call connect() manually. 1658 1659A bug that prevented the IO::Socket::protocol() accessor 1660from ever returning the correct value has been corrected. 1661 1662IO::Socket::connect now uses non-blocking IO instead of alarm() 1663to do connect timeouts. 1664 1665IO::Socket::accept now uses select() instead of alarm() for doing 1666timeouts. 1667 1668IO::Socket::INET->new now sets $! correctly on failure. $@ is 1669still set for backwards compatibility. 1670 1671=item JPL 1672 1673Java Perl Lingo is now distributed with Perl. See jpl/README 1674for more information. 1675 1676=item lib 1677 1678C<use lib> now weeds out any trailing duplicate entries. 1679C<no lib> removes all named entries. 1680 1681=item Math::BigInt 1682 1683The bitwise operations C<<< << >>>, C<<< >> >>>, C<&>, C<|>, 1684and C<~> are now supported on bigints. 1685 1686=item Math::Complex 1687 1688The accessor methods Re, Im, arg, abs, rho, and theta can now also 1689act as mutators (accessor $z->Re(), mutator $z->Re(3)). 1690 1691The class method C<display_format> and the corresponding object method 1692C<display_format>, in addition to accepting just one argument, now can 1693also accept a parameter hash. Recognized keys of a parameter hash are 1694C<"style">, which corresponds to the old one parameter case, and two 1695new parameters: C<"format">, which is a printf()-style format string 1696(defaults usually to C<"%.15g">, you can revert to the default by 1697setting the format string to C<undef>) used for both parts of a 1698complex number, and C<"polar_pretty_print"> (defaults to true), 1699which controls whether an attempt is made to try to recognize small 1700multiples and rationals of pi (2pi, pi/2) at the argument (angle) of a 1701polar complex number. 1702 1703The potentially disruptive change is that in list context both methods 1704now I<return the parameter hash>, instead of only the value of the 1705C<"style"> parameter. 1706 1707=item Math::Trig 1708 1709A little bit of radial trigonometry (cylindrical and spherical), 1710radial coordinate conversions, and the great circle distance were added. 1711 1712=item Pod::Parser, Pod::InputObjects 1713 1714Pod::Parser is a base class for parsing and selecting sections of 1715pod documentation from an input stream. This module takes care of 1716identifying pod paragraphs and commands in the input and hands off the 1717parsed paragraphs and commands to user-defined methods which are free 1718to interpret or translate them as they see fit. 1719 1720Pod::InputObjects defines some input objects needed by Pod::Parser, and 1721for advanced users of Pod::Parser that need more about a command besides 1722its name and text. 1723 1724As of release 5.6.0 of Perl, Pod::Parser is now the officially sanctioned 1725"base parser code" recommended for use by all pod2xxx translators. 1726Pod::Text (pod2text) and Pod::Man (pod2man) have already been converted 1727to use Pod::Parser and efforts to convert Pod::HTML (pod2html) are already 1728underway. For any questions or comments about pod parsing and translating 1729issues and utilities, please use the pod-people@perl.org mailing list. 1730 1731For further information, please see L<Pod::Parser> and L<Pod::InputObjects>. 1732 1733=item Pod::Checker, podchecker 1734 1735This utility checks pod files for correct syntax, according to 1736L<perlpod>. Obvious errors are flagged as such, while warnings are 1737printed for mistakes that can be handled gracefully. The checklist is 1738not complete yet. See L<Pod::Checker>. 1739 1740=item Pod::ParseUtils, Pod::Find 1741 1742These modules provide a set of gizmos that are useful mainly for pod 1743translators. L<Pod::Find|Pod::Find> traverses directory structures and 1744returns found pod files, along with their canonical names (like 1745C<File::Spec::Unix>). L<Pod::ParseUtils|Pod::ParseUtils> contains 1746B<Pod::List> (useful for storing pod list information), B<Pod::Hyperlink> 1747(for parsing the contents of C<LE<lt>E<gt>> sequences) and B<Pod::Cache> 1748(for caching information about pod files, e.g., link nodes). 1749 1750=item Pod::Select, podselect 1751 1752Pod::Select is a subclass of Pod::Parser which provides a function 1753named "podselect()" to filter out user-specified sections of raw pod 1754documentation from an input stream. podselect is a script that provides 1755access to Pod::Select from other scripts to be used as a filter. 1756See L<Pod::Select>. 1757 1758=item Pod::Usage, pod2usage 1759 1760Pod::Usage provides the function "pod2usage()" to print usage messages for 1761a Perl script based on its embedded pod documentation. The pod2usage() 1762function is generally useful to all script authors since it lets them 1763write and maintain a single source (the pods) for documentation, thus 1764removing the need to create and maintain redundant usage message text 1765consisting of information already in the pods. 1766 1767There is also a pod2usage script which can be used from other kinds of 1768scripts to print usage messages from pods (even for non-Perl scripts 1769with pods embedded in comments). 1770 1771For details and examples, please see L<Pod::Usage>. 1772 1773=item Pod::Text and Pod::Man 1774 1775Pod::Text has been rewritten to use Pod::Parser. While pod2text() is 1776still available for backwards compatibility, the module now has a new 1777preferred interface. See L<Pod::Text> for the details. The new Pod::Text 1778module is easily subclassed for tweaks to the output, and two such 1779subclasses (Pod::Text::Termcap for man-page-style bold and underlining 1780using termcap information, and Pod::Text::Color for markup with ANSI color 1781sequences) are now standard. 1782 1783pod2man has been turned into a module, Pod::Man, which also uses 1784Pod::Parser. In the process, several outstanding bugs related to quotes 1785in section headers, quoting of code escapes, and nested lists have been 1786fixed. pod2man is now a wrapper script around this module. 1787 1788=item SDBM_File 1789 1790An EXISTS method has been added to this module (and sdbm_exists() has 1791been added to the underlying sdbm library), so one can now call exists 1792on an SDBM_File tied hash and get the correct result, rather than a 1793runtime error. 1794 1795A bug that may have caused data loss when more than one disk block 1796happens to be read from the database in a single FETCH() has been 1797fixed. 1798 1799=item Sys::Syslog 1800 1801Sys::Syslog now uses XSUBs to access facilities from syslog.h so it 1802no longer requires syslog.ph to exist. 1803 1804=item Sys::Hostname 1805 1806Sys::Hostname now uses XSUBs to call the C library's gethostname() or 1807uname() if they exist. 1808 1809=item Term::ANSIColor 1810 1811Term::ANSIColor is a very simple module to provide easy and readable 1812access to the ANSI color and highlighting escape sequences, supported by 1813most ANSI terminal emulators. It is now included standard. 1814 1815=item Time::Local 1816 1817The timelocal() and timegm() functions used to silently return bogus 1818results when the date fell outside the machine's integer range. They 1819now consistently croak() if the date falls in an unsupported range. 1820 1821=item Win32 1822 1823The error return value in list context has been changed for all functions 1824that return a list of values. Previously these functions returned a list 1825with a single element C<undef> if an error occurred. Now these functions 1826return the empty list in these situations. This applies to the following 1827functions: 1828 1829 Win32::FsType 1830 Win32::GetOSVersion 1831 1832The remaining functions are unchanged and continue to return C<undef> on 1833error even in list context. 1834 1835The Win32::SetLastError(ERROR) function has been added as a complement 1836to the Win32::GetLastError() function. 1837 1838The new Win32::GetFullPathName(FILENAME) returns the full absolute 1839pathname for FILENAME in scalar context. In list context it returns 1840a two-element list containing the fully qualified directory name and 1841the filename. See L<Win32>. 1842 1843=item XSLoader 1844 1845The XSLoader extension is a simpler alternative to DynaLoader. 1846See L<XSLoader>. 1847 1848=item DBM Filters 1849 1850A new feature called "DBM Filters" has been added to all the 1851DBM modules--DB_File, GDBM_File, NDBM_File, ODBM_File, and SDBM_File. 1852DBM Filters add four new methods to each DBM module: 1853 1854 filter_store_key 1855 filter_store_value 1856 filter_fetch_key 1857 filter_fetch_value 1858 1859These can be used to filter key-value pairs before the pairs are 1860written to the database or just after they are read from the database. 1861See L<perldbmfilter> for further information. 1862 1863=back 1864 1865=head2 Pragmata 1866 1867C<use attrs> is now obsolete, and is only provided for 1868backward-compatibility. It's been replaced by the C<sub : attributes> 1869syntax. See L<perlsub/"Subroutine Attributes"> and L<attributes>. 1870 1871Lexical warnings pragma, C<use warnings;>, to control optional warnings. 1872See L<perllexwarn>. 1873 1874C<use filetest> to control the behaviour of filetests (C<-r> C<-w> 1875...). Currently only one subpragma implemented, "use filetest 1876'access';", that uses access(2) or equivalent to check permissions 1877instead of using stat(2) as usual. This matters in filesystems 1878where there are ACLs (access control lists): the stat(2) might lie, 1879but access(2) knows better. 1880 1881The C<open> pragma can be used to specify default disciplines for 1882handle constructors (e.g. open()) and for qx//. The two 1883pseudo-disciplines C<:raw> and C<:crlf> are currently supported on 1884DOS-derivative platforms (i.e. where binmode is not a no-op). 1885See also L</"binmode() can be used to set :crlf and :raw modes">. 1886 1887=head1 Utility Changes 1888 1889=head2 dprofpp 1890 1891C<dprofpp> is used to display profile data generated using C<Devel::DProf>. 1892See L<dprofpp>. 1893 1894=head2 find2perl 1895 1896The C<find2perl> utility now uses the enhanced features of the File::Find 1897module. The -depth and -follow options are supported. Pod documentation 1898is also included in the script. 1899 1900=head2 h2xs 1901 1902The C<h2xs> tool can now work in conjunction with C<C::Scan> (available 1903from CPAN) to automatically parse real-life header files. The C<-M>, 1904C<-a>, C<-k>, and C<-o> options are new. 1905 1906=head2 perlcc 1907 1908C<perlcc> now supports the C and Bytecode backends. By default, 1909it generates output from the simple C backend rather than the 1910optimized C backend. 1911 1912Support for non-Unix platforms has been improved. 1913 1914=head2 perldoc 1915 1916C<perldoc> has been reworked to avoid possible security holes. 1917It will not by default let itself be run as the superuser, but you 1918may still use the B<-U> switch to try to make it drop privileges 1919first. 1920 1921=head2 The Perl Debugger 1922 1923Many bug fixes and enhancements were added to F<perl5db.pl>, the 1924Perl debugger. The help documentation was rearranged. New commands 1925include C<< < ? >>, C<< > ? >>, and C<< { ? >> to list out current 1926actions, C<man I<docpage>> to run your doc viewer on some perl 1927docset, and support for quoted options. The help information was 1928rearranged, and should be viewable once again if you're using B<less> 1929as your pager. A serious security hole was plugged--you should 1930immediately remove all older versions of the Perl debugger as 1931installed in previous releases, all the way back to perl3, from 1932your system to avoid being bitten by this. 1933 1934=head1 Improved Documentation 1935 1936Many of the platform-specific README files are now part of the perl 1937installation. See L<perl> for the complete list. 1938 1939=over 4 1940 1941=item perlapi.pod 1942 1943The official list of public Perl API functions. 1944 1945=item perlboot.pod 1946 1947A tutorial for beginners on object-oriented Perl. 1948 1949=item perlcompile.pod 1950 1951An introduction to using the Perl Compiler suite. 1952 1953=item perldbmfilter.pod 1954 1955A howto document on using the DBM filter facility. 1956 1957=item perldebug.pod 1958 1959All material unrelated to running the Perl debugger, plus all 1960low-level guts-like details that risked crushing the casual user 1961of the debugger, have been relocated from the old manpage to the 1962next entry below. 1963 1964=item perldebguts.pod 1965 1966This new manpage contains excessively low-level material not related 1967to the Perl debugger, but slightly related to debugging Perl itself. 1968It also contains some arcane internal details of how the debugging 1969process works that may only be of interest to developers of Perl 1970debuggers. 1971 1972=item perlfork.pod 1973 1974Notes on the fork() emulation currently available for the Windows platform. 1975 1976=item perlfilter.pod 1977 1978An introduction to writing Perl source filters. 1979 1980=item perlhack.pod 1981 1982Some guidelines for hacking the Perl source code. 1983 1984=item perlintern.pod 1985 1986A list of internal functions in the Perl source code. 1987(List is currently empty.) 1988 1989=item perllexwarn.pod 1990 1991Introduction and reference information about lexically scoped 1992warning categories. 1993 1994=item perlnumber.pod 1995 1996Detailed information about numbers as they are represented in Perl. 1997 1998=item perlopentut.pod 1999 2000A tutorial on using open() effectively. 2001 2002=item perlreftut.pod 2003 2004A tutorial that introduces the essentials of references. 2005 2006=item perltootc.pod 2007 2008A tutorial on managing class data for object modules. 2009 2010=item perltodo.pod 2011 2012Discussion of the most often wanted features that may someday be 2013supported in Perl. 2014 2015=item perlunicode.pod 2016 2017An introduction to Unicode support features in Perl. 2018 2019=back 2020 2021=head1 Performance enhancements 2022 2023=head2 Simple sort() using { $a <=> $b } and the like are optimized 2024 2025Many common sort() operations using a simple inlined block are now 2026optimized for faster performance. 2027 2028=head2 Optimized assignments to lexical variables 2029 2030Certain operations in the RHS of assignment statements have been 2031optimized to directly set the lexical variable on the LHS, 2032eliminating redundant copying overheads. 2033 2034=head2 Faster subroutine calls 2035 2036Minor changes in how subroutine calls are handled internally 2037provide marginal improvements in performance. 2038 2039=head2 delete(), each(), values() and hash iteration are faster 2040 2041The hash values returned by delete(), each(), values() and hashes in a 2042list context are the actual values in the hash, instead of copies. 2043This results in significantly better performance, because it eliminates 2044needless copying in most situations. 2045 2046=head1 Installation and Configuration Improvements 2047 2048=head2 -Dusethreads means something different 2049 2050The -Dusethreads flag now enables the experimental interpreter-based thread 2051support by default. To get the flavor of experimental threads that was in 20525.005 instead, you need to run Configure with "-Dusethreads -Duse5005threads". 2053 2054As of v5.6.0, interpreter-threads support is still lacking a way to 2055create new threads from Perl (i.e., C<use Thread;> will not work with 2056interpreter threads). C<use Thread;> continues to be available when you 2057specify the -Duse5005threads option to Configure, bugs and all. 2058 2059 NOTE: Support for threads continues to be an experimental feature. 2060 Interfaces and implementation are subject to sudden and drastic changes. 2061 2062=head2 New Configure flags 2063 2064The following new flags may be enabled on the Configure command line 2065by running Configure with C<-Dflag>. 2066 2067 usemultiplicity 2068 usethreads useithreads (new interpreter threads: no Perl API yet) 2069 usethreads use5005threads (threads as they were in 5.005) 2070 2071 use64bitint (equal to now deprecated 'use64bits') 2072 use64bitall 2073 2074 uselongdouble 2075 usemorebits 2076 uselargefiles 2077 usesocks (only SOCKS v5 supported) 2078 2079=head2 Threadedness and 64-bitness now more daring 2080 2081The Configure options enabling the use of threads and the use of 208264-bitness are now more daring in the sense that they no more have an 2083explicit list of operating systems of known threads/64-bit 2084capabilities. In other words: if your operating system has the 2085necessary APIs and datatypes, you should be able just to go ahead and 2086use them, for threads by Configure -Dusethreads, and for 64 bits 2087either explicitly by Configure -Duse64bitint or implicitly if your 2088system has 64-bit wide datatypes. See also L<"64-bit support">. 2089 2090=head2 Long Doubles 2091 2092Some platforms have "long doubles", floating point numbers of even 2093larger range than ordinary "doubles". To enable using long doubles for 2094Perl's scalars, use -Duselongdouble. 2095 2096=head2 -Dusemorebits 2097 2098You can enable both -Duse64bitint and -Duselongdouble with -Dusemorebits. 2099See also L<"64-bit support">. 2100 2101=head2 -Duselargefiles 2102 2103Some platforms support system APIs that are capable of handling large files 2104(typically, files larger than two gigabytes). Perl will try to use these 2105APIs if you ask for -Duselargefiles. 2106 2107See L<"Large file support"> for more information. 2108 2109=head2 installusrbinperl 2110 2111You can use "Configure -Uinstallusrbinperl" which causes installperl 2112to skip installing perl also as /usr/bin/perl. This is useful if you 2113prefer not to modify /usr/bin for some reason or another but harmful 2114because many scripts assume to find Perl in /usr/bin/perl. 2115 2116=head2 SOCKS support 2117 2118You can use "Configure -Dusesocks" which causes Perl to probe 2119for the SOCKS proxy protocol library (v5, not v4). For more information 2120on SOCKS, see: 2121 2122 http://www.socks.nec.com/ 2123 2124=head2 C<-A> flag 2125 2126You can "post-edit" the Configure variables using the Configure C<-A> 2127switch. The editing happens immediately after the platform specific 2128hints files have been processed but before the actual configuration 2129process starts. Run C<Configure -h> to find out the full C<-A> syntax. 2130 2131=head2 Enhanced Installation Directories 2132 2133The installation structure has been enriched to improve the support 2134for maintaining multiple versions of perl, to provide locations for 2135vendor-supplied modules, scripts, and manpages, and to ease maintenance 2136of locally-added modules, scripts, and manpages. See the section on 2137Installation Directories in the INSTALL file for complete details. 2138For most users building and installing from source, the defaults should 2139be fine. 2140 2141If you previously used C<Configure -Dsitelib> or C<-Dsitearch> to set 2142special values for library directories, you might wish to consider using 2143the new C<-Dsiteprefix> setting instead. Also, if you wish to re-use a 2144config.sh file from an earlier version of perl, you should be sure to 2145check that Configure makes sensible choices for the new directories. 2146See INSTALL for complete details. 2147 2148=head2 gcc automatically tried if 'cc' does not seem to be working 2149 2150In many platforms the vendor-supplied 'cc' is too stripped-down to 2151build Perl (basically, the 'cc' doesn't do ANSI C). If this seems 2152to be the case and the 'cc' does not seem to be the GNU C compiler 2153'gcc', an automatic attempt is made to find and use 'gcc' instead. 2154 2155=head1 Platform specific changes 2156 2157=head2 Supported platforms 2158 2159=over 4 2160 2161=item * 2162 2163The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread 2164extension. 2165 2166=item * 2167 2168GNU/Hurd is now supported. 2169 2170=item * 2171 2172Rhapsody/Darwin is now supported. 2173 2174=item * 2175 2176EPOC is now supported (on Psion 5). 2177 2178=item * 2179 2180The cygwin port (formerly cygwin32) has been greatly improved. 2181 2182=back 2183 2184=head2 DOS 2185 2186=over 4 2187 2188=item * 2189 2190Perl now works with djgpp 2.02 (and 2.03 alpha). 2191 2192=item * 2193 2194Environment variable names are not converted to uppercase any more. 2195 2196=item * 2197 2198Incorrect exit codes from backticks have been fixed. 2199 2200=item * 2201 2202This port continues to use its own builtin globbing (not File::Glob). 2203 2204=back 2205 2206=head2 OS390 (OpenEdition MVS) 2207 2208Support for this EBCDIC platform has not been renewed in this release. 2209There are difficulties in reconciling Perl's standardization on UTF-8 2210as its internal representation for characters with the EBCDIC character 2211set, because the two are incompatible. 2212 2213It is unclear whether future versions will renew support for this 2214platform, but the possibility exists. 2215 2216=head2 VMS 2217 2218Numerous revisions and extensions to configuration, build, testing, and 2219installation process to accommodate core changes and VMS-specific options. 2220 2221Expand %ENV-handling code to allow runtime mapping to logical names, 2222CLI symbols, and CRTL environ array. 2223 2224Extension of subprocess invocation code to accept filespecs as command 2225"verbs". 2226 2227Add to Perl command line processing the ability to use default file types and 2228to recognize Unix-style C<2E<gt>&1>. 2229 2230Expansion of File::Spec::VMS routines, and integration into ExtUtils::MM_VMS. 2231 2232Extension of ExtUtils::MM_VMS to handle complex extensions more flexibly. 2233 2234Barewords at start of Unix-syntax paths may be treated as text rather than 2235only as logical names. 2236 2237Optional secure translation of several logical names used internally by Perl. 2238 2239Miscellaneous bugfixing and porting of new core code to VMS. 2240 2241Thanks are gladly extended to the many people who have contributed VMS 2242patches, testing, and ideas. 2243 2244=head2 Win32 2245 2246Perl can now emulate fork() internally, using multiple interpreters running 2247in different concurrent threads. This support must be enabled at build 2248time. See L<perlfork> for detailed information. 2249 2250When given a pathname that consists only of a drivename, such as C<A:>, 2251opendir() and stat() now use the current working directory for the drive 2252rather than the drive root. 2253 2254The builtin XSUB functions in the Win32:: namespace are documented. See 2255L<Win32>. 2256 2257$^X now contains the full path name of the running executable. 2258 2259A Win32::GetLongPathName() function is provided to complement 2260Win32::GetFullPathName() and Win32::GetShortPathName(). See L<Win32>. 2261 2262POSIX::uname() is supported. 2263 2264system(1,...) now returns true process IDs rather than process 2265handles. kill() accepts any real process id, rather than strictly 2266return values from system(1,...). 2267 2268For better compatibility with Unix, C<kill(0, $pid)> can now be used to 2269test whether a process exists. 2270 2271The C<Shell> module is supported. 2272 2273Better support for building Perl under command.com in Windows 95 2274has been added. 2275 2276Scripts are read in binary mode by default to allow ByteLoader (and 2277the filter mechanism in general) to work properly. For compatibility, 2278the DATA filehandle will be set to text mode if a carriage return is 2279detected at the end of the line containing the __END__ or __DATA__ 2280token; if not, the DATA filehandle will be left open in binary mode. 2281Earlier versions always opened the DATA filehandle in text mode. 2282 2283The glob() operator is implemented via the C<File::Glob> extension, 2284which supports glob syntax of the C shell. This increases the flexibility 2285of the glob() operator, but there may be compatibility issues for 2286programs that relied on the older globbing syntax. If you want to 2287preserve compatibility with the older syntax, you might want to run 2288perl with C<-MFile::DosGlob>. For details and compatibility information, 2289see L<File::Glob>. 2290 2291=head1 Significant bug fixes 2292 2293=head2 <HANDLE> on empty files 2294 2295With C<$/> set to C<undef>, "slurping" an empty file returns a string of 2296zero length (instead of C<undef>, as it used to) the first time the 2297HANDLE is read after C<$/> is set to C<undef>. Further reads yield 2298C<undef>. 2299 2300This means that the following will append "foo" to an empty file (it used 2301to do nothing): 2302 2303 perl -0777 -pi -e 's/^/foo/' empty_file 2304 2305The behaviour of: 2306 2307 perl -pi -e 's/^/foo/' empty_file 2308 2309is unchanged (it continues to leave the file empty). 2310 2311=head2 C<eval '...'> improvements 2312 2313Line numbers (as reflected by caller() and most diagnostics) within 2314C<eval '...'> were often incorrect where here documents were involved. 2315This has been corrected. 2316 2317Lexical lookups for variables appearing in C<eval '...'> within 2318functions that were themselves called within an C<eval '...'> were 2319searching the wrong place for lexicals. The lexical search now 2320correctly ends at the subroutine's block boundary. 2321 2322The use of C<return> within C<eval {...}> caused $@ not to be reset 2323correctly when no exception occurred within the eval. This has 2324been fixed. 2325 2326Parsing of here documents used to be flawed when they appeared as 2327the replacement expression in C<eval 's/.../.../e'>. This has 2328been fixed. 2329 2330=head2 All compilation errors are true errors 2331 2332Some "errors" encountered at compile time were by necessity 2333generated as warnings followed by eventual termination of the 2334program. This enabled more such errors to be reported in a 2335single run, rather than causing a hard stop at the first error 2336that was encountered. 2337 2338The mechanism for reporting such errors has been reimplemented 2339to queue compile-time errors and report them at the end of the 2340compilation as true errors rather than as warnings. This fixes 2341cases where error messages leaked through in the form of warnings 2342when code was compiled at run time using C<eval STRING>, and 2343also allows such errors to be reliably trapped using C<eval "...">. 2344 2345=head2 Implicitly closed filehandles are safer 2346 2347Sometimes implicitly closed filehandles (as when they are localized, 2348and Perl automatically closes them on exiting the scope) could 2349inadvertently set $? or $!. This has been corrected. 2350 2351 2352=head2 Behavior of list slices is more consistent 2353 2354When taking a slice of a literal list (as opposed to a slice of 2355an array or hash), Perl used to return an empty list if the 2356result happened to be composed of all undef values. 2357 2358The new behavior is to produce an empty list if (and only if) 2359the original list was empty. Consider the following example: 2360 2361 @a = (1,undef,undef,2)[2,1,2]; 2362 2363The old behavior would have resulted in @a having no elements. 2364The new behavior ensures it has three undefined elements. 2365 2366Note in particular that the behavior of slices of the following 2367cases remains unchanged: 2368 2369 @a = ()[1,2]; 2370 @a = (getpwent)[7,0]; 2371 @a = (anything_returning_empty_list())[2,1,2]; 2372 @a = @b[2,1,2]; 2373 @a = @c{'a','b','c'}; 2374 2375See L<perldata>. 2376 2377=head2 C<(\$)> prototype and C<$foo{a}> 2378 2379A scalar reference prototype now correctly allows a hash or 2380array element in that slot. 2381 2382=head2 C<goto &sub> and AUTOLOAD 2383 2384The C<goto &sub> construct works correctly when C<&sub> happens 2385to be autoloaded. 2386 2387=head2 C<-bareword> allowed under C<use integer> 2388 2389The autoquoting of barewords preceded by C<-> did not work 2390in prior versions when the C<integer> pragma was enabled. 2391This has been fixed. 2392 2393=head2 Failures in DESTROY() 2394 2395When code in a destructor threw an exception, it went unnoticed 2396in earlier versions of Perl, unless someone happened to be 2397looking in $@ just after the point the destructor happened to 2398run. Such failures are now visible as warnings when warnings are 2399enabled. 2400 2401=head2 Locale bugs fixed 2402 2403printf() and sprintf() previously reset the numeric locale 2404back to the default "C" locale. This has been fixed. 2405 2406Numbers formatted according to the local numeric locale 2407(such as using a decimal comma instead of a decimal dot) caused 2408"isn't numeric" warnings, even while the operations accessing 2409those numbers produced correct results. These warnings have been 2410discontinued. 2411 2412=head2 Memory leaks 2413 2414The C<eval 'return sub {...}'> construct could sometimes leak 2415memory. This has been fixed. 2416 2417Operations that aren't filehandle constructors used to leak memory 2418when used on invalid filehandles. This has been fixed. 2419 2420Constructs that modified C<@_> could fail to deallocate values 2421in C<@_> and thus leak memory. This has been corrected. 2422 2423=head2 Spurious subroutine stubs after failed subroutine calls 2424 2425Perl could sometimes create empty subroutine stubs when a 2426subroutine was not found in the package. Such cases stopped 2427later method lookups from progressing into base packages. 2428This has been corrected. 2429 2430=head2 Taint failures under C<-U> 2431 2432When running in unsafe mode, taint violations could sometimes 2433cause silent failures. This has been fixed. 2434 2435=head2 END blocks and the C<-c> switch 2436 2437Prior versions used to run BEGIN B<and> END blocks when Perl was 2438run in compile-only mode. Since this is typically not the expected 2439behavior, END blocks are not executed anymore when the C<-c> switch 2440is used, or if compilation fails. 2441 2442See L</"Support for CHECK blocks"> for how to run things when the compile 2443phase ends. 2444 2445=head2 Potential to leak DATA filehandles 2446 2447Using the C<__DATA__> token creates an implicit filehandle to 2448the file that contains the token. It is the program's 2449responsibility to close it when it is done reading from it. 2450 2451This caveat is now better explained in the documentation. 2452See L<perldata>. 2453 2454=head1 New or Changed Diagnostics 2455 2456=over 4 2457 2458=item "%s" variable %s masks earlier declaration in same %s 2459 2460(W misc) A "my" or "our" variable has been redeclared in the current scope or statement, 2461effectively eliminating all access to the previous instance. This is almost 2462always a typographical error. Note that the earlier variable will still exist 2463until the end of the scope or until all closure referents to it are 2464destroyed. 2465 2466=item "my sub" not yet implemented 2467 2468(F) Lexically scoped subroutines are not yet implemented. Don't try that 2469yet. 2470 2471=item "our" variable %s redeclared 2472 2473(W misc) You seem to have already declared the same global once before in the 2474current lexical scope. 2475 2476=item '!' allowed only after types %s 2477 2478(F) The '!' is allowed in pack() and unpack() only after certain types. 2479See L<perlfunc/pack>. 2480 2481=item / cannot take a count 2482 2483(F) You had an unpack template indicating a counted-length string, 2484but you have also specified an explicit size for the string. 2485See L<perlfunc/pack>. 2486 2487=item / must be followed by a, A or Z 2488 2489(F) You had an unpack template indicating a counted-length string, 2490which must be followed by one of the letters a, A or Z 2491to indicate what sort of string is to be unpacked. 2492See L<perlfunc/pack>. 2493 2494=item / must be followed by a*, A* or Z* 2495 2496(F) You had a pack template indicating a counted-length string, 2497Currently the only things that can have their length counted are a*, A* or Z*. 2498See L<perlfunc/pack>. 2499 2500=item / must follow a numeric type 2501 2502(F) You had an unpack template that contained a '#', 2503but this did not follow some numeric unpack specification. 2504See L<perlfunc/pack>. 2505 2506=item /%s/: Unrecognized escape \\%c passed through 2507 2508(W regexp) You used a backslash-character combination which is not recognized 2509by Perl. This combination appears in an interpolated variable or a 2510C<'>-delimited regular expression. The character was understood literally. 2511 2512=item /%s/: Unrecognized escape \\%c in character class passed through 2513 2514(W regexp) You used a backslash-character combination which is not recognized 2515by Perl inside character classes. The character was understood literally. 2516 2517=item /%s/ should probably be written as "%s" 2518 2519(W syntax) You have used a pattern where Perl expected to find a string, 2520as in the first argument to C<join>. Perl will treat the true 2521or false result of matching the pattern against $_ as the string, 2522which is probably not what you had in mind. 2523 2524=item %s() called too early to check prototype 2525 2526(W prototype) You've called a function that has a prototype before the parser saw a 2527definition or declaration for it, and Perl could not check that the call 2528conforms to the prototype. You need to either add an early prototype 2529declaration for the subroutine in question, or move the subroutine 2530definition ahead of the call to get proper prototype checking. Alternatively, 2531if you are certain that you're calling the function correctly, you may put 2532an ampersand before the name to avoid the warning. See L<perlsub>. 2533 2534=item %s argument is not a HASH or ARRAY element 2535 2536(F) The argument to exists() must be a hash or array element, such as: 2537 2538 $foo{$bar} 2539 $ref->{"susie"}[12] 2540 2541=item %s argument is not a HASH or ARRAY element or slice 2542 2543(F) The argument to delete() must be either a hash or array element, such as: 2544 2545 $foo{$bar} 2546 $ref->{"susie"}[12] 2547 2548or a hash or array slice, such as: 2549 2550 @foo[$bar, $baz, $xyzzy] 2551 @{$ref->[12]}{"susie", "queue"} 2552 2553=item %s argument is not a subroutine name 2554 2555(F) The argument to exists() for C<exists &sub> must be a subroutine 2556name, and not a subroutine call. C<exists &sub()> will generate this error. 2557 2558=item %s package attribute may clash with future reserved word: %s 2559 2560(W reserved) A lowercase attribute name was used that had a package-specific handler. 2561That name might have a meaning to Perl itself some day, even though it 2562doesn't yet. Perhaps you should use a mixed-case attribute name, instead. 2563See L<attributes>. 2564 2565=item (in cleanup) %s 2566 2567(W misc) This prefix usually indicates that a DESTROY() method raised 2568the indicated exception. Since destructors are usually called by 2569the system at arbitrary points during execution, and often a vast 2570number of times, the warning is issued only once for any number 2571of failures that would otherwise result in the same message being 2572repeated. 2573 2574Failure of user callbacks dispatched using the C<G_KEEPERR> flag 2575could also result in this warning. See L<perlcall/G_KEEPERR>. 2576 2577=item <> should be quotes 2578 2579(F) You wrote C<< require <file> >> when you should have written 2580C<require 'file'>. 2581 2582=item Attempt to join self 2583 2584(F) You tried to join a thread from within itself, which is an 2585impossible task. You may be joining the wrong thread, or you may 2586need to move the join() to some other thread. 2587 2588=item Bad evalled substitution pattern 2589 2590(F) You've used the /e switch to evaluate the replacement for a 2591substitution, but perl found a syntax error in the code to evaluate, 2592most likely an unexpected right brace '}'. 2593 2594=item Bad realloc() ignored 2595 2596(S) An internal routine called realloc() on something that had never been 2597malloc()ed in the first place. Mandatory, but can be disabled by 2598setting environment variable C<PERL_BADFREE> to 1. 2599 2600=item Bareword found in conditional 2601 2602(W bareword) The compiler found a bareword where it expected a conditional, 2603which often indicates that an || or && was parsed as part of the 2604last argument of the previous construct, for example: 2605 2606 open FOO || die; 2607 2608It may also indicate a misspelled constant that has been interpreted 2609as a bareword: 2610 2611 use constant TYPO => 1; 2612 if (TYOP) { print "foo" } 2613 2614The C<strict> pragma is useful in avoiding such errors. 2615 2616=item Binary number > 0b11111111111111111111111111111111 non-portable 2617 2618(W portable) The binary number you specified is larger than 2**32-1 2619(4294967295) and therefore non-portable between systems. See 2620L<perlport> for more on portability concerns. 2621 2622=item Bit vector size > 32 non-portable 2623 2624(W portable) Using bit vector sizes larger than 32 is non-portable. 2625 2626=item Buffer overflow in prime_env_iter: %s 2627 2628(W internal) A warning peculiar to VMS. While Perl was preparing to iterate over 2629%ENV, it encountered a logical name or symbol definition which was too long, 2630so it was truncated to the string shown. 2631 2632=item Can't check filesystem of script "%s" 2633 2634(P) For some reason you can't check the filesystem of the script for nosuid. 2635 2636=item Can't declare class for non-scalar %s in "%s" 2637 2638(S) Currently, only scalar variables can declared with a specific class 2639qualifier in a "my" or "our" declaration. The semantics may be extended 2640for other types of variables in future. 2641 2642=item Can't declare %s in "%s" 2643 2644(F) Only scalar, array, and hash variables may be declared as "my" or 2645"our" variables. They must have ordinary identifiers as names. 2646 2647=item Can't ignore signal CHLD, forcing to default 2648 2649(W signal) Perl has detected that it is being run with the SIGCHLD signal 2650(sometimes known as SIGCLD) disabled. Since disabling this signal 2651will interfere with proper determination of exit status of child 2652processes, Perl has reset the signal to its default value. 2653This situation typically indicates that the parent program under 2654which Perl may be running (e.g., cron) is being very careless. 2655 2656=item Can't modify non-lvalue subroutine call 2657 2658(F) Subroutines meant to be used in lvalue context should be declared as 2659such, see L<perlsub/"Lvalue subroutines">. 2660 2661=item Can't read CRTL environ 2662 2663(S) A warning peculiar to VMS. Perl tried to read an element of %ENV 2664from the CRTL's internal environment array and discovered the array was 2665missing. You need to figure out where your CRTL misplaced its environ 2666or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not searched. 2667 2668=item Can't remove %s: %s, skipping file 2669 2670(S) You requested an inplace edit without creating a backup file. Perl 2671was unable to remove the original file to replace it with the modified 2672file. The file was left unmodified. 2673 2674=item Can't return %s from lvalue subroutine 2675 2676(F) Perl detected an attempt to return illegal lvalues (such 2677as temporary or readonly values) from a subroutine used as an lvalue. 2678This is not allowed. 2679 2680=item Can't weaken a nonreference 2681 2682(F) You attempted to weaken something that was not a reference. Only 2683references can be weakened. 2684 2685=item Character class [:%s:] unknown 2686 2687(F) The class in the character class [: :] syntax is unknown. 2688See L<perlre>. 2689 2690=item Character class syntax [%s] belongs inside character classes 2691 2692(W unsafe) The character class constructs [: :], [= =], and [. .] go 2693I<inside> character classes, the [] are part of the construct, 2694for example: /[012[:alpha:]345]/. Note that [= =] and [. .] 2695are not currently implemented; they are simply placeholders for 2696future extensions. 2697 2698=item Constant is not %s reference 2699 2700(F) A constant value (perhaps declared using the C<use constant> pragma) 2701is being dereferenced, but it amounts to the wrong type of reference. The 2702message indicates the type of reference that was expected. This usually 2703indicates a syntax error in dereferencing the constant value. 2704See L<perlsub/"Constant Functions"> and L<constant>. 2705 2706=item constant(%s): %s 2707 2708(F) The parser found inconsistencies either while attempting to define an 2709overloaded constant, or when trying to find the character name specified 2710in the C<\N{...}> escape. Perhaps you forgot to load the corresponding 2711C<overload> or C<charnames> pragma? See L<charnames> and L<overload>. 2712 2713=item CORE::%s is not a keyword 2714 2715(F) The CORE:: namespace is reserved for Perl keywords. 2716 2717=item defined(@array) is deprecated 2718 2719(D) defined() is not usually useful on arrays because it checks for an 2720undefined I<scalar> value. If you want to see if the array is empty, 2721just use C<if (@array) { # not empty }> for example. 2722 2723=item defined(%hash) is deprecated 2724 2725(D) defined() is not usually useful on hashes because it checks for an 2726undefined I<scalar> value. If you want to see if the hash is empty, 2727just use C<if (%hash) { # not empty }> for example. 2728 2729=item Did not produce a valid header 2730 2731See Server error. 2732 2733=item (Did you mean "local" instead of "our"?) 2734 2735(W misc) Remember that "our" does not localize the declared global variable. 2736You have declared it again in the same lexical scope, which seems superfluous. 2737 2738=item Document contains no data 2739 2740See Server error. 2741 2742=item entering effective %s failed 2743 2744(F) While under the C<use filetest> pragma, switching the real and 2745effective uids or gids failed. 2746 2747=item false [] range "%s" in regexp 2748 2749(W regexp) A character class range must start and end at a literal character, not 2750another character class like C<\d> or C<[:alpha:]>. The "-" in your false 2751range is interpreted as a literal "-". Consider quoting the "-", "\-". 2752See L<perlre>. 2753 2754=item Filehandle %s opened only for output 2755 2756(W io) You tried to read from a filehandle opened only for writing. If you 2757intended it to be a read/write filehandle, you needed to open it with 2758"+<" or "+>" or "+>>" instead of with "<" or nothing. If 2759you intended only to read from the file, use "<". See 2760L<perlfunc/open>. 2761 2762=item flock() on closed filehandle %s 2763 2764(W closed) The filehandle you're attempting to flock() got itself closed some 2765time before now. Check your logic flow. flock() operates on filehandles. 2766Are you attempting to call flock() on a dirhandle by the same name? 2767 2768=item Global symbol "%s" requires explicit package name 2769 2770(F) You've said "use strict vars", which indicates that all variables 2771must either be lexically scoped (using "my"), declared beforehand using 2772"our", or explicitly qualified to say which package the global variable 2773is in (using "::"). 2774 2775=item Hexadecimal number > 0xffffffff non-portable 2776 2777(W portable) The hexadecimal number you specified is larger than 2**32-1 2778(4294967295) and therefore non-portable between systems. See 2779L<perlport> for more on portability concerns. 2780 2781=item Ill-formed CRTL environ value "%s" 2782 2783(W internal) A warning peculiar to VMS. Perl tried to read the CRTL's internal 2784environ array, and encountered an element without the C<=> delimiter 2785used to separate keys from values. The element is ignored. 2786 2787=item Ill-formed message in prime_env_iter: |%s| 2788 2789(W internal) A warning peculiar to VMS. Perl tried to read a logical name 2790or CLI symbol definition when preparing to iterate over %ENV, and 2791didn't see the expected delimiter between key and value, so the 2792line was ignored. 2793 2794=item Illegal binary digit %s 2795 2796(F) You used a digit other than 0 or 1 in a binary number. 2797 2798=item Illegal binary digit %s ignored 2799 2800(W digit) You may have tried to use a digit other than 0 or 1 in a binary number. 2801Interpretation of the binary number stopped before the offending digit. 2802 2803=item Illegal number of bits in vec 2804 2805(F) The number of bits in vec() (the third argument) must be a power of 2806two from 1 to 32 (or 64, if your platform supports that). 2807 2808=item Integer overflow in %s number 2809 2810(W overflow) The hexadecimal, octal or binary number you have specified either 2811as a literal or as an argument to hex() or oct() is too big for your 2812architecture, and has been converted to a floating point number. On a 281332-bit architecture the largest hexadecimal, octal or binary number 2814representable without overflow is 0xFFFFFFFF, 037777777777, or 28150b11111111111111111111111111111111 respectively. Note that Perl 2816transparently promotes all numbers to a floating point representation 2817internally--subject to loss of precision errors in subsequent 2818operations. 2819 2820=item Invalid %s attribute: %s 2821 2822The indicated attribute for a subroutine or variable was not recognized 2823by Perl or by a user-supplied handler. See L<attributes>. 2824 2825=item Invalid %s attributes: %s 2826 2827The indicated attributes for a subroutine or variable were not recognized 2828by Perl or by a user-supplied handler. See L<attributes>. 2829 2830=item invalid [] range "%s" in regexp 2831 2832The offending range is now explicitly displayed. 2833 2834=item Invalid separator character %s in attribute list 2835 2836(F) Something other than a colon or whitespace was seen between the 2837elements of an attribute list. If the previous attribute 2838had a parenthesised parameter list, perhaps that list was terminated 2839too soon. See L<attributes>. 2840 2841=item Invalid separator character %s in subroutine attribute list 2842 2843(F) Something other than a colon or whitespace was seen between the 2844elements of a subroutine attribute list. If the previous attribute 2845had a parenthesised parameter list, perhaps that list was terminated 2846too soon. 2847 2848=item leaving effective %s failed 2849 2850(F) While under the C<use filetest> pragma, switching the real and 2851effective uids or gids failed. 2852 2853=item Lvalue subs returning %s not implemented yet 2854 2855(F) Due to limitations in the current implementation, array and hash 2856values cannot be returned in subroutines used in lvalue context. 2857See L<perlsub/"Lvalue subroutines">. 2858 2859=item Method %s not permitted 2860 2861See Server error. 2862 2863=item Missing %sbrace%s on \N{} 2864 2865(F) Wrong syntax of character name literal C<\N{charname}> within 2866double-quotish context. 2867 2868=item Missing command in piped open 2869 2870(W pipe) You used the C<open(FH, "| command")> or C<open(FH, "command |")> 2871construction, but the command was missing or blank. 2872 2873=item Missing name in "my sub" 2874 2875(F) The reserved syntax for lexically scoped subroutines requires that they 2876have a name with which they can be found. 2877 2878=item No %s specified for -%c 2879 2880(F) The indicated command line switch needs a mandatory argument, but 2881you haven't specified one. 2882 2883=item No package name allowed for variable %s in "our" 2884 2885(F) Fully qualified variable names are not allowed in "our" declarations, 2886because that doesn't make much sense under existing semantics. Such 2887syntax is reserved for future extensions. 2888 2889=item No space allowed after -%c 2890 2891(F) The argument to the indicated command line switch must follow immediately 2892after the switch, without intervening spaces. 2893 2894=item no UTC offset information; assuming local time is UTC 2895 2896(S) A warning peculiar to VMS. Perl was unable to find the local 2897timezone offset, so it's assuming that local system time is equivalent 2898to UTC. If it's not, define the logical name F<SYS$TIMEZONE_DIFFERENTIAL> 2899to translate to the number of seconds which need to be added to UTC to 2900get local time. 2901 2902=item Octal number > 037777777777 non-portable 2903 2904(W portable) The octal number you specified is larger than 2**32-1 (4294967295) 2905and therefore non-portable between systems. See L<perlport> for more 2906on portability concerns. 2907 2908See also L<perlport> for writing portable code. 2909 2910=item panic: del_backref 2911 2912(P) Failed an internal consistency check while trying to reset a weak 2913reference. 2914 2915=item panic: kid popen errno read 2916 2917(F) forked child returned an incomprehensible message about its errno. 2918 2919=item panic: magic_killbackrefs 2920 2921(P) Failed an internal consistency check while trying to reset all weak 2922references to an object. 2923 2924=item Parentheses missing around "%s" list 2925 2926(W parenthesis) You said something like 2927 2928 my $foo, $bar = @_; 2929 2930when you meant 2931 2932 my ($foo, $bar) = @_; 2933 2934Remember that "my", "our", and "local" bind tighter than comma. 2935 2936=item Possible unintended interpolation of %s in string 2937 2938(W ambiguous) It used to be that Perl would try to guess whether you 2939wanted an array interpolated or a literal @. It no longer does this; 2940arrays are now I<always> interpolated into strings. This means that 2941if you try something like: 2942 2943 print "fred@example.com"; 2944 2945and the array C<@example> doesn't exist, Perl is going to print 2946C<fred.com>, which is probably not what you wanted. To get a literal 2947C<@> sign in a string, put a backslash before it, just as you would 2948to get a literal C<$> sign. 2949 2950=item Possible Y2K bug: %s 2951 2952(W y2k) You are concatenating the number 19 with another number, which 2953could be a potential Year 2000 problem. 2954 2955=item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead 2956 2957(W deprecated) You have written something like this: 2958 2959 sub doit 2960 { 2961 use attrs qw(locked); 2962 } 2963 2964You should use the new declaration syntax instead. 2965 2966 sub doit : locked 2967 { 2968 ... 2969 2970The C<use attrs> pragma is now obsolete, and is only provided for 2971backward-compatibility. See L<perlsub/"Subroutine Attributes">. 2972 2973 2974=item Premature end of script headers 2975 2976See Server error. 2977 2978=item Repeat count in pack overflows 2979 2980(F) You can't specify a repeat count so large that it overflows 2981your signed integers. See L<perlfunc/pack>. 2982 2983=item Repeat count in unpack overflows 2984 2985(F) You can't specify a repeat count so large that it overflows 2986your signed integers. See L<perlfunc/unpack>. 2987 2988=item realloc() of freed memory ignored 2989 2990(S) An internal routine called realloc() on something that had already 2991been freed. 2992 2993=item Reference is already weak 2994 2995(W misc) You have attempted to weaken a reference that is already weak. 2996Doing so has no effect. 2997 2998=item setpgrp can't take arguments 2999 3000(F) Your system has the setpgrp() from BSD 4.2, which takes no arguments, 3001unlike POSIX setpgid(), which takes a process ID and process group ID. 3002 3003=item Strange *+?{} on zero-length expression 3004 3005(W regexp) You applied a regular expression quantifier in a place where it 3006makes no sense, such as on a zero-width assertion. 3007Try putting the quantifier inside the assertion instead. For example, 3008the way to match "abc" provided that it is followed by three 3009repetitions of "xyz" is C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>. 3010 3011=item switching effective %s is not implemented 3012 3013(F) While under the C<use filetest> pragma, we cannot switch the 3014real and effective uids or gids. 3015 3016=item This Perl can't reset CRTL environ elements (%s) 3017 3018=item This Perl can't set CRTL environ elements (%s=%s) 3019 3020(W internal) Warnings peculiar to VMS. You tried to change or delete an element 3021of the CRTL's internal environ array, but your copy of Perl wasn't 3022built with a CRTL that contained the setenv() function. You'll need to 3023rebuild Perl with a CRTL that does, or redefine F<PERL_ENV_TABLES> (see 3024L<perlvms>) so that the environ array isn't the target of the change to 3025%ENV which produced the warning. 3026 3027=item Too late to run %s block 3028 3029(W void) A CHECK or INIT block is being defined during run time proper, 3030when the opportunity to run them has already passed. Perhaps you are 3031loading a file with C<require> or C<do> when you should be using 3032C<use> instead. Or perhaps you should put the C<require> or C<do> 3033inside a BEGIN block. 3034 3035=item Unknown open() mode '%s' 3036 3037(F) The second argument of 3-argument open() is not among the list 3038of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>, 3039C<< +> >>, C<<< +>> >>>, C<-|>, C<|->. 3040 3041=item Unknown process %x sent message to prime_env_iter: %s 3042 3043(P) An error peculiar to VMS. Perl was reading values for %ENV before 3044iterating over it, and someone else stuck a message in the stream of 3045data Perl expected. Someone's very confused, or perhaps trying to 3046subvert Perl's population of %ENV for nefarious purposes. 3047 3048=item Unrecognized escape \\%c passed through 3049 3050(W misc) You used a backslash-character combination which is not recognized 3051by Perl. The character was understood literally. 3052 3053=item Unterminated attribute parameter in attribute list 3054 3055(F) The lexer saw an opening (left) parenthesis character while parsing an 3056attribute list, but the matching closing (right) parenthesis 3057character was not found. You may need to add (or remove) a backslash 3058character to get your parentheses to balance. See L<attributes>. 3059 3060=item Unterminated attribute list 3061 3062(F) The lexer found something other than a simple identifier at the start 3063of an attribute, and it wasn't a semicolon or the start of a 3064block. Perhaps you terminated the parameter list of the previous attribute 3065too soon. See L<attributes>. 3066 3067=item Unterminated attribute parameter in subroutine attribute list 3068 3069(F) The lexer saw an opening (left) parenthesis character while parsing a 3070subroutine attribute list, but the matching closing (right) parenthesis 3071character was not found. You may need to add (or remove) a backslash 3072character to get your parentheses to balance. 3073 3074=item Unterminated subroutine attribute list 3075 3076(F) The lexer found something other than a simple identifier at the start 3077of a subroutine attribute, and it wasn't a semicolon or the start of a 3078block. Perhaps you terminated the parameter list of the previous attribute 3079too soon. 3080 3081=item Value of CLI symbol "%s" too long 3082 3083(W misc) A warning peculiar to VMS. Perl tried to read the value of an %ENV 3084element from a CLI symbol table, and found a resultant string longer 3085than 1024 characters. The return value has been truncated to 1024 3086characters. 3087 3088=item Version number must be a constant number 3089 3090(P) The attempt to translate a C<use Module n.n LIST> statement into 3091its equivalent C<BEGIN> block found an internal inconsistency with 3092the version number. 3093 3094=back 3095 3096=head1 New tests 3097 3098=over 4 3099 3100=item lib/attrs 3101 3102Compatibility tests for C<sub : attrs> vs the older C<use attrs>. 3103 3104=item lib/env 3105 3106Tests for new environment scalar capability (e.g., C<use Env qw($BAR);>). 3107 3108=item lib/env-array 3109 3110Tests for new environment array capability (e.g., C<use Env qw(@PATH);>). 3111 3112=item lib/io_const 3113 3114IO constants (SEEK_*, _IO*). 3115 3116=item lib/io_dir 3117 3118Directory-related IO methods (new, read, close, rewind, tied delete). 3119 3120=item lib/io_multihomed 3121 3122INET sockets with multi-homed hosts. 3123 3124=item lib/io_poll 3125 3126IO poll(). 3127 3128=item lib/io_unix 3129 3130UNIX sockets. 3131 3132=item op/attrs 3133 3134Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>. 3135 3136=item op/filetest 3137 3138File test operators. 3139 3140=item op/lex_assign 3141 3142Verify operations that access pad objects (lexicals and temporaries). 3143 3144=item op/exists_sub 3145 3146Verify C<exists &sub> operations. 3147 3148=back 3149 3150=head1 Incompatible Changes 3151 3152=head2 Perl Source Incompatibilities 3153 3154Beware that any new warnings that have been added or old ones 3155that have been enhanced are B<not> considered incompatible changes. 3156 3157Since all new warnings must be explicitly requested via the C<-w> 3158switch or the C<warnings> pragma, it is ultimately the programmer's 3159responsibility to ensure that warnings are enabled judiciously. 3160 3161=over 4 3162 3163=item CHECK is a new keyword 3164 3165All subroutine definitions named CHECK are now special. See 3166C</"Support for CHECK blocks"> for more information. 3167 3168=item Treatment of list slices of undef has changed 3169 3170There is a potential incompatibility in the behavior of list slices 3171that are comprised entirely of undefined values. 3172See L</"Behavior of list slices is more consistent">. 3173 3174=item Format of $English::PERL_VERSION is different 3175 3176The English module now sets $PERL_VERSION to $^V (a string value) rather 3177than C<$]> (a numeric value). This is a potential incompatibility. 3178Send us a report via perlbug if you are affected by this. 3179 3180See L</"Improved Perl version numbering system"> for the reasons for 3181this change. 3182 3183=item Literals of the form C<1.2.3> parse differently 3184 3185Previously, numeric literals with more than one dot in them were 3186interpreted as a floating point number concatenated with one or more 3187numbers. Such "numbers" are now parsed as strings composed of the 3188specified ordinals. 3189 3190For example, C<print 97.98.99> used to output C<97.9899> in earlier 3191versions, but now prints C<abc>. 3192 3193See L</"Support for strings represented as a vector of ordinals">. 3194 3195=item Possibly changed pseudo-random number generator 3196 3197Perl programs that depend on reproducing a specific set of pseudo-random 3198numbers may now produce different output due to improvements made to the 3199rand() builtin. You can use C<sh Configure -Drandfunc=rand> to obtain 3200the old behavior. 3201 3202See L</"Better pseudo-random number generator">. 3203 3204=item Hashing function for hash keys has changed 3205 3206Even though Perl hashes are not order preserving, the apparently 3207random order encountered when iterating on the contents of a hash 3208is actually determined by the hashing algorithm used. Improvements 3209in the algorithm may yield a random order that is B<different> from 3210that of previous versions, especially when iterating on hashes. 3211 3212See L</"Better worst-case behavior of hashes"> for additional 3213information. 3214 3215=item C<undef> fails on read only values 3216 3217Using the C<undef> operator on a readonly value (such as $1) has 3218the same effect as assigning C<undef> to the readonly value--it 3219throws an exception. 3220 3221=item Close-on-exec bit may be set on pipe and socket handles 3222 3223Pipe and socket handles are also now subject to the close-on-exec 3224behavior determined by the special variable $^F. 3225 3226See L</"More consistent close-on-exec behavior">. 3227 3228=item Writing C<"$$1"> to mean C<"${$}1"> is unsupported 3229 3230Perl 5.004 deprecated the interpretation of C<$$1> and 3231similar within interpolated strings to mean C<$$ . "1">, 3232but still allowed it. 3233 3234In Perl 5.6.0 and later, C<"$$1"> always means C<"${$1}">. 3235 3236=item delete(), each(), values() and C<\(%h)> 3237 3238operate on aliases to values, not copies 3239 3240delete(), each(), values() and hashes (e.g. C<\(%h)>) 3241in a list context return the actual 3242values in the hash, instead of copies (as they used to in earlier 3243versions). Typical idioms for using these constructs copy the 3244returned values, but this can make a significant difference when 3245creating references to the returned values. Keys in the hash are still 3246returned as copies when iterating on a hash. 3247 3248See also L</"delete(), each(), values() and hash iteration are faster">. 3249 3250=item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS 3251 3252vec() generates a run-time error if the BITS argument is not 3253a valid power-of-two integer. 3254 3255=item Text of some diagnostic output has changed 3256 3257Most references to internal Perl operations in diagnostics 3258have been changed to be more descriptive. This may be an 3259issue for programs that may incorrectly rely on the exact 3260text of diagnostics for proper functioning. 3261 3262=item C<%@> has been removed 3263 3264The undocumented special variable C<%@> that used to accumulate 3265"background" errors (such as those that happen in DESTROY()) 3266has been removed, because it could potentially result in memory 3267leaks. 3268 3269=item Parenthesized not() behaves like a list operator 3270 3271The C<not> operator now falls under the "if it looks like a function, 3272it behaves like a function" rule. 3273 3274As a result, the parenthesized form can be used with C<grep> and C<map>. 3275The following construct used to be a syntax error before, but it works 3276as expected now: 3277 3278 grep not($_), @things; 3279 3280On the other hand, using C<not> with a literal list slice may not 3281work. The following previously allowed construct: 3282 3283 print not (1,2,3)[0]; 3284 3285needs to be written with additional parentheses now: 3286 3287 print not((1,2,3)[0]); 3288 3289The behavior remains unaffected when C<not> is not followed by parentheses. 3290 3291=item Semantics of bareword prototype C<(*)> have changed 3292 3293The semantics of the bareword prototype C<*> have changed. Perl 5.005 3294always coerced simple scalar arguments to a typeglob, which wasn't useful 3295in situations where the subroutine must distinguish between a simple 3296scalar and a typeglob. The new behavior is to not coerce bareword 3297arguments to a typeglob. The value will always be visible as either 3298a simple scalar or as a reference to a typeglob. 3299 3300See L</"More functional bareword prototype (*)">. 3301 3302=item Semantics of bit operators may have changed on 64-bit platforms 3303 3304If your platform is either natively 64-bit or if Perl has been 3305configured to used 64-bit integers, i.e., $Config{ivsize} is 8, 3306there may be a potential incompatibility in the behavior of bitwise 3307numeric operators (& | ^ ~ << >>). These operators used to strictly 3308operate on the lower 32 bits of integers in previous versions, but now 3309operate over the entire native integral width. In particular, note 3310that unary C<~> will produce different results on platforms that have 3311different $Config{ivsize}. For portability, be sure to mask off 3312the excess bits in the result of unary C<~>, e.g., C<~$x & 0xffffffff>. 3313 3314See L</"Bit operators support full native integer width">. 3315 3316=item More builtins taint their results 3317 3318As described in L</"Improved security features">, there may be more 3319sources of taint in a Perl program. 3320 3321To avoid these new tainting behaviors, you can build Perl with the 3322Configure option C<-Accflags=-DINCOMPLETE_TAINTS>. Beware that the 3323ensuing perl binary may be insecure. 3324 3325=back 3326 3327=head2 C Source Incompatibilities 3328 3329=over 4 3330 3331=item C<PERL_POLLUTE> 3332 3333Release 5.005 grandfathered old global symbol names by providing preprocessor 3334macros for extension source compatibility. As of release 5.6.0, these 3335preprocessor definitions are not available by default. You need to explicitly 3336compile perl with C<-DPERL_POLLUTE> to get these definitions. For 3337extensions still using the old symbols, this option can be 3338specified via MakeMaker: 3339 3340 perl Makefile.PL POLLUTE=1 3341 3342=item C<PERL_IMPLICIT_CONTEXT> 3343 3344This new build option provides a set of macros for all API functions 3345such that an implicit interpreter/thread context argument is passed to 3346every API function. As a result of this, something like C<sv_setsv(foo,bar)> 3347amounts to a macro invocation that actually translates to something like 3348C<Perl_sv_setsv(my_perl,foo,bar)>. While this is generally expected 3349to not have any significant source compatibility issues, the difference 3350between a macro and a real function call will need to be considered. 3351 3352This means that there B<is> a source compatibility issue as a result of 3353this if your extensions attempt to use pointers to any of the Perl API 3354functions. 3355 3356Note that the above issue is not relevant to the default build of 3357Perl, whose interfaces continue to match those of prior versions 3358(but subject to the other options described here). 3359 3360See L<perlguts/"The Perl API"> for detailed information on the 3361ramifications of building Perl with this option. 3362 3363 NOTE: PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built 3364 with one of -Dusethreads, -Dusemultiplicity, or both. It is not 3365 intended to be enabled by users at this time. 3366 3367=item C<PERL_POLLUTE_MALLOC> 3368 3369Enabling Perl's malloc in release 5.005 and earlier caused the namespace of 3370the system's malloc family of functions to be usurped by the Perl versions, 3371since by default they used the same names. Besides causing problems on 3372platforms that do not allow these functions to be cleanly replaced, this 3373also meant that the system versions could not be called in programs that 3374used Perl's malloc. Previous versions of Perl have allowed this behaviour 3375to be suppressed with the HIDEMYMALLOC and EMBEDMYMALLOC preprocessor 3376definitions. 3377 3378As of release 5.6.0, Perl's malloc family of functions have default names 3379distinct from the system versions. You need to explicitly compile perl with 3380C<-DPERL_POLLUTE_MALLOC> to get the older behaviour. HIDEMYMALLOC 3381and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now 3382the default. 3383 3384Note that these functions do B<not> constitute Perl's memory allocation API. 3385See L<perlguts/"Memory Allocation"> for further information about that. 3386 3387=back 3388 3389=head2 Compatible C Source API Changes 3390 3391=over 4 3392 3393=item C<PATCHLEVEL> is now C<PERL_VERSION> 3394 3395The cpp macros C<PERL_REVISION>, C<PERL_VERSION>, and C<PERL_SUBVERSION> 3396are now available by default from perl.h, and reflect the base revision, 3397patchlevel, and subversion respectively. C<PERL_REVISION> had no 3398prior equivalent, while C<PERL_VERSION> and C<PERL_SUBVERSION> were 3399previously available as C<PATCHLEVEL> and C<SUBVERSION>. 3400 3401The new names cause less pollution of the B<cpp> namespace and reflect what 3402the numbers have come to stand for in common practice. For compatibility, 3403the old names are still supported when F<patchlevel.h> is explicitly 3404included (as required before), so there is no source incompatibility 3405from the change. 3406 3407=back 3408 3409=head2 Binary Incompatibilities 3410 3411In general, the default build of this release is expected to be binary 3412compatible for extensions built with the 5.005 release or its maintenance 3413versions. However, specific platforms may have broken binary compatibility 3414due to changes in the defaults used in hints files. Therefore, please be 3415sure to always check the platform-specific README files for any notes to 3416the contrary. 3417 3418The usethreads or usemultiplicity builds are B<not> binary compatible 3419with the corresponding builds in 5.005. 3420 3421On platforms that require an explicit list of exports (AIX, OS/2 and Windows, 3422among others), purely internal symbols such as parser functions and the 3423run time opcodes are not exported by default. Perl 5.005 used to export 3424all functions irrespective of whether they were considered part of the 3425public API or not. 3426 3427For the full list of public API functions, see L<perlapi>. 3428 3429=head1 Known Problems 3430 3431=head2 Localizing a tied hash element may leak memory 3432 3433As of the 5.6.1 release, there is a known leak when code such as this 3434is executed: 3435 3436 use Tie::Hash; 3437 tie my %tie_hash => 'Tie::StdHash'; 3438 3439 ... 3440 3441 local($tie_hash{Foo}) = 1; # leaks 3442 3443=head2 Known test failures 3444 3445=over 3446 3447=item 64-bit builds 3448 3449Subtest #15 of lib/b.t may fail under 64-bit builds on platforms such 3450as HP-UX PA64 and Linux IA64. The issue is still being investigated. 3451 3452The lib/io_multihomed test may hang in HP-UX if Perl has been 3453configured to be 64-bit. Because other 64-bit platforms do not 3454hang in this test, HP-UX is suspect. All other tests pass 3455in 64-bit HP-UX. The test attempts to create and connect to 3456"multihomed" sockets (sockets which have multiple IP addresses). 3457 3458Note that 64-bit support is still experimental. 3459 3460=item Failure of Thread tests 3461 3462The subtests 19 and 20 of lib/thr5005.t test are known to fail due to 3463fundamental problems in the 5.005 threading implementation. These are 3464not new failures--Perl 5.005_0x has the same bugs, but didn't have these 3465tests. (Note that support for 5.005-style threading remains experimental.) 3466 3467=item NEXTSTEP 3.3 POSIX test failure 3468 3469In NEXTSTEP 3.3p2 the implementation of the strftime(3) in the 3470operating system libraries is buggy: the %j format numbers the days of 3471a month starting from zero, which, while being logical to programmers, 3472will cause the subtests 19 to 27 of the lib/posix test may fail. 3473 3474=item Tru64 (aka Digital UNIX, aka DEC OSF/1) lib/sdbm test failure with gcc 3475 3476If compiled with gcc 2.95 the lib/sdbm test will fail (dump core). 3477The cure is to use the vendor cc, it comes with the operating system 3478and produces good code. 3479 3480=back 3481 3482=head2 EBCDIC platforms not fully supported 3483 3484In earlier releases of Perl, EBCDIC environments like OS390 (also 3485known as Open Edition MVS) and VM-ESA were supported. Due to changes 3486required by the UTF-8 (Unicode) support, the EBCDIC platforms are not 3487supported in Perl 5.6.0. 3488 3489The 5.6.1 release improves support for EBCDIC platforms, but they 3490are not fully supported yet. 3491 3492=head2 UNICOS/mk CC failures during Configure run 3493 3494In UNICOS/mk the following errors may appear during the Configure run: 3495 3496 Guessing which symbols your C compiler and preprocessor define... 3497 CC-20 cc: ERROR File = try.c, Line = 3 3498 ... 3499 bad switch yylook 79bad switch yylook 79bad switch yylook 79bad switch yylook 79#ifdef A29K 3500 ... 3501 4 errors detected in the compilation of "try.c". 3502 3503The culprit is the broken awk of UNICOS/mk. The effect is fortunately 3504rather mild: Perl itself is not adversely affected by the error, only 3505the h2ph utility coming with Perl, and that is rather rarely needed 3506these days. 3507 3508=head2 Arrow operator and arrays 3509 3510When the left argument to the arrow operator C<< -> >> is an array, or 3511the C<scalar> operator operating on an array, the result of the 3512operation must be considered erroneous. For example: 3513 3514 @x->[2] 3515 scalar(@x)->[2] 3516 3517These expressions will get run-time errors in some future release of 3518Perl. 3519 3520=head2 Experimental features 3521 3522As discussed above, many features are still experimental. Interfaces and 3523implementation of these features are subject to change, and in extreme cases, 3524even subject to removal in some future release of Perl. These features 3525include the following: 3526 3527=over 4 3528 3529=item Threads 3530 3531=item Unicode 3532 3533=item 64-bit support 3534 3535=item Lvalue subroutines 3536 3537=item Weak references 3538 3539=item The pseudo-hash data type 3540 3541=item The Compiler suite 3542 3543=item Internal implementation of file globbing 3544 3545=item The DB module 3546 3547=item The regular expression code constructs: 3548 3549C<(?{ code })> and C<(??{ code })> 3550 3551=back 3552 3553=head1 Obsolete Diagnostics 3554 3555=over 4 3556 3557=item Character class syntax [: :] is reserved for future extensions 3558 3559(W) Within regular expression character classes ([]) the syntax beginning 3560with "[:" and ending with ":]" is reserved for future extensions. 3561If you need to represent those character sequences inside a regular 3562expression character class, just quote the square brackets with the 3563backslash: "\[:" and ":\]". 3564 3565=item Ill-formed logical name |%s| in prime_env_iter 3566 3567(W) A warning peculiar to VMS. A logical name was encountered when preparing 3568to iterate over %ENV which violates the syntactic rules governing logical 3569names. Because it cannot be translated normally, it is skipped, and will not 3570appear in %ENV. This may be a benign occurrence, as some software packages 3571might directly modify logical name tables and introduce nonstandard names, 3572or it may indicate that a logical name table has been corrupted. 3573 3574=item In string, @%s now must be written as \@%s 3575 3576The description of this error used to say: 3577 3578 (Someday it will simply assume that an unbackslashed @ 3579 interpolates an array.) 3580 3581That day has come, and this fatal error has been removed. It has been 3582replaced by a non-fatal warning instead. 3583See L</Arrays now always interpolate into double-quoted strings> for 3584details. 3585 3586=item Probable precedence problem on %s 3587 3588(W) The compiler found a bareword where it expected a conditional, 3589which often indicates that an || or && was parsed as part of the 3590last argument of the previous construct, for example: 3591 3592 open FOO || die; 3593 3594=item regexp too big 3595 3596(F) The current implementation of regular expressions uses shorts as 3597address offsets within a string. Unfortunately this means that if 3598the regular expression compiles to longer than 32767, it'll blow up. 3599Usually when you want a regular expression this big, there is a better 3600way to do it with multiple statements. See L<perlre>. 3601 3602=item Use of "$$<digit>" to mean "${$}<digit>" is deprecated 3603 3604(D) Perl versions before 5.004 misinterpreted any type marker followed 3605by "$" and a digit. For example, "$$0" was incorrectly taken to mean 3606"${$}0" instead of "${$0}". This bug is (mostly) fixed in Perl 5.004. 3607 3608However, the developers of Perl 5.004 could not fix this bug completely, 3609because at least two widely-used modules depend on the old meaning of 3610"$$0" in a string. So Perl 5.004 still interprets "$$<digit>" in the 3611old (broken) way inside strings; but it generates this message as a 3612warning. And in Perl 5.005, this special treatment will cease. 3613 3614=back 3615 3616=head1 Reporting Bugs 3617 3618If you find what you think is a bug, you might check the 3619articles recently posted to the comp.lang.perl.misc newsgroup. 3620There may also be information at http://www.perl.com/, the Perl 3621Home Page. 3622 3623If you believe you have an unreported bug, please run the B<perlbug> 3624program included with your release. Be sure to trim your bug down 3625to a tiny but sufficient test case. Your bug report, along with the 3626output of C<perl -V>, will be sent off to perlbug@perl.org to be 3627analysed by the Perl porting team. 3628 3629=head1 SEE ALSO 3630 3631The F<Changes> file for exhaustive details on what changed. 3632 3633The F<INSTALL> file for how to build Perl. 3634 3635The F<README> file for general stuff. 3636 3637The F<Artistic> and F<Copying> files for copyright information. 3638 3639=head1 HISTORY 3640 3641Written by Gurusamy Sarathy <F<gsar@ActiveState.com>>, with many 3642contributions from The Perl Porters. 3643 3644Send omissions or corrections to <F<perlbug@perl.org>>. 3645 3646=cut 3647