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