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