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