3 perltrap - Perl traps for the unwary
7 The biggest trap of all is forgetting to use the B<-w> switch; see
8 L<perlrun>. The second biggest trap is not making your entire program
9 runnable under C<use strict>.
13 Accustomed B<awk> users should take special note of the following:
19 The English module, loaded via
23 allows you to refer to special variables (like $/ ($RS)) with their
24 B<awk> equivalent; see L<perlvar> for details.
28 Semicolons are required after all simple statements in Perl (except
29 at the end of a block). Newline is not a statement delimiter.
33 Curly brackets are required on C<if>s and C<while>s.
37 Variables begin with "$" or "@" in Perl.
41 Arrays index from 0. Likewise string positions in substr() and
46 You have to decide whether your array has numeric or string indices.
50 Hash values do not spring into existence upon mere reference.
54 You have to decide whether you want to use string or numeric
59 Reading an input line does not split it for you. You get to split it
60 to an array yourself. And the split() operator has different
61 arguments than B<awk>'s.
65 The current input line is normally in $_, not $0. It generally does
66 not have the newline stripped. ($0 is the name of the program
67 executed.) See L<perlvar>.
71 $E<lt>I<digit>E<gt> does not refer to fields--it refers to substrings matched
72 by the last match pattern.
76 The print() statement does not add field and record separators unless
77 you set C<$,> and C<$\>. You can set $OFS and $ORS if you're using
82 You must open your files before you print to them.
86 The range operator is "..", not comma. The comma operator works as in
91 The match operator is "=~", not "~". ("~" is the one's complement
96 The exponentiation operator is "**", not "^". "^" is the XOR
97 operator, as in C. (You know, one could get the feeling that B<awk> is
98 basically incompatible with C.)
102 The concatenation operator is ".", not the null string. (Using the
103 null string would render C</pat/ /pat/> unparsable, because the third slash
104 would be interpreted as a division operator--the tokenizer is in fact
105 slightly context sensitive for operators like "/", "?", and "E<gt>".
106 And in fact, "." itself can be the beginning of a number.)
110 The C<next>, C<exit>, and C<continue> keywords work differently.
115 The following variables work differently:
118 ARGC $#ARGV or scalar @ARGV
122 FS (whatever you like)
123 NF $#Fld, or some such
135 You cannot set $RS to a pattern, only a string.
139 When in doubt, run the B<awk> construct through B<a2p> and see what it
146 Cerebral C programmers should take note of the following:
152 Curly brackets are required on C<if>'s and C<while>'s.
156 You must use C<elsif> rather than C<else if>.
160 The C<break> and C<continue> keywords from C become in
161 Perl C<last> and C<next>, respectively.
162 Unlike in C, these do I<NOT> work within a C<do { } while> construct.
166 There's no switch statement. (But it's easy to build one on the fly.)
170 Variables begin with "$" or "@" in Perl.
174 C<printf()> does not implement the "*" format for interpolating
175 field widths, but it's trivial to use interpolation of double-quoted
176 strings to achieve the same effect.
180 Comments begin with "#", not "/*".
184 You can't take the address of anything, although a similar operator
185 in Perl is the backslash, which creates a reference.
189 C<ARGV> must be capitalized. C<$ARGV[0]> is C's C<argv[1]>, and C<argv[0]>
194 System calls such as link(), unlink(), rename(), etc. return nonzero for
199 Signal handlers deal with signal names, not numbers. Use C<kill -l>
200 to find their names on your system.
206 Seasoned B<sed> programmers should take note of the following:
212 Backreferences in substitutions use "$" rather than "\".
216 The pattern matching metacharacters "(", ")", and "|" do not have backslashes
221 The range operator is C<...>, rather than comma.
227 Sharp shell programmers should take note of the following:
233 The back-tick operator does variable interpolation without regard to
234 the presence of single quotes in the command.
238 The back-tick operator does no translation of the return value, unlike B<csh>.
242 Shells (especially B<csh>) do several levels of substitution on each
243 command line. Perl does substitution in only certain constructs
244 such as double quotes, back-ticks, angle brackets, and search patterns.
248 Shells interpret scripts a little bit at a time. Perl compiles the
249 entire program before executing it (except for C<BEGIN> blocks, which
250 execute at compile time).
254 The arguments are available via @ARGV, not $1, $2, etc.
258 The environment is not automatically made available as separate scalar
265 Practicing Perl Programmers should take note of the following:
271 Remember that many operations behave differently in a list
272 context than they do in a scalar one. See L<perldata> for details.
276 Avoid barewords if you can, especially all lowercase ones.
277 You can't tell by just looking at it whether a bareword is
278 a function or a string. By using quotes on strings and
279 parentheses on function calls, you won't ever get them confused.
283 You cannot discern from mere inspection which built-ins
284 are unary operators (like chop() and chdir())
285 and which are list operators (like print() and unlink()).
286 (User-defined subroutines can be B<only> list operators, never
287 unary ones.) See L<perlop>.
291 People have a hard time remembering that some functions
292 default to $_, or @ARGV, or whatever, but that others which
293 you might expect to do not.
297 The E<lt>FHE<gt> construct is not the name of the filehandle, it is a readline
298 operation on that handle. The data read is assigned to $_ only if the
299 file read is the sole condition in a while loop:
302 while ($_ = <FH>) { }..
303 <FH>; # data discarded!
307 Remember not to use "C<=>" when you need "C<=~>";
308 these two constructs are quite different:
315 The C<do {}> construct isn't a real loop that you can use
320 Use C<my()> for local variables whenever you can get away with
321 it (but see L<perlform> for where you can't).
322 Using C<local()> actually gives a local value to a global
323 variable, which leaves you open to unforeseen side-effects
328 If you localize an exported variable in a module, its exported value will
329 not change. The local name becomes an alias to a new value but the
330 external name is still an alias for the original.
334 =head2 Perl4 to Perl5 Traps
336 Practicing Perl4 Programmers should take note of the following
337 Perl4-to-Perl5 specific traps.
339 They're crudely ordered according to the following list:
343 =item Discontinuance, Deprecation, and BugFix traps
345 Anything that's been fixed as a perl4 bug, removed as a perl4 feature
346 or deprecated as a perl4 feature with the intent to encourage usage of
347 some other perl5 feature.
351 Traps that appear to stem from the new parser.
353 =item Numerical Traps
355 Traps having to do with numerical or mathematical operators.
357 =item General data type traps
359 Traps involving perl standard data types.
361 =item Context Traps - scalar, list contexts
363 Traps related to context within lists, scalar statements/declarations.
365 =item Precedence Traps
367 Traps related to the precedence of parsing, evaluation, and execution of
370 =item General Regular Expression Traps using s///, etc.
372 Traps related to the use of pattern matching.
374 =item Subroutine, Signal, Sorting Traps
376 Traps related to the use of signals and signal handlers, general subroutines,
377 and sorting, along with sorting subroutines.
385 Traps specific to the use of C<dbmopen()>, and specific dbm implementations.
387 =item Unclassified Traps
393 If you find an example of a conversion trap that is not listed here,
394 please submit it to Bill Middleton <F<wjm@best.com>> for inclusion.
395 Also note that at least some of these can be caught with B<-w>.
397 =head2 Discontinuance, Deprecation, and BugFix traps
399 Anything that has been discontinued, deprecated, or fixed as
404 =item * Discontinuance
406 Symbols starting with "_" are no longer forced into package main, except
407 for C<$_> itself (and C<@_>, etc.).
413 print "\$_legacy is ",$_legacy,"\n";
415 # perl4 prints: $_legacy is 1
416 # perl5 prints: $_legacy is
420 Double-colon is now a valid package separator in a variable name. Thus these
421 behave differently in perl4 vs. perl5, because the packages don't exist.
423 $a=1;$b=2;$c=3;$var=4;
425 print "$var::abc::xyz\n";
427 # perl4 prints: 1::2::3 4::abc::xyz
430 Given that C<::> is now the preferred package delimiter, it is debatable
431 whether this should be classed as a bug or not.
432 (The older package delimiter, ' ,is used here)
438 # perl5 prints: Can't find string terminator "'" anywhere before EOF
440 Also see precedence traps, for parsing C<$:>.
444 The second and third arguments of C<splice()> are now evaluated in scalar
445 context (as the Camel says) rather than list context.
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";
454 # perl5 prints: c d e
456 =item * Discontinuance
458 You can't do a C<goto> into a block that is optimized away. Darn.
464 print "Here I is!\n";
467 # perl4 prints: Here I is!
468 # perl5 dumps core (SEGV)
470 =item * Discontinuance
472 It is no longer syntactically legal to use whitespace as the name
473 of a variable, or as a delimiter for any kind of quote construct.
478 print "a is $a, b is $b\n";
480 # perl4 prints: a is foo bar, b is baz
481 # perl5 errors: Bare word found where operator expected
483 =item * Discontinuance
485 The archaic while/if BLOCK BLOCK syntax is no longer supported.
494 # perl4 prints: True!
495 # perl5 errors: syntax error at test.pl line 1, near "if {"
499 The C<**> operator now binds more tightly than unary minus.
500 It was documented to work this way before, but didn't.
507 =item * Discontinuance
509 The meaning of C<foreach{}> has changed slightly when it is iterating over a
510 list which is not an array. This used to assign the list to a
511 temporary array, but no longer does so (for efficiency). This means
512 that you'll now be iterating over the actual values, not over copies of
513 the values. Modifications to the loop variable can change the original
516 @list = ('ab','abc','bcd','def');
517 foreach $var (grep(/ab/,@list)){
520 print (join(':',@list));
522 # perl4 prints: ab:abc:bcd:def
523 # perl5 prints: 1:1:bcd:def
525 To retain Perl4 semantics you need to assign your list
526 explicitly to a temporary array and then iterate over that. For
527 example, you might need to change
529 foreach $var (grep(/ab/,@list)){
533 foreach $var (@tmp = grep(/ab/,@list)){
535 Otherwise changing $var will clobber the values of @list. (This most often
536 happens when you use C<$_> for the loop variable, and call subroutines in
537 the loop that don't properly localize C<$_>.)
539 =item * Discontinuance
541 C<split> with no arguments now behaves like C<split ' '> (which doesn't
542 return an initial null field if $_ starts with whitespace), it used to
543 behave like C<split /\s+/> (which does).
546 print join(':', split);
548 # perl4 prints: :hi:mom
549 # perl5 prints: hi:mom
553 Perl 4 would ignore any text which was attached to an B<-e> switch,
554 always taking the code snippet from the following arg. Additionally, it
555 would silently accept an B<-e> switch without a following arg. Both of
556 these behaviors have been fixed.
558 perl -e'print "attached to -e"' 'print "separate arg"'
560 # perl4 prints: separate arg
561 # perl5 prints: attached to -e
566 # perl5 dies: No code specified for -e.
568 =item * Discontinuance
570 In Perl 4 the return value of C<push> was undocumented, but it was
571 actually the last value being pushed onto the target list. In Perl 5
572 the return value of C<push> is documented, but has changed, it is the
573 number of elements in the resulting list.
576 print push(@x, 'first new', 'second new');
578 # perl4 prints: second new
581 =item * Discontinuance
583 In Perl 4 (and versions of Perl 5 before 5.004), C<'\r'> characters in
584 Perl code were silently allowed, although they could cause (mysterious!)
585 failures in certain constructs, particularly here documents. Now,
586 C<'\r'> characters cause an immediate fatal error. (Note: In this
587 example, the notation B<\015> represents the incorrect line
588 ending. Depending upon your text viewer, it will look different.)
593 # perl4 prints: foobar
594 # perl5.003 prints: foobar
595 # perl5.004 dies: Illegal character \015 (carriage return)
597 See L<perldiag> for full details.
601 Some error messages will be different.
603 =item * Discontinuance
605 Some bugs may have been inadvertently removed. :-)
611 Perl4-to-Perl5 traps from having to do with parsing.
617 Note the space between . and =
619 $string . = "more string";
622 # perl4 prints: more string
623 # perl5 prints: syntax error at - line 1, near ". ="
627 Better parsing in perl 5
631 print("hello, world\n");
633 # perl4 prints: hello, world
634 # perl5 prints: syntax error
638 "if it looks like a function, it is a function" rule.
641 ($foo == 1) ? "is one\n" : "is zero\n";
643 # perl4 prints: is zero
644 # perl5 warns: "Useless use of a constant in void context" if using -w
648 =head2 Numerical Traps
650 Perl4-to-Perl5 traps having to do with numerical operators,
651 operands, or output from same.
657 Formatted output and significant digits
659 print 7.373504 - 0, "\n";
660 printf "%20.18f\n", 7.373504 - 0;
672 This specific item has been deleted. It demonstrated how the auto-increment
673 operator would not catch when a number went over the signed int limit. Fixed
674 in version 5.003_04. But always be wary when using large integers.
681 Assignment of return values from numeric equality tests
682 does not work in perl5 when the test evaluates to false (0).
683 Logical tests now return an null, instead of 0
691 Also see the L<General Regular Expression Traps using s///, etc.>
692 tests for another example of this new feature...
696 =head2 General data type traps
698 Perl4-to-Perl5 traps involving most data-types, and their usage
699 within certain expressions and/or context.
705 Negative array subscripts now count from the end of the array.
707 @a = (1, 2, 3, 4, 5);
708 print "The third element of the array is $a[3] also expressed as $a[-2] \n";
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
715 Setting C<$#array> lower now discards array elements, and makes them
716 impossible to recover.
719 print "Before: ",join('',@a);
721 print ", After: ",join('',@a);
723 print ", Recovered: ",join('',@a),"\n";
725 # perl4 prints: Before: abcde, After: ab, Recovered: abcd
726 # perl5 prints: Before: abcde, After: ab, Recovered: ab
730 Hashes get defined before use
733 die "scalar \$s defined" if defined($s);
734 die "array \@a defined" if defined(@a);
735 die "hash \%h defined" if defined(%h);
738 # perl5 dies: hash %h defined
742 glob assignment from variable to variable will fail if the assigned
743 variable is localized subsequent to the assignment
745 @a = ("This is Perl 4");
750 # perl4 prints: This is Perl 4
755 *fred = *barney; # fred is aliased to barney
758 print "@fred"; # should print "1, 2, 4"
760 # perl4 prints: 1 2 4
761 # perl5 prints: In string, @fred now must be written as \@fred
763 =item * (Scalar String)
765 Changes in unary negation (of strings)
766 This change effects both the return value and what it
767 does to auto(magic)increment.
774 # perl4 prints: aab : -0 : 1
775 # perl5 prints: aab : -aab : aac
779 perl 4 lets you modify constants:
783 for ($x = 0; $x < 3; $x++) {
787 print "before: $_[0]";
789 print " after: $_[0]\n";
800 # Modification of a read-only value attempted at foo.pl line 12.
805 The behavior is slightly different for:
807 print "$x", defined $x
810 # perl 5: <no output, $x is not called into existence>
812 =item * (Variable Suicide)
814 Variable suicide behavior is more consistent under Perl 5.
815 Perl5 exhibits the same behavior for hashes and scalars,
816 that perl4 exhibits for only scalars.
818 $aGlobal{ "aKey" } = "global value";
819 print "MAIN:", $aGlobal{"aKey"}, "\n";
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
830 if( $GlobalLevel<4 ) {
845 # SUB: this should never appear
846 # SUB: this should never appear
847 # SUB: this should never appear
851 =head2 Context Traps - scalar, list contexts
855 =item * (list context)
857 The elements of argument lists for formats are now evaluated in list
858 context. This means you can interpolate list values now.
860 @fmt = ("foo","bar","baz");
867 # perl4 errors: Please use commas to separate fields in file
868 # perl5 prints: foo bar baz
870 =item * (scalar context)
872 The C<caller()> function now returns a false value in a scalar context
873 if there is no caller. This lets library files determine if they're
876 caller() ? (print "You rang?\n") : (print "Got a 0\n");
878 # perl4 errors: There is no caller
879 # perl5 prints: Got a 0
881 =item * (scalar context)
883 The comma operator in a scalar context is now guaranteed to give a
884 scalar context to its arguments.
890 # Perl4 prints: x = c # Thinks list context interpolates list
891 # Perl5 prints: x = 3 # Knows scalar uses length of list
893 =item * (list, builtin)
895 C<sprintf()> funkiness (array argument converted to scalar array count)
896 This test could be added to t/op/sprintf.t
898 @z = ('%s%s', 'foo', 'bar');
900 if ($x eq 'foobar') {print "ok 2\n";} else {print "not ok 2 '$x'\n";}
903 # perl5 prints: not ok 2
905 C<printf()> works fine, though:
910 # perl4 prints: foobar
911 # perl5 prints: foobar
917 =head2 Precedence Traps
919 Perl4-to-Perl5 traps involving precedence order.
925 LHS vs. RHS when both sides are getting an op.
927 @arr = ( 'left', 'right' );
928 $a{shift @arr} = shift @arr;
929 print join( ' ', keys %a );
932 # perl5 prints: right
936 These are now semantic errors because of precedence:
939 %map = ("a",1,"b",2,"c",3,"d",4);
940 $n = shift @list + 2; # first item in list plus 2
942 $m = keys %map + 2; # number of items in hash plus 2
945 # perl4 prints: n is 3, m is 6
946 # perl5 errors and fails to compile
950 The precedence of assignment operators is now the same as the precedence
951 of assignment. Perl 4 mistakenly gave them the precedence of the associated
952 operator. So you now must parenthesize them in expressions like
954 /foo/ ? ($a += 2) : ($a -= 2);
958 /foo/ ? $a += 2 : $a -= 2
960 would be erroneously parsed as
962 (/foo/ ? $a += 2 : $a) -= 2;
968 now works as a C programmer would expect.
974 is now incorrect. You need parentheses around the filehandle.
975 Otherwise, perl5 leaves the statement as its default precedence:
979 # perl4 opens or dies
980 # perl5 errors: Precedence problem: open FOO should be open(FOO)
984 perl4 gives the special variable, C<$:> precedence, where perl5
985 treats C<$::> as main C<package>
987 $a = "x"; print "$::a";
994 concatenation precedence over filetest operator?
998 # perl4 prints: no output
999 # perl5 prints: Can't modify -e in concatenation
1003 Assignment to value takes precedence over assignment to key in
1004 perl5 when using the shift operator on both sides.
1006 @arr = ( 'left', 'right' );
1007 $a{shift @arr} = shift @arr;
1008 print join( ' ', keys %a );
1010 # perl4 prints: left
1011 # perl5 prints: right
1015 =head2 General Regular Expression Traps using s///, etc.
1017 All types of RE traps.
1021 =item * Regular Expression
1023 C<s'$lhs'$rhs'> now does no interpolation on either side. It used to
1024 interpolate C<$lhs> but not C<$rhs>. (And still does not match a literal
1028 $string = '1 2 $a $b';
1029 $string =~ s'$a'$b';
1032 # perl4 prints: $b 2 $a $b
1033 # perl5 prints: 1 2 $a $b
1035 =item * Regular Expression
1037 C<m//g> now attaches its state to the searched string rather than the
1038 regular expression. (Once the scope of a block is left for the sub, the
1039 state of the searched string is lost)
1045 sub doit{local($_) = shift; print "Got $_ "}
1047 # perl4 prints: blah blah blah
1048 # perl5 prints: infinite loop blah...
1050 =item * Regular Expression
1052 Currently, if you use the C<m//o> qualifier on a regular expression
1053 within an anonymous sub, I<all> closures generated from that anonymous
1054 sub will use the regular expression as it was compiled when it was used
1055 the very first time in any such closure. For instance, if you say
1058 my($left,$right) = @_;
1059 return sub { $_[0] =~ /$left stuff $right/o; };
1062 build_match() will always return a sub which matches the contents of
1063 C<$left> and C<$right> as they were the I<first> time that build_match()
1064 was called, not as they are in the current call.
1066 This is probably a bug, and may change in future versions of Perl.
1068 =item * Regular Expression
1070 If no parentheses are used in a match, Perl4 sets C<$+> to
1071 the whole match, just like C<$&>. Perl5 does not.
1076 # perl4 prints: bcde
1079 =item * Regular Expression
1081 substitution now returns the null string if it fails
1084 $value = ($string =~ s/foo//);
1090 Also see L<Numerical Traps> for another example of this new feature.
1092 =item * Regular Expression
1094 C<s`lhs`rhs`> (using back-ticks) is now a normal substitution, with no
1098 $string =~ s`^`hostname`;
1099 print $string, "\n";
1101 # perl4 prints: <the local hostname>
1102 # perl5 prints: hostname
1104 =item * Regular Expression
1106 Stricter parsing of variables used in regular expressions
1108 s/^([^$grpc]*$grpc[$opt$plus$rep]?)//o;
1110 # perl4: compiles w/o error
1111 # perl5: with Scalar found where operator expected ..., near "$opt$plus"
1113 an added component of this example, apparently from the same script, is
1114 the actual value of the s'd string after the substitution.
1115 C<[$opt]> is a character class in perl4 and an array subscript in perl5
1120 s/^([^$grpc]*$grpc[$opt]?)/foo/;
1124 # perl5 prints: foobar
1126 =item * Regular Expression
1128 Under perl5, C<m?x?> matches only once, like C<?x?>. Under perl4, it matched
1129 repeatedly, like C</x/> or C<m!x!>.
1132 sub match { $test =~ m?once?; }
1135 # m?x? matches more then once
1138 # m?x? matches only once
1142 # perl4 prints: perl4
1143 # perl5 prints: perl5
1146 =item * Regular Expression
1148 Under perl4 and upto version 5.003, a failed C<m//g> match used to
1149 reset the internal iterator, so that subsequent C<m//g> match attempts
1150 began from the beginning of the string. In perl version 5.004 and later,
1151 failed C<m//g> matches do not reset the iterator position (which can be
1152 found using the C<pos()> function--see L<perlfunc/pos>).
1156 print $1 while ($test =~ /(o)/g);
1157 # pos $test = 0; # to get old behavior
1160 # perl4 prints: oooooo
1161 # perl5.004 prints: oo
1163 You may always reset the iterator yourself as shown in the commented line
1164 to get the old behavior.
1168 =head2 Subroutine, Signal, Sorting Traps
1170 The general group of Perl4-to-Perl5 traps having to do with
1171 Signals, Sorting, and their related subroutines, as well as
1172 general subroutine traps. Includes some OS-Specific traps.
1178 Barewords that used to look like strings to Perl will now look like subroutine
1179 calls if a subroutine by that name is defined before the compiler sees them.
1181 sub SeeYa { warn"Hasta la vista, baby!" }
1182 $SIG{'TERM'} = SeeYa;
1183 print "SIGTERM is now $SIG{'TERM'}\n";
1185 # perl4 prints: SIGTERM is main'SeeYa
1186 # perl5 prints: SIGTERM is now main::1
1188 Use B<-w> to catch this one
1190 =item * (Sort Subroutine)
1192 reverse is no longer allowed as the name of a sort subroutine.
1194 sub reverse{ print "yup "; $a <=> $b }
1195 print sort reverse a,b,c;
1197 # perl4 prints: yup yup yup yup abc
1200 =item * warn() won't let you specify a filehandle.
1202 Although it _always_ printed to STDERR, warn() would let you specify a
1203 filehandle in perl4. With perl5 it does not.
1207 # perl4 prints: Foo!
1208 # perl5 prints: String found where operator expected
1218 Under HPUX, and some other SysV OS's, one had to reset any signal handler,
1219 within the signal handler function, each time a signal was handled with
1220 perl4. With perl5, the reset is now done correctly. Any code relying
1221 on the handler _not_ being reset will have to be reworked.
1223 Since version 5.002, Perl uses sigaction() under SysV.
1228 $SIG{'INT'} = 'gotit';
1237 while (1) {sleep(10);}
1240 # perl4 (HPUX) prints: Got INT...
1241 # perl5 (HPUX) prints: Got INT... Got INT...
1245 Under SysV OS's, C<seek()> on a file opened to append C<E<gt>E<gt>> now does
1246 the right thing w.r.t. the fopen() man page. e.g., - When a file is opened
1247 for append, it is impossible to overwrite information already in
1250 open(TEST,">>seek.test");
1251 $start = tell TEST ;
1256 seek(TEST,$start,0);
1257 print TEST "18 characters here";
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
1266 =head2 Interpolation Traps
1268 Perl4-to-Perl5 traps having to do with how things get interpolated
1269 within certain expressions, statements, contexts, or whatever.
1273 =item * Interpolation
1275 @ now always interpolates an array in double-quotish strings.
1277 print "To: someone@somewhere.com\n";
1279 # perl4 prints: To:someone@somewhere.com
1280 # perl5 errors : In string, @somewhere now must be written as \@somewhere
1282 =item * Interpolation
1284 Double-quoted strings may no longer end with an unescaped $ or @.
1288 print "foo is $foo, bar is $bar\n";
1290 # perl4 prints: foo is foo$, bar is bar@
1291 # perl5 errors: Final $ should be \$ or $name
1293 Note: perl5 DOES NOT error on the terminating @ in $bar
1295 =item * Interpolation
1297 Perl now sometimes evaluates arbitrary expressions inside braces that occur
1298 within double quotes (usually when the opening brace is preceded by C<$>
1304 sub foo { return "bar" };
1305 print "|@{w.w.w}|${main'foo}|";
1307 # perl4 prints: |@{w.w.w}|foo|
1308 # perl5 prints: |buz|bar|
1310 Note that you can C<use strict;> to ward off such trappiness under perl5.
1312 =item * Interpolation
1314 The construct "this is $$x" used to interpolate the pid at that
1315 point, but now apparently tries to dereference C<$x>. C<$$> by itself still
1316 works fine, however.
1318 print "this is $$x\n";
1320 # perl4 prints: this is XXXx (XXX is the current pid)
1321 # perl5 prints: this is
1323 =item * Interpolation
1325 Creation of hashes on the fly with C<eval "EXPR"> now requires either both
1326 C<$>'s to be protected in the specification of the hash name, or both curlies
1327 to be protected. If both curlies are protected, the result will be compatible
1328 with perl4 and perl5. This is a very common practice, and should be changed
1329 to use the block form of C<eval{}> if possible.
1331 $hashname = "foobar";
1334 eval "\$$hashname{'$key'} = q|$value|";
1335 (defined($foobar{'baz'})) ? (print "Yup") : (print "Nope");
1338 # perl5 prints: Nope
1342 eval "\$$hashname{'$key'} = q|$value|";
1346 eval "\$\$hashname{'$key'} = q|$value|";
1348 causes the following result:
1350 # perl4 prints: Nope
1355 eval "\$$hashname\{'$key'\} = q|$value|";
1357 causes the following result:
1361 # and is compatible for both versions
1364 =item * Interpolation
1366 perl4 programs which unconsciously rely on the bugs in earlier perl versions.
1368 perl -e '$bar=q/not/; print "This is $foo{$bar} perl5"'
1370 # perl4 prints: This is not perl5
1371 # perl5 prints: This is perl5
1373 =item * Interpolation
1375 You also have to be careful about array references.
1380 perl 5 prints: syntax error
1382 =item * Interpolation
1384 Similarly, watch out for:
1387 print "\$$foo{bar}\n";
1389 # perl4 prints: $array{bar}
1392 Perl 5 is looking for C<$array{bar}> which doesn't exist, but perl 4 is
1393 happy just to expand $foo to "array" by itself. Watch out for this
1394 especially in C<eval>'s.
1396 =item * Interpolation
1398 C<qq()> string passed to C<eval>
1401 foreach \$y (keys %\$x\) {
1406 # perl4 runs this ok
1407 # perl5 prints: Can't find string terminator ")"
1419 Existing dbm databases created under perl4 (or any other dbm/ndbm tool)
1420 may cause the same script, run under perl5, to fail. The build of perl5
1421 must have been linked with the same dbm/ndbm as the default for C<dbmopen()>
1422 to function properly without C<tie>'ing to an extension dbm implementation.
1424 dbmopen (%dbm, "file", undef);
1428 # perl5 prints: ok (IFF linked with -ldbm or -lndbm)
1433 Existing dbm databases created under perl4 (or any other dbm/ndbm tool)
1434 may cause the same script, run under perl5, to fail. The error generated
1435 when exceeding the limit on the key/value size will cause perl5 to exit
1438 dbmopen(DB, "testdb",0600) || die "couldn't open db! $!";
1439 $DB{'trap'} = "x" x 1024; # value too large for most dbm/ndbm
1443 dbm store returned -1, errno 28, key "trap" at - line 3.
1447 dbm store returned -1, errno 28, key "trap" at - line 3.
1451 =head2 Unclassified Traps
1457 =item * Unclassified
1459 C<require>/C<do> trap using returned value
1461 If the file doit.pl has:
1469 And the do.pl file has the following single line:
1473 Running doit.pl gives the following:
1475 # perl 4 prints: 3 (aborts the subroutine early)
1478 Same behavior if you replace C<do> with C<require>.
1482 As always, if any of these are ever officially declared as bugs,
1483 they'll be fixed and removed.