| 1 | =head1 NAME |
| 2 | |
| 3 | perltrap - Perl traps for the unwary |
| 4 | |
| 5 | =head1 DESCRIPTION |
| 6 | |
| 7 | The biggest trap of all is forgetting to C<use warnings> or use the B<-w> |
| 8 | switch; see L<perllexwarn> and L<perlrun>. The second biggest trap is not |
| 9 | making your entire program runnable under C<use strict>. The third biggest |
| 10 | trap is not reading the list of changes in this version of Perl; see |
| 11 | L<perldelta>. |
| 12 | |
| 13 | =head2 Awk Traps |
| 14 | |
| 15 | Accustomed B<awk> users should take special note of the following: |
| 16 | |
| 17 | =over 4 |
| 18 | |
| 19 | =item * |
| 20 | |
| 21 | The English module, loaded via |
| 22 | |
| 23 | use English; |
| 24 | |
| 25 | allows you to refer to special variables (like C<$/>) with names (like |
| 26 | $RS), as though they were in B<awk>; see L<perlvar> for details. |
| 27 | |
| 28 | =item * |
| 29 | |
| 30 | Semicolons are required after all simple statements in Perl (except |
| 31 | at the end of a block). Newline is not a statement delimiter. |
| 32 | |
| 33 | =item * |
| 34 | |
| 35 | Curly brackets are required on C<if>s and C<while>s. |
| 36 | |
| 37 | =item * |
| 38 | |
| 39 | Variables begin with "$", "@" or "%" in Perl. |
| 40 | |
| 41 | =item * |
| 42 | |
| 43 | Arrays index from 0. Likewise string positions in substr() and |
| 44 | index(). |
| 45 | |
| 46 | =item * |
| 47 | |
| 48 | You have to decide whether your array has numeric or string indices. |
| 49 | |
| 50 | =item * |
| 51 | |
| 52 | Hash values do not spring into existence upon mere reference. |
| 53 | |
| 54 | =item * |
| 55 | |
| 56 | You have to decide whether you want to use string or numeric |
| 57 | comparisons. |
| 58 | |
| 59 | =item * |
| 60 | |
| 61 | Reading an input line does not split it for you. You get to split it |
| 62 | to an array yourself. And the split() operator has different |
| 63 | arguments than B<awk>'s. |
| 64 | |
| 65 | =item * |
| 66 | |
| 67 | The current input line is normally in $_, not $0. It generally does |
| 68 | not have the newline stripped. ($0 is the name of the program |
| 69 | executed.) See L<perlvar>. |
| 70 | |
| 71 | =item * |
| 72 | |
| 73 | $<I<digit>> does not refer to fields--it refers to substrings matched |
| 74 | by the last match pattern. |
| 75 | |
| 76 | =item * |
| 77 | |
| 78 | The print() statement does not add field and record separators unless |
| 79 | you set C<$,> and C<$\>. You can set $OFS and $ORS if you're using |
| 80 | the English module. |
| 81 | |
| 82 | =item * |
| 83 | |
| 84 | You must open your files before you print to them. |
| 85 | |
| 86 | =item * |
| 87 | |
| 88 | The range operator is "..", not comma. The comma operator works as in |
| 89 | C. |
| 90 | |
| 91 | =item * |
| 92 | |
| 93 | The match operator is "=~", not "~". ("~" is the one's complement |
| 94 | operator, as in C.) |
| 95 | |
| 96 | =item * |
| 97 | |
| 98 | The exponentiation operator is "**", not "^". "^" is the XOR |
| 99 | operator, as in C. (You know, one could get the feeling that B<awk> is |
| 100 | basically incompatible with C.) |
| 101 | |
| 102 | =item * |
| 103 | |
| 104 | The concatenation operator is ".", not the null string. (Using the |
| 105 | null string would render C</pat/ /pat/> unparsable, because the third slash |
| 106 | would be interpreted as a division operator--the tokenizer is in fact |
| 107 | slightly context sensitive for operators like "/", "?", and ">". |
| 108 | And in fact, "." itself can be the beginning of a number.) |
| 109 | |
| 110 | =item * |
| 111 | |
| 112 | The C<next>, C<exit>, and C<continue> keywords work differently. |
| 113 | |
| 114 | =item * |
| 115 | |
| 116 | |
| 117 | The following variables work differently: |
| 118 | |
| 119 | Awk Perl |
| 120 | ARGC scalar @ARGV (compare with $#ARGV) |
| 121 | ARGV[0] $0 |
| 122 | FILENAME $ARGV |
| 123 | FNR $. - something |
| 124 | FS (whatever you like) |
| 125 | NF $#Fld, or some such |
| 126 | NR $. |
| 127 | OFMT $# |
| 128 | OFS $, |
| 129 | ORS $\ |
| 130 | RLENGTH length($&) |
| 131 | RS $/ |
| 132 | RSTART length($`) |
| 133 | SUBSEP $; |
| 134 | |
| 135 | =item * |
| 136 | |
| 137 | You cannot set $RS to a pattern, only a string. |
| 138 | |
| 139 | =item * |
| 140 | |
| 141 | When in doubt, run the B<awk> construct through B<a2p> and see what it |
| 142 | gives you. |
| 143 | |
| 144 | =back |
| 145 | |
| 146 | =head2 C Traps |
| 147 | |
| 148 | Cerebral C programmers should take note of the following: |
| 149 | |
| 150 | =over 4 |
| 151 | |
| 152 | =item * |
| 153 | |
| 154 | Curly brackets are required on C<if>'s and C<while>'s. |
| 155 | |
| 156 | =item * |
| 157 | |
| 158 | You must use C<elsif> rather than C<else if>. |
| 159 | |
| 160 | =item * |
| 161 | |
| 162 | The C<break> and C<continue> keywords from C become in |
| 163 | Perl C<last> and C<next>, respectively. |
| 164 | Unlike in C, these do I<not> work within a C<do { } while> construct. |
| 165 | |
| 166 | =item * |
| 167 | |
| 168 | There's no switch statement. (But it's easy to build one on the fly.) |
| 169 | |
| 170 | =item * |
| 171 | |
| 172 | Variables begin with "$", "@" or "%" in Perl. |
| 173 | |
| 174 | =item * |
| 175 | |
| 176 | Comments begin with "#", not "/*". |
| 177 | |
| 178 | =item * |
| 179 | |
| 180 | You can't take the address of anything, although a similar operator |
| 181 | in Perl is the backslash, which creates a reference. |
| 182 | |
| 183 | =item * |
| 184 | |
| 185 | C<ARGV> must be capitalized. C<$ARGV[0]> is C's C<argv[1]>, and C<argv[0]> |
| 186 | ends up in C<$0>. |
| 187 | |
| 188 | =item * |
| 189 | |
| 190 | System calls such as link(), unlink(), rename(), etc. return nonzero for |
| 191 | success, not 0. (system(), however, returns zero for success.) |
| 192 | |
| 193 | =item * |
| 194 | |
| 195 | Signal handlers deal with signal names, not numbers. Use C<kill -l> |
| 196 | to find their names on your system. |
| 197 | |
| 198 | =back |
| 199 | |
| 200 | =head2 Sed Traps |
| 201 | |
| 202 | Seasoned B<sed> programmers should take note of the following: |
| 203 | |
| 204 | =over 4 |
| 205 | |
| 206 | =item * |
| 207 | |
| 208 | Backreferences in substitutions use "$" rather than "\". |
| 209 | |
| 210 | =item * |
| 211 | |
| 212 | The pattern matching metacharacters "(", ")", and "|" do not have backslashes |
| 213 | in front. |
| 214 | |
| 215 | =item * |
| 216 | |
| 217 | The range operator is C<...>, rather than comma. |
| 218 | |
| 219 | =back |
| 220 | |
| 221 | =head2 Shell Traps |
| 222 | |
| 223 | Sharp shell programmers should take note of the following: |
| 224 | |
| 225 | =over 4 |
| 226 | |
| 227 | =item * |
| 228 | |
| 229 | The backtick operator does variable interpolation without regard to |
| 230 | the presence of single quotes in the command. |
| 231 | |
| 232 | =item * |
| 233 | |
| 234 | The backtick operator does no translation of the return value, unlike B<csh>. |
| 235 | |
| 236 | =item * |
| 237 | |
| 238 | Shells (especially B<csh>) do several levels of substitution on each |
| 239 | command line. Perl does substitution in only certain constructs |
| 240 | such as double quotes, backticks, angle brackets, and search patterns. |
| 241 | |
| 242 | =item * |
| 243 | |
| 244 | Shells interpret scripts a little bit at a time. Perl compiles the |
| 245 | entire program before executing it (except for C<BEGIN> blocks, which |
| 246 | execute at compile time). |
| 247 | |
| 248 | =item * |
| 249 | |
| 250 | The arguments are available via @ARGV, not $1, $2, etc. |
| 251 | |
| 252 | =item * |
| 253 | |
| 254 | The environment is not automatically made available as separate scalar |
| 255 | variables. |
| 256 | |
| 257 | =back |
| 258 | |
| 259 | =head2 Perl Traps |
| 260 | |
| 261 | Practicing Perl Programmers should take note of the following: |
| 262 | |
| 263 | =over 4 |
| 264 | |
| 265 | =item * |
| 266 | |
| 267 | Remember that many operations behave differently in a list |
| 268 | context than they do in a scalar one. See L<perldata> for details. |
| 269 | |
| 270 | =item * |
| 271 | |
| 272 | Avoid barewords if you can, especially all lowercase ones. |
| 273 | You can't tell by just looking at it whether a bareword is |
| 274 | a function or a string. By using quotes on strings and |
| 275 | parentheses on function calls, you won't ever get them confused. |
| 276 | |
| 277 | =item * |
| 278 | |
| 279 | You cannot discern from mere inspection which builtins |
| 280 | are unary operators (like chop() and chdir()) |
| 281 | and which are list operators (like print() and unlink()). |
| 282 | (Unless prototyped, user-defined subroutines can B<only> be list |
| 283 | operators, never unary ones.) See L<perlop> and L<perlsub>. |
| 284 | |
| 285 | =item * |
| 286 | |
| 287 | People have a hard time remembering that some functions |
| 288 | default to $_, or @ARGV, or whatever, but that others which |
| 289 | you might expect to do not. |
| 290 | |
| 291 | =item * |
| 292 | |
| 293 | The <FH> construct is not the name of the filehandle, it is a readline |
| 294 | operation on that handle. The data read is assigned to $_ only if the |
| 295 | file read is the sole condition in a while loop: |
| 296 | |
| 297 | while (<FH>) { } |
| 298 | while (defined($_ = <FH>)) { }.. |
| 299 | <FH>; # data discarded! |
| 300 | |
| 301 | =item * |
| 302 | |
| 303 | Remember not to use C<=> when you need C<=~>; |
| 304 | these two constructs are quite different: |
| 305 | |
| 306 | $x = /foo/; |
| 307 | $x =~ /foo/; |
| 308 | |
| 309 | =item * |
| 310 | |
| 311 | The C<do {}> construct isn't a real loop that you can use |
| 312 | loop control on. |
| 313 | |
| 314 | =item * |
| 315 | |
| 316 | Use C<my()> for local variables whenever you can get away with |
| 317 | it (but see L<perlform> for where you can't). |
| 318 | Using C<local()> actually gives a local value to a global |
| 319 | variable, which leaves you open to unforeseen side-effects |
| 320 | of dynamic scoping. |
| 321 | |
| 322 | =item * |
| 323 | |
| 324 | If you localize an exported variable in a module, its exported value will |
| 325 | not change. The local name becomes an alias to a new value but the |
| 326 | external name is still an alias for the original. |
| 327 | |
| 328 | =back |
| 329 | |
| 330 | =head2 Perl4 to Perl5 Traps |
| 331 | |
| 332 | Practicing Perl4 Programmers should take note of the following |
| 333 | Perl4-to-Perl5 specific traps. |
| 334 | |
| 335 | They're crudely ordered according to the following list: |
| 336 | |
| 337 | =over 4 |
| 338 | |
| 339 | =item Discontinuance, Deprecation, and BugFix traps |
| 340 | |
| 341 | Anything that's been fixed as a perl4 bug, removed as a perl4 feature |
| 342 | or deprecated as a perl4 feature with the intent to encourage usage of |
| 343 | some other perl5 feature. |
| 344 | |
| 345 | =item Parsing Traps |
| 346 | |
| 347 | Traps that appear to stem from the new parser. |
| 348 | |
| 349 | =item Numerical Traps |
| 350 | |
| 351 | Traps having to do with numerical or mathematical operators. |
| 352 | |
| 353 | =item General data type traps |
| 354 | |
| 355 | Traps involving perl standard data types. |
| 356 | |
| 357 | =item Context Traps - scalar, list contexts |
| 358 | |
| 359 | Traps related to context within lists, scalar statements/declarations. |
| 360 | |
| 361 | =item Precedence Traps |
| 362 | |
| 363 | Traps related to the precedence of parsing, evaluation, and execution of |
| 364 | code. |
| 365 | |
| 366 | =item General Regular Expression Traps using s///, etc. |
| 367 | |
| 368 | Traps related to the use of pattern matching. |
| 369 | |
| 370 | =item Subroutine, Signal, Sorting Traps |
| 371 | |
| 372 | Traps related to the use of signals and signal handlers, general subroutines, |
| 373 | and sorting, along with sorting subroutines. |
| 374 | |
| 375 | =item OS Traps |
| 376 | |
| 377 | OS-specific traps. |
| 378 | |
| 379 | =item DBM Traps |
| 380 | |
| 381 | Traps specific to the use of C<dbmopen()>, and specific dbm implementations. |
| 382 | |
| 383 | =item Unclassified Traps |
| 384 | |
| 385 | Everything else. |
| 386 | |
| 387 | =back |
| 388 | |
| 389 | If you find an example of a conversion trap that is not listed here, |
| 390 | please submit it to <F<perlbug@perl.org>> for inclusion. |
| 391 | Also note that at least some of these can be caught with the |
| 392 | C<use warnings> pragma or the B<-w> switch. |
| 393 | |
| 394 | =head2 Discontinuance, Deprecation, and BugFix traps |
| 395 | |
| 396 | Anything that has been discontinued, deprecated, or fixed as |
| 397 | a bug from perl4. |
| 398 | |
| 399 | =over 4 |
| 400 | |
| 401 | =item * Discontinuance |
| 402 | |
| 403 | Symbols starting with "_" are no longer forced into package main, except |
| 404 | for C<$_> itself (and C<@_>, etc.). |
| 405 | |
| 406 | package test; |
| 407 | $_legacy = 1; |
| 408 | |
| 409 | package main; |
| 410 | print "\$_legacy is ",$_legacy,"\n"; |
| 411 | |
| 412 | # perl4 prints: $_legacy is 1 |
| 413 | # perl5 prints: $_legacy is |
| 414 | |
| 415 | =item * Deprecation |
| 416 | |
| 417 | Double-colon is now a valid package separator in a variable name. Thus these |
| 418 | behave differently in perl4 vs. perl5, because the packages don't exist. |
| 419 | |
| 420 | $a=1;$b=2;$c=3;$var=4; |
| 421 | print "$a::$b::$c "; |
| 422 | print "$var::abc::xyz\n"; |
| 423 | |
| 424 | # perl4 prints: 1::2::3 4::abc::xyz |
| 425 | # perl5 prints: 3 |
| 426 | |
| 427 | Given that C<::> is now the preferred package delimiter, it is debatable |
| 428 | whether this should be classed as a bug or not. |
| 429 | (The older package delimiter, ' ,is used here) |
| 430 | |
| 431 | $x = 10 ; |
| 432 | print "x=${'x}\n" ; |
| 433 | |
| 434 | # perl4 prints: x=10 |
| 435 | # perl5 prints: Can't find string terminator "'" anywhere before EOF |
| 436 | |
| 437 | You can avoid this problem, and remain compatible with perl4, if you |
| 438 | always explicitly include the package name: |
| 439 | |
| 440 | $x = 10 ; |
| 441 | print "x=${main'x}\n" ; |
| 442 | |
| 443 | Also see precedence traps, for parsing C<$:>. |
| 444 | |
| 445 | =item * BugFix |
| 446 | |
| 447 | The second and third arguments of C<splice()> are now evaluated in scalar |
| 448 | context (as the Camel says) rather than list context. |
| 449 | |
| 450 | sub sub1{return(0,2) } # return a 2-element list |
| 451 | sub sub2{ return(1,2,3)} # return a 3-element list |
| 452 | @a1 = ("a","b","c","d","e"); |
| 453 | @a2 = splice(@a1,&sub1,&sub2); |
| 454 | print join(' ',@a2),"\n"; |
| 455 | |
| 456 | # perl4 prints: a b |
| 457 | # perl5 prints: c d e |
| 458 | |
| 459 | =item * Discontinuance |
| 460 | |
| 461 | You can't do a C<goto> into a block that is optimized away. Darn. |
| 462 | |
| 463 | goto marker1; |
| 464 | |
| 465 | for(1){ |
| 466 | marker1: |
| 467 | print "Here I is!\n"; |
| 468 | } |
| 469 | |
| 470 | # perl4 prints: Here I is! |
| 471 | # perl5 errors: Can't "goto" into the middle of a foreach loop |
| 472 | |
| 473 | =item * Discontinuance |
| 474 | |
| 475 | It is no longer syntactically legal to use whitespace as the name |
| 476 | of a variable, or as a delimiter for any kind of quote construct. |
| 477 | Double darn. |
| 478 | |
| 479 | $a = ("foo bar"); |
| 480 | $b = q baz ; |
| 481 | print "a is $a, b is $b\n"; |
| 482 | |
| 483 | # perl4 prints: a is foo bar, b is baz |
| 484 | # perl5 errors: Bareword found where operator expected |
| 485 | |
| 486 | =item * Discontinuance |
| 487 | |
| 488 | The archaic while/if BLOCK BLOCK syntax is no longer supported. |
| 489 | |
| 490 | if { 1 } { |
| 491 | print "True!"; |
| 492 | } |
| 493 | else { |
| 494 | print "False!"; |
| 495 | } |
| 496 | |
| 497 | # perl4 prints: True! |
| 498 | # perl5 errors: syntax error at test.pl line 1, near "if {" |
| 499 | |
| 500 | =item * BugFix |
| 501 | |
| 502 | The C<**> operator now binds more tightly than unary minus. |
| 503 | It was documented to work this way before, but didn't. |
| 504 | |
| 505 | print -4**2,"\n"; |
| 506 | |
| 507 | # perl4 prints: 16 |
| 508 | # perl5 prints: -16 |
| 509 | |
| 510 | =item * Discontinuance |
| 511 | |
| 512 | The meaning of C<foreach{}> has changed slightly when it is iterating over a |
| 513 | list which is not an array. This used to assign the list to a |
| 514 | temporary array, but no longer does so (for efficiency). This means |
| 515 | that you'll now be iterating over the actual values, not over copies of |
| 516 | the values. Modifications to the loop variable can change the original |
| 517 | values. |
| 518 | |
| 519 | @list = ('ab','abc','bcd','def'); |
| 520 | foreach $var (grep(/ab/,@list)){ |
| 521 | $var = 1; |
| 522 | } |
| 523 | print (join(':',@list)); |
| 524 | |
| 525 | # perl4 prints: ab:abc:bcd:def |
| 526 | # perl5 prints: 1:1:bcd:def |
| 527 | |
| 528 | To retain Perl4 semantics you need to assign your list |
| 529 | explicitly to a temporary array and then iterate over that. For |
| 530 | example, you might need to change |
| 531 | |
| 532 | foreach $var (grep(/ab/,@list)){ |
| 533 | |
| 534 | to |
| 535 | |
| 536 | foreach $var (@tmp = grep(/ab/,@list)){ |
| 537 | |
| 538 | Otherwise changing $var will clobber the values of @list. (This most often |
| 539 | happens when you use C<$_> for the loop variable, and call subroutines in |
| 540 | the loop that don't properly localize C<$_>.) |
| 541 | |
| 542 | =item * Discontinuance |
| 543 | |
| 544 | C<split> with no arguments now behaves like C<split ' '> (which doesn't |
| 545 | return an initial null field if $_ starts with whitespace), it used to |
| 546 | behave like C<split /\s+/> (which does). |
| 547 | |
| 548 | $_ = ' hi mom'; |
| 549 | print join(':', split); |
| 550 | |
| 551 | # perl4 prints: :hi:mom |
| 552 | # perl5 prints: hi:mom |
| 553 | |
| 554 | =item * BugFix |
| 555 | |
| 556 | Perl 4 would ignore any text which was attached to an B<-e> switch, |
| 557 | always taking the code snippet from the following arg. Additionally, it |
| 558 | would silently accept an B<-e> switch without a following arg. Both of |
| 559 | these behaviors have been fixed. |
| 560 | |
| 561 | perl -e'print "attached to -e"' 'print "separate arg"' |
| 562 | |
| 563 | # perl4 prints: separate arg |
| 564 | # perl5 prints: attached to -e |
| 565 | |
| 566 | perl -e |
| 567 | |
| 568 | # perl4 prints: |
| 569 | # perl5 dies: No code specified for -e. |
| 570 | |
| 571 | =item * Discontinuance |
| 572 | |
| 573 | In Perl 4 the return value of C<push> was undocumented, but it was |
| 574 | actually the last value being pushed onto the target list. In Perl 5 |
| 575 | the return value of C<push> is documented, but has changed, it is the |
| 576 | number of elements in the resulting list. |
| 577 | |
| 578 | @x = ('existing'); |
| 579 | print push(@x, 'first new', 'second new'); |
| 580 | |
| 581 | # perl4 prints: second new |
| 582 | # perl5 prints: 3 |
| 583 | |
| 584 | =item * Deprecation |
| 585 | |
| 586 | Some error messages will be different. |
| 587 | |
| 588 | =item * Discontinuance |
| 589 | |
| 590 | In Perl 4, if in list context the delimiters to the first argument of |
| 591 | C<split()> were C<??>, the result would be placed in C<@_> as well as |
| 592 | being returned. Perl 5 has more respect for your subroutine arguments. |
| 593 | |
| 594 | =item * Discontinuance |
| 595 | |
| 596 | Some bugs may have been inadvertently removed. :-) |
| 597 | |
| 598 | =back |
| 599 | |
| 600 | =head2 Parsing Traps |
| 601 | |
| 602 | Perl4-to-Perl5 traps from having to do with parsing. |
| 603 | |
| 604 | =over 4 |
| 605 | |
| 606 | =item * Parsing |
| 607 | |
| 608 | Note the space between . and = |
| 609 | |
| 610 | $string . = "more string"; |
| 611 | print $string; |
| 612 | |
| 613 | # perl4 prints: more string |
| 614 | # perl5 prints: syntax error at - line 1, near ". =" |
| 615 | |
| 616 | =item * Parsing |
| 617 | |
| 618 | Better parsing in perl 5 |
| 619 | |
| 620 | sub foo {} |
| 621 | &foo |
| 622 | print("hello, world\n"); |
| 623 | |
| 624 | # perl4 prints: hello, world |
| 625 | # perl5 prints: syntax error |
| 626 | |
| 627 | =item * Parsing |
| 628 | |
| 629 | "if it looks like a function, it is a function" rule. |
| 630 | |
| 631 | print |
| 632 | ($foo == 1) ? "is one\n" : "is zero\n"; |
| 633 | |
| 634 | # perl4 prints: is zero |
| 635 | # perl5 warns: "Useless use of a constant in void context" if using -w |
| 636 | |
| 637 | =item * Parsing |
| 638 | |
| 639 | String interpolation of the C<$#array> construct differs when braces |
| 640 | are to used around the name. |
| 641 | |
| 642 | @a = (1..3); |
| 643 | print "${#a}"; |
| 644 | |
| 645 | # perl4 prints: 2 |
| 646 | # perl5 fails with syntax error |
| 647 | |
| 648 | @ = (1..3); |
| 649 | print "$#{a}"; |
| 650 | |
| 651 | # perl4 prints: {a} |
| 652 | # perl5 prints: 2 |
| 653 | |
| 654 | =item * Parsing |
| 655 | |
| 656 | When perl sees C<map {> (or C<grep {>), it has to guess whether the C<{> |
| 657 | starts a BLOCK or a hash reference. If it guesses wrong, it will report |
| 658 | a syntax error near the C<}> and the missing (or unexpected) comma. |
| 659 | |
| 660 | Use unary C<+> before C<{> on a hash reference, and unary C<+> applied |
| 661 | to the first thing in a BLOCK (after C<{>), for perl to guess right all |
| 662 | the time. (See L<perlfunc/map>.) |
| 663 | |
| 664 | =back |
| 665 | |
| 666 | =head2 Numerical Traps |
| 667 | |
| 668 | Perl4-to-Perl5 traps having to do with numerical operators, |
| 669 | operands, or output from same. |
| 670 | |
| 671 | =over 5 |
| 672 | |
| 673 | =item * Numerical |
| 674 | |
| 675 | Formatted output and significant digits. In general, Perl 5 |
| 676 | tries to be more precise. For example, on a Solaris Sparc: |
| 677 | |
| 678 | print 7.373504 - 0, "\n"; |
| 679 | printf "%20.18f\n", 7.373504 - 0; |
| 680 | |
| 681 | # Perl4 prints: |
| 682 | 7.3750399999999996141 |
| 683 | 7.375039999999999614 |
| 684 | |
| 685 | # Perl5 prints: |
| 686 | 7.373504 |
| 687 | 7.375039999999999614 |
| 688 | |
| 689 | Notice how the first result looks better in Perl 5. |
| 690 | |
| 691 | Your results may vary, since your floating point formatting routines |
| 692 | and even floating point format may be slightly different. |
| 693 | |
| 694 | =item * Numerical |
| 695 | |
| 696 | This specific item has been deleted. It demonstrated how the auto-increment |
| 697 | operator would not catch when a number went over the signed int limit. Fixed |
| 698 | in version 5.003_04. But always be wary when using large integers. |
| 699 | If in doubt: |
| 700 | |
| 701 | use Math::BigInt; |
| 702 | |
| 703 | =item * Numerical |
| 704 | |
| 705 | Assignment of return values from numeric equality tests |
| 706 | does not work in perl5 when the test evaluates to false (0). |
| 707 | Logical tests now return a null, instead of 0 |
| 708 | |
| 709 | $p = ($test == 1); |
| 710 | print $p,"\n"; |
| 711 | |
| 712 | # perl4 prints: 0 |
| 713 | # perl5 prints: |
| 714 | |
| 715 | Also see L<"General Regular Expression Traps using s///, etc."> |
| 716 | for another example of this new feature... |
| 717 | |
| 718 | =item * Bitwise string ops |
| 719 | |
| 720 | When bitwise operators which can operate upon either numbers or |
| 721 | strings (C<& | ^ ~>) are given only strings as arguments, perl4 would |
| 722 | treat the operands as bitstrings so long as the program contained a call |
| 723 | to the C<vec()> function. perl5 treats the string operands as bitstrings. |
| 724 | (See L<perlop/Bitwise String Operators> for more details.) |
| 725 | |
| 726 | $fred = "10"; |
| 727 | $barney = "12"; |
| 728 | $betty = $fred & $barney; |
| 729 | print "$betty\n"; |
| 730 | # Uncomment the next line to change perl4's behavior |
| 731 | # ($dummy) = vec("dummy", 0, 0); |
| 732 | |
| 733 | # Perl4 prints: |
| 734 | 8 |
| 735 | |
| 736 | # Perl5 prints: |
| 737 | 10 |
| 738 | |
| 739 | # If vec() is used anywhere in the program, both print: |
| 740 | 10 |
| 741 | |
| 742 | =back |
| 743 | |
| 744 | =head2 General data type traps |
| 745 | |
| 746 | Perl4-to-Perl5 traps involving most data-types, and their usage |
| 747 | within certain expressions and/or context. |
| 748 | |
| 749 | =over 5 |
| 750 | |
| 751 | =item * (Arrays) |
| 752 | |
| 753 | Negative array subscripts now count from the end of the array. |
| 754 | |
| 755 | @a = (1, 2, 3, 4, 5); |
| 756 | print "The third element of the array is $a[3] also expressed as $a[-2] \n"; |
| 757 | |
| 758 | # perl4 prints: The third element of the array is 4 also expressed as |
| 759 | # perl5 prints: The third element of the array is 4 also expressed as 4 |
| 760 | |
| 761 | =item * (Arrays) |
| 762 | |
| 763 | Setting C<$#array> lower now discards array elements, and makes them |
| 764 | impossible to recover. |
| 765 | |
| 766 | @a = (a,b,c,d,e); |
| 767 | print "Before: ",join('',@a); |
| 768 | $#a =1; |
| 769 | print ", After: ",join('',@a); |
| 770 | $#a =3; |
| 771 | print ", Recovered: ",join('',@a),"\n"; |
| 772 | |
| 773 | # perl4 prints: Before: abcde, After: ab, Recovered: abcd |
| 774 | # perl5 prints: Before: abcde, After: ab, Recovered: ab |
| 775 | |
| 776 | =item * (Hashes) |
| 777 | |
| 778 | Hashes get defined before use |
| 779 | |
| 780 | local($s,@a,%h); |
| 781 | die "scalar \$s defined" if defined($s); |
| 782 | die "array \@a defined" if defined(@a); |
| 783 | die "hash \%h defined" if defined(%h); |
| 784 | |
| 785 | # perl4 prints: |
| 786 | # perl5 dies: hash %h defined |
| 787 | |
| 788 | Perl will now generate a warning when it sees defined(@a) and |
| 789 | defined(%h). |
| 790 | |
| 791 | =item * (Globs) |
| 792 | |
| 793 | glob assignment from variable to variable will fail if the assigned |
| 794 | variable is localized subsequent to the assignment |
| 795 | |
| 796 | @a = ("This is Perl 4"); |
| 797 | *b = *a; |
| 798 | local(@a); |
| 799 | print @b,"\n"; |
| 800 | |
| 801 | # perl4 prints: This is Perl 4 |
| 802 | # perl5 prints: |
| 803 | |
| 804 | =item * (Globs) |
| 805 | |
| 806 | Assigning C<undef> to a glob has no effect in Perl 5. In Perl 4 |
| 807 | it undefines the associated scalar (but may have other side effects |
| 808 | including SEGVs). Perl 5 will also warn if C<undef> is assigned to a |
| 809 | typeglob. (Note that assigning C<undef> to a typeglob is different |
| 810 | than calling the C<undef> function on a typeglob (C<undef *foo>), which |
| 811 | has quite a few effects. |
| 812 | |
| 813 | $foo = "bar"; |
| 814 | *foo = undef; |
| 815 | print $foo; |
| 816 | |
| 817 | # perl4 prints: |
| 818 | # perl4 warns: "Use of uninitialized variable" if using -w |
| 819 | # perl5 prints: bar |
| 820 | # perl5 warns: "Undefined value assigned to typeglob" if using -w |
| 821 | |
| 822 | =item * (Scalar String) |
| 823 | |
| 824 | Changes in unary negation (of strings) |
| 825 | This change effects both the return value and what it |
| 826 | does to auto(magic)increment. |
| 827 | |
| 828 | $x = "aaa"; |
| 829 | print ++$x," : "; |
| 830 | print -$x," : "; |
| 831 | print ++$x,"\n"; |
| 832 | |
| 833 | # perl4 prints: aab : -0 : 1 |
| 834 | # perl5 prints: aab : -aab : aac |
| 835 | |
| 836 | =item * (Constants) |
| 837 | |
| 838 | perl 4 lets you modify constants: |
| 839 | |
| 840 | $foo = "x"; |
| 841 | &mod($foo); |
| 842 | for ($x = 0; $x < 3; $x++) { |
| 843 | &mod("a"); |
| 844 | } |
| 845 | sub mod { |
| 846 | print "before: $_[0]"; |
| 847 | $_[0] = "m"; |
| 848 | print " after: $_[0]\n"; |
| 849 | } |
| 850 | |
| 851 | # perl4: |
| 852 | # before: x after: m |
| 853 | # before: a after: m |
| 854 | # before: m after: m |
| 855 | # before: m after: m |
| 856 | |
| 857 | # Perl5: |
| 858 | # before: x after: m |
| 859 | # Modification of a read-only value attempted at foo.pl line 12. |
| 860 | # before: a |
| 861 | |
| 862 | =item * (Scalars) |
| 863 | |
| 864 | The behavior is slightly different for: |
| 865 | |
| 866 | print "$x", defined $x |
| 867 | |
| 868 | # perl 4: 1 |
| 869 | # perl 5: <no output, $x is not called into existence> |
| 870 | |
| 871 | =item * (Variable Suicide) |
| 872 | |
| 873 | Variable suicide behavior is more consistent under Perl 5. |
| 874 | Perl5 exhibits the same behavior for hashes and scalars, |
| 875 | that perl4 exhibits for only scalars. |
| 876 | |
| 877 | $aGlobal{ "aKey" } = "global value"; |
| 878 | print "MAIN:", $aGlobal{"aKey"}, "\n"; |
| 879 | $GlobalLevel = 0; |
| 880 | &test( *aGlobal ); |
| 881 | |
| 882 | sub test { |
| 883 | local( *theArgument ) = @_; |
| 884 | local( %aNewLocal ); # perl 4 != 5.001l,m |
| 885 | $aNewLocal{"aKey"} = "this should never appear"; |
| 886 | print "SUB: ", $theArgument{"aKey"}, "\n"; |
| 887 | $aNewLocal{"aKey"} = "level $GlobalLevel"; # what should print |
| 888 | $GlobalLevel++; |
| 889 | if( $GlobalLevel<4 ) { |
| 890 | &test( *aNewLocal ); |
| 891 | } |
| 892 | } |
| 893 | |
| 894 | # Perl4: |
| 895 | # MAIN:global value |
| 896 | # SUB: global value |
| 897 | # SUB: level 0 |
| 898 | # SUB: level 1 |
| 899 | # SUB: level 2 |
| 900 | |
| 901 | # Perl5: |
| 902 | # MAIN:global value |
| 903 | # SUB: global value |
| 904 | # SUB: this should never appear |
| 905 | # SUB: this should never appear |
| 906 | # SUB: this should never appear |
| 907 | |
| 908 | =back |
| 909 | |
| 910 | =head2 Context Traps - scalar, list contexts |
| 911 | |
| 912 | =over 5 |
| 913 | |
| 914 | =item * (list context) |
| 915 | |
| 916 | The elements of argument lists for formats are now evaluated in list |
| 917 | context. This means you can interpolate list values now. |
| 918 | |
| 919 | @fmt = ("foo","bar","baz"); |
| 920 | format STDOUT= |
| 921 | @<<<<< @||||| @>>>>> |
| 922 | @fmt; |
| 923 | . |
| 924 | write; |
| 925 | |
| 926 | # perl4 errors: Please use commas to separate fields in file |
| 927 | # perl5 prints: foo bar baz |
| 928 | |
| 929 | =item * (scalar context) |
| 930 | |
| 931 | The C<caller()> function now returns a false value in a scalar context |
| 932 | if there is no caller. This lets library files determine if they're |
| 933 | being required. |
| 934 | |
| 935 | caller() ? (print "You rang?\n") : (print "Got a 0\n"); |
| 936 | |
| 937 | # perl4 errors: There is no caller |
| 938 | # perl5 prints: Got a 0 |
| 939 | |
| 940 | =item * (scalar context) |
| 941 | |
| 942 | The comma operator in a scalar context is now guaranteed to give a |
| 943 | scalar context to its arguments. |
| 944 | |
| 945 | @y= ('a','b','c'); |
| 946 | $x = (1, 2, @y); |
| 947 | print "x = $x\n"; |
| 948 | |
| 949 | # Perl4 prints: x = c # Thinks list context interpolates list |
| 950 | # Perl5 prints: x = 3 # Knows scalar uses length of list |
| 951 | |
| 952 | =item * (list, builtin) |
| 953 | |
| 954 | C<sprintf()> is prototyped as ($;@), so its first argument is given scalar |
| 955 | context. Thus, if passed an array, it will probably not do what you want, |
| 956 | unlike Perl 4: |
| 957 | |
| 958 | @z = ('%s%s', 'foo', 'bar'); |
| 959 | $x = sprintf(@z); |
| 960 | print $x; |
| 961 | |
| 962 | # perl4 prints: foobar |
| 963 | # perl5 prints: 3 |
| 964 | |
| 965 | C<printf()> works the same as it did in Perl 4, though: |
| 966 | |
| 967 | @z = ('%s%s', 'foo', 'bar'); |
| 968 | printf STDOUT (@z); |
| 969 | |
| 970 | # perl4 prints: foobar |
| 971 | # perl5 prints: foobar |
| 972 | |
| 973 | =back |
| 974 | |
| 975 | =head2 Precedence Traps |
| 976 | |
| 977 | Perl4-to-Perl5 traps involving precedence order. |
| 978 | |
| 979 | Perl 4 has almost the same precedence rules as Perl 5 for the operators |
| 980 | that they both have. Perl 4 however, seems to have had some |
| 981 | inconsistencies that made the behavior differ from what was documented. |
| 982 | |
| 983 | =over 5 |
| 984 | |
| 985 | =item * Precedence |
| 986 | |
| 987 | LHS vs. RHS of any assignment operator. LHS is evaluated first |
| 988 | in perl4, second in perl5; this can affect the relationship |
| 989 | between side-effects in sub-expressions. |
| 990 | |
| 991 | @arr = ( 'left', 'right' ); |
| 992 | $a{shift @arr} = shift @arr; |
| 993 | print join( ' ', keys %a ); |
| 994 | |
| 995 | # perl4 prints: left |
| 996 | # perl5 prints: right |
| 997 | |
| 998 | =item * Precedence |
| 999 | |
| 1000 | These are now semantic errors because of precedence: |
| 1001 | |
| 1002 | @list = (1,2,3,4,5); |
| 1003 | %map = ("a",1,"b",2,"c",3,"d",4); |
| 1004 | $n = shift @list + 2; # first item in list plus 2 |
| 1005 | print "n is $n, "; |
| 1006 | $m = keys %map + 2; # number of items in hash plus 2 |
| 1007 | print "m is $m\n"; |
| 1008 | |
| 1009 | # perl4 prints: n is 3, m is 6 |
| 1010 | # perl5 errors and fails to compile |
| 1011 | |
| 1012 | =item * Precedence |
| 1013 | |
| 1014 | The precedence of assignment operators is now the same as the precedence |
| 1015 | of assignment. Perl 4 mistakenly gave them the precedence of the associated |
| 1016 | operator. So you now must parenthesize them in expressions like |
| 1017 | |
| 1018 | /foo/ ? ($a += 2) : ($a -= 2); |
| 1019 | |
| 1020 | Otherwise |
| 1021 | |
| 1022 | /foo/ ? $a += 2 : $a -= 2 |
| 1023 | |
| 1024 | would be erroneously parsed as |
| 1025 | |
| 1026 | (/foo/ ? $a += 2 : $a) -= 2; |
| 1027 | |
| 1028 | On the other hand, |
| 1029 | |
| 1030 | $a += /foo/ ? 1 : 2; |
| 1031 | |
| 1032 | now works as a C programmer would expect. |
| 1033 | |
| 1034 | =item * Precedence |
| 1035 | |
| 1036 | open FOO || die; |
| 1037 | |
| 1038 | is now incorrect. You need parentheses around the filehandle. |
| 1039 | Otherwise, perl5 leaves the statement as its default precedence: |
| 1040 | |
| 1041 | open(FOO || die); |
| 1042 | |
| 1043 | # perl4 opens or dies |
| 1044 | # perl5 opens FOO, dying only if 'FOO' is false, i.e. never |
| 1045 | |
| 1046 | =item * Precedence |
| 1047 | |
| 1048 | perl4 gives the special variable, C<$:> precedence, where perl5 |
| 1049 | treats C<$::> as main C<package> |
| 1050 | |
| 1051 | $a = "x"; print "$::a"; |
| 1052 | |
| 1053 | # perl 4 prints: -:a |
| 1054 | # perl 5 prints: x |
| 1055 | |
| 1056 | =item * Precedence |
| 1057 | |
| 1058 | perl4 had buggy precedence for the file test operators vis-a-vis |
| 1059 | the assignment operators. Thus, although the precedence table |
| 1060 | for perl4 leads one to believe C<-e $foo .= "q"> should parse as |
| 1061 | C<((-e $foo) .= "q")>, it actually parses as C<(-e ($foo .= "q"))>. |
| 1062 | In perl5, the precedence is as documented. |
| 1063 | |
| 1064 | -e $foo .= "q" |
| 1065 | |
| 1066 | # perl4 prints: no output |
| 1067 | # perl5 prints: Can't modify -e in concatenation |
| 1068 | |
| 1069 | =item * Precedence |
| 1070 | |
| 1071 | In perl4, keys(), each() and values() were special high-precedence operators |
| 1072 | that operated on a single hash, but in perl5, they are regular named unary |
| 1073 | operators. As documented, named unary operators have lower precedence |
| 1074 | than the arithmetic and concatenation operators C<+ - .>, but the perl4 |
| 1075 | variants of these operators actually bind tighter than C<+ - .>. |
| 1076 | Thus, for: |
| 1077 | |
| 1078 | %foo = 1..10; |
| 1079 | print keys %foo - 1 |
| 1080 | |
| 1081 | # perl4 prints: 4 |
| 1082 | # perl5 prints: Type of arg 1 to keys must be hash (not subtraction) |
| 1083 | |
| 1084 | The perl4 behavior was probably more useful, if less consistent. |
| 1085 | |
| 1086 | =back |
| 1087 | |
| 1088 | =head2 General Regular Expression Traps using s///, etc. |
| 1089 | |
| 1090 | All types of RE traps. |
| 1091 | |
| 1092 | =over 5 |
| 1093 | |
| 1094 | =item * Regular Expression |
| 1095 | |
| 1096 | C<s'$lhs'$rhs'> now does no interpolation on either side. It used to |
| 1097 | interpolate $lhs but not $rhs. (And still does not match a literal |
| 1098 | '$' in string) |
| 1099 | |
| 1100 | $a=1;$b=2; |
| 1101 | $string = '1 2 $a $b'; |
| 1102 | $string =~ s'$a'$b'; |
| 1103 | print $string,"\n"; |
| 1104 | |
| 1105 | # perl4 prints: $b 2 $a $b |
| 1106 | # perl5 prints: 1 2 $a $b |
| 1107 | |
| 1108 | =item * Regular Expression |
| 1109 | |
| 1110 | C<m//g> now attaches its state to the searched string rather than the |
| 1111 | regular expression. (Once the scope of a block is left for the sub, the |
| 1112 | state of the searched string is lost) |
| 1113 | |
| 1114 | $_ = "ababab"; |
| 1115 | while(m/ab/g){ |
| 1116 | &doit("blah"); |
| 1117 | } |
| 1118 | sub doit{local($_) = shift; print "Got $_ "} |
| 1119 | |
| 1120 | # perl4 prints: Got blah Got blah Got blah Got blah |
| 1121 | # perl5 prints: infinite loop blah... |
| 1122 | |
| 1123 | =item * Regular Expression |
| 1124 | |
| 1125 | Currently, if you use the C<m//o> qualifier on a regular expression |
| 1126 | within an anonymous sub, I<all> closures generated from that anonymous |
| 1127 | sub will use the regular expression as it was compiled when it was used |
| 1128 | the very first time in any such closure. For instance, if you say |
| 1129 | |
| 1130 | sub build_match { |
| 1131 | my($left,$right) = @_; |
| 1132 | return sub { $_[0] =~ /$left stuff $right/o; }; |
| 1133 | } |
| 1134 | $good = build_match('foo','bar'); |
| 1135 | $bad = build_match('baz','blarch'); |
| 1136 | print $good->('foo stuff bar') ? "ok\n" : "not ok\n"; |
| 1137 | print $bad->('baz stuff blarch') ? "ok\n" : "not ok\n"; |
| 1138 | print $bad->('foo stuff bar') ? "not ok\n" : "ok\n"; |
| 1139 | |
| 1140 | For most builds of Perl5, this will print: |
| 1141 | ok |
| 1142 | not ok |
| 1143 | not ok |
| 1144 | |
| 1145 | build_match() will always return a sub which matches the contents of |
| 1146 | $left and $right as they were the I<first> time that build_match() |
| 1147 | was called, not as they are in the current call. |
| 1148 | |
| 1149 | =item * Regular Expression |
| 1150 | |
| 1151 | If no parentheses are used in a match, Perl4 sets C<$+> to |
| 1152 | the whole match, just like C<$&>. Perl5 does not. |
| 1153 | |
| 1154 | "abcdef" =~ /b.*e/; |
| 1155 | print "\$+ = $+\n"; |
| 1156 | |
| 1157 | # perl4 prints: bcde |
| 1158 | # perl5 prints: |
| 1159 | |
| 1160 | =item * Regular Expression |
| 1161 | |
| 1162 | substitution now returns the null string if it fails |
| 1163 | |
| 1164 | $string = "test"; |
| 1165 | $value = ($string =~ s/foo//); |
| 1166 | print $value, "\n"; |
| 1167 | |
| 1168 | # perl4 prints: 0 |
| 1169 | # perl5 prints: |
| 1170 | |
| 1171 | Also see L<Numerical Traps> for another example of this new feature. |
| 1172 | |
| 1173 | =item * Regular Expression |
| 1174 | |
| 1175 | C<s`lhs`rhs`> (using backticks) is now a normal substitution, with no |
| 1176 | backtick expansion |
| 1177 | |
| 1178 | $string = ""; |
| 1179 | $string =~ s`^`hostname`; |
| 1180 | print $string, "\n"; |
| 1181 | |
| 1182 | # perl4 prints: <the local hostname> |
| 1183 | # perl5 prints: hostname |
| 1184 | |
| 1185 | =item * Regular Expression |
| 1186 | |
| 1187 | Stricter parsing of variables used in regular expressions |
| 1188 | |
| 1189 | s/^([^$grpc]*$grpc[$opt$plus$rep]?)//o; |
| 1190 | |
| 1191 | # perl4: compiles w/o error |
| 1192 | # perl5: with Scalar found where operator expected ..., near "$opt$plus" |
| 1193 | |
| 1194 | an added component of this example, apparently from the same script, is |
| 1195 | the actual value of the s'd string after the substitution. |
| 1196 | C<[$opt]> is a character class in perl4 and an array subscript in perl5 |
| 1197 | |
| 1198 | $grpc = 'a'; |
| 1199 | $opt = 'r'; |
| 1200 | $_ = 'bar'; |
| 1201 | s/^([^$grpc]*$grpc[$opt]?)/foo/; |
| 1202 | print ; |
| 1203 | |
| 1204 | # perl4 prints: foo |
| 1205 | # perl5 prints: foobar |
| 1206 | |
| 1207 | =item * Regular Expression |
| 1208 | |
| 1209 | Under perl5, C<m?x?> matches only once, like C<?x?>. Under perl4, it matched |
| 1210 | repeatedly, like C</x/> or C<m!x!>. |
| 1211 | |
| 1212 | $test = "once"; |
| 1213 | sub match { $test =~ m?once?; } |
| 1214 | &match(); |
| 1215 | if( &match() ) { |
| 1216 | # m?x? matches more then once |
| 1217 | print "perl4\n"; |
| 1218 | } else { |
| 1219 | # m?x? matches only once |
| 1220 | print "perl5\n"; |
| 1221 | } |
| 1222 | |
| 1223 | # perl4 prints: perl4 |
| 1224 | # perl5 prints: perl5 |
| 1225 | |
| 1226 | |
| 1227 | =back |
| 1228 | |
| 1229 | =head2 Subroutine, Signal, Sorting Traps |
| 1230 | |
| 1231 | The general group of Perl4-to-Perl5 traps having to do with |
| 1232 | Signals, Sorting, and their related subroutines, as well as |
| 1233 | general subroutine traps. Includes some OS-Specific traps. |
| 1234 | |
| 1235 | =over 5 |
| 1236 | |
| 1237 | =item * (Signals) |
| 1238 | |
| 1239 | Barewords that used to look like strings to Perl will now look like subroutine |
| 1240 | calls if a subroutine by that name is defined before the compiler sees them. |
| 1241 | |
| 1242 | sub SeeYa { warn"Hasta la vista, baby!" } |
| 1243 | $SIG{'TERM'} = SeeYa; |
| 1244 | print "SIGTERM is now $SIG{'TERM'}\n"; |
| 1245 | |
| 1246 | # perl4 prints: SIGTERM is now main'SeeYa |
| 1247 | # perl5 prints: SIGTERM is now main::1 (and warns "Hasta la vista, baby!") |
| 1248 | |
| 1249 | Use B<-w> to catch this one |
| 1250 | |
| 1251 | =item * (Sort Subroutine) |
| 1252 | |
| 1253 | reverse is no longer allowed as the name of a sort subroutine. |
| 1254 | |
| 1255 | sub reverse{ print "yup "; $a <=> $b } |
| 1256 | print sort reverse (2,1,3); |
| 1257 | |
| 1258 | # perl4 prints: yup yup 123 |
| 1259 | # perl5 prints: 123 |
| 1260 | # perl5 warns (if using -w): Ambiguous call resolved as CORE::reverse() |
| 1261 | |
| 1262 | =item * warn() won't let you specify a filehandle. |
| 1263 | |
| 1264 | Although it _always_ printed to STDERR, warn() would let you specify a |
| 1265 | filehandle in perl4. With perl5 it does not. |
| 1266 | |
| 1267 | warn STDERR "Foo!"; |
| 1268 | |
| 1269 | # perl4 prints: Foo! |
| 1270 | # perl5 prints: String found where operator expected |
| 1271 | |
| 1272 | =back |
| 1273 | |
| 1274 | =head2 OS Traps |
| 1275 | |
| 1276 | =over 5 |
| 1277 | |
| 1278 | =item * (SysV) |
| 1279 | |
| 1280 | Under HPUX, and some other SysV OSes, one had to reset any signal handler, |
| 1281 | within the signal handler function, each time a signal was handled with |
| 1282 | perl4. With perl5, the reset is now done correctly. Any code relying |
| 1283 | on the handler _not_ being reset will have to be reworked. |
| 1284 | |
| 1285 | Since version 5.002, Perl uses sigaction() under SysV. |
| 1286 | |
| 1287 | sub gotit { |
| 1288 | print "Got @_... "; |
| 1289 | } |
| 1290 | $SIG{'INT'} = 'gotit'; |
| 1291 | |
| 1292 | $| = 1; |
| 1293 | $pid = fork; |
| 1294 | if ($pid) { |
| 1295 | kill('INT', $pid); |
| 1296 | sleep(1); |
| 1297 | kill('INT', $pid); |
| 1298 | } else { |
| 1299 | while (1) {sleep(10);} |
| 1300 | } |
| 1301 | |
| 1302 | # perl4 (HPUX) prints: Got INT... |
| 1303 | # perl5 (HPUX) prints: Got INT... Got INT... |
| 1304 | |
| 1305 | =item * (SysV) |
| 1306 | |
| 1307 | Under SysV OSes, C<seek()> on a file opened to append C<<< >> >>> now does |
| 1308 | the right thing w.r.t. the fopen() manpage. e.g., - When a file is opened |
| 1309 | for append, it is impossible to overwrite information already in |
| 1310 | the file. |
| 1311 | |
| 1312 | open(TEST,">>seek.test"); |
| 1313 | $start = tell TEST ; |
| 1314 | foreach(1 .. 9){ |
| 1315 | print TEST "$_ "; |
| 1316 | } |
| 1317 | $end = tell TEST ; |
| 1318 | seek(TEST,$start,0); |
| 1319 | print TEST "18 characters here"; |
| 1320 | |
| 1321 | # perl4 (solaris) seek.test has: 18 characters here |
| 1322 | # perl5 (solaris) seek.test has: 1 2 3 4 5 6 7 8 9 18 characters here |
| 1323 | |
| 1324 | |
| 1325 | |
| 1326 | =back |
| 1327 | |
| 1328 | =head2 Interpolation Traps |
| 1329 | |
| 1330 | Perl4-to-Perl5 traps having to do with how things get interpolated |
| 1331 | within certain expressions, statements, contexts, or whatever. |
| 1332 | |
| 1333 | =over 5 |
| 1334 | |
| 1335 | =item * Interpolation |
| 1336 | |
| 1337 | @ now always interpolates an array in double-quotish strings. |
| 1338 | |
| 1339 | print "To: someone@somewhere.com\n"; |
| 1340 | |
| 1341 | # perl4 prints: To:someone@somewhere.com |
| 1342 | # perl < 5.6.1, error : In string, @somewhere now must be written as \@somewhere |
| 1343 | # perl >= 5.6.1, warning : Possible unintended interpolation of @somewhere in string |
| 1344 | |
| 1345 | =item * Interpolation |
| 1346 | |
| 1347 | Double-quoted strings may no longer end with an unescaped $ or @. |
| 1348 | |
| 1349 | $foo = "foo$"; |
| 1350 | $bar = "bar@"; |
| 1351 | print "foo is $foo, bar is $bar\n"; |
| 1352 | |
| 1353 | # perl4 prints: foo is foo$, bar is bar@ |
| 1354 | # perl5 errors: Final $ should be \$ or $name |
| 1355 | |
| 1356 | Note: perl5 DOES NOT error on the terminating @ in $bar |
| 1357 | |
| 1358 | =item * Interpolation |
| 1359 | |
| 1360 | Perl now sometimes evaluates arbitrary expressions inside braces that occur |
| 1361 | within double quotes (usually when the opening brace is preceded by C<$> |
| 1362 | or C<@>). |
| 1363 | |
| 1364 | @www = "buz"; |
| 1365 | $foo = "foo"; |
| 1366 | $bar = "bar"; |
| 1367 | sub foo { return "bar" }; |
| 1368 | print "|@{w.w.w}|${main'foo}|"; |
| 1369 | |
| 1370 | # perl4 prints: |@{w.w.w}|foo| |
| 1371 | # perl5 prints: |buz|bar| |
| 1372 | |
| 1373 | Note that you can C<use strict;> to ward off such trappiness under perl5. |
| 1374 | |
| 1375 | =item * Interpolation |
| 1376 | |
| 1377 | The construct "this is $$x" used to interpolate the pid at that point, but |
| 1378 | now tries to dereference $x. C<$$> by itself still works fine, however. |
| 1379 | |
| 1380 | $s = "a reference"; |
| 1381 | $x = *s; |
| 1382 | print "this is $$x\n"; |
| 1383 | |
| 1384 | # perl4 prints: this is XXXx (XXX is the current pid) |
| 1385 | # perl5 prints: this is a reference |
| 1386 | |
| 1387 | =item * Interpolation |
| 1388 | |
| 1389 | Creation of hashes on the fly with C<eval "EXPR"> now requires either both |
| 1390 | C<$>'s to be protected in the specification of the hash name, or both curlies |
| 1391 | to be protected. If both curlies are protected, the result will be compatible |
| 1392 | with perl4 and perl5. This is a very common practice, and should be changed |
| 1393 | to use the block form of C<eval{}> if possible. |
| 1394 | |
| 1395 | $hashname = "foobar"; |
| 1396 | $key = "baz"; |
| 1397 | $value = 1234; |
| 1398 | eval "\$$hashname{'$key'} = q|$value|"; |
| 1399 | (defined($foobar{'baz'})) ? (print "Yup") : (print "Nope"); |
| 1400 | |
| 1401 | # perl4 prints: Yup |
| 1402 | # perl5 prints: Nope |
| 1403 | |
| 1404 | Changing |
| 1405 | |
| 1406 | eval "\$$hashname{'$key'} = q|$value|"; |
| 1407 | |
| 1408 | to |
| 1409 | |
| 1410 | eval "\$\$hashname{'$key'} = q|$value|"; |
| 1411 | |
| 1412 | causes the following result: |
| 1413 | |
| 1414 | # perl4 prints: Nope |
| 1415 | # perl5 prints: Yup |
| 1416 | |
| 1417 | or, changing to |
| 1418 | |
| 1419 | eval "\$$hashname\{'$key'\} = q|$value|"; |
| 1420 | |
| 1421 | causes the following result: |
| 1422 | |
| 1423 | # perl4 prints: Yup |
| 1424 | # perl5 prints: Yup |
| 1425 | # and is compatible for both versions |
| 1426 | |
| 1427 | |
| 1428 | =item * Interpolation |
| 1429 | |
| 1430 | perl4 programs which unconsciously rely on the bugs in earlier perl versions. |
| 1431 | |
| 1432 | perl -e '$bar=q/not/; print "This is $foo{$bar} perl5"' |
| 1433 | |
| 1434 | # perl4 prints: This is not perl5 |
| 1435 | # perl5 prints: This is perl5 |
| 1436 | |
| 1437 | =item * Interpolation |
| 1438 | |
| 1439 | You also have to be careful about array references. |
| 1440 | |
| 1441 | print "$foo{" |
| 1442 | |
| 1443 | perl 4 prints: { |
| 1444 | perl 5 prints: syntax error |
| 1445 | |
| 1446 | =item * Interpolation |
| 1447 | |
| 1448 | Similarly, watch out for: |
| 1449 | |
| 1450 | $foo = "baz"; |
| 1451 | print "\$$foo{bar}\n"; |
| 1452 | |
| 1453 | # perl4 prints: $baz{bar} |
| 1454 | # perl5 prints: $ |
| 1455 | |
| 1456 | Perl 5 is looking for C<$foo{bar}> which doesn't exist, but perl 4 is |
| 1457 | happy just to expand $foo to "baz" by itself. Watch out for this |
| 1458 | especially in C<eval>'s. |
| 1459 | |
| 1460 | =item * Interpolation |
| 1461 | |
| 1462 | C<qq()> string passed to C<eval> |
| 1463 | |
| 1464 | eval qq( |
| 1465 | foreach \$y (keys %\$x\) { |
| 1466 | \$count++; |
| 1467 | } |
| 1468 | ); |
| 1469 | |
| 1470 | # perl4 runs this ok |
| 1471 | # perl5 prints: Can't find string terminator ")" |
| 1472 | |
| 1473 | =back |
| 1474 | |
| 1475 | =head2 DBM Traps |
| 1476 | |
| 1477 | General DBM traps. |
| 1478 | |
| 1479 | =over 5 |
| 1480 | |
| 1481 | =item * DBM |
| 1482 | |
| 1483 | Existing dbm databases created under perl4 (or any other dbm/ndbm tool) |
| 1484 | may cause the same script, run under perl5, to fail. The build of perl5 |
| 1485 | must have been linked with the same dbm/ndbm as the default for C<dbmopen()> |
| 1486 | to function properly without C<tie>'ing to an extension dbm implementation. |
| 1487 | |
| 1488 | dbmopen (%dbm, "file", undef); |
| 1489 | print "ok\n"; |
| 1490 | |
| 1491 | # perl4 prints: ok |
| 1492 | # perl5 prints: ok (IFF linked with -ldbm or -lndbm) |
| 1493 | |
| 1494 | |
| 1495 | =item * DBM |
| 1496 | |
| 1497 | Existing dbm databases created under perl4 (or any other dbm/ndbm tool) |
| 1498 | may cause the same script, run under perl5, to fail. The error generated |
| 1499 | when exceeding the limit on the key/value size will cause perl5 to exit |
| 1500 | immediately. |
| 1501 | |
| 1502 | dbmopen(DB, "testdb",0600) || die "couldn't open db! $!"; |
| 1503 | $DB{'trap'} = "x" x 1024; # value too large for most dbm/ndbm |
| 1504 | print "YUP\n"; |
| 1505 | |
| 1506 | # perl4 prints: |
| 1507 | dbm store returned -1, errno 28, key "trap" at - line 3. |
| 1508 | YUP |
| 1509 | |
| 1510 | # perl5 prints: |
| 1511 | dbm store returned -1, errno 28, key "trap" at - line 3. |
| 1512 | |
| 1513 | =back |
| 1514 | |
| 1515 | =head2 Unclassified Traps |
| 1516 | |
| 1517 | Everything else. |
| 1518 | |
| 1519 | =over 5 |
| 1520 | |
| 1521 | =item * C<require>/C<do> trap using returned value |
| 1522 | |
| 1523 | If the file doit.pl has: |
| 1524 | |
| 1525 | sub foo { |
| 1526 | $rc = do "./do.pl"; |
| 1527 | return 8; |
| 1528 | } |
| 1529 | print &foo, "\n"; |
| 1530 | |
| 1531 | And the do.pl file has the following single line: |
| 1532 | |
| 1533 | return 3; |
| 1534 | |
| 1535 | Running doit.pl gives the following: |
| 1536 | |
| 1537 | # perl 4 prints: 3 (aborts the subroutine early) |
| 1538 | # perl 5 prints: 8 |
| 1539 | |
| 1540 | Same behavior if you replace C<do> with C<require>. |
| 1541 | |
| 1542 | =item * C<split> on empty string with LIMIT specified |
| 1543 | |
| 1544 | $string = ''; |
| 1545 | @list = split(/foo/, $string, 2) |
| 1546 | |
| 1547 | Perl4 returns a one element list containing the empty string but Perl5 |
| 1548 | returns an empty list. |
| 1549 | |
| 1550 | =back |
| 1551 | |
| 1552 | As always, if any of these are ever officially declared as bugs, |
| 1553 | they'll be fixed and removed. |
| 1554 | |