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