Commit | Line | Data |
---|---|---|
a0d0e21e LW |
1 | =head1 NAME |
2 | ||
3 | perltrap - Perl traps for the unwary | |
4 | ||
5 | =head1 DESCRIPTION | |
6 | ||
cb1a09d0 AD |
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 LW |
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 LW |
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 | ||
8b0a4b75 | 72 | $E<lt>I<digit>E<gt> does not refer to fields--it refers to substrings matched |
73 | by the last match pattern. | |
a0d0e21e LW |
74 | |
75 | =item * | |
76 | ||
77 | The print() statement does not add field and record separators unless | |
8b0a4b75 | 78 | you set C<$,> and C<$\>. You can set $OFS and $ORS if you're using |
a0d0e21e LW |
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 | |
5f05dabc | 104 | null string would render C</pat/ /pat/> unparsable, because the third slash |
105 | would be interpreted as a division operator--the tokenizer is in fact | |
8b0a4b75 | 106 | slightly context sensitive for operators like "/", "?", and "E<gt>". |
a0d0e21e LW |
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 LW |
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 | |
5f05dabc | 186 | in Perl is the backslash, which creates a reference. |
a0d0e21e LW |
187 | |
188 | =item * | |
189 | ||
4633a7c4 LW |
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 LW |
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 | ||
5f05dabc | 234 | The back-tick operator does variable interpolation without regard to |
a0d0e21e LW |
235 | the presence of single quotes in the command. |
236 | ||
237 | =item * | |
238 | ||
5f05dabc | 239 | The back-tick operator does no translation of the return value, unlike B<csh>. |
a0d0e21e LW |
240 | |
241 | =item * | |
242 | ||
243 | Shells (especially B<csh>) do several levels of substitution on each | |
5f05dabc | 244 | command line. Perl does substitution in only certain constructs |
245 | such as double quotes, back-ticks, angle brackets, and search patterns. | |
a0d0e21e LW |
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. | |
5f05dabc | 278 | You can't tell by just looking at it whether a bareword is |
a0d0e21e | 279 | a function or a string. By using quotes on strings and |
5f05dabc | 280 | parentheses on function calls, you won't ever get them confused. |
a0d0e21e LW |
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()). | |
5f05dabc | 287 | (User-defined subroutines can be B<only> list operators, never |
a0d0e21e LW |
288 | unary ones.) See L<perlop>. |
289 | ||
290 | =item * | |
291 | ||
748a9306 | 292 | People have a hard time remembering that some functions |
a0d0e21e LW |
293 | default to $_, or @ARGV, or whatever, but that others which |
294 | you might expect to do not. | |
295 | ||
6dbacca0 | 296 | =item * |
a0d0e21e | 297 | |
8b0a4b75 | 298 | The E<lt>FHE<gt> construct is not the name of the filehandle, it is a readline |
5f05dabc | 299 | operation on that handle. The data read is assigned to $_ only if the |
748a9306 LW |
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 LW |
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 LW |
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 LW |
333 | =back |
334 | ||
5f05dabc | 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 LW |
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 | |
5f05dabc | 422 | behave differently in perl4 vs. perl5, because the packages don't exist. |
6dbacca0 | 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 | |
5e378fdf | 483 | |
6dbacca0 | 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 | ||
5e378fdf | 540 | =item * Discontinuance |
541 | ||
542 | C<split> with no arguments now behaves like C<split ' '> (which doesn't | |
543 | return an initial null field if $_ starts with whitespace), it used to | |
544 | behave like C<split /\s+/> (which does). | |
545 | ||
546 | $_ = ' hi mom'; | |
547 | print join(':', split); | |
548 | ||
549 | # perl4 prints: :hi:mom | |
550 | # perl5 prints: hi:mom | |
551 | ||
55497cff | 552 | =item * BugFix |
553 | ||
554 | Perl 4 would ignore any text which was attached to an C<-e> switch, | |
555 | always taking the code snippet from the following arg. Additionally, it | |
556 | would silently accept an C<-e> switch without a following arg. Both of | |
557 | these behaviors have been fixed. | |
558 | ||
559 | perl -e'print "attached to -e"' 'print "separate arg"' | |
560 | ||
561 | # perl4 prints: separate arg | |
562 | # perl5 prints: attached to -e | |
563 | ||
564 | perl -e | |
565 | ||
566 | # perl4 prints: | |
567 | # perl5 dies: No code specified for -e. | |
568 | ||
569 | =item * Discontinuance | |
570 | ||
571 | In Perl 4 the return value of C<push> was undocumented, but it was | |
572 | actually the last value being pushed onto the target list. In Perl 5 | |
573 | the return value of C<push> is documented, but has changed, it is the | |
574 | number of elements in the resulting list. | |
575 | ||
576 | @x = ('existing'); | |
577 | print push(@x, 'first new', 'second new'); | |
578 | ||
579 | # perl4 prints: second new | |
580 | # perl5 prints: 3 | |
581 | ||
6dbacca0 | 582 | =item * Deprecation |
583 | ||
584 | Some error messages will be different. | |
585 | ||
586 | =item * Discontinuance | |
587 | ||
588 | Some bugs may have been inadvertently removed. :-) | |
589 | ||
590 | =back | |
591 | ||
592 | =head2 Parsing Traps | |
593 | ||
594 | Perl4-to-Perl5 traps from having to do with parsing. | |
595 | ||
596 | =over 4 | |
597 | ||
598 | =item * Parsing | |
599 | ||
600 | Note the space between . and = | |
601 | ||
602 | $string . = "more string"; | |
603 | print $string; | |
604 | ||
605 | # perl4 prints: more string | |
606 | # perl5 prints: syntax error at - line 1, near ". =" | |
607 | ||
608 | =item * Parsing | |
609 | ||
610 | Better parsing in perl 5 | |
611 | ||
612 | sub foo {} | |
613 | &foo | |
614 | print("hello, world\n"); | |
615 | ||
616 | # perl4 prints: hello, world | |
617 | # perl5 prints: syntax error | |
618 | ||
619 | =item * Parsing | |
620 | ||
621 | "if it looks like a function, it is a function" rule. | |
622 | ||
623 | ||
624 | ($foo == 1) ? "is one\n" : "is zero\n"; | |
625 | ||
626 | # perl4 prints: is zero | |
627 | # perl5 warns: "Useless use of a constant in void context" if using -w | |
628 | ||
629 | =back | |
630 | ||
631 | =head2 Numerical Traps | |
632 | ||
633 | Perl4-to-Perl5 traps having to do with numerical operators, | |
634 | operands, or output from same. | |
635 | ||
636 | =over 5 | |
637 | ||
638 | =item * Numerical | |
639 | ||
640 | Formatted output and significant digits | |
641 | ||
642 | print 7.373504 - 0, "\n"; | |
643 | printf "%20.18f\n", 7.373504 - 0; | |
644 | ||
645 | # Perl4 prints: | |
646 | 7.375039999999996141 | |
647 | 7.37503999999999614 | |
648 | ||
649 | # Perl5 prints: | |
650 | 7.373504 | |
651 | 7.37503999999999614 | |
652 | ||
653 | =item * Numerical | |
654 | ||
5f05dabc | 655 | This specific item has been deleted. It demonstrated how the auto-increment |
5e378fdf | 656 | operator would not catch when a number went over the signed int limit. Fixed |
a6006777 | 657 | in version 5.003_04. But always be wary when using large integers. |
658 | If in doubt: | |
6dbacca0 | 659 | |
5e378fdf | 660 | use Math::BigInt; |
6dbacca0 | 661 | |
662 | =item * Numerical | |
663 | ||
664 | Assignment of return values from numeric equality tests | |
665 | does not work in perl5 when the test evaluates to false (0). | |
666 | Logical tests now return an null, instead of 0 | |
a6006777 | 667 | |
6dbacca0 | 668 | $p = ($test == 1); |
669 | print $p,"\n"; | |
a6006777 | 670 | |
6dbacca0 | 671 | # perl4 prints: 0 |
672 | # perl5 prints: | |
673 | ||
55497cff | 674 | Also see the L<General Regular Expression Traps using s///, etc.> |
675 | tests for another example of this new feature... | |
6dbacca0 | 676 | |
677 | =back | |
678 | ||
679 | =head2 General data type traps | |
680 | ||
681 | Perl4-to-Perl5 traps involving most data-types, and their usage | |
682 | within certain expressions and/or context. | |
683 | ||
684 | =over 5 | |
685 | ||
686 | =item * (Arrays) | |
687 | ||
688 | Negative array subscripts now count from the end of the array. | |
689 | ||
690 | @a = (1, 2, 3, 4, 5); | |
691 | print "The third element of the array is $a[3] also expressed as $a[-2] \n"; | |
692 | ||
693 | # perl4 prints: The third element of the array is 4 also expressed as | |
694 | # perl5 prints: The third element of the array is 4 also expressed as 4 | |
695 | ||
696 | =item * (Arrays) | |
697 | ||
698 | Setting C<$#array> lower now discards array elements, and makes them | |
699 | impossible to recover. | |
700 | ||
701 | @a = (a,b,c,d,e); | |
702 | print "Before: ",join('',@a); | |
703 | $#a =1; | |
704 | print ", After: ",join('',@a); | |
705 | $#a =3; | |
706 | print ", Recovered: ",join('',@a),"\n"; | |
707 | ||
708 | # perl4 prints: Before: abcde, After: ab, Recovered: abcd | |
709 | # perl5 prints: Before: abcde, After: ab, Recovered: ab | |
710 | ||
711 | =item * (Hashes) | |
712 | ||
713 | Hashes get defined before use | |
714 | ||
715 | local($s,@a,%h); | |
716 | die "scalar \$s defined" if defined($s); | |
717 | die "array \@a defined" if defined(@a); | |
718 | die "hash \%h defined" if defined(%h); | |
719 | ||
720 | # perl4 prints: | |
721 | # perl5 dies: hash %h defined | |
722 | ||
723 | =item * (Globs) | |
724 | ||
725 | glob assignment from variable to variable will fail if the assigned | |
726 | variable is localized subsequent to the assignment | |
727 | ||
728 | @a = ("This is Perl 4"); | |
729 | *b = *a; | |
730 | local(@a); | |
731 | print @b,"\n"; | |
732 | ||
733 | # perl4 prints: This is Perl 4 | |
734 | # perl5 prints: | |
735 | ||
736 | # Another example | |
737 | ||
738 | *fred = *barney; # fred is aliased to barney | |
739 | @barney = (1, 2, 4); | |
740 | # @fred; | |
741 | print "@fred"; # should print "1, 2, 4" | |
742 | ||
743 | # perl4 prints: 1 2 4 | |
744 | # perl5 prints: Literal @fred now requires backslash | |
5e378fdf | 745 | |
6dbacca0 | 746 | =item * (Scalar String) |
747 | ||
748 | Changes in unary negation (of strings) | |
749 | This change effects both the return value and what it | |
750 | does to auto(magic)increment. | |
751 | ||
752 | $x = "aaa"; | |
753 | print ++$x," : "; | |
754 | print -$x," : "; | |
755 | print ++$x,"\n"; | |
756 | ||
757 | # perl4 prints: aab : -0 : 1 | |
758 | # perl5 prints: aab : -aab : aac | |
759 | ||
760 | =item * (Constants) | |
761 | ||
762 | perl 4 lets you modify constants: | |
763 | ||
764 | $foo = "x"; | |
765 | &mod($foo); | |
766 | for ($x = 0; $x < 3; $x++) { | |
767 | &mod("a"); | |
768 | } | |
769 | sub mod { | |
770 | print "before: $_[0]"; | |
771 | $_[0] = "m"; | |
772 | print " after: $_[0]\n"; | |
773 | } | |
774 | ||
775 | # perl4: | |
776 | # before: x after: m | |
777 | # before: a after: m | |
778 | # before: m after: m | |
779 | # before: m after: m | |
780 | ||
781 | # Perl5: | |
782 | # before: x after: m | |
783 | # Modification of a read-only value attempted at foo.pl line 12. | |
784 | # before: a | |
785 | ||
786 | =item * (Scalars) | |
787 | ||
788 | The behavior is slightly different for: | |
789 | ||
790 | print "$x", defined $x | |
791 | ||
792 | # perl 4: 1 | |
793 | # perl 5: <no output, $x is not called into existence> | |
794 | ||
795 | =item * (Variable Suicide) | |
796 | ||
797 | Variable suicide behavior is more consistent under Perl 5. | |
798 | Perl5 exhibits the same behavior for associative arrays and scalars, | |
5f05dabc | 799 | that perl4 exhibits for only scalars. |
6dbacca0 | 800 | |
801 | $aGlobal{ "aKey" } = "global value"; | |
802 | print "MAIN:", $aGlobal{"aKey"}, "\n"; | |
803 | $GlobalLevel = 0; | |
804 | &test( *aGlobal ); | |
805 | ||
806 | sub test { | |
807 | local( *theArgument ) = @_; | |
808 | local( %aNewLocal ); # perl 4 != 5.001l,m | |
809 | $aNewLocal{"aKey"} = "this should never appear"; | |
810 | print "SUB: ", $theArgument{"aKey"}, "\n"; | |
811 | $aNewLocal{"aKey"} = "level $GlobalLevel"; # what should print | |
812 | $GlobalLevel++; | |
813 | if( $GlobalLevel<4 ) { | |
814 | &test( *aNewLocal ); | |
815 | } | |
816 | } | |
817 | ||
818 | # Perl4: | |
819 | # MAIN:global value | |
820 | # SUB: global value | |
821 | # SUB: level 0 | |
822 | # SUB: level 1 | |
823 | # SUB: level 2 | |
824 | ||
825 | # Perl5: | |
826 | # MAIN:global value | |
827 | # SUB: global value | |
828 | # SUB: this should never appear | |
829 | # SUB: this should never appear | |
830 | # SUB: this should never appear | |
831 | ||
84dc3c4d | 832 | =back |
6dbacca0 | 833 | |
834 | =head2 Context Traps - scalar, list contexts | |
835 | ||
836 | =over 5 | |
837 | ||
838 | =item * (list context) | |
839 | ||
840 | The elements of argument lists for formats are now evaluated in list | |
841 | context. This means you can interpolate list values now. | |
842 | ||
843 | @fmt = ("foo","bar","baz"); | |
844 | format STDOUT= | |
845 | @<<<<< @||||| @>>>>> | |
846 | @fmt; | |
847 | . | |
848 | write; | |
849 | ||
850 | # perl4 errors: Please use commas to separate fields in file | |
851 | # perl5 prints: foo bar baz | |
852 | ||
853 | =item * (scalar context) | |
854 | ||
855 | The C<caller()> function now returns a false value in a scalar context | |
856 | if there is no caller. This lets library files determine if they're | |
857 | being required. | |
858 | ||
859 | caller() ? (print "You rang?\n") : (print "Got a 0\n"); | |
860 | ||
861 | # perl4 errors: There is no caller | |
862 | # perl5 prints: Got a 0 | |
5e378fdf | 863 | |
6dbacca0 | 864 | =item * (scalar context) |
865 | ||
866 | The comma operator in a scalar context is now guaranteed to give a | |
867 | scalar context to its arguments. | |
868 | ||
869 | @y= ('a','b','c'); | |
870 | $x = (1, 2, @y); | |
871 | print "x = $x\n"; | |
872 | ||
873 | # Perl4 prints: x = c # Thinks list context interpolates list | |
874 | # Perl5 prints: x = 3 # Knows scalar uses length of list | |
875 | ||
876 | =item * (list, builtin) | |
877 | ||
878 | C<sprintf()> funkiness (array argument converted to scalar array count) | |
879 | This test could be added to t/op/sprintf.t | |
880 | ||
881 | @z = ('%s%s', 'foo', 'bar'); | |
882 | $x = sprintf(@z); | |
883 | if ($x eq 'foobar') {print "ok 2\n";} else {print "not ok 2 '$x'\n";} | |
884 | ||
885 | # perl4 prints: ok 2 | |
886 | # perl5 prints: not ok 2 | |
887 | ||
888 | C<printf()> works fine, though: | |
889 | ||
890 | printf STDOUT (@z); | |
891 | print "\n"; | |
892 | ||
893 | # perl4 prints: foobar | |
894 | # perl5 prints: foobar | |
895 | ||
896 | Probably a bug. | |
897 | ||
898 | =back | |
899 | ||
900 | =head2 Precedence Traps | |
901 | ||
902 | Perl4-to-Perl5 traps involving precedence order. | |
903 | ||
84dc3c4d | 904 | =over 5 |
905 | ||
5e378fdf | 906 | =item * Precedence |
907 | ||
908 | LHS vs. RHS when both sides are getting an op. | |
909 | ||
910 | @arr = ( 'left', 'right' ); | |
911 | $a{shift @arr} = shift @arr; | |
912 | print join( ' ', keys %a ); | |
913 | ||
914 | # perl4 prints: left | |
915 | # perl5 prints: right | |
916 | ||
917 | =item * Precedence | |
6dbacca0 | 918 | |
919 | These are now semantic errors because of precedence: | |
920 | ||
921 | @list = (1,2,3,4,5); | |
922 | %map = ("a",1,"b",2,"c",3,"d",4); | |
923 | $n = shift @list + 2; # first item in list plus 2 | |
924 | print "n is $n, "; | |
925 | $m = keys %map + 2; # number of items in hash plus 2 | |
926 | print "m is $m\n"; | |
927 | ||
928 | # perl4 prints: n is 3, m is 6 | |
929 | # perl5 errors and fails to compile | |
930 | ||
931 | =item * Precedence | |
a0d0e21e | 932 | |
4633a7c4 LW |
933 | The precedence of assignment operators is now the same as the precedence |
934 | of assignment. Perl 4 mistakenly gave them the precedence of the associated | |
935 | operator. So you now must parenthesize them in expressions like | |
936 | ||
937 | /foo/ ? ($a += 2) : ($a -= 2); | |
a6006777 | 938 | |
4633a7c4 LW |
939 | Otherwise |
940 | ||
6dbacca0 | 941 | /foo/ ? $a += 2 : $a -= 2 |
4633a7c4 LW |
942 | |
943 | would be erroneously parsed as | |
944 | ||
945 | (/foo/ ? $a += 2 : $a) -= 2; | |
946 | ||
947 | On the other hand, | |
948 | ||
6dbacca0 | 949 | $a += /foo/ ? 1 : 2; |
4633a7c4 LW |
950 | |
951 | now works as a C programmer would expect. | |
952 | ||
6dbacca0 | 953 | =item * Precedence |
4633a7c4 | 954 | |
6dbacca0 | 955 | open FOO || die; |
a0d0e21e | 956 | |
5f05dabc | 957 | is now incorrect. You need parentheses around the filehandle. |
958 | Otherwise, perl5 leaves the statement as its default precedence: | |
a0d0e21e | 959 | |
6dbacca0 | 960 | open(FOO || die); |
961 | ||
962 | # perl4 opens or dies | |
963 | # perl5 errors: Precedence problem: open FOO should be open(FOO) | |
a0d0e21e | 964 | |
6dbacca0 | 965 | =item * Precedence |
a0d0e21e | 966 | |
6dbacca0 | 967 | perl4 gives the special variable, C<$:> precedence, where perl5 |
968 | treats C<$::> as main C<package> | |
a0d0e21e | 969 | |
6dbacca0 | 970 | $a = "x"; print "$::a"; |
971 | ||
972 | # perl 4 prints: -:a | |
973 | # perl 5 prints: x | |
5e378fdf | 974 | |
6dbacca0 | 975 | =item * Precedence |
a0d0e21e | 976 | |
6dbacca0 | 977 | concatenation precedence over filetest operator? |
a0d0e21e | 978 | |
6dbacca0 | 979 | -e $foo .= "q" |
980 | ||
981 | # perl4 prints: no output | |
982 | # perl5 prints: Can't modify -e in concatenation | |
a0d0e21e | 983 | |
6dbacca0 | 984 | =item * Precedence |
a0d0e21e | 985 | |
6dbacca0 | 986 | Assignment to value takes precedence over assignment to key in |
987 | perl5 when using the shift operator on both sides. | |
988 | ||
989 | @arr = ( 'left', 'right' ); | |
990 | $a{shift @arr} = shift @arr; | |
991 | print join( ' ', keys %a ); | |
992 | ||
993 | # perl4 prints: left | |
994 | # perl5 prints: right | |
995 | ||
996 | =back | |
997 | ||
998 | =head2 General Regular Expression Traps using s///, etc. | |
999 | ||
1000 | All types of RE traps. | |
1001 | ||
1002 | =over 5 | |
1003 | ||
1004 | =item * Regular Expression | |
1005 | ||
1006 | C<s'$lhs'$rhs'> now does no interpolation on either side. It used to | |
1007 | interpolate C<$lhs> but not C<$rhs>. (And still does not match a literal | |
1008 | '$' in string) | |
1009 | ||
1010 | $a=1;$b=2; | |
1011 | $string = '1 2 $a $b'; | |
1012 | $string =~ s'$a'$b'; | |
1013 | print $string,"\n"; | |
1014 | ||
1015 | # perl4 prints: $b 2 $a $b | |
1016 | # perl5 prints: 1 2 $a $b | |
1017 | ||
1018 | =item * Regular Expression | |
a0d0e21e LW |
1019 | |
1020 | C<m//g> now attaches its state to the searched string rather than the | |
6dbacca0 | 1021 | regular expression. (Once the scope of a block is left for the sub, the |
1022 | state of the searched string is lost) | |
1023 | ||
1024 | $_ = "ababab"; | |
1025 | while(m/ab/g){ | |
1026 | &doit("blah"); | |
1027 | } | |
1028 | sub doit{local($_) = shift; print "Got $_ "} | |
1029 | ||
1030 | # perl4 prints: blah blah blah | |
1031 | # perl5 prints: infinite loop blah... | |
1032 | ||
1033 | =item * Regular Expression | |
1034 | ||
1035 | If no parentheses are used in a match, Perl4 sets C<$+> to | |
1036 | the whole match, just like C<$&>. Perl5 does not. | |
1037 | ||
1038 | "abcdef" =~ /b.*e/; | |
1039 | print "\$+ = $+\n"; | |
1040 | ||
1041 | # perl4 prints: bcde | |
1042 | # perl5 prints: | |
1043 | ||
1044 | =item * Regular Expression | |
1045 | ||
1046 | substitution now returns the null string if it fails | |
1047 | ||
1048 | $string = "test"; | |
1049 | $value = ($string =~ s/foo//); | |
1050 | print $value, "\n"; | |
1051 | ||
1052 | # perl4 prints: 0 | |
1053 | # perl5 prints: | |
1054 | ||
1055 | Also see L<Numerical Traps> for another example of this new feature. | |
1056 | ||
1057 | =item * Regular Expression | |
1058 | ||
5f05dabc | 1059 | C<s`lhs`rhs`> (using back-ticks) is now a normal substitution, with no |
1060 | back-tick expansion | |
6dbacca0 | 1061 | |
1062 | $string = ""; | |
1063 | $string =~ s`^`hostname`; | |
1064 | print $string, "\n"; | |
1065 | ||
1066 | # perl4 prints: <the local hostname> | |
1067 | # perl5 prints: hostname | |
1068 | ||
1069 | =item * Regular Expression | |
1070 | ||
1071 | Stricter parsing of variables used in regular expressions | |
1072 | ||
1073 | s/^([^$grpc]*$grpc[$opt$plus$rep]?)//o; | |
1074 | ||
1075 | # perl4: compiles w/o error | |
1076 | # perl5: with Scalar found where operator expected ..., near "$opt$plus" | |
1077 | ||
1078 | an added component of this example, apparently from the same script, is | |
1079 | the actual value of the s'd string after the substitution. | |
1080 | C<[$opt]> is a character class in perl4 and an array subscript in perl5 | |
1081 | ||
1082 | $grpc = 'a'; | |
1083 | $opt = 'r'; | |
1084 | $_ = 'bar'; | |
1085 | s/^([^$grpc]*$grpc[$opt]?)/foo/; | |
1086 | print ; | |
1087 | ||
1088 | # perl4 prints: foo | |
1089 | # perl5 prints: foobar | |
1090 | ||
1091 | =item * Regular Expression | |
1092 | ||
1093 | Under perl5, C<m?x?> matches only once, like C<?x?>. Under perl4, it matched | |
1094 | repeatedly, like C</x/> or C<m!x!>. | |
1095 | ||
1096 | $test = "once"; | |
1097 | sub match { $test =~ m?once?; } | |
1098 | &match(); | |
1099 | if( &match() ) { | |
1100 | # m?x? matches more then once | |
1101 | print "perl4\n"; | |
1102 | } else { | |
1103 | # m?x? matches only once | |
1104 | print "perl5\n"; | |
1105 | } | |
1106 | ||
1107 | # perl4 prints: perl4 | |
1108 | # perl5 prints: perl5 | |
a0d0e21e | 1109 | |
a0d0e21e | 1110 | |
b2a07c1c GS |
1111 | =item * Regular Expression |
1112 | ||
1113 | Under perl4 and upto version 5.003, a failed C<m//g> match used to | |
1114 | reset the internal iterator, so that subsequent C<m//g> match attempts | |
1115 | began from the beginning of the string. In perl version 5.004 and later, | |
1116 | failed C<m//g> matches do not reset the iterator position (which can be | |
1117 | found using the C<pos()> function--see L<perlfunc/pos>). | |
1118 | ||
1119 | $test = "foop"; | |
1120 | for (1..3) { | |
1121 | print $1 while ($test =~ /(o)/g); | |
1122 | # pos $test = 0; # to get old behavior | |
1123 | } | |
1124 | ||
1125 | # perl4 prints: oooooo | |
1126 | # perl5.004 prints: oo | |
1127 | ||
1128 | You may always reset the iterator yourself as shown in the commented line | |
1129 | to get the old behavior. | |
1130 | ||
6dbacca0 | 1131 | =back |
1132 | ||
1133 | =head2 Subroutine, Signal, Sorting Traps | |
a0d0e21e | 1134 | |
6dbacca0 | 1135 | The general group of Perl4-to-Perl5 traps having to do with |
1136 | Signals, Sorting, and their related subroutines, as well as | |
1137 | general subroutine traps. Includes some OS-Specific traps. | |
a0d0e21e | 1138 | |
6dbacca0 | 1139 | =over 5 |
a0d0e21e | 1140 | |
6dbacca0 | 1141 | =item * (Signals) |
a0d0e21e | 1142 | |
6dbacca0 | 1143 | Barewords that used to look like strings to Perl will now look like subroutine |
1144 | calls if a subroutine by that name is defined before the compiler sees them. | |
a0d0e21e | 1145 | |
6dbacca0 | 1146 | sub SeeYa { warn"Hasta la vista, baby!" } |
1147 | $SIG{'TERM'} = SeeYa; | |
1148 | print "SIGTERM is now $SIG{'TERM'}\n"; | |
1149 | ||
1150 | # perl4 prints: SIGTERM is main'SeeYa | |
1151 | # perl5 prints: SIGTERM is now main::1 | |
a0d0e21e | 1152 | |
6dbacca0 | 1153 | Use B<-w> to catch this one |
a0d0e21e | 1154 | |
6dbacca0 | 1155 | =item * (Sort Subroutine) |
a0d0e21e | 1156 | |
6dbacca0 | 1157 | reverse is no longer allowed as the name of a sort subroutine. |
a0d0e21e | 1158 | |
6dbacca0 | 1159 | sub reverse{ print "yup "; $a <=> $b } |
1160 | print sort reverse a,b,c; | |
1161 | ||
1162 | # perl4 prints: yup yup yup yup abc | |
1163 | # perl5 prints: abc | |
a0d0e21e | 1164 | |
b996531f | 1165 | =item * warn() won't let you specify a filehandle. |
1166 | ||
1167 | Although it _always_ printed to STDERR, warn() would let you specify a | |
1168 | filehandle in perl4. With perl5 it does not. | |
5e378fdf | 1169 | |
1170 | warn STDERR "Foo!"; | |
1171 | ||
1172 | # perl4 prints: Foo! | |
1173 | # perl5 prints: String found where operator expected | |
1174 | ||
6dbacca0 | 1175 | =back |
a0d0e21e | 1176 | |
6dbacca0 | 1177 | =head2 OS Traps |
1178 | ||
1179 | =over 5 | |
1180 | ||
1181 | =item * (SysV) | |
1182 | ||
1183 | Under HPUX, and some other SysV OS's, one had to reset any signal handler, | |
1184 | within the signal handler function, each time a signal was handled with | |
1185 | perl4. With perl5, the reset is now done correctly. Any code relying | |
1186 | on the handler _not_ being reset will have to be reworked. | |
1187 | ||
a6006777 | 1188 | Since version 5.002, Perl uses sigaction() under SysV. |
6dbacca0 | 1189 | |
1190 | sub gotit { | |
1191 | print "Got @_... "; | |
1192 | } | |
1193 | $SIG{'INT'} = 'gotit'; | |
1194 | ||
1195 | $| = 1; | |
1196 | $pid = fork; | |
1197 | if ($pid) { | |
1198 | kill('INT', $pid); | |
1199 | sleep(1); | |
1200 | kill('INT', $pid); | |
1201 | } else { | |
1202 | while (1) {sleep(10);} | |
1203 | } | |
1204 | ||
1205 | # perl4 (HPUX) prints: Got INT... | |
1206 | # perl5 (HPUX) prints: Got INT... Got INT... | |
1207 | ||
1208 | =item * (SysV) | |
1209 | ||
1210 | Under SysV OS's, C<seek()> on a file opened to append C<E<gt>E<gt>> now does | |
5f05dabc | 1211 | the right thing w.r.t. the fopen() man page. e.g., - When a file is opened |
6dbacca0 | 1212 | for append, it is impossible to overwrite information already in |
1213 | the file. | |
1214 | ||
1215 | open(TEST,">>seek.test"); | |
1216 | $start = tell TEST ; | |
1217 | foreach(1 .. 9){ | |
1218 | print TEST "$_ "; | |
1219 | } | |
1220 | $end = tell TEST ; | |
1221 | seek(TEST,$start,0); | |
1222 | print TEST "18 characters here"; | |
1223 | ||
1224 | # perl4 (solaris) seek.test has: 18 characters here | |
1225 | # perl5 (solaris) seek.test has: 1 2 3 4 5 6 7 8 9 18 characters here | |
a0d0e21e | 1226 | |
a0d0e21e | 1227 | |
a0d0e21e | 1228 | |
6dbacca0 | 1229 | =back |
a0d0e21e | 1230 | |
6dbacca0 | 1231 | =head2 Interpolation Traps |
a0d0e21e | 1232 | |
8b0a4b75 | 1233 | Perl4-to-Perl5 traps having to do with how things get interpolated |
1234 | within certain expressions, statements, contexts, or whatever. | |
1235 | ||
6dbacca0 | 1236 | =over 5 |
a0d0e21e | 1237 | |
6dbacca0 | 1238 | =item * Interpolation |
a0d0e21e | 1239 | |
6dbacca0 | 1240 | @ now always interpolates an array in double-quotish strings. |
1241 | ||
1242 | print "To: someone@somewhere.com\n"; | |
1243 | ||
1244 | # perl4 prints: To:someone@somewhere.com | |
1245 | # perl5 errors : Literal @somewhere now requires backslash | |
1246 | ||
1247 | =item * Interpolation | |
1248 | ||
6dbacca0 | 1249 | Double-quoted strings may no longer end with an unescaped $ or @. |
1250 | ||
1251 | $foo = "foo$"; | |
1252 | $bar = "bar@"; | |
1253 | print "foo is $foo, bar is $bar\n"; | |
1254 | ||
1255 | # perl4 prints: foo is foo$, bar is bar@ | |
1256 | # perl5 errors: Final $ should be \$ or $name | |
1257 | ||
1258 | Note: perl5 DOES NOT error on the terminating @ in $bar | |
1259 | ||
1260 | =item * Interpolation | |
a0d0e21e | 1261 | |
8b0a4b75 | 1262 | Perl now sometimes evaluates arbitrary expressions inside braces that occur |
1263 | within double quotes (usually when the opening brace is preceded by C<$> | |
1264 | or C<@>). | |
1265 | ||
1266 | @www = "buz"; | |
1267 | $foo = "foo"; | |
1268 | $bar = "bar"; | |
1269 | sub foo { return "bar" }; | |
1270 | print "|@{w.w.w}|${main'foo}|"; | |
1271 | ||
1272 | # perl4 prints: |@{w.w.w}|foo| | |
1273 | # perl5 prints: |buz|bar| | |
1274 | ||
1275 | Note that you can C<use strict;> to ward off such trappiness under perl5. | |
1276 | ||
1277 | =item * Interpolation | |
1278 | ||
748a9306 | 1279 | The construct "this is $$x" used to interpolate the pid at that |
6dbacca0 | 1280 | point, but now apparently tries to dereference C<$x>. C<$$> by itself still |
748a9306 LW |
1281 | works fine, however. |
1282 | ||
6dbacca0 | 1283 | print "this is $$x\n"; |
748a9306 | 1284 | |
6dbacca0 | 1285 | # perl4 prints: this is XXXx (XXX is the current pid) |
1286 | # perl5 prints: this is | |
1287 | ||
1288 | =item * Interpolation | |
1289 | ||
1290 | Creation of hashes on the fly with C<eval "EXPR"> now requires either both | |
1291 | C<$>'s to be protected in the specification of the hash name, or both curlies | |
1292 | to be protected. If both curlies are protected, the result will be compatible | |
1293 | with perl4 and perl5. This is a very common practice, and should be changed | |
1294 | to use the block form of C<eval{}> if possible. | |
c07a80fd | 1295 | |
6dbacca0 | 1296 | $hashname = "foobar"; |
1297 | $key = "baz"; | |
1298 | $value = 1234; | |
1299 | eval "\$$hashname{'$key'} = q|$value|"; | |
1300 | (defined($foobar{'baz'})) ? (print "Yup") : (print "Nope"); | |
1301 | ||
1302 | # perl4 prints: Yup | |
1303 | # perl5 prints: Nope | |
1304 | ||
1305 | Changing | |
1306 | ||
1307 | eval "\$$hashname{'$key'} = q|$value|"; | |
c07a80fd | 1308 | |
1309 | to | |
1310 | ||
6dbacca0 | 1311 | eval "\$\$hashname{'$key'} = q|$value|"; |
c07a80fd | 1312 | |
6dbacca0 | 1313 | causes the following result: |
c07a80fd | 1314 | |
6dbacca0 | 1315 | # perl4 prints: Nope |
1316 | # perl5 prints: Yup | |
c07a80fd | 1317 | |
6dbacca0 | 1318 | or, changing to |
a0d0e21e | 1319 | |
6dbacca0 | 1320 | eval "\$$hashname\{'$key'\} = q|$value|"; |
1321 | ||
1322 | causes the following result: | |
1323 | ||
1324 | # perl4 prints: Yup | |
1325 | # perl5 prints: Yup | |
1326 | # and is compatible for both versions | |
1327 | ||
1328 | ||
1329 | =item * Interpolation | |
1330 | ||
1331 | perl4 programs which unconsciously rely on the bugs in earlier perl versions. | |
1332 | ||
1333 | perl -e '$bar=q/not/; print "This is $foo{$bar} perl5"' | |
1334 | ||
1335 | # perl4 prints: This is not perl5 | |
1336 | # perl5 prints: This is perl5 | |
1337 | ||
1338 | =item * Interpolation | |
1339 | ||
1340 | You also have to be careful about array references. | |
1341 | ||
1342 | print "$foo{" | |
1343 | ||
1344 | perl 4 prints: { | |
1345 | perl 5 prints: syntax error | |
1346 | ||
1347 | =item * Interpolation | |
1348 | ||
1349 | Similarly, watch out for: | |
1350 | ||
1351 | $foo = "array"; | |
1352 | print "\$$foo{bar}\n"; | |
1353 | ||
1354 | # perl4 prints: $array{bar} | |
1355 | # perl5 prints: $ | |
1356 | ||
1357 | Perl 5 is looking for C<$array{bar}> which doesn't exist, but perl 4 is | |
1358 | happy just to expand $foo to "array" by itself. Watch out for this | |
1359 | especially in C<eval>'s. | |
1360 | ||
1361 | =item * Interpolation | |
1362 | ||
1363 | C<qq()> string passed to C<eval> | |
1364 | ||
1365 | eval qq( | |
1366 | foreach \$y (keys %\$x\) { | |
1367 | \$count++; | |
1368 | } | |
1369 | ); | |
1370 | ||
1371 | # perl4 runs this ok | |
1372 | # perl5 prints: Can't find string terminator ")" | |
a0d0e21e | 1373 | |
6dbacca0 | 1374 | =back |
1375 | ||
1376 | =head2 DBM Traps | |
1377 | ||
1378 | General DBM traps. | |
1379 | ||
1380 | =over 5 | |
1381 | ||
1382 | =item * DBM | |
1383 | ||
1384 | Existing dbm databases created under perl4 (or any other dbm/ndbm tool) | |
1385 | may cause the same script, run under perl5, to fail. The build of perl5 | |
1386 | must have been linked with the same dbm/ndbm as the default for C<dbmopen()> | |
1387 | to function properly without C<tie>'ing to an extension dbm implementation. | |
1388 | ||
1389 | dbmopen (%dbm, "file", undef); | |
1390 | print "ok\n"; | |
1391 | ||
1392 | # perl4 prints: ok | |
1393 | # perl5 prints: ok (IFF linked with -ldbm or -lndbm) | |
1394 | ||
1395 | ||
1396 | =item * DBM | |
1397 | ||
1398 | Existing dbm databases created under perl4 (or any other dbm/ndbm tool) | |
1399 | may cause the same script, run under perl5, to fail. The error generated | |
1400 | when exceeding the limit on the key/value size will cause perl5 to exit | |
1401 | immediately. | |
1402 | ||
1403 | dbmopen(DB, "testdb",0600) || die "couldn't open db! $!"; | |
1404 | $DB{'trap'} = "x" x 1024; # value too large for most dbm/ndbm | |
1405 | print "YUP\n"; | |
1406 | ||
1407 | # perl4 prints: | |
1408 | dbm store returned -1, errno 28, key "trap" at - line 3. | |
1409 | YUP | |
1410 | ||
1411 | # perl5 prints: | |
1412 | dbm store returned -1, errno 28, key "trap" at - line 3. | |
a0d0e21e LW |
1413 | |
1414 | =back | |
6dbacca0 | 1415 | |
1416 | =head2 Unclassified Traps | |
1417 | ||
1418 | Everything else. | |
1419 | ||
84dc3c4d | 1420 | =over 5 |
1421 | ||
6dbacca0 | 1422 | =item * Unclassified |
1423 | ||
1424 | C<require>/C<do> trap using returned value | |
1425 | ||
1426 | If the file doit.pl has: | |
1427 | ||
1428 | sub foo { | |
1429 | $rc = do "./do.pl"; | |
1430 | return 8; | |
1431 | } | |
1432 | print &foo, "\n"; | |
1433 | ||
1434 | And the do.pl file has the following single line: | |
1435 | ||
1436 | return 3; | |
1437 | ||
1438 | Running doit.pl gives the following: | |
1439 | ||
1440 | # perl 4 prints: 3 (aborts the subroutine early) | |
1441 | # perl 5 prints: 8 | |
1442 | ||
1443 | Same behavior if you replace C<do> with C<require>. | |
1444 | ||
1445 | =back | |
1446 | ||
1447 | As always, if any of these are ever officially declared as bugs, | |
1448 | they'll be fixed and removed. | |
1449 |