=head1 DESCRIPTION
-The biggest trap of all is forgetting to use the B<-w> switch;
-see L<perlrun>. Making your entire program runnable under
-
- use strict;
-
-can help make your program more bullet-proof, but sometimes
-it's too annoying for quick throw-away programs.
+The biggest trap of all is forgetting to C<use warnings> or use the B<-w>
+switch; see L<perllexwarn> and L<perlrun>. The second biggest trap is not
+making your entire program runnable under C<use strict>. The third biggest
+trap is not reading the list of changes in this version of Perl; see
+L<perldelta>.
=head2 Awk Traps
=item *
+A Perl program executes only once, not once for each input line. You can
+do an implicit loop with C<-n> or C<-p>.
+
+=item *
+
The English module, loaded via
use English;
-allows you to refer to special variables (like $RS) as
-though they were in B<awk>; see L<perlvar> for details.
+allows you to refer to special variables (like C<$/>) with names (like
+
$RS), as though they were in B<awk>; see L<perlvar> for details.
=item *
=item *
-Variables begin with "$" or "@" in Perl.
+Variables begin with "$", "@" or "%" in Perl.
=item *
=item *
-Associative array values do not spring into existence upon mere
-reference.
+Hash values do not spring into existence upon mere reference.
=item *
=item *
Reading an input line does not split it for you. You get to split it
-yourself to an array. And split() operator has different
-arguments.
+to an array yourself. And the split() operator has different
+arguments than B<awk>'s.
=item *
=item *
-$<I<digit>> does not refer to fields--it refers to substrings matched by
-the last match pattern.
+$<I<digit>> does not refer to fields--it refers to substrings matched
+by the last match pattern.
=item *
The print() statement does not add field and record separators unless
-you set C<$,> and C<$.>. You can set $OFS and $ORS if you're using
+you set C<$,> and C<$\>. You can set $OFS and $ORS if you're using
the English module.
=item *
=item *
The concatenation operator is ".", not the null string. (Using the
-null string would render C</pat/ /pat/> unparsable, since the third slash
-would be interpreted as a division operator--the tokener is in fact
+null string would render C</pat/ /pat/> unparsable, because the third slash
+would be interpreted as a division operator--the tokenizer is in fact
slightly context sensitive for operators like "/", "?", and ">".
And in fact, "." itself can be the beginning of a number.)
The following variables work differently:
Awk Perl
- ARGC $#ARGV or scalar @ARGV
+ ARGC scalar @ARGV (compare with $#ARGV)
ARGV[0] $0
FILENAME $ARGV
FNR $. - something
=back
-=head2 C Traps
+=head2 C/C++ Traps
-Cerebral C programmers should take note of the following:
+Cerebral C and C++ programmers should take note of the following:
=over 4
=item *
-The C<break> and C<continue> keywords from C become in
-Perl C<last> and C<next>, respectively.
-Unlike in C, these do I<NOT> work within a C<do { } while> construct.
-
-=item *
-
-There's no switch statement. (But it's easy to build one on the fly.)
+The C<break> and C<continue> keywords from C become in Perl C<last>
+and C<next>, respectively. Unlike in C, these do I<not> work within a
+C<do { } while> construct. See L<perlsyn/"Loop Control">.
=item *
-Variables begin with "$" or "@" in Perl.
+There's no switch statement. (But it's easy to build one on the fly,
+see L<perlsyn/"Basic BLOCKs and Switch Statements">)
=item *
-printf() does not implement the "*" format for interpolating
-field widths, but it's trivial to use interpolation of double-quoted
-strings to achieve the same effect.
+Variables begin with "$", "@" or "%" in Perl.
=item *
-Comments begin with "#", not "/*".
+Comments begin with "#", not "/*" or "//". Perl may interpret C/C++
+comments as division operators, unterminated regular expressions or
+the defined-or operator.
=item *
You can't take the address of anything, although a similar operator
-in Perl 5 is the backslash, which creates a reference.
+in Perl is the backslash, which creates a reference.
=item *
-C<ARGV> must be capitalized.
+C<ARGV> must be capitalized. C<$ARGV[0]> is C's C<argv[1]>, and C<argv[0]>
+ends up in C<$0>.
=item *
System calls such as link(), unlink(), rename(), etc. return nonzero for
-success, not 0.
+success, not 0. (system(), however, returns zero for success.)
=item *
=item *
+A Perl program executes only once, not once for each input line. You can
+do an implicit loop with C<-n> or C<-p>.
+
+=item *
+
Backreferences in substitutions use "$" rather than "\".
=item *
=item *
-The backtick operator does variable interpretation without regard to
+The backtick operator does variable interpolation without regard to
the presence of single quotes in the command.
=item *
=item *
Shells (especially B<csh>) do several levels of substitution on each
-command line. Perl does substitution only in certain constructs
+command line. Perl does substitution in only certain constructs
such as double quotes, backticks, angle brackets, and search patterns.
=item *
The environment is not automatically made available as separate scalar
variables.
+=item *
+
+The shell's C<test> uses "=", "!=", "<" etc for string comparisons and "-eq",
+"-ne", "-lt" etc for numeric comparisons. This is the reverse of Perl, which
+uses C<eq>, C<ne>, C<lt> for string comparisons, and C<==>, C<!=> C<< < >> etc
+for numeric comparisons.
+
=back
=head2 Perl Traps
=item *
-Avoid barewords if you can, especially all lower-case ones.
-You can't tell just by looking at it whether a bareword is
-a function or a string. By using quotes on strings and
-parens on function calls, you won't ever get them confused.
+Avoid barewords if you can, especially all lowercase ones.
+You can't tell by just looking at it whether a bareword is
+a function or a string. By using quotes on strings and
+parentheses on function calls, you won't ever get them confused.
=item *
-You cannot discern from mere inspection which built-ins
-are unary operators (like chop() and chdir())
+You cannot discern from mere inspection which builtins
+are unary operators (like chop() and chdir())
and which are list operators (like print() and unlink()).
-(User-defined subroutines can B<only> be list operators, never
-unary ones.) See L<perlop>.
+(Unless prototyped, user-defined subroutines can B<only> be list
+operators, never unary ones.) See L<perlop> and L<perlsub>.
=item *
-People have a hard type remembering that some functions
+People have a hard time remembering that some functions
default to $_, or @ARGV, or whatever, but that others which
-you might expect to do not.
+you might expect to do not.
-=item *
+=item *
+
+The <FH> construct is not the name of the filehandle, it is a readline
+operation on that handle. The data read is assigned to $_ only if the
+file read is the sole condition in a while loop:
-Remember not to use "C<=>" when you need "C<=~>";
+ while (<FH>) { }
+ while (defined($_ = <FH>)) { }..
+ <FH>; # data discarded!
+
+=item *
+
+Remember not to use C<=> when you need C<=~>;
these two constructs are quite different:
$x = /foo/;
=item *
-The C<do {}> construct isn't a real loop that you can use
+The C<do {}> construct isn't a real loop that you can use
loop control on.
=item *
-Use my() for local variables whenever you can get away with
-it (but see L<perlform> for where you can't).
-Using local() actually gives a local value to a global
+Use C<my()> for local variables whenever you can get away with
+it (but see L<perlform> for where you can't).
+Using C<local()> actually gives a local value to a global
variable, which leaves you open to unforeseen side-effects
of dynamic scoping.
+=item *
+
+If you localize an exported variable in a module, its exported value will
+not change. The local name becomes an alias to a new value but the
+external name is still an alias for the original.
+
=back
-=head2 Perl4 Traps
+=head2 Perl4 to Perl5 Traps
+
+Practicing Perl4 Programmers should take note of the following
+Perl4-to-Perl5 specific traps.
-Penitent Perl 4 Programmers should take note of the following
-incompatible changes that occurred between release 4 and release 5:
+They're crudely ordered according to the following list:
=over 4
-=item *
+=item Discontinuance, Deprecation, and BugFix traps
-C<@> now always interpolates an array in double-quotish strings. Some programs
-may now need to use backslash to protect any C<@> that shouldn't interpolate.
+Anything that's been fixed as a perl4 bug, removed as a perl4 feature
+or deprecated as a perl4 feature with the intent to encourage usage of
+some other perl5 feature.
-=item *
-Barewords that used to look like strings to Perl will now look like subroutine
-calls if a subroutine by that name is defined before the compiler sees them.
-For example:
+=item Parsing Traps
- sub SeeYa { die "Hasta la vista, baby!" }
- $SIG{QUIT} = SeeYa;
+Traps that appear to stem from the new parser.
-In Perl 4, that set the signal handler; in Perl 5, it actually calls the
-function! You may use the B<-w> switch to find such places.
+=item Numerical Traps
-=item *
+Traps having to do with numerical or mathematical operators.
-Symbols starting with C<_> are no longer forced into package C<main>, except
-for $_ itself (and @_, etc.).
+=item General data type traps
-=item *
+Traps involving perl standard data types.
-C<s'$lhs'$rhs'> now does no interpolation on either side. It used to
-interpolate C<$lhs> but not C<$rhs>.
+=item Context Traps - scalar, list contexts
-=item *
+Traps related to context within lists, scalar statements/declarations.
-The second and third arguments of splice() are now evaluated in scalar
-context (as the book says) rather than list context.
+=item Precedence Traps
-=item *
+Traps related to the precedence of parsing, evaluation, and execution of
+code.
-These are now semantic errors because of precedence:
+=item General Regular Expression Traps using s///, etc.
- shift @list + 20;
- $n = keys %map + 20;
+Traps related to the use of pattern matching.
-Because if that were to work, then this couldn't:
+=item Subroutine, Signal, Sorting Traps
- sleep $dormancy + 20;
+Traps related to the use of signals and signal handlers, general subroutines,
+and sorting, along with sorting subroutines.
-=item *
+=item OS Traps
-C<open FOO || die> is now incorrect. You need parens around the filehandle.
-While temporarily supported, using such a construct will
-generate a non-fatal (but non-suppressible) warning.
+OS-specific traps.
-=item *
+=item DBM Traps
-The elements of argument lists for formats are now evaluated in list
-context. This means you can interpolate list values now.
+Traps specific to the use of C<dbmopen()>, and specific dbm implementations.
-=item *
+=item Unclassified Traps
+
+Everything else.
+
+=back
+
+If you find an example of a conversion trap that is not listed here,
+please submit it to <F<perlbug@perl.org>> for inclusion.
+Also note that at least some of these can be caught with the
+C<use warnings> pragma or the B<-w> switch.
+
+=head2 Discontinuance, Deprecation, and BugFix traps
+
+Anything that has been discontinued, deprecated, or fixed as
+a bug from perl4.
+
+=over 4
+
+=item * Symbols starting with "_" no longer forced into main
+
+Symbols starting with "_" are no longer forced into package main, except
+for C<$_> itself (and C<@_>, etc.).
+
+ package test;
+ $_legacy = 1;
+
+ package main;
+ print "\$_legacy is ",$_legacy,"\n";
+
+ # perl4 prints: $_legacy is 1
+ # perl5 prints: $_legacy is
+
+=item * Double-colon valid package separator in variable name
+
+Double-colon is now a valid package separator in a variable name. Thus these
+behave differently in perl4 vs. perl5, because the packages don't exist.
+
+ $a=1;$b=2;$c=3;$var=4;
+ print "$a::$b::$c ";
+ print "$var::abc::xyz\n";
+
+ # perl4 prints: 1::2::3 4::abc::xyz
+ # perl5 prints: 3
+
+Given that C<::> is now the preferred package delimiter, it is debatable
+whether this should be classed as a bug or not.
+(The older package delimiter, ' ,is used here)
+
+ $x = 10 ;
+ print "x=${'x}\n" ;
+
+ # perl4 prints: x=10
+ # perl5 prints: Can't find string terminator "'" anywhere before EOF
+
+You can avoid this problem, and remain compatible with perl4, if you
+always explicitly include the package name:
+
+ $x = 10 ;
+ print "x=${main'x}\n" ;
+
+Also see precedence traps, for parsing C<$:>.
+
+=item * 2nd and 3rd args to C<splice()> are now in scalar context
+
+The second and third arguments of C<splice()> are now evaluated in scalar
+context (as the Camel says) rather than list context.
+
+ sub sub1{return(0,2) } # return a 2-element list
+ sub sub2{ return(1,2,3)} # return a 3-element list
+ @a1 = ("a","b","c","d","e");
+ @a2 = splice(@a1,&sub1,&sub2);
+ print join(' ',@a2),"\n";
+
+ # perl4 prints: a b
+ # perl5 prints: c d e
+
+=item * Can't do C<goto> into a block that is optimized away
You can't do a C<goto> into a block that is optimized away. Darn.
-=item *
+ goto marker1;
+
+ for(1){
+ marker1:
+ print "Here I is!\n";
+ }
+
+ # perl4 prints: Here I is!
+ # perl5 errors: Can't "goto" into the middle of a foreach loop
+
+=item * Can't use whitespace as variable name or quote delimiter
It is no longer syntactically legal to use whitespace as the name
of a variable, or as a delimiter for any kind of quote construct.
Double darn.
-=item *
+ $a = ("foo bar");
+ $b = q baz ;
+ print "a is $a, b is $b\n";
-The caller() function now returns a false value in a scalar context if there
-is no caller. This lets library files determine if they're being required.
+ # perl4 prints: a is foo bar, b is baz
+ # perl5 errors: Bareword found where operator expected
-=item *
+=item * C<while/if BLOCK BLOCK> gone
-C<m//g> now attaches its state to the searched string rather than the
-regular expression.
+The archaic while/if BLOCK BLOCK syntax is no longer supported.
-=item *
+ if { 1 } {
+ print "True!";
+ }
+ else {
+ print "False!";
+ }
-C<reverse> is no longer allowed as the name of a sort subroutine.
+ # perl4 prints: True!
+ # perl5 errors: syntax error at test.pl line 1, near "if {"
-=item *
+=item * C<**> binds tighter than unary minus
-B<taintperl> is no longer a separate executable. There is now a B<-T>
-switch to turn on tainting when it isn't turned on automatically.
+The C<**> operator now binds more tightly than unary minus.
+It was documented to work this way before, but didn't.
-=item *
+ print -4**2,"\n";
-Double-quoted strings may no longer end with an unescaped C<$> or C<@>.
+ # perl4 prints: 16
+ # perl5 prints: -16
-=item *
+=item * C<foreach> changed when iterating over a list
-The archaic C<while/if> BLOCK BLOCK syntax is no longer supported.
+The meaning of C<foreach{}> has changed slightly when it is iterating over a
+list which is not an array. This used to assign the list to a
+temporary array, but no longer does so (for efficiency). This means
+that you'll now be iterating over the actual values, not over copies of
+the values. Modifications to the loop variable can change the original
+values.
+ @list = ('ab','abc','bcd','def');
+ foreach $var (grep(/ab/,@list)){
+ $var = 1;
+ }
+ print (join(':',@list));
-=item *
+ # perl4 prints: ab:abc:bcd:def
+ # perl5 prints: 1:1:bcd:def
+
+To retain Perl4 semantics you need to assign your list
+explicitly to a temporary array and then iterate over that. For
+example, you might need to change
+
+ foreach $var (grep(/ab/,@list)){
+
+to
+
+ foreach $var (@tmp = grep(/ab/,@list)){
+
+Otherwise changing $var will clobber the values of @list. (This most often
+happens when you use C<$_> for the loop variable, and call subroutines in
+the loop that don't properly localize C<$_>.)
+
+=item * C<split> with no args behavior changed
+
+C<split> with no arguments now behaves like C<split ' '> (which doesn't
+return an initial null field if $_ starts with whitespace), it used to
+behave like C<split /\s+/> (which does).
+
+ $_ = ' hi mom';
+ print join(':', split);
+
+ # perl4 prints: :hi:mom
+ # perl5 prints: hi:mom
+
+=item * B<-e> behavior fixed
+
+Perl 4 would ignore any text which was attached to an B<-e> switch,
+always taking the code snippet from the following arg. Additionally, it
+would silently accept an B<-e> switch without a following arg. Both of
+these behaviors have been fixed.
+
+ perl -e'print "attached to -e"' 'print "separate arg"'
+
+ # perl4 prints: separate arg
+ # perl5 prints: attached to -e
+
+ perl -e
+
+ # perl4 prints:
+ # perl5 dies: No code specified for -e.
+
+=item * C<push> returns number of elements in resulting list
+
+In Perl 4 the return value of C<push> was undocumented, but it was
+actually the last value being pushed onto the target list. In Perl 5
+the return value of C<push> is documented, but has changed, it is the
+number of elements in the resulting list.
+
+ @x = ('existing');
+ print push(@x, 'first new', 'second new');
+
+ # perl4 prints: second new
+ # perl5 prints: 3
+
+=item * Some error messages differ
+
+Some error messages will be different.
+
+=item * C<split()> honors subroutine args
+
+In Perl 4, if in list context the delimiters to the first argument of
+C<split()> were C<??>, the result would be placed in C<@_> as well as
+being returned. Perl 5 has more respect for your subroutine arguments.
+
+=item * Bugs removed
+
+Some bugs may have been inadvertently removed. :-)
+
+=back
+
+=head2 Parsing Traps
+
+Perl4-to-Perl5 traps from having to do with parsing.
+
+=over 4
+
+=item * Space between . and = triggers syntax error
+
+Note the space between . and =
+
+ $string . = "more string";
+ print $string;
+
+ # perl4 prints: more string
+ # perl5 prints: syntax error at - line 1, near ". ="
+
+=item * Better parsing in perl 5
+
+Better parsing in perl 5
+
+ sub foo {}
+ &foo
+ print("hello, world\n");
+
+ # perl4 prints: hello, world
+ # perl5 prints: syntax error
+
+=item * Function parsing
+
+"if it looks like a function, it is a function" rule.
+
+ print
+ ($foo == 1) ? "is one\n" : "is zero\n";
+
+ # perl4 prints: is zero
+ # perl5 warns: "Useless use of a constant in void context" if using -w
+
+=item * String interpolation of C<$#array> differs
+
+String interpolation of the C<$#array> construct differs when braces
+are to used around the name.
+
+ @a = (1..3);
+ print "${#a}";
+
+ # perl4 prints: 2
+ # perl5 fails with syntax error
+
+ @ = (1..3);
+ print "$#{a}";
+
+ # perl4 prints: {a}
+ # perl5 prints: 2
+
+=item * Perl guesses on C<map>, C<grep> followed by C<{> if it starts BLOCK or hash ref
+
+When perl sees C<map {> (or C<grep {>), it has to guess whether the C<{>
+starts a BLOCK or a hash reference. If it guesses wrong, it will report
+a syntax error near the C<}> and the missing (or unexpected) comma.
+
+Use unary C<+> before C<{> on a hash reference, and unary C<+> applied
+to the first thing in a BLOCK (after C<{>), for perl to guess right all
+the time. (See L<perlfunc/map>.)
+
+=back
+
+=head2 Numerical Traps
+
+Perl4-to-Perl5 traps having to do with numerical operators,
+operands, or output from same.
+
+=over 5
+
+=item * Formatted output and significant digits
+
+Formatted output and significant digits. In general, Perl 5
+tries to be more precise. For example, on a Solaris Sparc:
+
+ print 7.373504 - 0, "\n";
+ printf "%20.18f\n", 7.373504 - 0;
+
+ # Perl4 prints:
+ 7.3750399999999996141
+ 7.375039999999999614
+
+ # Perl5 prints:
+ 7.373504
+ 7.375039999999999614
+
+Notice how the first result looks better in Perl 5.
+
+Your results may vary, since your floating point formatting routines
+and even floating point format may be slightly different.
+
+=item * Auto-increment operator over signed int limit deleted
+
+This specific item has been deleted. It demonstrated how the auto-increment
+operator would not catch when a number went over the signed int limit. Fixed
+in version 5.003_04. But always be wary when using large integers.
+If in doubt:
+
+ use Math::BigInt;
+
+=item * Assignment of return values from numeric equality tests doesn't work
+
+Assignment of return values from numeric equality tests
+does not work in perl5 when the test evaluates to false (0).
+Logical tests now return a null, instead of 0
+
+ $p = ($test == 1);
+ print $p,"\n";
+
+ # perl4 prints: 0
+ # perl5 prints:
+
+Also see L<"General Regular Expression Traps using s///, etc.">
+for another example of this new feature...
+
+=item * Bitwise string ops
+
+When bitwise operators which can operate upon either numbers or
+strings (C<& | ^ ~>) are given only strings as arguments, perl4 would
+treat the operands as bitstrings so long as the program contained a call
+to the C<vec()> function. perl5 treats the string operands as bitstrings.
+(See L<perlop/Bitwise String Operators> for more details.)
+
+ $fred = "10";
+ $barney = "12";
+ $betty = $fred & $barney;
+ print "$betty\n";
+ # Uncomment the next line to change perl4's behavior
+ # ($dummy) = vec("dummy", 0, 0);
+
+ # Perl4 prints:
+ 8
+
+ # Perl5 prints:
+ 10
+
+ # If vec() is used anywhere in the program, both print:
+ 10
+
+=back
+
+=head2 General data type traps
+
+Perl4-to-Perl5 traps involving most data-types, and their usage
+within certain expressions and/or context.
+
+=over 5
+
+=item * Negative array subscripts now count from the end of array
Negative array subscripts now count from the end of the array.
-=item *
+ @a = (1, 2, 3, 4, 5);
+ print "The third element of the array is $a[3] also expressed as $a[-2] \n";
+
+ # perl4 prints: The third element of the array is 4 also expressed as
+ # perl5 prints: The third element of the array is 4 also expressed as 4
+
+=item * Setting C<$#array> lower now discards array elements
+
+Setting C<$#array> lower now discards array elements, and makes them
+impossible to recover.
+
+ @a = (a,b,c,d,e);
+ print "Before: ",join('',@a);
+ $#a =1;
+ print ", After: ",join('',@a);
+ $#a =3;
+ print ", Recovered: ",join('',@a),"\n";
+
+ # perl4 prints: Before: abcde, After: ab, Recovered: abcd
+ # perl5 prints: Before: abcde, After: ab, Recovered: ab
+
+=item * Hashes get defined before use
+
+Hashes get defined before use
+
+ local($s,@a,%h);
+ die "scalar \$s defined" if defined($s);
+ die "array \@a defined" if defined(@a);
+ die "hash \%h defined" if defined(%h);
+
+ # perl4 prints:
+ # perl5 dies: hash %h defined
+
+Perl will now generate a warning when it sees defined(@a) and
+defined(%h).
+
+=item * Glob assignment from localized variable to variable
+
+glob assignment from variable to variable will fail if the assigned
+variable is localized subsequent to the assignment
+
+ @a = ("This is Perl 4");
+ *b = *a;
+ local(@a);
+ print @b,"\n";
+
+ # perl4 prints: This is Perl 4
+ # perl5 prints:
+
+=item * Assigning C<undef> to glob
+
+Assigning C<undef> to a glob has no effect in Perl 5. In Perl 4
+it undefines the associated scalar (but may have other side effects
+including SEGVs). Perl 5 will also warn if C<undef> is assigned to a
+typeglob. (Note that assigning C<undef> to a typeglob is different
+than calling the C<undef> function on a typeglob (C<undef *foo>), which
+has quite a few effects.
+
+ $foo = "bar";
+ *foo = undef;
+ print $foo;
+
+ # perl4 prints:
+ # perl4 warns: "Use of uninitialized variable" if using -w
+ # perl5 prints: bar
+ # perl5 warns: "Undefined value assigned to typeglob" if using -w
+
+=item * Changes in unary negation (of strings)
+
+Changes in unary negation (of strings)
+This change effects both the return value and what it
+does to auto(magic)increment.
+
+ $x = "aaa";
+ print ++$x," : ";
+ print -$x," : ";
+ print ++$x,"\n";
+
+ # perl4 prints: aab : -0 : 1
+ # perl5 prints: aab : -aab : aac
+
+=item * Modifying of constants prohibited
+
+perl 4 lets you modify constants:
+
+ $foo = "x";
+ &mod($foo);
+ for ($x = 0; $x < 3; $x++) {
+ &mod("a");
+ }
+ sub mod {
+ print "before: $_[0]";
+ $_[0] = "m";
+ print " after: $_[0]\n";
+ }
+
+ # perl4:
+ # before: x after: m
+ # before: a after: m
+ # before: m after: m
+ # before: m after: m
+
+ # Perl5:
+ # before: x after: m
+ # Modification of a read-only value attempted at foo.pl line 12.
+ # before: a
+
+=item * C<defined $var> behavior changed
+
+The behavior is slightly different for:
+
+ print "$x", defined $x
+
+ # perl 4: 1
+ # perl 5: <no output, $x is not called into existence>
+
+=item * Variable Suicide
+
+Variable suicide behavior is more consistent under Perl 5.
+Perl5 exhibits the same behavior for hashes and scalars,
+that perl4 exhibits for only scalars.
+
+ $aGlobal{ "aKey" } = "global value";
+ print "MAIN:", $aGlobal{"aKey"}, "\n";
+ $GlobalLevel = 0;
+ &test( *aGlobal );
+
+ sub test {
+ local( *theArgument ) = @_;
+ local( %aNewLocal ); # perl 4 != 5.001l,m
+ $aNewLocal{"aKey"} = "this should never appear";
+ print "SUB: ", $theArgument{"aKey"}, "\n";
+ $aNewLocal{"aKey"} = "level $GlobalLevel"; # what should print
+ $GlobalLevel++;
+ if( $GlobalLevel<4 ) {
+ &test( *aNewLocal );
+ }
+ }
+
+ # Perl4:
+ # MAIN:global value
+ # SUB: global value
+ # SUB: level 0
+ # SUB: level 1
+ # SUB: level 2
+
+ # Perl5:
+ # MAIN:global value
+ # SUB: global value
+ # SUB: this should never appear
+ # SUB: this should never appear
+ # SUB: this should never appear
+
+=back
+
+=head2 Context Traps - scalar, list contexts
+
+=over 5
+
+=item * Elements of argument lists for formats evaluated in list context
+
+The elements of argument lists for formats are now evaluated in list
+context. This means you can interpolate list values now.
+
+ @fmt = ("foo","bar","baz");
+ format STDOUT=
+ @<<<<< @||||| @>>>>>
+ @fmt;
+ .
+ write;
+
+ # perl4 errors: Please use commas to separate fields in file
+ # perl5 prints: foo bar baz
+
+=item * C<caller()> returns false value in scalar context if no caller present
+
+The C<caller()> function now returns a false value in a scalar context
+if there is no caller. This lets library files determine if they're
+being required.
+
+ caller() ? (print "You rang?\n") : (print "Got a 0\n");
+
+ # perl4 errors: There is no caller
+ # perl5 prints: Got a 0
+
+=item * Comma operator in scalar context gives scalar context to args
The comma operator in a scalar context is now guaranteed to give a
scalar context to its arguments.
-=item *
+ @y= ('a','b','c');
+ $x = (1, 2, @y);
+ print "x = $x\n";
-The C<**> operator now binds more tightly than unary minus.
-It was documented to work this way before, but didn't.
+ # Perl4 prints: x = c # Thinks list context interpolates list
+ # Perl5 prints: x = 3 # Knows scalar uses length of list
-=item *
+=item * C<sprintf()> prototyped as C<($;@)>
-Setting C<$#array> lower now discards array elements.
+C<sprintf()> is prototyped as ($;@), so its first argument is given scalar
+context. Thus, if passed an array, it will probably not do what you want,
+unlike Perl 4:
-=item *
+ @z = ('%s%s', 'foo', 'bar');
+ $x = sprintf(@z);
+ print $x;
-delete() is not guaranteed to return the old value for tie()d arrays,
-since this capability may be onerous for some modules to implement.
+ # perl4 prints: foobar
+ # perl5 prints: 3
-=item *
+C<printf()> works the same as it did in Perl 4, though:
-Some error messages will be different.
+ @z = ('%s%s', 'foo', 'bar');
+ printf STDOUT (@z);
-=item *
+ # perl4 prints: foobar
+ # perl5 prints: foobar
+
+=back
+
+=head2 Precedence Traps
+
+Perl4-to-Perl5 traps involving precedence order.
+
+Perl 4 has almost the same precedence rules as Perl 5 for the operators
+that they both have. Perl 4 however, seems to have had some
+inconsistencies that made the behavior differ from what was documented.
+
+=over 5
+
+=item * LHS vs. RHS of any assignment operator
+
+LHS vs. RHS of any assignment operator. LHS is evaluated first
+in perl4, second in perl5; this can affect the relationship
+between side-effects in sub-expressions.
+
+ @arr = ( 'left', 'right' );
+ $a{shift @arr} = shift @arr;
+ print join( ' ', keys %a );
+
+ # perl4 prints: left
+ # perl5 prints: right
+
+=item * Semantic errors introduced due to precedence
+
+These are now semantic errors because of precedence:
+
+ @list = (1,2,3,4,5);
+ %map = ("a",1,"b",2,"c",3,"d",4);
+ $n = shift @list + 2; # first item in list plus 2
+ print "n is $n, ";
+ $m = keys %map + 2; # number of items in hash plus 2
+ print "m is $m\n";
+
+ # perl4 prints: n is 3, m is 6
+ # perl5 errors and fails to compile
+
+=item * Precedence of assignment operators same as the precedence of assignment
+
+The precedence of assignment operators is now the same as the precedence
+of assignment. Perl 4 mistakenly gave them the precedence of the associated
+operator. So you now must parenthesize them in expressions like
+
+ /foo/ ? ($a += 2) : ($a -= 2);
+
+Otherwise
+
+ /foo/ ? $a += 2 : $a -= 2
+
+would be erroneously parsed as
+
+ (/foo/ ? $a += 2 : $a) -= 2;
+
+On the other hand,
+
+ $a += /foo/ ? 1 : 2;
+
+now works as a C programmer would expect.
+
+=item * C<open> requires parentheses around filehandle
+
+ open FOO || die;
+
+is now incorrect. You need parentheses around the filehandle.
+Otherwise, perl5 leaves the statement as its default precedence:
+
+ open(FOO || die);
+
+ # perl4 opens or dies
+ # perl5 opens FOO, dying only if 'FOO' is false, i.e. never
+
+=item * C<$:> precedence over C<$::> gone
+
+perl4 gives the special variable, C<$:> precedence, where perl5
+treats C<$::> as main C<package>
+
+ $a = "x"; print "$::a";
+
+ # perl 4 prints: -:a
+ # perl 5 prints: x
+
+=item * Precedence of file test operators documented
+
+perl4 had buggy precedence for the file test operators vis-a-vis
+the assignment operators. Thus, although the precedence table
+for perl4 leads one to believe C<-e $foo .= "q"> should parse as
+C<((-e $foo) .= "q")>, it actually parses as C<(-e ($foo .= "q"))>.
+In perl5, the precedence is as documented.
+
+ -e $foo .= "q"
+
+ # perl4 prints: no output
+ # perl5 prints: Can't modify -e in concatenation
+
+=item * C<keys>, C<each>, C<values> are regular named unary operators
+
+In perl4, keys(), each() and values() were special high-precedence operators
+that operated on a single hash, but in perl5, they are regular named unary
+operators. As documented, named unary operators have lower precedence
+than the arithmetic and concatenation operators C<+ - .>, but the perl4
+variants of these operators actually bind tighter than C<+ - .>.
+Thus, for:
+
+ %foo = 1..10;
+ print keys %foo - 1
+
+ # perl4 prints: 4
+ # perl5 prints: Type of arg 1 to keys must be hash (not subtraction)
+
+The perl4 behavior was probably more useful, if less consistent.
+
+=back
+
+=head2 General Regular Expression Traps using s///, etc.
+
+All types of RE traps.
+
+=over 5
+
+=item * C<s'$lhs'$rhs'> interpolates on either side
+
+C<s'$lhs'$rhs'> now does no interpolation on either side. It used to
+interpolate $lhs but not $rhs. (And still does not match a literal
+'$' in string)
+
+ $a=1;$b=2;
+ $string = '1 2 $a $b';
+ $string =~ s'$a'$b';
+ print $string,"\n";
+
+ # perl4 prints: $b 2 $a $b
+ # perl5 prints: 1 2 $a $b
+
+=item * C<m//g> attaches its state to the searched string
+
+C<m//g> now attaches its state to the searched string rather than the
+regular expression. (Once the scope of a block is left for the sub, the
+state of the searched string is lost)
+
+ $_ = "ababab";
+ while(m/ab/g){
+ &doit("blah");
+ }
+ sub doit{local($_) = shift; print "Got $_ "}
+
+ # perl4 prints: Got blah Got blah Got blah Got blah
+ # perl5 prints: infinite loop blah...
+
+=item * C<m//o> used within an anonymous sub
+
+Currently, if you use the C<m//o> qualifier on a regular expression
+within an anonymous sub, I<all> closures generated from that anonymous
+sub will use the regular expression as it was compiled when it was used
+the very first time in any such closure. For instance, if you say
+
+ sub build_match {
+ my($left,$right) = @_;
+ return sub { $_[0] =~ /$left stuff $right/o; };
+ }
+ $good = build_match('foo','bar');
+ $bad = build_match('baz','blarch');
+ print $good->('foo stuff bar') ? "ok\n" : "not ok\n";
+ print $bad->('baz stuff blarch') ? "ok\n" : "not ok\n";
+ print $bad->('foo stuff bar') ? "not ok\n" : "ok\n";
+
+For most builds of Perl5, this will print:
+ok
+not ok
+not ok
+
+build_match() will always return a sub which matches the contents of
+$left and $right as they were the I<first> time that build_match()
+was called, not as they are in the current call.
+
+=item * C<$+> isn't set to whole match
+
+If no parentheses are used in a match, Perl4 sets C<$+> to
+the whole match, just like C<$&>. Perl5 does not.
+
+ "abcdef" =~ /b.*e/;
+ print "\$+ = $+\n";
+
+ # perl4 prints: bcde
+ # perl5 prints:
+
+=item * Substitution now returns null string if it fails
+
+substitution now returns the null string if it fails
+
+ $string = "test";
+ $value = ($string =~ s/foo//);
+ print $value, "\n";
+
+ # perl4 prints: 0
+ # perl5 prints:
+
+Also see L<Numerical Traps> for another example of this new feature.
+
+=item * C<s`lhs`rhs`> is now a normal substitution
+
+C<s`lhs`rhs`> (using backticks) is now a normal substitution, with no
+backtick expansion
+
+ $string = "";
+ $string =~ s`^`hostname`;
+ print $string, "\n";
+
+ # perl4 prints: <the local hostname>
+ # perl5 prints: hostname
+
+=item * Stricter parsing of variables in regular expressions
+
+Stricter parsing of variables used in regular expressions
+
+ s/^([^$grpc]*$grpc[$opt$plus$rep]?)//o;
+
+ # perl4: compiles w/o error
+ # perl5: with Scalar found where operator expected ..., near "$opt$plus"
+
+an added component of this example, apparently from the same script, is
+the actual value of the s'd string after the substitution.
+C<[$opt]> is a character class in perl4 and an array subscript in perl5
+
+ $grpc = 'a';
+ $opt = 'r';
+ $_ = 'bar';
+ s/^([^$grpc]*$grpc[$opt]?)/foo/;
+ print ;
+
+ # perl4 prints: foo
+ # perl5 prints: foobar
+
+=item * C<m?x?> matches only once
+
+Under perl5, C<m?x?> matches only once, like C<?x?>. Under perl4, it matched
+repeatedly, like C</x/> or C<m!x!>.
+
+ $test = "once";
+ sub match { $test =~ m?once?; }
+ &match();
+ if( &match() ) {
+ # m?x? matches more then once
+ print "perl4\n";
+ } else {
+ # m?x? matches only once
+ print "perl5\n";
+ }
+
+ # perl4 prints: perl4
+ # perl5 prints: perl5
+
+=item * Failed matches don't reset the match variables
+
+Unlike in Ruby, failed matches in Perl do not reset the match variables
+($1, $2, ..., C<$`>, ...).
+
+=back
+
+=head2 Subroutine, Signal, Sorting Traps
+
+The general group of Perl4-to-Perl5 traps having to do with
+Signals, Sorting, and their related subroutines, as well as
+general subroutine traps. Includes some OS-Specific traps.
+
+=over 5
+
+=item * Barewords that used to look like strings look like subroutine calls
+
+Barewords that used to look like strings to Perl will now look like subroutine
+calls if a subroutine by that name is defined before the compiler sees them.
+
+ sub SeeYa { warn"Hasta la vista, baby!" }
+ $SIG{'TERM'} = SeeYa;
+ print "SIGTERM is now $SIG{'TERM'}\n";
+
+ # perl4 prints: SIGTERM is now main'SeeYa
+ # perl5 prints: SIGTERM is now main::1 (and warns "Hasta la vista, baby!")
+
+Use B<-w> to catch this one
+
+=item * Reverse is no longer allowed as the name of a sort subroutine
+
+reverse is no longer allowed as the name of a sort subroutine.
+
+ sub reverse{ print "yup "; $a <=> $b }
+ print sort reverse (2,1,3);
+
+ # perl4 prints: yup yup 123
+ # perl5 prints: 123
+ # perl5 warns (if using -w): Ambiguous call resolved as CORE::reverse()
+
+=item * C<warn()> won't let you specify a filehandle.
+
+Although it _always_ printed to STDERR, warn() would let you specify a
+filehandle in perl4. With perl5 it does not.
+
+ warn STDERR "Foo!";
-Some bugs may have been inadvertently removed.
+ # perl4 prints: Foo!
+ # perl5 prints: String found where operator expected
=back
+
+=head2 OS Traps
+
+=over 5
+
+=item * SysV resets signal handler correctly
+
+Under HPUX, and some other SysV OSes, one had to reset any signal handler,
+within the signal handler function, each time a signal was handled with
+perl4. With perl5, the reset is now done correctly. Any code relying
+on the handler _not_ being reset will have to be reworked.
+
+Since version 5.002, Perl uses sigaction() under SysV.
+
+ sub gotit {
+ print "Got @_... ";
+ }
+ $SIG{'INT'} = 'gotit';
+
+ $| = 1;
+ $pid = fork;
+ if ($pid) {
+ kill('INT', $pid);
+ sleep(1);
+ kill('INT', $pid);
+ } else {
+ while (1) {sleep(10);}
+ }
+
+ # perl4 (HPUX) prints: Got INT...
+ # perl5 (HPUX) prints: Got INT... Got INT...
+
+=item * SysV C<seek()> appends correctly
+
+Under SysV OSes, C<seek()> on a file opened to append C<<< >> >>> now does
+the right thing w.r.t. the fopen() manpage. e.g., - When a file is opened
+for append, it is impossible to overwrite information already in
+the file.
+
+ open(TEST,">>seek.test");
+ $start = tell TEST ;
+ foreach(1 .. 9){
+ print TEST "$_ ";
+ }
+ $end = tell TEST ;
+ seek(TEST,$start,0);
+ print TEST "18 characters here";
+
+ # perl4 (solaris) seek.test has: 18 characters here
+ # perl5 (solaris) seek.test has: 1 2 3 4 5 6 7 8 9 18 characters here
+
+
+
+=back
+
+=head2 Interpolation Traps
+
+Perl4-to-Perl5 traps having to do with how things get interpolated
+within certain expressions, statements, contexts, or whatever.
+
+=over 5
+
+=item * C<@> always interpolates an array in double-quotish strings
+
+@ now always interpolates an array in double-quotish strings.
+
+ print "To: someone@somewhere.com\n";
+
+ # perl4 prints: To:someone@somewhere.com
+ # perl < 5.6.1, error : In string, @somewhere now must be written as \@somewhere
+ # perl >= 5.6.1, warning : Possible unintended interpolation of @somewhere in string
+
+=item * Double-quoted strings may no longer end with an unescaped $
+
+Double-quoted strings may no longer end with an unescaped $.
+
+ $foo = "foo$";
+ print "foo is $foo\n";
+
+ # perl4 prints: foo is foo$
+ # perl5 errors: Final $ should be \$ or $name
+
+Note: perl5 DOES NOT error on the terminating @ in $bar
+
+=item * Arbitrary expressions are evaluated inside braces within double quotes
+
+Perl now sometimes evaluates arbitrary expressions inside braces that occur
+within double quotes (usually when the opening brace is preceded by C<$>
+or C<@>).
+
+ @www = "buz";
+ $foo = "foo";
+ $bar = "bar";
+ sub foo { return "bar" };
+ print "|@{w.w.w}|${main'foo}|";
+
+ # perl4 prints: |@{w.w.w}|foo|
+ # perl5 prints: |buz|bar|
+
+Note that you can C<use strict;> to ward off such trappiness under perl5.
+
+=item * C<$$x> now tries to dereference $x
+
+The construct "this is $$x" used to interpolate the pid at that point, but
+now tries to dereference $x. C<$$> by itself still works fine, however.
+
+ $s = "a reference";
+ $x = *s;
+ print "this is $$x\n";
+
+ # perl4 prints: this is XXXx (XXX is the current pid)
+ # perl5 prints: this is a reference
+
+=item * Creation of hashes on the fly with C<eval "EXPR"> requires protection
+
+Creation of hashes on the fly with C<eval "EXPR"> now requires either both
+C<$>'s to be protected in the specification of the hash name, or both curlies
+to be protected. If both curlies are protected, the result will be compatible
+with perl4 and perl5. This is a very common practice, and should be changed
+to use the block form of C<eval{}> if possible.
+
+ $hashname = "foobar";
+ $key = "baz";
+ $value = 1234;
+ eval "\$$hashname{'$key'} = q|$value|";
+ (defined($foobar{'baz'})) ? (print "Yup") : (print "Nope");
+
+ # perl4 prints: Yup
+ # perl5 prints: Nope
+
+Changing
+
+ eval "\$$hashname{'$key'} = q|$value|";
+
+to
+
+ eval "\$\$hashname{'$key'} = q|$value|";
+
+causes the following result:
+
+ # perl4 prints: Nope
+ # perl5 prints: Yup
+
+or, changing to
+
+ eval "\$$hashname\{'$key'\} = q|$value|";
+
+causes the following result:
+
+ # perl4 prints: Yup
+ # perl5 prints: Yup
+ # and is compatible for both versions
+
+
+=item * Bugs in earlier perl versions
+
+perl4 programs which unconsciously rely on the bugs in earlier perl versions.
+
+ perl -e '$bar=q/not/; print "This is $foo{$bar} perl5"'
+
+ # perl4 prints: This is not perl5
+ # perl5 prints: This is perl5
+
+=item * Array and hash brackets during interpolation
+
+You also have to be careful about array and hash brackets during
+interpolation.
+
+ print "$foo["
+
+ perl 4 prints: [
+ perl 5 prints: syntax error
+
+ print "$foo{"
+
+ perl 4 prints: {
+ perl 5 prints: syntax error
+
+Perl 5 is expecting to find an index or key name following the respective
+brackets, as well as an ending bracket of the appropriate type. In order
+to mimic the behavior of Perl 4, you must escape the bracket like so.
+
+ print "$foo\[";
+ print "$foo\{";
+
+=item * Interpolation of C<\$$foo{bar}>
+
+Similarly, watch out for: C<\$$foo{bar}>
+
+ $foo = "baz";
+ print "\$$foo{bar}\n";
+
+ # perl4 prints: $baz{bar}
+ # perl5 prints: $
+
+Perl 5 is looking for C<$foo{bar}> which doesn't exist, but perl 4 is
+happy just to expand $foo to "baz" by itself. Watch out for this
+especially in C<eval>'s.
+
+=item * C<qq()> string passed to C<eval> will not find string terminator
+
+C<qq()> string passed to C<eval>
+
+ eval qq(
+ foreach \$y (keys %\$x\) {
+ \$count++;
+ }
+ );
+
+ # perl4 runs this ok
+ # perl5 prints: Can't find string terminator ")"
+
+=back
+
+=head2 DBM Traps
+
+General DBM traps.
+
+=over 5
+
+=item * Perl5 must have been linked with same dbm/ndbm as the default for C<dbmopen()>
+
+Existing dbm databases created under perl4 (or any other dbm/ndbm tool)
+may cause the same script, run under perl5, to fail. The build of perl5
+must have been linked with the same dbm/ndbm as the default for C<dbmopen()>
+to function properly without C<tie>'ing to an extension dbm implementation.
+
+ dbmopen (%dbm, "file", undef);
+ print "ok\n";
+
+ # perl4 prints: ok
+ # perl5 prints: ok (IFF linked with -ldbm or -lndbm)
+
+
+=item * DBM exceeding limit on the key/value size will cause perl5 to exit immediately
+
+Existing dbm databases created under perl4 (or any other dbm/ndbm tool)
+may cause the same script, run under perl5, to fail. The error generated
+when exceeding the limit on the key/value size will cause perl5 to exit
+immediately.
+
+ dbmopen(DB, "testdb",0600) || die "couldn't open db! $!";
+ $DB{'trap'} = "x" x 1024; # value too large for most dbm/ndbm
+ print "YUP\n";
+
+ # perl4 prints:
+ dbm store returned -1, errno 28, key "trap" at - line 3.
+ YUP
+
+ # perl5 prints:
+ dbm store returned -1, errno 28, key "trap" at - line 3.
+
+=back
+
+=head2 Unclassified Traps
+
+Everything else.
+
+=over 5
+
+=item * C<require>/C<do> trap using returned value
+
+If the file doit.pl has:
+
+ sub foo {
+ $rc = do "./do.pl";
+ return 8;
+ }
+ print &foo, "\n";
+
+And the do.pl file has the following single line:
+
+ return 3;
+
+Running doit.pl gives the following:
+
+ # perl 4 prints: 3 (aborts the subroutine early)
+ # perl 5 prints: 8
+
+Same behavior if you replace C<do> with C<require>.
+
+=item * C<split> on empty string with LIMIT specified
+
+ $string = '';
+ @list = split(/foo/, $string, 2)
+
+Perl4 returns a one element list containing the empty string but Perl5
+returns an empty list.
+
+=back
+
+As always, if any of these are ever officially declared as bugs,
+they'll be fixed and removed.
+
https://perl5.git.perl.org / perl5.git / blobdiff