Commit | Line | Data |
493a87da |
1 | =head1 NAME |
2 | |
688005af |
3 | perl561delta - what's new for perl v5.6.x |
493a87da |
4 | |
5 | =head1 DESCRIPTION |
6 | |
7 | This document describes differences between the 5.005 release and the 5.6.1 |
8 | release. |
9 | |
10 | =head1 Summary of changes between 5.6.0 and 5.6.1 |
11 | |
12 | This section contains a summary of the changes between the 5.6.0 release |
13 | and the 5.6.1 release. More details about the changes mentioned here |
14 | may be found in the F<Changes> files that accompany the Perl source |
15 | distribution. See L<perlhack> for pointers to online resources where you |
16 | can inspect the individual patches described by these changes. |
17 | |
18 | =head2 Security Issues |
19 | |
20 | suidperl will not run /bin/mail anymore, because some platforms have |
21 | a /bin/mail that is vulnerable to buffer overflow attacks. |
22 | |
23 | Note that suidperl is neither built nor installed by default in |
24 | any recent version of perl. Use of suidperl is highly discouraged. |
25 | If you think you need it, try alternatives such as sudo first. |
1577cd80 |
26 | See http://www.courtesan.com/sudo/ . |
493a87da |
27 | |
28 | =head2 Core bug fixes |
29 | |
30 | This is not an exhaustive list. It is intended to cover only the |
31 | significant user-visible changes. |
32 | |
33 | =over |
34 | |
35 | =item C<UNIVERSAL::isa()> |
36 | |
37 | A bug in the caching mechanism used by C<UNIVERSAL::isa()> that affected |
38 | base.pm has been fixed. The bug has existed since the 5.005 releases, |
39 | but wasn't tickled by base.pm in those releases. |
40 | |
41 | =item Memory leaks |
42 | |
43 | Various cases of memory leaks and attempts to access uninitialized memory |
44 | have been cured. See L</"Known Problems"> below for further issues. |
45 | |
46 | =item Numeric conversions |
47 | |
48 | Numeric conversions did not recognize changes in the string value |
49 | properly in certain circumstances. |
50 | |
51 | In other situations, large unsigned numbers (those above 2**31) could |
52 | sometimes lose their unsignedness, causing bogus results in arithmetic |
53 | operations. |
54 | |
55 | Integer modulus on large unsigned integers sometimes returned |
56 | incorrect values. |
57 | |
58 | Perl 5.6.0 generated "not a number" warnings on certain conversions where |
59 | previous versions didn't. |
60 | |
61 | These problems have all been rectified. |
62 | |
63 | Infinity is now recognized as a number. |
64 | |
65 | =item qw(a\\b) |
66 | |
67 | In Perl 5.6.0, qw(a\\b) produced a string with two backslashes instead |
68 | of one, in a departure from the behavior in previous versions. The |
69 | older behavior has been reinstated. |
70 | |
71 | =item caller() |
72 | |
73 | caller() could cause core dumps in certain situations. Carp was sometimes |
74 | affected by this problem. |
75 | |
76 | =item Bugs in regular expressions |
77 | |
78 | Pattern matches on overloaded values are now handled correctly. |
79 | |
80 | Perl 5.6.0 parsed m/\x{ab}/ incorrectly, leading to spurious warnings. |
81 | This has been corrected. |
82 | |
83 | The RE engine found in Perl 5.6.0 accidentally pessimised certain kinds |
84 | of simple pattern matches. These are now handled better. |
85 | |
86 | Regular expression debug output (whether through C<use re 'debug'> |
87 | or via C<-Dr>) now looks better. |
88 | |
89 | Multi-line matches like C<"a\nxb\n" =~ /(?!\A)x/m> were flawed. The |
90 | bug has been fixed. |
91 | |
92 | Use of $& could trigger a core dump under some situations. This |
93 | is now avoided. |
94 | |
95 | Match variables $1 et al., weren't being unset when a pattern match |
96 | was backtracking, and the anomaly showed up inside C</...(?{ ... }).../> |
97 | etc. These variables are now tracked correctly. |
98 | |
99 | pos() did not return the correct value within s///ge in earlier |
100 | versions. This is now handled correctly. |
101 | |
102 | =item "slurp" mode |
103 | |
104 | readline() on files opened in "slurp" mode could return an extra "" at |
105 | the end in certain situations. This has been corrected. |
106 | |
107 | =item Autovivification of symbolic references to special variables |
108 | |
109 | Autovivification of symbolic references of special variables described |
110 | in L<perlvar> (as in C<${$num}>) was accidentally disabled. This works |
111 | again now. |
112 | |
113 | =item Lexical warnings |
114 | |
115 | Lexical warnings now propagate correctly into C<eval "...">. |
116 | |
117 | C<use warnings qw(FATAL all)> did not work as intended. This has been |
118 | corrected. |
119 | |
120 | Lexical warnings could leak into other scopes in some situations. |
121 | This is now fixed. |
122 | |
123 | warnings::enabled() now reports the state of $^W correctly if the caller |
124 | isn't using lexical warnings. |
125 | |
126 | =item Spurious warnings and errors |
127 | |
128 | Perl 5.6.0 could emit spurious warnings about redefinition of dl_error() |
129 | when statically building extensions into perl. This has been corrected. |
130 | |
131 | "our" variables could result in bogus "Variable will not stay shared" |
132 | warnings. This is now fixed. |
133 | |
134 | "our" variables of the same name declared in two sibling blocks |
135 | resulted in bogus warnings about "redeclaration" of the variables. |
136 | The problem has been corrected. |
137 | |
138 | =item glob() |
139 | |
140 | Compatibility of the builtin glob() with old csh-based glob has been |
141 | improved with the addition of GLOB_ALPHASORT option. See C<File::Glob>. |
142 | |
143 | File::Glob::glob() has been renamed to File::Glob::bsd_glob() |
144 | because the name clashes with the builtin glob(). The older |
145 | name is still available for compatibility, but is deprecated. |
146 | |
147 | Spurious syntax errors generated in certain situations, when glob() |
148 | caused File::Glob to be loaded for the first time, have been fixed. |
149 | |
150 | =item Tainting |
151 | |
152 | Some cases of inconsistent taint propagation (such as within hash |
153 | values) have been fixed. |
154 | |
155 | The tainting behavior of sprintf() has been rationalized. It does |
156 | not taint the result of floating point formats anymore, making the |
157 | behavior consistent with that of string interpolation. |
158 | |
159 | =item sort() |
160 | |
161 | Arguments to sort() weren't being provided the right wantarray() context. |
162 | The comparison block is now run in scalar context, and the arguments to |
163 | be sorted are always provided list context. |
164 | |
165 | sort() is also fully reentrant, in the sense that the sort function |
166 | can itself call sort(). This did not work reliably in previous releases. |
167 | |
168 | =item #line directives |
169 | |
170 | #line directives now work correctly when they appear at the very |
171 | beginning of C<eval "...">. |
172 | |
173 | =item Subroutine prototypes |
174 | |
175 | The (\&) prototype now works properly. |
176 | |
177 | =item map() |
178 | |
179 | map() could get pathologically slow when the result list it generates |
180 | is larger than the source list. The performance has been improved for |
181 | common scenarios. |
182 | |
183 | =item Debugger |
184 | |
185 | Debugger exit code now reflects the script exit code. |
186 | |
187 | Condition C<"0"> in breakpoints is now treated correctly. |
188 | |
189 | The C<d> command now checks the line number. |
190 | |
191 | C<$.> is no longer corrupted by the debugger. |
192 | |
193 | All debugger output now correctly goes to the socket if RemotePort |
194 | is set. |
195 | |
196 | =item PERL5OPT |
197 | |
198 | PERL5OPT can be set to more than one switch group. Previously, |
199 | it used to be limited to one group of options only. |
200 | |
201 | =item chop() |
202 | |
203 | chop(@list) in list context returned the characters chopped in reverse |
204 | order. This has been reversed to be in the right order. |
205 | |
206 | =item Unicode support |
207 | |
208 | Unicode support has seen a large number of incremental improvements, |
209 | but continues to be highly experimental. It is not expected to be |
210 | fully supported in the 5.6.x maintenance releases. |
211 | |
212 | substr(), join(), repeat(), reverse(), quotemeta() and string |
213 | concatenation were all handling Unicode strings incorrectly in |
214 | Perl 5.6.0. This has been corrected. |
215 | |
216 | Support for C<tr///CU> and C<tr///UC> etc., have been removed since |
217 | we realized the interface is broken. For similar functionality, |
218 | see L<perlfunc/pack>. |
219 | |
220 | The Unicode Character Database has been updated to version 3.0.1 |
221 | with additions made available to the public as of August 30, 2000. |
222 | |
223 | The Unicode character classes \p{Blank} and \p{SpacePerl} have been |
224 | added. "Blank" is like C isblank(), that is, it contains only |
225 | "horizontal whitespace" (the space character is, the newline isn't), |
226 | and the "SpacePerl" is the Unicode equivalent of C<\s> (\p{Space} |
227 | isn't, since that includes the vertical tabulator character, whereas |
228 | C<\s> doesn't.) |
229 | |
230 | If you are experimenting with Unicode support in perl, the development |
231 | versions of Perl may have more to offer. In particular, I/O layers |
232 | are now available in the development track, but not in the maintenance |
233 | track, primarily to do backward compatibility issues. Unicode support |
234 | is also evolving rapidly on a daily basis in the development track--the |
235 | maintenance track only reflects the most conservative of these changes. |
236 | |
237 | =item 64-bit support |
238 | |
239 | Support for 64-bit platforms has been improved, but continues to be |
240 | experimental. The level of support varies greatly among platforms. |
241 | |
242 | =item Compiler |
243 | |
244 | The B Compiler and its various backends have had many incremental |
245 | improvements, but they continue to remain highly experimental. Use in |
246 | production environments is discouraged. |
247 | |
248 | The perlcc tool has been rewritten so that the user interface is much |
249 | more like that of a C compiler. |
250 | |
251 | The perlbc tools has been removed. Use C<perlcc -B> instead. |
252 | |
253 | =item Lvalue subroutines |
254 | |
255 | There have been various bugfixes to support lvalue subroutines better. |
256 | However, the feature still remains experimental. |
257 | |
258 | =item IO::Socket |
259 | |
260 | IO::Socket::INET failed to open the specified port if the service |
261 | name was not known. It now correctly uses the supplied port number |
262 | as is. |
263 | |
264 | =item File::Find |
265 | |
266 | File::Find now chdir()s correctly when chasing symbolic links. |
267 | |
268 | =item xsubpp |
269 | |
270 | xsubpp now tolerates embedded POD sections. |
271 | |
272 | =item C<no Module;> |
273 | |
274 | C<no Module;> does not produce an error even if Module does not have an |
275 | unimport() method. This parallels the behavior of C<use> vis-a-vis |
276 | C<import>. |
277 | |
278 | =item Tests |
279 | |
280 | A large number of tests have been added. |
281 | |
282 | =back |
283 | |
284 | =head2 Core features |
285 | |
286 | untie() will now call an UNTIE() hook if it exists. See L<perltie> |
287 | for details. |
288 | |
289 | The C<-DT> command line switch outputs copious tokenizing information. |
290 | See L<perlrun>. |
291 | |
292 | Arrays are now always interpolated in double-quotish strings. Previously, |
293 | C<"foo@bar.com"> used to be a fatal error at compile time, if an array |
294 | C<@bar> was not used or declared. This transitional behavior was |
295 | intended to help migrate perl4 code, and is deemed to be no longer useful. |
296 | See L</"Arrays now always interpolate into double-quoted strings">. |
297 | |
298 | keys(), each(), pop(), push(), shift(), splice() and unshift() |
299 | can all be overridden now. |
300 | |
301 | C<my __PACKAGE__ $obj> now does the expected thing. |
302 | |
303 | =head2 Configuration issues |
304 | |
305 | On some systems (IRIX and Solaris among them) the system malloc is demonstrably |
306 | better. While the defaults haven't been changed in order to retain binary |
307 | compatibility with earlier releases, you may be better off building perl |
308 | with C<Configure -Uusemymalloc ...> as discussed in the F<INSTALL> file. |
309 | |
310 | C<Configure> has been enhanced in various ways: |
311 | |
312 | =over |
313 | |
314 | =item * |
315 | |
316 | Minimizes use of temporary files. |
317 | |
318 | =item * |
319 | |
320 | By default, does not link perl with libraries not used by it, such as |
321 | the various dbm libraries. SunOS 4.x hints preserve behavior on that |
322 | platform. |
323 | |
324 | =item * |
325 | |
326 | Support for pdp11-style memory models has been removed due to obsolescence. |
327 | |
328 | =item * |
329 | |
330 | Building outside the source tree is supported on systems that have |
331 | symbolic links. This is done by running |
332 | |
333 | sh /path/to/source/Configure -Dmksymlinks ... |
334 | make all test install |
335 | |
336 | in a directory other than the perl source directory. See F<INSTALL>. |
337 | |
338 | =item * |
339 | |
340 | C<Configure -S> can be run non-interactively. |
341 | |
342 | =back |
343 | |
344 | =head2 Documentation |
345 | |
8939ba94 |
346 | README.aix, README.solaris and README.macos have been added. |
347 | README.posix-bc has been renamed to README.bs2000. These are |
348 | installed as L<perlaix>, L<perlsolaris>, L<perlmacos>, and |
349 | L<perlbs2000> respectively. |
493a87da |
350 | |
351 | The following pod documents are brand new: |
352 | |
353 | perlclib Internal replacements for standard C library functions |
354 | perldebtut Perl debugging tutorial |
355 | perlebcdic Considerations for running Perl on EBCDIC platforms |
356 | perlnewmod Perl modules: preparing a new module for distribution |
357 | perlrequick Perl regular expressions quick start |
358 | perlretut Perl regular expressions tutorial |
359 | perlutil utilities packaged with the Perl distribution |
360 | |
361 | The F<INSTALL> file has been expanded to cover various issues, such as |
362 | 64-bit support. |
363 | |
364 | A longer list of contributors has been added to the source distribution. |
365 | See the file C<AUTHORS>. |
366 | |
367 | Numerous other changes have been made to the included documentation and FAQs. |
368 | |
369 | =head2 Bundled modules |
370 | |
371 | The following modules have been added. |
372 | |
373 | =over |
374 | |
375 | =item B::Concise |
376 | |
377 | Walks Perl syntax tree, printing concise info about ops. See L<B::Concise>. |
378 | |
379 | =item File::Temp |
380 | |
381 | Returns name and handle of a temporary file safely. See L<File::Temp>. |
382 | |
383 | =item Pod::LaTeX |
384 | |
385 | Converts Pod data to formatted LaTeX. See L<Pod::LaTeX>. |
386 | |
387 | =item Pod::Text::Overstrike |
388 | |
389 | Converts POD data to formatted overstrike text. See L<Pod::Text::Overstrike>. |
390 | |
391 | =back |
392 | |
393 | The following modules have been upgraded. |
394 | |
395 | =over |
396 | |
397 | =item CGI |
398 | |
399 | CGI v2.752 is now included. |
400 | |
401 | =item CPAN |
402 | |
403 | CPAN v1.59_54 is now included. |
404 | |
405 | =item Class::Struct |
406 | |
407 | Various bugfixes have been added. |
408 | |
409 | =item DB_File |
410 | |
411 | DB_File v1.75 supports newer Berkeley DB versions, among other |
412 | improvements. |
413 | |
414 | =item Devel::Peek |
415 | |
416 | Devel::Peek has been enhanced to support dumping of memory statistics, |
417 | when perl is built with the included malloc(). |
418 | |
419 | =item File::Find |
420 | |
421 | File::Find now supports pre and post-processing of the files in order |
422 | to sort() them, etc. |
423 | |
424 | =item Getopt::Long |
425 | |
426 | Getopt::Long v2.25 is included. |
427 | |
428 | =item IO::Poll |
429 | |
430 | Various bug fixes have been included. |
431 | |
432 | =item IPC::Open3 |
433 | |
434 | IPC::Open3 allows use of numeric file descriptors. |
435 | |
436 | =item Math::BigFloat |
437 | |
438 | The fmod() function supports modulus operations. Various bug fixes |
439 | have also been included. |
440 | |
441 | =item Math::Complex |
442 | |
443 | Math::Complex handles inf, NaN etc., better. |
444 | |
445 | =item Net::Ping |
446 | |
447 | ping() could fail on odd number of data bytes, and when the echo service |
448 | isn't running. This has been corrected. |
449 | |
450 | =item Opcode |
451 | |
452 | A memory leak has been fixed. |
453 | |
454 | =item Pod::Parser |
455 | |
456 | Version 1.13 of the Pod::Parser suite is included. |
457 | |
458 | =item Pod::Text |
459 | |
460 | Pod::Text and related modules have been upgraded to the versions |
461 | in podlators suite v2.08. |
462 | |
463 | =item SDBM_File |
464 | |
465 | On dosish platforms, some keys went missing because of lack of support for |
466 | files with "holes". A workaround for the problem has been added. |
467 | |
468 | =item Sys::Syslog |
469 | |
470 | Various bug fixes have been included. |
471 | |
472 | =item Tie::RefHash |
473 | |
474 | Now supports Tie::RefHash::Nestable to automagically tie hashref values. |
475 | |
476 | =item Tie::SubstrHash |
477 | |
478 | Various bug fixes have been included. |
479 | |
480 | =back |
481 | |
482 | =head2 Platform-specific improvements |
483 | |
484 | The following new ports are now available. |
485 | |
486 | =over |
487 | |
488 | =item NCR MP-RAS |
489 | |
490 | =item NonStop-UX |
491 | |
492 | =back |
493 | |
494 | Perl now builds under Amdahl UTS. |
495 | |
496 | Perl has also been verified to build under Amiga OS. |
497 | |
498 | Support for EPOC has been much improved. See README.epoc. |
499 | |
500 | Building perl with -Duseithreads or -Duse5005threads now works |
501 | under HP-UX 10.20 (previously it only worked under 10.30 or later). |
502 | You will need a thread library package installed. See README.hpux. |
503 | |
504 | Long doubles should now work under Linux. |
505 | |
8939ba94 |
506 | Mac OS Classic is now supported in the mainstream source package. |
493a87da |
507 | See README.macos. |
508 | |
509 | Support for MPE/iX has been updated. See README.mpeix. |
510 | |
511 | Support for OS/2 has been improved. See C<os2/Changes> and README.os2. |
512 | |
513 | Dynamic loading on z/OS (formerly OS/390) has been improved. See |
514 | README.os390. |
515 | |
516 | Support for VMS has seen many incremental improvements, including |
517 | better support for operators like backticks and system(), and better |
518 | %ENV handling. See C<README.vms> and L<perlvms>. |
519 | |
520 | Support for Stratus VOS has been improved. See C<vos/Changes> and README.vos. |
521 | |
522 | Support for Windows has been improved. |
523 | |
524 | =over |
525 | |
526 | =item * |
527 | |
528 | fork() emulation has been improved in various ways, but still continues |
529 | to be experimental. See L<perlfork> for known bugs and caveats. |
530 | |
531 | =item * |
532 | |
533 | %SIG has been enabled under USE_ITHREADS, but its use is completely |
534 | unsupported under all configurations. |
535 | |
536 | =item * |
537 | |
538 | Borland C++ v5.5 is now a supported compiler that can build Perl. |
539 | However, the generated binaries continue to be incompatible with those |
540 | generated by the other supported compilers (GCC and Visual C++). |
541 | |
542 | =item * |
543 | |
544 | Non-blocking waits for child processes (or pseudo-processes) are |
545 | supported via C<waitpid($pid, &POSIX::WNOHANG)>. |
546 | |
547 | =item * |
548 | |
549 | A memory leak in accept() has been fixed. |
550 | |
551 | =item * |
552 | |
553 | wait(), waitpid() and backticks now return the correct exit status under |
554 | Windows 9x. |
555 | |
556 | =item * |
557 | |
558 | Trailing new %ENV entries weren't propagated to child processes. This |
559 | is now fixed. |
560 | |
561 | =item * |
562 | |
563 | Current directory entries in %ENV are now correctly propagated to child |
564 | processes. |
565 | |
566 | =item * |
567 | |
568 | Duping socket handles with open(F, ">&MYSOCK") now works under Windows 9x. |
569 | |
570 | =item * |
571 | |
572 | The makefiles now provide a single switch to bulk-enable all the features |
573 | enabled in ActiveState ActivePerl (a popular binary distribution). |
574 | |
575 | =item * |
576 | |
577 | Win32::GetCwd() correctly returns C:\ instead of C: when at the drive root. |
578 | Other bugs in chdir() and Cwd::cwd() have also been fixed. |
579 | |
580 | =item * |
581 | |
582 | fork() correctly returns undef and sets EAGAIN when it runs out of |
583 | pseudo-process handles. |
584 | |
585 | =item * |
586 | |
587 | ExtUtils::MakeMaker now uses $ENV{LIB} to search for libraries. |
588 | |
589 | =item * |
590 | |
591 | UNC path handling is better when perl is built to support fork(). |
592 | |
593 | =item * |
594 | |
595 | A handle leak in socket handling has been fixed. |
596 | |
597 | =item * |
598 | |
599 | send() works from within a pseudo-process. |
600 | |
601 | =back |
602 | |
603 | Unless specifically qualified otherwise, the remainder of this document |
604 | covers changes between the 5.005 and 5.6.0 releases. |
7207e29d |
605 | |
493a87da |
606 | =head1 Core Enhancements |
607 | |
608 | =head2 Interpreter cloning, threads, and concurrency |
609 | |
610 | Perl 5.6.0 introduces the beginnings of support for running multiple |
611 | interpreters concurrently in different threads. In conjunction with |
612 | the perl_clone() API call, which can be used to selectively duplicate |
613 | the state of any given interpreter, it is possible to compile a |
614 | piece of code once in an interpreter, clone that interpreter |
615 | one or more times, and run all the resulting interpreters in distinct |
616 | threads. |
617 | |
618 | On the Windows platform, this feature is used to emulate fork() at the |
619 | interpreter level. See L<perlfork> for details about that. |
620 | |
621 | This feature is still in evolution. It is eventually meant to be used |
622 | to selectively clone a subroutine and data reachable from that |
623 | subroutine in a separate interpreter and run the cloned subroutine |
624 | in a separate thread. Since there is no shared data between the |
625 | interpreters, little or no locking will be needed (unless parts of |
626 | the symbol table are explicitly shared). This is obviously intended |
627 | to be an easy-to-use replacement for the existing threads support. |
628 | |
629 | Support for cloning interpreters and interpreter concurrency can be |
630 | enabled using the -Dusethreads Configure option (see win32/Makefile for |
631 | how to enable it on Windows.) The resulting perl executable will be |
632 | functionally identical to one that was built with -Dmultiplicity, but |
633 | the perl_clone() API call will only be available in the former. |
634 | |
635 | -Dusethreads enables the cpp macro USE_ITHREADS by default, which in turn |
636 | enables Perl source code changes that provide a clear separation between |
637 | the op tree and the data it operates with. The former is immutable, and |
638 | can therefore be shared between an interpreter and all of its clones, |
639 | while the latter is considered local to each interpreter, and is therefore |
640 | copied for each clone. |
641 | |
642 | Note that building Perl with the -Dusemultiplicity Configure option |
643 | is adequate if you wish to run multiple B<independent> interpreters |
644 | concurrently in different threads. -Dusethreads only provides the |
645 | additional functionality of the perl_clone() API call and other |
646 | support for running B<cloned> interpreters concurrently. |
647 | |
648 | NOTE: This is an experimental feature. Implementation details are |
649 | subject to change. |
650 | |
651 | =head2 Lexically scoped warning categories |
652 | |
653 | You can now control the granularity of warnings emitted by perl at a finer |
654 | level using the C<use warnings> pragma. L<warnings> and L<perllexwarn> |
655 | have copious documentation on this feature. |
656 | |
657 | =head2 Unicode and UTF-8 support |
658 | |
659 | Perl now uses UTF-8 as its internal representation for character |
660 | strings. The C<utf8> and C<bytes> pragmas are used to control this support |
661 | in the current lexical scope. See L<perlunicode>, L<utf8> and L<bytes> for |
662 | more information. |
663 | |
664 | This feature is expected to evolve quickly to support some form of I/O |
665 | disciplines that can be used to specify the kind of input and output data |
666 | (bytes or characters). Until that happens, additional modules from CPAN |
667 | will be needed to complete the toolkit for dealing with Unicode. |
668 | |
669 | NOTE: This should be considered an experimental feature. Implementation |
670 | details are subject to change. |
671 | |
672 | =head2 Support for interpolating named characters |
673 | |
674 | The new C<\N> escape interpolates named characters within strings. |
675 | For example, C<"Hi! \N{WHITE SMILING FACE}"> evaluates to a string |
676 | with a Unicode smiley face at the end. |
677 | |
678 | =head2 "our" declarations |
679 | |
680 | An "our" declaration introduces a value that can be best understood |
681 | as a lexically scoped symbolic alias to a global variable in the |
682 | package that was current where the variable was declared. This is |
683 | mostly useful as an alternative to the C<vars> pragma, but also provides |
684 | the opportunity to introduce typing and other attributes for such |
685 | variables. See L<perlfunc/our>. |
686 | |
687 | =head2 Support for strings represented as a vector of ordinals |
688 | |
689 | Literals of the form C<v1.2.3.4> are now parsed as a string composed |
690 | of characters with the specified ordinals. This is an alternative, more |
691 | readable way to construct (possibly Unicode) strings instead of |
692 | interpolating characters, as in C<"\x{1}\x{2}\x{3}\x{4}">. The leading |
693 | C<v> may be omitted if there are more than two ordinals, so C<1.2.3> is |
694 | parsed the same as C<v1.2.3>. |
695 | |
696 | Strings written in this form are also useful to represent version "numbers". |
697 | It is easy to compare such version "numbers" (which are really just plain |
698 | strings) using any of the usual string comparison operators C<eq>, C<ne>, |
699 | C<lt>, C<gt>, etc., or perform bitwise string operations on them using C<|>, |
700 | C<&>, etc. |
701 | |
702 | In conjunction with the new C<$^V> magic variable (which contains |
703 | the perl version as a string), such literals can be used as a readable way |
704 | to check if you're running a particular version of Perl: |
705 | |
706 | # this will parse in older versions of Perl also |
707 | if ($^V and $^V gt v5.6.0) { |
708 | # new features supported |
709 | } |
710 | |
711 | C<require> and C<use> also have some special magic to support such literals. |
712 | They will be interpreted as a version rather than as a module name: |
713 | |
714 | require v5.6.0; # croak if $^V lt v5.6.0 |
715 | use v5.6.0; # same, but croaks at compile-time |
716 | |
717 | Alternatively, the C<v> may be omitted if there is more than one dot: |
718 | |
719 | require 5.6.0; |
720 | use 5.6.0; |
721 | |
722 | Also, C<sprintf> and C<printf> support the Perl-specific format flag C<%v> |
723 | to print ordinals of characters in arbitrary strings: |
724 | |
725 | printf "v%vd", $^V; # prints current version, such as "v5.5.650" |
726 | printf "%*vX", ":", $addr; # formats IPv6 address |
727 | printf "%*vb", " ", $bits; # displays bitstring |
728 | |
729 | See L<perldata/"Scalar value constructors"> for additional information. |
730 | |
731 | =head2 Improved Perl version numbering system |
732 | |
733 | Beginning with Perl version 5.6.0, the version number convention has been |
734 | changed to a "dotted integer" scheme that is more commonly found in open |
735 | source projects. |
736 | |
737 | Maintenance versions of v5.6.0 will be released as v5.6.1, v5.6.2 etc. |
738 | The next development series following v5.6.0 will be numbered v5.7.x, |
739 | beginning with v5.7.0, and the next major production release following |
740 | v5.6.0 will be v5.8.0. |
741 | |
742 | The English module now sets $PERL_VERSION to $^V (a string value) rather |
743 | than C<$]> (a numeric value). (This is a potential incompatibility. |
744 | Send us a report via perlbug if you are affected by this.) |
745 | |
746 | The v1.2.3 syntax is also now legal in Perl. |
747 | See L<Support for strings represented as a vector of ordinals> for more on that. |
748 | |
749 | To cope with the new versioning system's use of at least three significant |
750 | digits for each version component, the method used for incrementing the |
751 | subversion number has also changed slightly. We assume that versions older |
752 | than v5.6.0 have been incrementing the subversion component in multiples of |
753 | 10. Versions after v5.6.0 will increment them by 1. Thus, using the new |
754 | notation, 5.005_03 is the "same" as v5.5.30, and the first maintenance |
755 | version following v5.6.0 will be v5.6.1 (which should be read as being |
756 | equivalent to a floating point value of 5.006_001 in the older format, |
757 | stored in C<$]>). |
758 | |
759 | =head2 New syntax for declaring subroutine attributes |
760 | |
761 | Formerly, if you wanted to mark a subroutine as being a method call or |
762 | as requiring an automatic lock() when it is entered, you had to declare |
763 | that with a C<use attrs> pragma in the body of the subroutine. |
764 | That can now be accomplished with declaration syntax, like this: |
765 | |
766 | sub mymethod : locked method ; |
767 | ... |
768 | sub mymethod : locked method { |
769 | ... |
770 | } |
771 | |
772 | sub othermethod :locked :method ; |
773 | ... |
774 | sub othermethod :locked :method { |
775 | ... |
776 | } |
777 | |
778 | |
779 | (Note how only the first C<:> is mandatory, and whitespace surrounding |
780 | the C<:> is optional.) |
781 | |
782 | F<AutoSplit.pm> and F<SelfLoader.pm> have been updated to keep the attributes |
783 | with the stubs they provide. See L<attributes>. |
784 | |
785 | =head2 File and directory handles can be autovivified |
786 | |
787 | Similar to how constructs such as C<< $x->[0] >> autovivify a reference, |
788 | handle constructors (open(), opendir(), pipe(), socketpair(), sysopen(), |
789 | socket(), and accept()) now autovivify a file or directory handle |
790 | if the handle passed to them is an uninitialized scalar variable. This |
791 | allows the constructs such as C<open(my $fh, ...)> and C<open(local $fh,...)> |
792 | to be used to create filehandles that will conveniently be closed |
793 | automatically when the scope ends, provided there are no other references |
794 | to them. This largely eliminates the need for typeglobs when opening |
795 | filehandles that must be passed around, as in the following example: |
796 | |
797 | sub myopen { |
798 | open my $fh, "@_" |
799 | or die "Can't open '@_': $!"; |
800 | return $fh; |
801 | } |
802 | |
803 | { |
804 | my $f = myopen("</etc/motd"); |
805 | print <$f>; |
806 | # $f implicitly closed here |
807 | } |
808 | |
809 | =head2 open() with more than two arguments |
810 | |
811 | If open() is passed three arguments instead of two, the second argument |
812 | is used as the mode and the third argument is taken to be the file name. |
813 | This is primarily useful for protecting against unintended magic behavior |
814 | of the traditional two-argument form. See L<perlfunc/open>. |
815 | |
816 | =head2 64-bit support |
817 | |
818 | Any platform that has 64-bit integers either |
819 | |
820 | (1) natively as longs or ints |
821 | (2) via special compiler flags |
822 | (3) using long long or int64_t |
823 | |
824 | is able to use "quads" (64-bit integers) as follows: |
825 | |
826 | =over 4 |
827 | |
828 | =item * |
829 | |
830 | constants (decimal, hexadecimal, octal, binary) in the code |
831 | |
832 | =item * |
833 | |
834 | arguments to oct() and hex() |
835 | |
836 | =item * |
837 | |
838 | arguments to print(), printf() and sprintf() (flag prefixes ll, L, q) |
839 | |
840 | =item * |
841 | |
842 | printed as such |
843 | |
844 | =item * |
845 | |
846 | pack() and unpack() "q" and "Q" formats |
847 | |
848 | =item * |
849 | |
850 | in basic arithmetics: + - * / % (NOTE: operating close to the limits |
851 | of the integer values may produce surprising results) |
852 | |
853 | =item * |
854 | |
855 | in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced |
856 | to be 32 bits wide but now operate on the full native width.) |
857 | |
858 | =item * |
859 | |
860 | vec() |
861 | |
862 | =back |
863 | |
864 | Note that unless you have the case (a) you will have to configure |
865 | and compile Perl using the -Duse64bitint Configure flag. |
866 | |
867 | NOTE: The Configure flags -Duselonglong and -Duse64bits have been |
868 | deprecated. Use -Duse64bitint instead. |
869 | |
870 | There are actually two modes of 64-bitness: the first one is achieved |
871 | using Configure -Duse64bitint and the second one using Configure |
872 | -Duse64bitall. The difference is that the first one is minimal and |
873 | the second one maximal. The first works in more places than the second. |
874 | |
875 | The C<use64bitint> does only as much as is required to get 64-bit |
876 | integers into Perl (this may mean, for example, using "long longs") |
877 | while your memory may still be limited to 2 gigabytes (because your |
878 | pointers could still be 32-bit). Note that the name C<64bitint> does |
879 | not imply that your C compiler will be using 64-bit C<int>s (it might, |
880 | but it doesn't have to): the C<use64bitint> means that you will be |
881 | able to have 64 bits wide scalar values. |
882 | |
883 | The C<use64bitall> goes all the way by attempting to switch also |
884 | integers (if it can), longs (and pointers) to being 64-bit. This may |
885 | create an even more binary incompatible Perl than -Duse64bitint: the |
886 | resulting executable may not run at all in a 32-bit box, or you may |
887 | have to reboot/reconfigure/rebuild your operating system to be 64-bit |
888 | aware. |
889 | |
890 | Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint |
891 | nor -Duse64bitall. |
892 | |
893 | Last but not least: note that due to Perl's habit of always using |
894 | floating point numbers, the quads are still not true integers. |
895 | When quads overflow their limits (0...18_446_744_073_709_551_615 unsigned, |
896 | -9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they |
897 | are silently promoted to floating point numbers, after which they will |
898 | start losing precision (in their lower digits). |
899 | |
900 | NOTE: 64-bit support is still experimental on most platforms. |
901 | Existing support only covers the LP64 data model. In particular, the |
902 | LLP64 data model is not yet supported. 64-bit libraries and system |
903 | APIs on many platforms have not stabilized--your mileage may vary. |
904 | |
905 | =head2 Large file support |
906 | |
907 | If you have filesystems that support "large files" (files larger than |
908 | 2 gigabytes), you may now also be able to create and access them from |
909 | Perl. |
910 | |
911 | NOTE: The default action is to enable large file support, if |
912 | available on the platform. |
913 | |
914 | If the large file support is on, and you have a Fcntl constant |
915 | O_LARGEFILE, the O_LARGEFILE is automatically added to the flags |
916 | of sysopen(). |
917 | |
918 | Beware that unless your filesystem also supports "sparse files" seeking |
919 | to umpteen petabytes may be inadvisable. |
920 | |
921 | Note that in addition to requiring a proper file system to do large |
922 | files you may also need to adjust your per-process (or your |
923 | per-system, or per-process-group, or per-user-group) maximum filesize |
924 | limits before running Perl scripts that try to handle large files, |
925 | especially if you intend to write such files. |
926 | |
927 | Finally, in addition to your process/process group maximum filesize |
928 | limits, you may have quota limits on your filesystems that stop you |
929 | (your user id or your user group id) from using large files. |
930 | |
931 | Adjusting your process/user/group/file system/operating system limits |
932 | is outside the scope of Perl core language. For process limits, you |
933 | may try increasing the limits using your shell's limits/limit/ulimit |
934 | command before running Perl. The BSD::Resource extension (not |
935 | included with the standard Perl distribution) may also be of use, it |
936 | offers the getrlimit/setrlimit interface that can be used to adjust |
937 | process resource usage limits, including the maximum filesize limit. |
938 | |
939 | =head2 Long doubles |
940 | |
941 | In some systems you may be able to use long doubles to enhance the |
942 | range and precision of your double precision floating point numbers |
943 | (that is, Perl's numbers). Use Configure -Duselongdouble to enable |
944 | this support (if it is available). |
945 | |
946 | =head2 "more bits" |
947 | |
948 | You can "Configure -Dusemorebits" to turn on both the 64-bit support |
949 | and the long double support. |
950 | |
951 | =head2 Enhanced support for sort() subroutines |
952 | |
953 | Perl subroutines with a prototype of C<($$)>, and XSUBs in general, can |
954 | now be used as sort subroutines. In either case, the two elements to |
955 | be compared are passed as normal parameters in @_. See L<perlfunc/sort>. |
956 | |
957 | For unprototyped sort subroutines, the historical behavior of passing |
958 | the elements to be compared as the global variables $a and $b remains |
959 | unchanged. |
960 | |
961 | =head2 C<sort $coderef @foo> allowed |
962 | |
963 | sort() did not accept a subroutine reference as the comparison |
964 | function in earlier versions. This is now permitted. |
965 | |
966 | =head2 File globbing implemented internally |
967 | |
968 | Perl now uses the File::Glob implementation of the glob() operator |
969 | automatically. This avoids using an external csh process and the |
970 | problems associated with it. |
971 | |
972 | NOTE: This is currently an experimental feature. Interfaces and |
973 | implementation are subject to change. |
974 | |
975 | =head2 Support for CHECK blocks |
976 | |
977 | In addition to C<BEGIN>, C<INIT>, C<END>, C<DESTROY> and C<AUTOLOAD>, |
978 | subroutines named C<CHECK> are now special. These are queued up during |
979 | compilation and behave similar to END blocks, except they are called at |
980 | the end of compilation rather than at the end of execution. They cannot |
981 | be called directly. |
982 | |
983 | =head2 POSIX character class syntax [: :] supported |
984 | |
985 | For example to match alphabetic characters use /[[:alpha:]]/. |
986 | See L<perlre> for details. |
987 | |
988 | =head2 Better pseudo-random number generator |
989 | |
990 | In 5.005_0x and earlier, perl's rand() function used the C library |
991 | rand(3) function. As of 5.005_52, Configure tests for drand48(), |
992 | random(), and rand() (in that order) and picks the first one it finds. |
993 | |
994 | These changes should result in better random numbers from rand(). |
995 | |
996 | =head2 Improved C<qw//> operator |
997 | |
998 | The C<qw//> operator is now evaluated at compile time into a true list |
999 | instead of being replaced with a run time call to C<split()>. This |
1000 | removes the confusing misbehaviour of C<qw//> in scalar context, which |
1001 | had inherited that behaviour from split(). |
1002 | |
1003 | Thus: |
1004 | |
1005 | $foo = ($bar) = qw(a b c); print "$foo|$bar\n"; |
1006 | |
1007 | now correctly prints "3|a", instead of "2|a". |
1008 | |
1009 | =head2 Better worst-case behavior of hashes |
1010 | |
1011 | Small changes in the hashing algorithm have been implemented in |
1012 | order to improve the distribution of lower order bits in the |
1013 | hashed value. This is expected to yield better performance on |
1014 | keys that are repeated sequences. |
1015 | |
1016 | =head2 pack() format 'Z' supported |
1017 | |
1018 | The new format type 'Z' is useful for packing and unpacking null-terminated |
1019 | strings. See L<perlfunc/"pack">. |
1020 | |
1021 | =head2 pack() format modifier '!' supported |
1022 | |
1023 | The new format type modifier '!' is useful for packing and unpacking |
1024 | native shorts, ints, and longs. See L<perlfunc/"pack">. |
1025 | |
1026 | =head2 pack() and unpack() support counted strings |
1027 | |
1028 | The template character '/' can be used to specify a counted string |
1029 | type to be packed or unpacked. See L<perlfunc/"pack">. |
1030 | |
1031 | =head2 Comments in pack() templates |
1032 | |
1033 | The '#' character in a template introduces a comment up to |
1034 | end of the line. This facilitates documentation of pack() |
1035 | templates. |
1036 | |
1037 | =head2 Weak references |
1038 | |
1039 | In previous versions of Perl, you couldn't cache objects so as |
1040 | to allow them to be deleted if the last reference from outside |
1041 | the cache is deleted. The reference in the cache would hold a |
1042 | reference count on the object and the objects would never be |
1043 | destroyed. |
1044 | |
1045 | Another familiar problem is with circular references. When an |
1046 | object references itself, its reference count would never go |
1047 | down to zero, and it would not get destroyed until the program |
1048 | is about to exit. |
1049 | |
1050 | Weak references solve this by allowing you to "weaken" any |
1051 | reference, that is, make it not count towards the reference count. |
1052 | When the last non-weak reference to an object is deleted, the object |
1053 | is destroyed and all the weak references to the object are |
1054 | automatically undef-ed. |
1055 | |
1bb10054 |
1056 | To use this feature, you need the Devel::WeakRef package from CPAN, which |
493a87da |
1057 | contains additional documentation. |
1058 | |
1059 | NOTE: This is an experimental feature. Details are subject to change. |
1060 | |
1061 | =head2 Binary numbers supported |
1062 | |
1063 | Binary numbers are now supported as literals, in s?printf formats, and |
1064 | C<oct()>: |
1065 | |
1066 | $answer = 0b101010; |
1067 | printf "The answer is: %b\n", oct("0b101010"); |
1068 | |
1069 | =head2 Lvalue subroutines |
1070 | |
1071 | Subroutines can now return modifiable lvalues. |
1072 | See L<perlsub/"Lvalue subroutines">. |
1073 | |
1074 | NOTE: This is an experimental feature. Details are subject to change. |
1075 | |
1076 | =head2 Some arrows may be omitted in calls through references |
1077 | |
1078 | Perl now allows the arrow to be omitted in many constructs |
1079 | involving subroutine calls through references. For example, |
1080 | C<< $foo[10]->('foo') >> may now be written C<$foo[10]('foo')>. |
1081 | This is rather similar to how the arrow may be omitted from |
1082 | C<< $foo[10]->{'foo'} >>. Note however, that the arrow is still |
1083 | required for C<< foo(10)->('bar') >>. |
1084 | |
1085 | =head2 Boolean assignment operators are legal lvalues |
1086 | |
1087 | Constructs such as C<($a ||= 2) += 1> are now allowed. |
1088 | |
1089 | =head2 exists() is supported on subroutine names |
1090 | |
1091 | The exists() builtin now works on subroutine names. A subroutine |
1092 | is considered to exist if it has been declared (even if implicitly). |
1093 | See L<perlfunc/exists> for examples. |
1094 | |
1095 | =head2 exists() and delete() are supported on array elements |
1096 | |
1097 | The exists() and delete() builtins now work on simple arrays as well. |
1098 | The behavior is similar to that on hash elements. |
1099 | |
1100 | exists() can be used to check whether an array element has been |
1101 | initialized. This avoids autovivifying array elements that don't exist. |
1102 | If the array is tied, the EXISTS() method in the corresponding tied |
1103 | package will be invoked. |
1104 | |
1105 | delete() may be used to remove an element from the array and return |
1106 | it. The array element at that position returns to its uninitialized |
1107 | state, so that testing for the same element with exists() will return |
1108 | false. If the element happens to be the one at the end, the size of |
1109 | the array also shrinks up to the highest element that tests true for |
1110 | exists(), or 0 if none such is found. If the array is tied, the DELETE() |
1111 | method in the corresponding tied package will be invoked. |
1112 | |
1113 | See L<perlfunc/exists> and L<perlfunc/delete> for examples. |
1114 | |
1115 | =head2 Pseudo-hashes work better |
1116 | |
1117 | Dereferencing some types of reference values in a pseudo-hash, |
1118 | such as C<< $ph->{foo}[1] >>, was accidentally disallowed. This has |
1119 | been corrected. |
1120 | |
1121 | When applied to a pseudo-hash element, exists() now reports whether |
1122 | the specified value exists, not merely if the key is valid. |
1123 | |
1124 | delete() now works on pseudo-hashes. When given a pseudo-hash element |
1125 | or slice it deletes the values corresponding to the keys (but not the keys |
1126 | themselves). See L<perlref/"Pseudo-hashes: Using an array as a hash">. |
1127 | |
1128 | Pseudo-hash slices with constant keys are now optimized to array lookups |
1129 | at compile-time. |
1130 | |
1131 | List assignments to pseudo-hash slices are now supported. |
1132 | |
1133 | The C<fields> pragma now provides ways to create pseudo-hashes, via |
1134 | fields::new() and fields::phash(). See L<fields>. |
1135 | |
1136 | NOTE: The pseudo-hash data type continues to be experimental. |
1137 | Limiting oneself to the interface elements provided by the |
1138 | fields pragma will provide protection from any future changes. |
1139 | |
1140 | =head2 Automatic flushing of output buffers |
1141 | |
1142 | fork(), exec(), system(), qx//, and pipe open()s now flush buffers |
1143 | of all files opened for output when the operation was attempted. This |
1144 | mostly eliminates confusing buffering mishaps suffered by users unaware |
1145 | of how Perl internally handles I/O. |
1146 | |
1147 | This is not supported on some platforms like Solaris where a suitably |
1148 | correct implementation of fflush(NULL) isn't available. |
1149 | |
1150 | =head2 Better diagnostics on meaningless filehandle operations |
1151 | |
1152 | Constructs such as C<< open(<FH>) >> and C<< close(<FH>) >> |
1153 | are compile time errors. Attempting to read from filehandles that |
1154 | were opened only for writing will now produce warnings (just as |
1155 | writing to read-only filehandles does). |
1156 | |
1157 | =head2 Where possible, buffered data discarded from duped input filehandle |
1158 | |
1159 | C<< open(NEW, "<&OLD") >> now attempts to discard any data that |
1160 | was previously read and buffered in C<OLD> before duping the handle. |
1161 | On platforms where doing this is allowed, the next read operation |
1162 | on C<NEW> will return the same data as the corresponding operation |
1163 | on C<OLD>. Formerly, it would have returned the data from the start |
1164 | of the following disk block instead. |
1165 | |
1166 | =head2 eof() has the same old magic as <> |
1167 | |
1168 | C<eof()> would return true if no attempt to read from C<< <> >> had |
1169 | yet been made. C<eof()> has been changed to have a little magic of its |
1170 | own, it now opens the C<< <> >> files. |
1171 | |
1172 | =head2 binmode() can be used to set :crlf and :raw modes |
1173 | |
1174 | binmode() now accepts a second argument that specifies a discipline |
1175 | for the handle in question. The two pseudo-disciplines ":raw" and |
1176 | ":crlf" are currently supported on DOS-derivative platforms. |
1177 | See L<perlfunc/"binmode"> and L<open>. |
1178 | |
1179 | =head2 C<-T> filetest recognizes UTF-8 encoded files as "text" |
1180 | |
1181 | The algorithm used for the C<-T> filetest has been enhanced to |
1182 | correctly identify UTF-8 content as "text". |
1183 | |
1184 | =head2 system(), backticks and pipe open now reflect exec() failure |
1185 | |
1186 | On Unix and similar platforms, system(), qx() and open(FOO, "cmd |") |
1187 | etc., are implemented via fork() and exec(). When the underlying |
1188 | exec() fails, earlier versions did not report the error properly, |
1189 | since the exec() happened to be in a different process. |
1190 | |
1191 | The child process now communicates with the parent about the |
1192 | error in launching the external command, which allows these |
1193 | constructs to return with their usual error value and set $!. |
1194 | |
1195 | =head2 Improved diagnostics |
1196 | |
1197 | Line numbers are no longer suppressed (under most likely circumstances) |
1198 | during the global destruction phase. |
1199 | |
1200 | Diagnostics emitted from code running in threads other than the main |
1201 | thread are now accompanied by the thread ID. |
1202 | |
1203 | Embedded null characters in diagnostics now actually show up. They |
1204 | used to truncate the message in prior versions. |
1205 | |
1206 | $foo::a and $foo::b are now exempt from "possible typo" warnings only |
1207 | if sort() is encountered in package C<foo>. |
1208 | |
1209 | Unrecognized alphabetic escapes encountered when parsing quote |
1210 | constructs now generate a warning, since they may take on new |
1211 | semantics in later versions of Perl. |
1212 | |
1213 | Many diagnostics now report the internal operation in which the warning |
1214 | was provoked, like so: |
1215 | |
1216 | Use of uninitialized value in concatenation (.) at (eval 1) line 1. |
1217 | Use of uninitialized value in print at (eval 1) line 1. |
1218 | |
1219 | Diagnostics that occur within eval may also report the file and line |
1220 | number where the eval is located, in addition to the eval sequence |
1221 | number and the line number within the evaluated text itself. For |
1222 | example: |
1223 | |
1224 | Not enough arguments for scalar at (eval 4)[newlib/perl5db.pl:1411] line 2, at EOF |
1225 | |
1226 | =head2 Diagnostics follow STDERR |
1227 | |
1228 | Diagnostic output now goes to whichever file the C<STDERR> handle |
1229 | is pointing at, instead of always going to the underlying C runtime |
1230 | library's C<stderr>. |
1231 | |
1232 | =head2 More consistent close-on-exec behavior |
1233 | |
1234 | On systems that support a close-on-exec flag on filehandles, the |
1235 | flag is now set for any handles created by pipe(), socketpair(), |
1236 | socket(), and accept(), if that is warranted by the value of $^F |
1237 | that may be in effect. Earlier versions neglected to set the flag |
1238 | for handles created with these operators. See L<perlfunc/pipe>, |
1239 | L<perlfunc/socketpair>, L<perlfunc/socket>, L<perlfunc/accept>, |
1240 | and L<perlvar/$^F>. |
1241 | |
1242 | =head2 syswrite() ease-of-use |
1243 | |
1244 | The length argument of C<syswrite()> has become optional. |
1245 | |
1246 | =head2 Better syntax checks on parenthesized unary operators |
1247 | |
1248 | Expressions such as: |
1249 | |
1250 | print defined(&foo,&bar,&baz); |
1251 | print uc("foo","bar","baz"); |
1252 | undef($foo,&bar); |
1253 | |
1254 | used to be accidentally allowed in earlier versions, and produced |
1255 | unpredictable behaviour. Some produced ancillary warnings |
1256 | when used in this way; others silently did the wrong thing. |
1257 | |
1258 | The parenthesized forms of most unary operators that expect a single |
1259 | argument now ensure that they are not called with more than one |
1260 | argument, making the cases shown above syntax errors. The usual |
1261 | behaviour of: |
1262 | |
1263 | print defined &foo, &bar, &baz; |
1264 | print uc "foo", "bar", "baz"; |
1265 | undef $foo, &bar; |
1266 | |
1267 | remains unchanged. See L<perlop>. |
1268 | |
1269 | =head2 Bit operators support full native integer width |
1270 | |
1271 | The bit operators (& | ^ ~ << >>) now operate on the full native |
1272 | integral width (the exact size of which is available in $Config{ivsize}). |
1273 | For example, if your platform is either natively 64-bit or if Perl |
1274 | has been configured to use 64-bit integers, these operations apply |
1275 | to 8 bytes (as opposed to 4 bytes on 32-bit platforms). |
1276 | For portability, be sure to mask off the excess bits in the result of |
1277 | unary C<~>, e.g., C<~$x & 0xffffffff>. |
1278 | |
1279 | =head2 Improved security features |
1280 | |
1281 | More potentially unsafe operations taint their results for improved |
1282 | security. |
1283 | |
1284 | The C<passwd> and C<shell> fields returned by the getpwent(), getpwnam(), |
1285 | and getpwuid() are now tainted, because the user can affect their own |
1286 | encrypted password and login shell. |
1287 | |
1288 | The variable modified by shmread(), and messages returned by msgrcv() |
1289 | (and its object-oriented interface IPC::SysV::Msg::rcv) are also tainted, |
1290 | because other untrusted processes can modify messages and shared memory |
1291 | segments for their own nefarious purposes. |
1292 | |
1293 | =head2 More functional bareword prototype (*) |
1294 | |
1295 | Bareword prototypes have been rationalized to enable them to be used |
1296 | to override builtins that accept barewords and interpret them in |
1297 | a special way, such as C<require> or C<do>. |
1298 | |
1299 | Arguments prototyped as C<*> will now be visible within the subroutine |
1300 | as either a simple scalar or as a reference to a typeglob. |
1301 | See L<perlsub/Prototypes>. |
1302 | |
1303 | =head2 C<require> and C<do> may be overridden |
1304 | |
1305 | C<require> and C<do 'file'> operations may be overridden locally |
1306 | by importing subroutines of the same name into the current package |
1307 | (or globally by importing them into the CORE::GLOBAL:: namespace). |
1308 | Overriding C<require> will also affect C<use>, provided the override |
1309 | is visible at compile-time. |
1310 | See L<perlsub/"Overriding Built-in Functions">. |
1311 | |
1312 | =head2 $^X variables may now have names longer than one character |
1313 | |
1314 | Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax |
1315 | error. Now variable names that begin with a control character may be |
1316 | arbitrarily long. However, for compatibility reasons, these variables |
1317 | I<must> be written with explicit braces, as C<${^XY}> for example. |
1318 | C<${^XYZ}> is synonymous with ${"\cXYZ"}. Variable names with more |
1319 | than one control character, such as C<${^XY^Z}>, are illegal. |
1320 | |
1321 | The old syntax has not changed. As before, `^X' may be either a |
1322 | literal control-X character or the two-character sequence `caret' plus |
1323 | `X'. When braces are omitted, the variable name stops after the |
1324 | control character. Thus C<"$^XYZ"> continues to be synonymous with |
1325 | C<$^X . "YZ"> as before. |
1326 | |
1327 | As before, lexical variables may not have names beginning with control |
1328 | characters. As before, variables whose names begin with a control |
1329 | character are always forced to be in package `main'. All such variables |
1330 | are reserved for future extensions, except those that begin with |
1331 | C<^_>, which may be used by user programs and are guaranteed not to |
1332 | acquire special meaning in any future version of Perl. |
1333 | |
1334 | =head2 New variable $^C reflects C<-c> switch |
1335 | |
1336 | C<$^C> has a boolean value that reflects whether perl is being run |
1337 | in compile-only mode (i.e. via the C<-c> switch). Since |
1338 | BEGIN blocks are executed under such conditions, this variable |
1339 | enables perl code to determine whether actions that make sense |
1340 | only during normal running are warranted. See L<perlvar>. |
1341 | |
1342 | =head2 New variable $^V contains Perl version as a string |
1343 | |
1344 | C<$^V> contains the Perl version number as a string composed of |
1345 | characters whose ordinals match the version numbers, i.e. v5.6.0. |
1346 | This may be used in string comparisons. |
1347 | |
1348 | See C<Support for strings represented as a vector of ordinals> for an |
1349 | example. |
1350 | |
1351 | =head2 Optional Y2K warnings |
1352 | |
1353 | If Perl is built with the cpp macro C<PERL_Y2KWARN> defined, |
1354 | it emits optional warnings when concatenating the number 19 |
1355 | with another number. |
1356 | |
1357 | This behavior must be specifically enabled when running Configure. |
1358 | See F<INSTALL> and F<README.Y2K>. |
1359 | |
1360 | =head2 Arrays now always interpolate into double-quoted strings |
1361 | |
1362 | In double-quoted strings, arrays now interpolate, no matter what. The |
1363 | behavior in earlier versions of perl 5 was that arrays would interpolate |
1364 | into strings if the array had been mentioned before the string was |
1365 | compiled, and otherwise Perl would raise a fatal compile-time error. |
1366 | In versions 5.000 through 5.003, the error was |
1367 | |
1368 | Literal @example now requires backslash |
1369 | |
1370 | In versions 5.004_01 through 5.6.0, the error was |
1371 | |
1372 | In string, @example now must be written as \@example |
1373 | |
1374 | The idea here was to get people into the habit of writing |
1375 | C<"fred\@example.com"> when they wanted a literal C<@> sign, just as |
1376 | they have always written C<"Give me back my \$5"> when they wanted a |
1377 | literal C<$> sign. |
1378 | |
1379 | Starting with 5.6.1, when Perl now sees an C<@> sign in a |
1380 | double-quoted string, it I<always> attempts to interpolate an array, |
1381 | regardless of whether or not the array has been used or declared |
1382 | already. The fatal error has been downgraded to an optional warning: |
1383 | |
1384 | Possible unintended interpolation of @example in string |
1385 | |
1386 | This warns you that C<"fred@example.com"> is going to turn into |
1387 | C<fred.com> if you don't backslash the C<@>. |
1388 | See http://www.plover.com/~mjd/perl/at-error.html for more details |
1389 | about the history here. |
1390 | |
1391 | =head1 Modules and Pragmata |
1392 | |
1393 | =head2 Modules |
1394 | |
1395 | =over 4 |
1396 | |
1397 | =item attributes |
1398 | |
1399 | While used internally by Perl as a pragma, this module also |
1400 | provides a way to fetch subroutine and variable attributes. |
1401 | See L<attributes>. |
1402 | |
1403 | =item B |
1404 | |
1405 | The Perl Compiler suite has been extensively reworked for this |
1406 | release. More of the standard Perl testsuite passes when run |
1407 | under the Compiler, but there is still a significant way to |
1408 | go to achieve production quality compiled executables. |
1409 | |
1410 | NOTE: The Compiler suite remains highly experimental. The |
1411 | generated code may not be correct, even when it manages to execute |
1412 | without errors. |
1413 | |
1414 | =item Benchmark |
1415 | |
1416 | Overall, Benchmark results exhibit lower average error and better timing |
1417 | accuracy. |
1418 | |
1419 | You can now run tests for I<n> seconds instead of guessing the right |
1420 | number of tests to run: e.g., timethese(-5, ...) will run each |
1421 | code for at least 5 CPU seconds. Zero as the "number of repetitions" |
1422 | means "for at least 3 CPU seconds". The output format has also |
1423 | changed. For example: |
1424 | |
1425 | use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}}) |
1426 | |
1427 | will now output something like this: |
1428 | |
1429 | Benchmark: running a, b, each for at least 5 CPU seconds... |
1430 | a: 5 wallclock secs ( 5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91/s (n=1156516) |
1431 | b: 4 wallclock secs ( 5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18/s (n=800686) |
1432 | |
1433 | New features: "each for at least N CPU seconds...", "wallclock secs", |
1434 | and the "@ operations/CPU second (n=operations)". |
1435 | |
1436 | timethese() now returns a reference to a hash of Benchmark objects containing |
1437 | the test results, keyed on the names of the tests. |
1438 | |
1439 | timethis() now returns the iterations field in the Benchmark result object |
1440 | instead of 0. |
1441 | |
1442 | timethese(), timethis(), and the new cmpthese() (see below) can also take |
1443 | a format specifier of 'none' to suppress output. |
1444 | |
1445 | A new function countit() is just like timeit() except that it takes a |
1446 | TIME instead of a COUNT. |
1447 | |
1448 | A new function cmpthese() prints a chart comparing the results of each test |
1449 | returned from a timethese() call. For each possible pair of tests, the |
1450 | percentage speed difference (iters/sec or seconds/iter) is shown. |
1451 | |
1452 | For other details, see L<Benchmark>. |
1453 | |
1454 | =item ByteLoader |
1455 | |
1456 | The ByteLoader is a dedicated extension to generate and run |
1457 | Perl bytecode. See L<ByteLoader>. |
1458 | |
1459 | =item constant |
1460 | |
1461 | References can now be used. |
1462 | |
1463 | The new version also allows a leading underscore in constant names, but |
1464 | disallows a double leading underscore (as in "__LINE__"). Some other names |
1465 | are disallowed or warned against, including BEGIN, END, etc. Some names |
1466 | which were forced into main:: used to fail silently in some cases; now they're |
1467 | fatal (outside of main::) and an optional warning (inside of main::). |
1468 | The ability to detect whether a constant had been set with a given name has |
1469 | been added. |
1470 | |
1471 | See L<constant>. |
1472 | |
1473 | =item charnames |
1474 | |
1475 | This pragma implements the C<\N> string escape. See L<charnames>. |
1476 | |
1477 | =item Data::Dumper |
1478 | |
1479 | A C<Maxdepth> setting can be specified to avoid venturing |
1480 | too deeply into deep data structures. See L<Data::Dumper>. |
1481 | |
1482 | The XSUB implementation of Dump() is now automatically called if the |
1483 | C<Useqq> setting is not in use. |
1484 | |
1485 | Dumping C<qr//> objects works correctly. |
1486 | |
1487 | =item DB |
1488 | |
1489 | C<DB> is an experimental module that exposes a clean abstraction |
1490 | to Perl's debugging API. |
1491 | |
1492 | =item DB_File |
1493 | |
1494 | DB_File can now be built with Berkeley DB versions 1, 2 or 3. |
1495 | See C<ext/DB_File/Changes>. |
1496 | |
1497 | =item Devel::DProf |
1498 | |
1499 | Devel::DProf, a Perl source code profiler has been added. See |
1500 | L<Devel::DProf> and L<dprofpp>. |
1501 | |
1502 | =item Devel::Peek |
1503 | |
1504 | The Devel::Peek module provides access to the internal representation |
1505 | of Perl variables and data. It is a data debugging tool for the XS programmer. |
1506 | |
1507 | =item Dumpvalue |
1508 | |
1509 | The Dumpvalue module provides screen dumps of Perl data. |
1510 | |
1511 | =item DynaLoader |
1512 | |
1513 | DynaLoader now supports a dl_unload_file() function on platforms that |
1514 | support unloading shared objects using dlclose(). |
1515 | |
1516 | Perl can also optionally arrange to unload all extension shared objects |
1517 | loaded by Perl. To enable this, build Perl with the Configure option |
1518 | C<-Accflags=-DDL_UNLOAD_ALL_AT_EXIT>. (This maybe useful if you are |
1519 | using Apache with mod_perl.) |
1520 | |
1521 | =item English |
1522 | |
1523 | $PERL_VERSION now stands for C<$^V> (a string value) rather than for C<$]> |
1524 | (a numeric value). |
1525 | |
1526 | =item Env |
1527 | |
1528 | Env now supports accessing environment variables like PATH as array |
1529 | variables. |
1530 | |
1531 | =item Fcntl |
1532 | |
1533 | More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for |
1534 | large file (more than 4GB) access (NOTE: the O_LARGEFILE is |
1535 | automatically added to sysopen() flags if large file support has been |
1536 | configured, as is the default), Free/Net/OpenBSD locking behaviour |
1537 | flags F_FLOCK, F_POSIX, Linux F_SHLCK, and O_ACCMODE: the combined |
1538 | mask of O_RDONLY, O_WRONLY, and O_RDWR. The seek()/sysseek() |
1539 | constants SEEK_SET, SEEK_CUR, and SEEK_END are available via the |
1540 | C<:seek> tag. The chmod()/stat() S_IF* constants and S_IS* functions |
1541 | are available via the C<:mode> tag. |
1542 | |
1543 | =item File::Compare |
1544 | |
1545 | A compare_text() function has been added, which allows custom |
1546 | comparison functions. See L<File::Compare>. |
1547 | |
1548 | =item File::Find |
1549 | |
1550 | File::Find now works correctly when the wanted() function is either |
1551 | autoloaded or is a symbolic reference. |
1552 | |
1553 | A bug that caused File::Find to lose track of the working directory |
1554 | when pruning top-level directories has been fixed. |
1555 | |
1556 | File::Find now also supports several other options to control its |
1557 | behavior. It can follow symbolic links if the C<follow> option is |
1558 | specified. Enabling the C<no_chdir> option will make File::Find skip |
1559 | changing the current directory when walking directories. The C<untaint> |
1560 | flag can be useful when running with taint checks enabled. |
1561 | |
1562 | See L<File::Find>. |
1563 | |
1564 | =item File::Glob |
1565 | |
1566 | This extension implements BSD-style file globbing. By default, |
1567 | it will also be used for the internal implementation of the glob() |
1568 | operator. See L<File::Glob>. |
1569 | |
1570 | =item File::Spec |
1571 | |
1572 | New methods have been added to the File::Spec module: devnull() returns |
1573 | the name of the null device (/dev/null on Unix) and tmpdir() the name of |
1574 | the temp directory (normally /tmp on Unix). There are now also methods |
1575 | to convert between absolute and relative filenames: abs2rel() and |
1576 | rel2abs(). For compatibility with operating systems that specify volume |
1577 | names in file paths, the splitpath(), splitdir(), and catdir() methods |
1578 | have been added. |
1579 | |
1580 | =item File::Spec::Functions |
1581 | |
1582 | The new File::Spec::Functions modules provides a function interface |
1583 | to the File::Spec module. Allows shorthand |
1584 | |
1585 | $fullname = catfile($dir1, $dir2, $file); |
1586 | |
1587 | instead of |
1588 | |
1589 | $fullname = File::Spec->catfile($dir1, $dir2, $file); |
1590 | |
1591 | =item Getopt::Long |
1592 | |
1593 | Getopt::Long licensing has changed to allow the Perl Artistic License |
1594 | as well as the GPL. It used to be GPL only, which got in the way of |
1595 | non-GPL applications that wanted to use Getopt::Long. |
1596 | |
1597 | Getopt::Long encourages the use of Pod::Usage to produce help |
1598 | messages. For example: |
1599 | |
1600 | use Getopt::Long; |
1601 | use Pod::Usage; |
1602 | my $man = 0; |
1603 | my $help = 0; |
1604 | GetOptions('help|?' => \$help, man => \$man) or pod2usage(2); |
1605 | pod2usage(1) if $help; |
1606 | pod2usage(-exitstatus => 0, -verbose => 2) if $man; |
1607 | |
1608 | __END__ |
1609 | |
1610 | =head1 NAME |
1611 | |
fe854a6f |
1612 | sample - Using Getopt::Long and Pod::Usage |
493a87da |
1613 | |
1614 | =head1 SYNOPSIS |
1615 | |
1616 | sample [options] [file ...] |
1617 | |
1618 | Options: |
1619 | -help brief help message |
1620 | -man full documentation |
1621 | |
1622 | =head1 OPTIONS |
1623 | |
1624 | =over 8 |
1625 | |
1626 | =item B<-help> |
1627 | |
1628 | Print a brief help message and exits. |
1629 | |
1630 | =item B<-man> |
1631 | |
1632 | Prints the manual page and exits. |
1633 | |
1634 | =back |
1635 | |
1636 | =head1 DESCRIPTION |
1637 | |
1638 | B<This program> will read the given input file(s) and do something |
1639 | useful with the contents thereof. |
1640 | |
1641 | =cut |
1642 | |
1643 | See L<Pod::Usage> for details. |
1644 | |
1645 | A bug that prevented the non-option call-back <> from being |
1646 | specified as the first argument has been fixed. |
1647 | |
1648 | To specify the characters < and > as option starters, use ><. Note, |
1649 | however, that changing option starters is strongly deprecated. |
1650 | |
1651 | =item IO |
1652 | |
1653 | write() and syswrite() will now accept a single-argument |
1654 | form of the call, for consistency with Perl's syswrite(). |
1655 | |
1656 | You can now create a TCP-based IO::Socket::INET without forcing |
1657 | a connect attempt. This allows you to configure its options |
1658 | (like making it non-blocking) and then call connect() manually. |
1659 | |
1660 | A bug that prevented the IO::Socket::protocol() accessor |
1661 | from ever returning the correct value has been corrected. |
1662 | |
1663 | IO::Socket::connect now uses non-blocking IO instead of alarm() |
1664 | to do connect timeouts. |
1665 | |
1666 | IO::Socket::accept now uses select() instead of alarm() for doing |
1667 | timeouts. |
1668 | |
1669 | IO::Socket::INET->new now sets $! correctly on failure. $@ is |
1670 | still set for backwards compatibility. |
1671 | |
1672 | =item JPL |
1673 | |
1674 | Java Perl Lingo is now distributed with Perl. See jpl/README |
1675 | for more information. |
1676 | |
1677 | =item lib |
1678 | |
1679 | C<use lib> now weeds out any trailing duplicate entries. |
1680 | C<no lib> removes all named entries. |
1681 | |
1682 | =item Math::BigInt |
1683 | |
1684 | The bitwise operations C<<< << >>>, C<<< >> >>>, C<&>, C<|>, |
1685 | and C<~> are now supported on bigints. |
1686 | |
1687 | =item Math::Complex |
1688 | |
1689 | The accessor methods Re, Im, arg, abs, rho, and theta can now also |
1690 | act as mutators (accessor $z->Re(), mutator $z->Re(3)). |
1691 | |
1692 | The class method C<display_format> and the corresponding object method |
1693 | C<display_format>, in addition to accepting just one argument, now can |
1694 | also accept a parameter hash. Recognized keys of a parameter hash are |
1695 | C<"style">, which corresponds to the old one parameter case, and two |
1696 | new parameters: C<"format">, which is a printf()-style format string |
1697 | (defaults usually to C<"%.15g">, you can revert to the default by |
1698 | setting the format string to C<undef>) used for both parts of a |
1699 | complex number, and C<"polar_pretty_print"> (defaults to true), |
1700 | which controls whether an attempt is made to try to recognize small |
1701 | multiples and rationals of pi (2pi, pi/2) at the argument (angle) of a |
1702 | polar complex number. |
1703 | |
1704 | The potentially disruptive change is that in list context both methods |
1705 | now I<return the parameter hash>, instead of only the value of the |
1706 | C<"style"> parameter. |
1707 | |
1708 | =item Math::Trig |
1709 | |
1710 | A little bit of radial trigonometry (cylindrical and spherical), |
1711 | radial coordinate conversions, and the great circle distance were added. |
1712 | |
1713 | =item Pod::Parser, Pod::InputObjects |
1714 | |
1715 | Pod::Parser is a base class for parsing and selecting sections of |
1716 | pod documentation from an input stream. This module takes care of |
1717 | identifying pod paragraphs and commands in the input and hands off the |
1718 | parsed paragraphs and commands to user-defined methods which are free |
1719 | to interpret or translate them as they see fit. |
1720 | |
1721 | Pod::InputObjects defines some input objects needed by Pod::Parser, and |
1722 | for advanced users of Pod::Parser that need more about a command besides |
1723 | its name and text. |
1724 | |
1725 | As of release 5.6.0 of Perl, Pod::Parser is now the officially sanctioned |
1726 | "base parser code" recommended for use by all pod2xxx translators. |
1727 | Pod::Text (pod2text) and Pod::Man (pod2man) have already been converted |
1728 | to use Pod::Parser and efforts to convert Pod::HTML (pod2html) are already |
1729 | underway. For any questions or comments about pod parsing and translating |
1730 | issues and utilities, please use the pod-people@perl.org mailing list. |
1731 | |
1732 | For further information, please see L<Pod::Parser> and L<Pod::InputObjects>. |
1733 | |
1734 | =item Pod::Checker, podchecker |
1735 | |
1736 | This utility checks pod files for correct syntax, according to |
1737 | L<perlpod>. Obvious errors are flagged as such, while warnings are |
1738 | printed for mistakes that can be handled gracefully. The checklist is |
1739 | not complete yet. See L<Pod::Checker>. |
1740 | |
1741 | =item Pod::ParseUtils, Pod::Find |
1742 | |
1743 | These modules provide a set of gizmos that are useful mainly for pod |
1744 | translators. L<Pod::Find|Pod::Find> traverses directory structures and |
1745 | returns found pod files, along with their canonical names (like |
1746 | C<File::Spec::Unix>). L<Pod::ParseUtils|Pod::ParseUtils> contains |
1747 | B<Pod::List> (useful for storing pod list information), B<Pod::Hyperlink> |
1748 | (for parsing the contents of C<LE<lt>E<gt>> sequences) and B<Pod::Cache> |
1749 | (for caching information about pod files, e.g., link nodes). |
1750 | |
1751 | =item Pod::Select, podselect |
1752 | |
1753 | Pod::Select is a subclass of Pod::Parser which provides a function |
1754 | named "podselect()" to filter out user-specified sections of raw pod |
1755 | documentation from an input stream. podselect is a script that provides |
1756 | access to Pod::Select from other scripts to be used as a filter. |
1757 | See L<Pod::Select>. |
1758 | |
1759 | =item Pod::Usage, pod2usage |
1760 | |
1761 | Pod::Usage provides the function "pod2usage()" to print usage messages for |
1762 | a Perl script based on its embedded pod documentation. The pod2usage() |
1763 | function is generally useful to all script authors since it lets them |
1764 | write and maintain a single source (the pods) for documentation, thus |
1765 | removing the need to create and maintain redundant usage message text |
1766 | consisting of information already in the pods. |
1767 | |
1768 | There is also a pod2usage script which can be used from other kinds of |
1769 | scripts to print usage messages from pods (even for non-Perl scripts |
1770 | with pods embedded in comments). |
1771 | |
1772 | For details and examples, please see L<Pod::Usage>. |
1773 | |
1774 | =item Pod::Text and Pod::Man |
1775 | |
1776 | Pod::Text has been rewritten to use Pod::Parser. While pod2text() is |
1777 | still available for backwards compatibility, the module now has a new |
1778 | preferred interface. See L<Pod::Text> for the details. The new Pod::Text |
1779 | module is easily subclassed for tweaks to the output, and two such |
1780 | subclasses (Pod::Text::Termcap for man-page-style bold and underlining |
1781 | using termcap information, and Pod::Text::Color for markup with ANSI color |
1782 | sequences) are now standard. |
1783 | |
1784 | pod2man has been turned into a module, Pod::Man, which also uses |
1785 | Pod::Parser. In the process, several outstanding bugs related to quotes |
1786 | in section headers, quoting of code escapes, and nested lists have been |
1787 | fixed. pod2man is now a wrapper script around this module. |
1788 | |
1789 | =item SDBM_File |
1790 | |
1791 | An EXISTS method has been added to this module (and sdbm_exists() has |
1792 | been added to the underlying sdbm library), so one can now call exists |
1793 | on an SDBM_File tied hash and get the correct result, rather than a |
1794 | runtime error. |
1795 | |
1796 | A bug that may have caused data loss when more than one disk block |
1797 | happens to be read from the database in a single FETCH() has been |
1798 | fixed. |
1799 | |
1800 | =item Sys::Syslog |
1801 | |
1802 | Sys::Syslog now uses XSUBs to access facilities from syslog.h so it |
1803 | no longer requires syslog.ph to exist. |
1804 | |
1805 | =item Sys::Hostname |
1806 | |
1807 | Sys::Hostname now uses XSUBs to call the C library's gethostname() or |
1808 | uname() if they exist. |
1809 | |
1810 | =item Term::ANSIColor |
1811 | |
1812 | Term::ANSIColor is a very simple module to provide easy and readable |
1813 | access to the ANSI color and highlighting escape sequences, supported by |
1814 | most ANSI terminal emulators. It is now included standard. |
1815 | |
1816 | =item Time::Local |
1817 | |
1818 | The timelocal() and timegm() functions used to silently return bogus |
1819 | results when the date fell outside the machine's integer range. They |
1820 | now consistently croak() if the date falls in an unsupported range. |
1821 | |
1822 | =item Win32 |
1823 | |
1824 | The error return value in list context has been changed for all functions |
1825 | that return a list of values. Previously these functions returned a list |
1826 | with a single element C<undef> if an error occurred. Now these functions |
1827 | return the empty list in these situations. This applies to the following |
1828 | functions: |
1829 | |
1830 | Win32::FsType |
1831 | Win32::GetOSVersion |
1832 | |
1833 | The remaining functions are unchanged and continue to return C<undef> on |
1834 | error even in list context. |
1835 | |
1836 | The Win32::SetLastError(ERROR) function has been added as a complement |
1837 | to the Win32::GetLastError() function. |
1838 | |
1839 | The new Win32::GetFullPathName(FILENAME) returns the full absolute |
1840 | pathname for FILENAME in scalar context. In list context it returns |
1841 | a two-element list containing the fully qualified directory name and |
1842 | the filename. See L<Win32>. |
1843 | |
1844 | =item XSLoader |
1845 | |
1846 | The XSLoader extension is a simpler alternative to DynaLoader. |
1847 | See L<XSLoader>. |
1848 | |
1849 | =item DBM Filters |
1850 | |
1851 | A new feature called "DBM Filters" has been added to all the |
1852 | DBM modules--DB_File, GDBM_File, NDBM_File, ODBM_File, and SDBM_File. |
1853 | DBM Filters add four new methods to each DBM module: |
1854 | |
1855 | filter_store_key |
1856 | filter_store_value |
1857 | filter_fetch_key |
1858 | filter_fetch_value |
1859 | |
1860 | These can be used to filter key-value pairs before the pairs are |
1861 | written to the database or just after they are read from the database. |
1862 | See L<perldbmfilter> for further information. |
1863 | |
1864 | =back |
1865 | |
1866 | =head2 Pragmata |
1867 | |
1868 | C<use attrs> is now obsolete, and is only provided for |
1869 | backward-compatibility. It's been replaced by the C<sub : attributes> |
1870 | syntax. See L<perlsub/"Subroutine Attributes"> and L<attributes>. |
1871 | |
1872 | Lexical warnings pragma, C<use warnings;>, to control optional warnings. |
1873 | See L<perllexwarn>. |
1874 | |
1875 | C<use filetest> to control the behaviour of filetests (C<-r> C<-w> |
1876 | ...). Currently only one subpragma implemented, "use filetest |
1877 | 'access';", that uses access(2) or equivalent to check permissions |
1878 | instead of using stat(2) as usual. This matters in filesystems |
1879 | where there are ACLs (access control lists): the stat(2) might lie, |
1880 | but access(2) knows better. |
1881 | |
1882 | The C<open> pragma can be used to specify default disciplines for |
1883 | handle constructors (e.g. open()) and for qx//. The two |
1884 | pseudo-disciplines C<:raw> and C<:crlf> are currently supported on |
1885 | DOS-derivative platforms (i.e. where binmode is not a no-op). |
1886 | See also L</"binmode() can be used to set :crlf and :raw modes">. |
1887 | |
1888 | =head1 Utility Changes |
1889 | |
1890 | =head2 dprofpp |
1891 | |
1892 | C<dprofpp> is used to display profile data generated using C<Devel::DProf>. |
1893 | See L<dprofpp>. |
1894 | |
1895 | =head2 find2perl |
1896 | |
1897 | The C<find2perl> utility now uses the enhanced features of the File::Find |
1898 | module. The -depth and -follow options are supported. Pod documentation |
1899 | is also included in the script. |
1900 | |
1901 | =head2 h2xs |
1902 | |
1903 | The C<h2xs> tool can now work in conjunction with C<C::Scan> (available |
1904 | from CPAN) to automatically parse real-life header files. The C<-M>, |
1905 | C<-a>, C<-k>, and C<-o> options are new. |
1906 | |
1907 | =head2 perlcc |
1908 | |
1909 | C<perlcc> now supports the C and Bytecode backends. By default, |
1910 | it generates output from the simple C backend rather than the |
1911 | optimized C backend. |
1912 | |
1913 | Support for non-Unix platforms has been improved. |
1914 | |
1915 | =head2 perldoc |
1916 | |
1917 | C<perldoc> has been reworked to avoid possible security holes. |
1918 | It will not by default let itself be run as the superuser, but you |
1919 | may still use the B<-U> switch to try to make it drop privileges |
1920 | first. |
1921 | |
1922 | =head2 The Perl Debugger |
1923 | |
1924 | Many bug fixes and enhancements were added to F<perl5db.pl>, the |
1925 | Perl debugger. The help documentation was rearranged. New commands |
1926 | include C<< < ? >>, C<< > ? >>, and C<< { ? >> to list out current |
1927 | actions, C<man I<docpage>> to run your doc viewer on some perl |
1928 | docset, and support for quoted options. The help information was |
1929 | rearranged, and should be viewable once again if you're using B<less> |
1930 | as your pager. A serious security hole was plugged--you should |
1931 | immediately remove all older versions of the Perl debugger as |
1932 | installed in previous releases, all the way back to perl3, from |
1933 | your system to avoid being bitten by this. |
1934 | |
1935 | =head1 Improved Documentation |
1936 | |
1937 | Many of the platform-specific README files are now part of the perl |
1938 | installation. See L<perl> for the complete list. |
1939 | |
1940 | =over 4 |
1941 | |
1942 | =item perlapi.pod |
1943 | |
1944 | The official list of public Perl API functions. |
1945 | |
1946 | =item perlboot.pod |
1947 | |
1948 | A tutorial for beginners on object-oriented Perl. |
1949 | |
1950 | =item perlcompile.pod |
1951 | |
1952 | An introduction to using the Perl Compiler suite. |
1953 | |
1954 | =item perldbmfilter.pod |
1955 | |
1956 | A howto document on using the DBM filter facility. |
1957 | |
1958 | =item perldebug.pod |
1959 | |
1960 | All material unrelated to running the Perl debugger, plus all |
1961 | low-level guts-like details that risked crushing the casual user |
1962 | of the debugger, have been relocated from the old manpage to the |
1963 | next entry below. |
1964 | |
1965 | =item perldebguts.pod |
1966 | |
1967 | This new manpage contains excessively low-level material not related |
1968 | to the Perl debugger, but slightly related to debugging Perl itself. |
1969 | It also contains some arcane internal details of how the debugging |
1970 | process works that may only be of interest to developers of Perl |
1971 | debuggers. |
1972 | |
1973 | =item perlfork.pod |
1974 | |
1975 | Notes on the fork() emulation currently available for the Windows platform. |
1976 | |
1977 | =item perlfilter.pod |
1978 | |
1979 | An introduction to writing Perl source filters. |
1980 | |
1981 | =item perlhack.pod |
1982 | |
1983 | Some guidelines for hacking the Perl source code. |
1984 | |
1985 | =item perlintern.pod |
1986 | |
1987 | A list of internal functions in the Perl source code. |
1988 | (List is currently empty.) |
1989 | |
1990 | =item perllexwarn.pod |
1991 | |
1992 | Introduction and reference information about lexically scoped |
1993 | warning categories. |
1994 | |
1995 | =item perlnumber.pod |
1996 | |
1997 | Detailed information about numbers as they are represented in Perl. |
1998 | |
1999 | =item perlopentut.pod |
2000 | |
2001 | A tutorial on using open() effectively. |
2002 | |
2003 | =item perlreftut.pod |
2004 | |
2005 | A tutorial that introduces the essentials of references. |
2006 | |
2007 | =item perltootc.pod |
2008 | |
2009 | A tutorial on managing class data for object modules. |
2010 | |
2011 | =item perltodo.pod |
2012 | |
2013 | Discussion of the most often wanted features that may someday be |
2014 | supported in Perl. |
2015 | |
2016 | =item perlunicode.pod |
2017 | |
2018 | An introduction to Unicode support features in Perl. |
2019 | |
2020 | =back |
2021 | |
2022 | =head1 Performance enhancements |
2023 | |
2024 | =head2 Simple sort() using { $a <=> $b } and the like are optimized |
2025 | |
2026 | Many common sort() operations using a simple inlined block are now |
2027 | optimized for faster performance. |
2028 | |
2029 | =head2 Optimized assignments to lexical variables |
2030 | |
2031 | Certain operations in the RHS of assignment statements have been |
2032 | optimized to directly set the lexical variable on the LHS, |
2033 | eliminating redundant copying overheads. |
2034 | |
2035 | =head2 Faster subroutine calls |
2036 | |
2037 | Minor changes in how subroutine calls are handled internally |
2038 | provide marginal improvements in performance. |
2039 | |
2040 | =head2 delete(), each(), values() and hash iteration are faster |
2041 | |
2042 | The hash values returned by delete(), each(), values() and hashes in a |
2043 | list context are the actual values in the hash, instead of copies. |
2044 | This results in significantly better performance, because it eliminates |
2045 | needless copying in most situations. |
2046 | |
2047 | =head1 Installation and Configuration Improvements |
2048 | |
2049 | =head2 -Dusethreads means something different |
2050 | |
2051 | The -Dusethreads flag now enables the experimental interpreter-based thread |
2052 | support by default. To get the flavor of experimental threads that was in |
2053 | 5.005 instead, you need to run Configure with "-Dusethreads -Duse5005threads". |
2054 | |
2055 | As of v5.6.0, interpreter-threads support is still lacking a way to |
2056 | create new threads from Perl (i.e., C<use Thread;> will not work with |
2057 | interpreter threads). C<use Thread;> continues to be available when you |
2058 | specify the -Duse5005threads option to Configure, bugs and all. |
2059 | |
2060 | NOTE: Support for threads continues to be an experimental feature. |
2061 | Interfaces and implementation are subject to sudden and drastic changes. |
2062 | |
2063 | =head2 New Configure flags |
2064 | |
2065 | The following new flags may be enabled on the Configure command line |
2066 | by running Configure with C<-Dflag>. |
2067 | |
2068 | usemultiplicity |
2069 | usethreads useithreads (new interpreter threads: no Perl API yet) |
2070 | usethreads use5005threads (threads as they were in 5.005) |
2071 | |
2072 | use64bitint (equal to now deprecated 'use64bits') |
2073 | use64bitall |
2074 | |
2075 | uselongdouble |
2076 | usemorebits |
2077 | uselargefiles |
2078 | usesocks (only SOCKS v5 supported) |
2079 | |
2080 | =head2 Threadedness and 64-bitness now more daring |
2081 | |
2082 | The Configure options enabling the use of threads and the use of |
2083 | 64-bitness are now more daring in the sense that they no more have an |
2084 | explicit list of operating systems of known threads/64-bit |
2085 | capabilities. In other words: if your operating system has the |
2086 | necessary APIs and datatypes, you should be able just to go ahead and |
2087 | use them, for threads by Configure -Dusethreads, and for 64 bits |
2088 | either explicitly by Configure -Duse64bitint or implicitly if your |
2089 | system has 64-bit wide datatypes. See also L<"64-bit support">. |
2090 | |
2091 | =head2 Long Doubles |
2092 | |
2093 | Some platforms have "long doubles", floating point numbers of even |
2094 | larger range than ordinary "doubles". To enable using long doubles for |
2095 | Perl's scalars, use -Duselongdouble. |
2096 | |
2097 | =head2 -Dusemorebits |
2098 | |
2099 | You can enable both -Duse64bitint and -Duselongdouble with -Dusemorebits. |
2100 | See also L<"64-bit support">. |
2101 | |
2102 | =head2 -Duselargefiles |
2103 | |
2104 | Some platforms support system APIs that are capable of handling large files |
2105 | (typically, files larger than two gigabytes). Perl will try to use these |
2106 | APIs if you ask for -Duselargefiles. |
2107 | |
2108 | See L<"Large file support"> for more information. |
2109 | |
2110 | =head2 installusrbinperl |
2111 | |
2112 | You can use "Configure -Uinstallusrbinperl" which causes installperl |
2113 | to skip installing perl also as /usr/bin/perl. This is useful if you |
2114 | prefer not to modify /usr/bin for some reason or another but harmful |
2115 | because many scripts assume to find Perl in /usr/bin/perl. |
2116 | |
2117 | =head2 SOCKS support |
2118 | |
2119 | You can use "Configure -Dusesocks" which causes Perl to probe |
2120 | for the SOCKS proxy protocol library (v5, not v4). For more information |
2121 | on SOCKS, see: |
2122 | |
2123 | http://www.socks.nec.com/ |
2124 | |
2125 | =head2 C<-A> flag |
2126 | |
2127 | You can "post-edit" the Configure variables using the Configure C<-A> |
2128 | switch. The editing happens immediately after the platform specific |
2129 | hints files have been processed but before the actual configuration |
2130 | process starts. Run C<Configure -h> to find out the full C<-A> syntax. |
2131 | |
2132 | =head2 Enhanced Installation Directories |
2133 | |
2134 | The installation structure has been enriched to improve the support |
2135 | for maintaining multiple versions of perl, to provide locations for |
2136 | vendor-supplied modules, scripts, and manpages, and to ease maintenance |
2137 | of locally-added modules, scripts, and manpages. See the section on |
2138 | Installation Directories in the INSTALL file for complete details. |
2139 | For most users building and installing from source, the defaults should |
2140 | be fine. |
2141 | |
2142 | If you previously used C<Configure -Dsitelib> or C<-Dsitearch> to set |
2143 | special values for library directories, you might wish to consider using |
2144 | the new C<-Dsiteprefix> setting instead. Also, if you wish to re-use a |
2145 | config.sh file from an earlier version of perl, you should be sure to |
2146 | check that Configure makes sensible choices for the new directories. |
2147 | See INSTALL for complete details. |
2148 | |
2149 | =head2 gcc automatically tried if 'cc' does not seem to be working |
2150 | |
2151 | In many platforms the vendor-supplied 'cc' is too stripped-down to |
2152 | build Perl (basically, the 'cc' doesn't do ANSI C). If this seems |
2153 | to be the case and the 'cc' does not seem to be the GNU C compiler |
2154 | 'gcc', an automatic attempt is made to find and use 'gcc' instead. |
2155 | |
2156 | =head1 Platform specific changes |
2157 | |
2158 | =head2 Supported platforms |
2159 | |
2160 | =over 4 |
2161 | |
2162 | =item * |
2163 | |
2164 | The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread |
2165 | extension. |
2166 | |
2167 | =item * |
2168 | |
2169 | GNU/Hurd is now supported. |
2170 | |
2171 | =item * |
2172 | |
2173 | Rhapsody/Darwin is now supported. |
2174 | |
2175 | =item * |
2176 | |
2177 | EPOC is now supported (on Psion 5). |
2178 | |
2179 | =item * |
2180 | |
2181 | The cygwin port (formerly cygwin32) has been greatly improved. |
2182 | |
2183 | =back |
2184 | |
2185 | =head2 DOS |
2186 | |
2187 | =over 4 |
2188 | |
2189 | =item * |
2190 | |
2191 | Perl now works with djgpp 2.02 (and 2.03 alpha). |
2192 | |
2193 | =item * |
2194 | |
2195 | Environment variable names are not converted to uppercase any more. |
2196 | |
2197 | =item * |
2198 | |
2199 | Incorrect exit codes from backticks have been fixed. |
2200 | |
2201 | =item * |
2202 | |
2203 | This port continues to use its own builtin globbing (not File::Glob). |
2204 | |
2205 | =back |
2206 | |
2207 | =head2 OS390 (OpenEdition MVS) |
2208 | |
2209 | Support for this EBCDIC platform has not been renewed in this release. |
2210 | There are difficulties in reconciling Perl's standardization on UTF-8 |
2211 | as its internal representation for characters with the EBCDIC character |
2212 | set, because the two are incompatible. |
2213 | |
2214 | It is unclear whether future versions will renew support for this |
2215 | platform, but the possibility exists. |
2216 | |
2217 | =head2 VMS |
2218 | |
2219 | Numerous revisions and extensions to configuration, build, testing, and |
2220 | installation process to accommodate core changes and VMS-specific options. |
2221 | |
2222 | Expand %ENV-handling code to allow runtime mapping to logical names, |
2223 | CLI symbols, and CRTL environ array. |
2224 | |
2225 | Extension of subprocess invocation code to accept filespecs as command |
2226 | "verbs". |
2227 | |
2228 | Add to Perl command line processing the ability to use default file types and |
2229 | to recognize Unix-style C<2E<gt>&1>. |
2230 | |
2231 | Expansion of File::Spec::VMS routines, and integration into ExtUtils::MM_VMS. |
2232 | |
2233 | Extension of ExtUtils::MM_VMS to handle complex extensions more flexibly. |
2234 | |
2235 | Barewords at start of Unix-syntax paths may be treated as text rather than |
2236 | only as logical names. |
2237 | |
2238 | Optional secure translation of several logical names used internally by Perl. |
2239 | |
2240 | Miscellaneous bugfixing and porting of new core code to VMS. |
2241 | |
2242 | Thanks are gladly extended to the many people who have contributed VMS |
2243 | patches, testing, and ideas. |
2244 | |
2245 | =head2 Win32 |
2246 | |
2247 | Perl can now emulate fork() internally, using multiple interpreters running |
2248 | in different concurrent threads. This support must be enabled at build |
2249 | time. See L<perlfork> for detailed information. |
2250 | |
2251 | When given a pathname that consists only of a drivename, such as C<A:>, |
2252 | opendir() and stat() now use the current working directory for the drive |
2253 | rather than the drive root. |
2254 | |
2255 | The builtin XSUB functions in the Win32:: namespace are documented. See |
2256 | L<Win32>. |
2257 | |
2258 | $^X now contains the full path name of the running executable. |
2259 | |
2260 | A Win32::GetLongPathName() function is provided to complement |
2261 | Win32::GetFullPathName() and Win32::GetShortPathName(). See L<Win32>. |
2262 | |
2263 | POSIX::uname() is supported. |
2264 | |
2265 | system(1,...) now returns true process IDs rather than process |
2266 | handles. kill() accepts any real process id, rather than strictly |
2267 | return values from system(1,...). |
2268 | |
2269 | For better compatibility with Unix, C<kill(0, $pid)> can now be used to |
2270 | test whether a process exists. |
2271 | |
2272 | The C<Shell> module is supported. |
2273 | |
2274 | Better support for building Perl under command.com in Windows 95 |
2275 | has been added. |
2276 | |
2277 | Scripts are read in binary mode by default to allow ByteLoader (and |
2278 | the filter mechanism in general) to work properly. For compatibility, |
2279 | the DATA filehandle will be set to text mode if a carriage return is |
2280 | detected at the end of the line containing the __END__ or __DATA__ |
2281 | token; if not, the DATA filehandle will be left open in binary mode. |
2282 | Earlier versions always opened the DATA filehandle in text mode. |
2283 | |
2284 | The glob() operator is implemented via the C<File::Glob> extension, |
2285 | which supports glob syntax of the C shell. This increases the flexibility |
2286 | of the glob() operator, but there may be compatibility issues for |
2287 | programs that relied on the older globbing syntax. If you want to |
2288 | preserve compatibility with the older syntax, you might want to run |
2289 | perl with C<-MFile::DosGlob>. For details and compatibility information, |
2290 | see L<File::Glob>. |
2291 | |
2292 | =head1 Significant bug fixes |
2293 | |
2294 | =head2 <HANDLE> on empty files |
2295 | |
2296 | With C<$/> set to C<undef>, "slurping" an empty file returns a string of |
2297 | zero length (instead of C<undef>, as it used to) the first time the |
2298 | HANDLE is read after C<$/> is set to C<undef>. Further reads yield |
2299 | C<undef>. |
2300 | |
2301 | This means that the following will append "foo" to an empty file (it used |
2302 | to do nothing): |
2303 | |
2304 | perl -0777 -pi -e 's/^/foo/' empty_file |
2305 | |
2306 | The behaviour of: |
2307 | |
2308 | perl -pi -e 's/^/foo/' empty_file |
2309 | |
2310 | is unchanged (it continues to leave the file empty). |
2311 | |
2312 | =head2 C<eval '...'> improvements |
2313 | |
2314 | Line numbers (as reflected by caller() and most diagnostics) within |
2315 | C<eval '...'> were often incorrect where here documents were involved. |
2316 | This has been corrected. |
2317 | |
2318 | Lexical lookups for variables appearing in C<eval '...'> within |
2319 | functions that were themselves called within an C<eval '...'> were |
2320 | searching the wrong place for lexicals. The lexical search now |
2321 | correctly ends at the subroutine's block boundary. |
2322 | |
2323 | The use of C<return> within C<eval {...}> caused $@ not to be reset |
2324 | correctly when no exception occurred within the eval. This has |
2325 | been fixed. |
2326 | |
2327 | Parsing of here documents used to be flawed when they appeared as |
2328 | the replacement expression in C<eval 's/.../.../e'>. This has |
2329 | been fixed. |
2330 | |
2331 | =head2 All compilation errors are true errors |
2332 | |
2333 | Some "errors" encountered at compile time were by necessity |
2334 | generated as warnings followed by eventual termination of the |
2335 | program. This enabled more such errors to be reported in a |
2336 | single run, rather than causing a hard stop at the first error |
2337 | that was encountered. |
2338 | |
2339 | The mechanism for reporting such errors has been reimplemented |
2340 | to queue compile-time errors and report them at the end of the |
2341 | compilation as true errors rather than as warnings. This fixes |
2342 | cases where error messages leaked through in the form of warnings |
2343 | when code was compiled at run time using C<eval STRING>, and |
2344 | also allows such errors to be reliably trapped using C<eval "...">. |
2345 | |
2346 | =head2 Implicitly closed filehandles are safer |
2347 | |
2348 | Sometimes implicitly closed filehandles (as when they are localized, |
2349 | and Perl automatically closes them on exiting the scope) could |
2350 | inadvertently set $? or $!. This has been corrected. |
2351 | |
2352 | |
2353 | =head2 Behavior of list slices is more consistent |
2354 | |
2355 | When taking a slice of a literal list (as opposed to a slice of |
2356 | an array or hash), Perl used to return an empty list if the |
2357 | result happened to be composed of all undef values. |
2358 | |
2359 | The new behavior is to produce an empty list if (and only if) |
2360 | the original list was empty. Consider the following example: |
2361 | |
2362 | @a = (1,undef,undef,2)[2,1,2]; |
2363 | |
2364 | The old behavior would have resulted in @a having no elements. |
2365 | The new behavior ensures it has three undefined elements. |
2366 | |
2367 | Note in particular that the behavior of slices of the following |
2368 | cases remains unchanged: |
2369 | |
2370 | @a = ()[1,2]; |
2371 | @a = (getpwent)[7,0]; |
2372 | @a = (anything_returning_empty_list())[2,1,2]; |
2373 | @a = @b[2,1,2]; |
2374 | @a = @c{'a','b','c'}; |
2375 | |
2376 | See L<perldata>. |
2377 | |
2378 | =head2 C<(\$)> prototype and C<$foo{a}> |
2379 | |
2380 | A scalar reference prototype now correctly allows a hash or |
2381 | array element in that slot. |
2382 | |
2383 | =head2 C<goto &sub> and AUTOLOAD |
2384 | |
2385 | The C<goto &sub> construct works correctly when C<&sub> happens |
2386 | to be autoloaded. |
2387 | |
2388 | =head2 C<-bareword> allowed under C<use integer> |
2389 | |
2390 | The autoquoting of barewords preceded by C<-> did not work |
2391 | in prior versions when the C<integer> pragma was enabled. |
2392 | This has been fixed. |
2393 | |
2394 | =head2 Failures in DESTROY() |
2395 | |
2396 | When code in a destructor threw an exception, it went unnoticed |
2397 | in earlier versions of Perl, unless someone happened to be |
2398 | looking in $@ just after the point the destructor happened to |
2399 | run. Such failures are now visible as warnings when warnings are |
2400 | enabled. |
2401 | |
2402 | =head2 Locale bugs fixed |
2403 | |
2404 | printf() and sprintf() previously reset the numeric locale |
2405 | back to the default "C" locale. This has been fixed. |
2406 | |
2407 | Numbers formatted according to the local numeric locale |
2408 | (such as using a decimal comma instead of a decimal dot) caused |
2409 | "isn't numeric" warnings, even while the operations accessing |
2410 | those numbers produced correct results. These warnings have been |
2411 | discontinued. |
2412 | |
2413 | =head2 Memory leaks |
2414 | |
2415 | The C<eval 'return sub {...}'> construct could sometimes leak |
2416 | memory. This has been fixed. |
2417 | |
2418 | Operations that aren't filehandle constructors used to leak memory |
2419 | when used on invalid filehandles. This has been fixed. |
2420 | |
2421 | Constructs that modified C<@_> could fail to deallocate values |
2422 | in C<@_> and thus leak memory. This has been corrected. |
2423 | |
2424 | =head2 Spurious subroutine stubs after failed subroutine calls |
2425 | |
2426 | Perl could sometimes create empty subroutine stubs when a |
2427 | subroutine was not found in the package. Such cases stopped |
2428 | later method lookups from progressing into base packages. |
2429 | This has been corrected. |
2430 | |
2431 | =head2 Taint failures under C<-U> |
2432 | |
2433 | When running in unsafe mode, taint violations could sometimes |
2434 | cause silent failures. This has been fixed. |
2435 | |
2436 | =head2 END blocks and the C<-c> switch |
2437 | |
2438 | Prior versions used to run BEGIN B<and> END blocks when Perl was |
2439 | run in compile-only mode. Since this is typically not the expected |
2440 | behavior, END blocks are not executed anymore when the C<-c> switch |
2441 | is used, or if compilation fails. |
2442 | |
2443 | See L</"Support for CHECK blocks"> for how to run things when the compile |
2444 | phase ends. |
2445 | |
2446 | =head2 Potential to leak DATA filehandles |
2447 | |
2448 | Using the C<__DATA__> token creates an implicit filehandle to |
2449 | the file that contains the token. It is the program's |
2450 | responsibility to close it when it is done reading from it. |
2451 | |
2452 | This caveat is now better explained in the documentation. |
2453 | See L<perldata>. |
2454 | |
2455 | =head1 New or Changed Diagnostics |
2456 | |
2457 | =over 4 |
2458 | |
2459 | =item "%s" variable %s masks earlier declaration in same %s |
2460 | |
2461 | (W misc) A "my" or "our" variable has been redeclared in the current scope or statement, |
2462 | effectively eliminating all access to the previous instance. This is almost |
2463 | always a typographical error. Note that the earlier variable will still exist |
2464 | until the end of the scope or until all closure referents to it are |
2465 | destroyed. |
2466 | |
2467 | =item "my sub" not yet implemented |
2468 | |
2469 | (F) Lexically scoped subroutines are not yet implemented. Don't try that |
2470 | yet. |
2471 | |
2472 | =item "our" variable %s redeclared |
2473 | |
2474 | (W misc) You seem to have already declared the same global once before in the |
2475 | current lexical scope. |
2476 | |
2477 | =item '!' allowed only after types %s |
2478 | |
2479 | (F) The '!' is allowed in pack() and unpack() only after certain types. |
2480 | See L<perlfunc/pack>. |
2481 | |
2482 | =item / cannot take a count |
2483 | |
2484 | (F) You had an unpack template indicating a counted-length string, |
2485 | but you have also specified an explicit size for the string. |
2486 | See L<perlfunc/pack>. |
2487 | |
2488 | =item / must be followed by a, A or Z |
2489 | |
2490 | (F) You had an unpack template indicating a counted-length string, |
2491 | which must be followed by one of the letters a, A or Z |
2492 | to indicate what sort of string is to be unpacked. |
2493 | See L<perlfunc/pack>. |
2494 | |
2495 | =item / must be followed by a*, A* or Z* |
2496 | |
2497 | (F) You had a pack template indicating a counted-length string, |
2498 | Currently the only things that can have their length counted are a*, A* or Z*. |
2499 | See L<perlfunc/pack>. |
2500 | |
2501 | =item / must follow a numeric type |
2502 | |
2503 | (F) You had an unpack template that contained a '#', |
2504 | but this did not follow some numeric unpack specification. |
2505 | See L<perlfunc/pack>. |
2506 | |
2507 | =item /%s/: Unrecognized escape \\%c passed through |
2508 | |
2509 | (W regexp) You used a backslash-character combination which is not recognized |
2510 | by Perl. This combination appears in an interpolated variable or a |
2511 | C<'>-delimited regular expression. The character was understood literally. |
2512 | |
2513 | =item /%s/: Unrecognized escape \\%c in character class passed through |
2514 | |
2515 | (W regexp) You used a backslash-character combination which is not recognized |
2516 | by Perl inside character classes. The character was understood literally. |
2517 | |
2518 | =item /%s/ should probably be written as "%s" |
2519 | |
2520 | (W syntax) You have used a pattern where Perl expected to find a string, |
2521 | as in the first argument to C<join>. Perl will treat the true |
2522 | or false result of matching the pattern against $_ as the string, |
2523 | which is probably not what you had in mind. |
2524 | |
2525 | =item %s() called too early to check prototype |
2526 | |
2527 | (W prototype) You've called a function that has a prototype before the parser saw a |
2528 | definition or declaration for it, and Perl could not check that the call |
2529 | conforms to the prototype. You need to either add an early prototype |
2530 | declaration for the subroutine in question, or move the subroutine |
2531 | definition ahead of the call to get proper prototype checking. Alternatively, |
2532 | if you are certain that you're calling the function correctly, you may put |
2533 | an ampersand before the name to avoid the warning. See L<perlsub>. |
2534 | |
2535 | =item %s argument is not a HASH or ARRAY element |
2536 | |
2537 | (F) The argument to exists() must be a hash or array element, such as: |
2538 | |
2539 | $foo{$bar} |
2540 | $ref->{"susie"}[12] |
2541 | |
2542 | =item %s argument is not a HASH or ARRAY element or slice |
2543 | |
2544 | (F) The argument to delete() must be either a hash or array element, such as: |
2545 | |
2546 | $foo{$bar} |
2547 | $ref->{"susie"}[12] |
2548 | |
2549 | or a hash or array slice, such as: |
2550 | |
2551 | @foo[$bar, $baz, $xyzzy] |
2552 | @{$ref->[12]}{"susie", "queue"} |
2553 | |
2554 | =item %s argument is not a subroutine name |
2555 | |
2556 | (F) The argument to exists() for C<exists &sub> must be a subroutine |
2557 | name, and not a subroutine call. C<exists &sub()> will generate this error. |
2558 | |
2559 | =item %s package attribute may clash with future reserved word: %s |
2560 | |
2561 | (W reserved) A lowercase attribute name was used that had a package-specific handler. |
2562 | That name might have a meaning to Perl itself some day, even though it |
2563 | doesn't yet. Perhaps you should use a mixed-case attribute name, instead. |
2564 | See L<attributes>. |
2565 | |
2566 | =item (in cleanup) %s |
2567 | |
2568 | (W misc) This prefix usually indicates that a DESTROY() method raised |
2569 | the indicated exception. Since destructors are usually called by |
2570 | the system at arbitrary points during execution, and often a vast |
2571 | number of times, the warning is issued only once for any number |
2572 | of failures that would otherwise result in the same message being |
2573 | repeated. |
2574 | |
2575 | Failure of user callbacks dispatched using the C<G_KEEPERR> flag |
2576 | could also result in this warning. See L<perlcall/G_KEEPERR>. |
2577 | |
2578 | =item <> should be quotes |
2579 | |
2580 | (F) You wrote C<< require <file> >> when you should have written |
2581 | C<require 'file'>. |
2582 | |
2583 | =item Attempt to join self |
2584 | |
2585 | (F) You tried to join a thread from within itself, which is an |
2586 | impossible task. You may be joining the wrong thread, or you may |
2587 | need to move the join() to some other thread. |
2588 | |
2589 | =item Bad evalled substitution pattern |
2590 | |
2591 | (F) You've used the /e switch to evaluate the replacement for a |
2592 | substitution, but perl found a syntax error in the code to evaluate, |
2593 | most likely an unexpected right brace '}'. |
2594 | |
2595 | =item Bad realloc() ignored |
2596 | |
2597 | (S) An internal routine called realloc() on something that had never been |
2598 | malloc()ed in the first place. Mandatory, but can be disabled by |
2599 | setting environment variable C<PERL_BADFREE> to 1. |
2600 | |
2601 | =item Bareword found in conditional |
2602 | |
2603 | (W bareword) The compiler found a bareword where it expected a conditional, |
2604 | which often indicates that an || or && was parsed as part of the |
2605 | last argument of the previous construct, for example: |
2606 | |
2607 | open FOO || die; |
2608 | |
2609 | It may also indicate a misspelled constant that has been interpreted |
2610 | as a bareword: |
2611 | |
2612 | use constant TYPO => 1; |
2613 | if (TYOP) { print "foo" } |
2614 | |
2615 | The C<strict> pragma is useful in avoiding such errors. |
2616 | |
2617 | =item Binary number > 0b11111111111111111111111111111111 non-portable |
2618 | |
2619 | (W portable) The binary number you specified is larger than 2**32-1 |
2620 | (4294967295) and therefore non-portable between systems. See |
2621 | L<perlport> for more on portability concerns. |
2622 | |
2623 | =item Bit vector size > 32 non-portable |
2624 | |
2625 | (W portable) Using bit vector sizes larger than 32 is non-portable. |
2626 | |
2627 | =item Buffer overflow in prime_env_iter: %s |
2628 | |
2629 | (W internal) A warning peculiar to VMS. While Perl was preparing to iterate over |
2630 | %ENV, it encountered a logical name or symbol definition which was too long, |
2631 | so it was truncated to the string shown. |
2632 | |
2633 | =item Can't check filesystem of script "%s" |
2634 | |
2635 | (P) For some reason you can't check the filesystem of the script for nosuid. |
2636 | |
2637 | =item Can't declare class for non-scalar %s in "%s" |
2638 | |
2639 | (S) Currently, only scalar variables can declared with a specific class |
2640 | qualifier in a "my" or "our" declaration. The semantics may be extended |
2641 | for other types of variables in future. |
2642 | |
2643 | =item Can't declare %s in "%s" |
2644 | |
2645 | (F) Only scalar, array, and hash variables may be declared as "my" or |
2646 | "our" variables. They must have ordinary identifiers as names. |
2647 | |
2648 | =item Can't ignore signal CHLD, forcing to default |
2649 | |
2650 | (W signal) Perl has detected that it is being run with the SIGCHLD signal |
2651 | (sometimes known as SIGCLD) disabled. Since disabling this signal |
2652 | will interfere with proper determination of exit status of child |
2653 | processes, Perl has reset the signal to its default value. |
2654 | This situation typically indicates that the parent program under |
2655 | which Perl may be running (e.g., cron) is being very careless. |
2656 | |
2657 | =item Can't modify non-lvalue subroutine call |
2658 | |
2659 | (F) Subroutines meant to be used in lvalue context should be declared as |
2660 | such, see L<perlsub/"Lvalue subroutines">. |
2661 | |
2662 | =item Can't read CRTL environ |
2663 | |
2664 | (S) A warning peculiar to VMS. Perl tried to read an element of %ENV |
2665 | from the CRTL's internal environment array and discovered the array was |
2666 | missing. You need to figure out where your CRTL misplaced its environ |
2667 | or define F<PERL_ENV_TABLES> (see L<perlvms>) so that environ is not searched. |
2668 | |
2669 | =item Can't remove %s: %s, skipping file |
2670 | |
2671 | (S) You requested an inplace edit without creating a backup file. Perl |
2672 | was unable to remove the original file to replace it with the modified |
2673 | file. The file was left unmodified. |
2674 | |
2675 | =item Can't return %s from lvalue subroutine |
2676 | |
2677 | (F) Perl detected an attempt to return illegal lvalues (such |
2678 | as temporary or readonly values) from a subroutine used as an lvalue. |
2679 | This is not allowed. |
2680 | |
2681 | =item Can't weaken a nonreference |
2682 | |
2683 | (F) You attempted to weaken something that was not a reference. Only |
2684 | references can be weakened. |
2685 | |
2686 | =item Character class [:%s:] unknown |
2687 | |
2688 | (F) The class in the character class [: :] syntax is unknown. |
2689 | See L<perlre>. |
2690 | |
2691 | =item Character class syntax [%s] belongs inside character classes |
2692 | |
2693 | (W unsafe) The character class constructs [: :], [= =], and [. .] go |
2694 | I<inside> character classes, the [] are part of the construct, |
2695 | for example: /[012[:alpha:]345]/. Note that [= =] and [. .] |
2696 | are not currently implemented; they are simply placeholders for |
2697 | future extensions. |
2698 | |
2699 | =item Constant is not %s reference |
2700 | |
2701 | (F) A constant value (perhaps declared using the C<use constant> pragma) |
2702 | is being dereferenced, but it amounts to the wrong type of reference. The |
2703 | message indicates the type of reference that was expected. This usually |
2704 | indicates a syntax error in dereferencing the constant value. |
2705 | See L<perlsub/"Constant Functions"> and L<constant>. |
2706 | |
2707 | =item constant(%s): %s |
2708 | |
2709 | (F) The parser found inconsistencies either while attempting to define an |
2710 | overloaded constant, or when trying to find the character name specified |
2711 | in the C<\N{...}> escape. Perhaps you forgot to load the corresponding |
2712 | C<overload> or C<charnames> pragma? See L<charnames> and L<overload>. |
2713 | |
2714 | =item CORE::%s is not a keyword |
2715 | |
2716 | (F) The CORE:: namespace is reserved for Perl keywords. |
2717 | |
2718 | =item defined(@array) is deprecated |
2719 | |
2720 | (D) defined() is not usually useful on arrays because it checks for an |
2721 | undefined I<scalar> value. If you want to see if the array is empty, |
2722 | just use C<if (@array) { # not empty }> for example. |
2723 | |
2724 | =item defined(%hash) is deprecated |
2725 | |
2726 | (D) defined() is not usually useful on hashes because it checks for an |
2727 | undefined I<scalar> value. If you want to see if the hash is empty, |
2728 | just use C<if (%hash) { # not empty }> for example. |
2729 | |
2730 | =item Did not produce a valid header |
2731 | |
2732 | See Server error. |
2733 | |
2734 | =item (Did you mean "local" instead of "our"?) |
2735 | |
2736 | (W misc) Remember that "our" does not localize the declared global variable. |
2737 | You have declared it again in the same lexical scope, which seems superfluous. |
2738 | |
2739 | =item Document contains no data |
2740 | |
2741 | See Server error. |
2742 | |
2743 | =item entering effective %s failed |
2744 | |
2745 | (F) While under the C<use filetest> pragma, switching the real and |
2746 | effective uids or gids failed. |
2747 | |
2748 | =item false [] range "%s" in regexp |
2749 | |
2750 | (W regexp) A character class range must start and end at a literal character, not |
2751 | another character class like C<\d> or C<[:alpha:]>. The "-" in your false |
2752 | range is interpreted as a literal "-". Consider quoting the "-", "\-". |
2753 | See L<perlre>. |
2754 | |
2755 | =item Filehandle %s opened only for output |
2756 | |
2757 | (W io) You tried to read from a filehandle opened only for writing. If you |
2758 | intended it to be a read/write filehandle, you needed to open it with |
2759 | "+<" or "+>" or "+>>" instead of with "<" or nothing. If |
2760 | you intended only to read from the file, use "<". See |
2761 | L<perlfunc/open>. |
2762 | |
2763 | =item flock() on closed filehandle %s |
2764 | |
2765 | (W closed) The filehandle you're attempting to flock() got itself closed some |
2766 | time before now. Check your logic flow. flock() operates on filehandles. |
2767 | Are you attempting to call flock() on a dirhandle by the same name? |
2768 | |
2769 | =item Global symbol "%s" requires explicit package name |
2770 | |
2771 | (F) You've said "use strict vars", which indicates that all variables |
2772 | must either be lexically scoped (using "my"), declared beforehand using |
2773 | "our", or explicitly qualified to say which package the global variable |
2774 | is in (using "::"). |
2775 | |
2776 | =item Hexadecimal number > 0xffffffff non-portable |
2777 | |
2778 | (W portable) The hexadecimal number you specified is larger than 2**32-1 |
2779 | (4294967295) and therefore non-portable between systems. See |
2780 | L<perlport> for more on portability concerns. |
2781 | |
2782 | =item Ill-formed CRTL environ value "%s" |
2783 | |
2784 | (W internal) A warning peculiar to VMS. Perl tried to read the CRTL's internal |
2785 | environ array, and encountered an element without the C<=> delimiter |
2786 | used to separate keys from values. The element is ignored. |
2787 | |
2788 | =item Ill-formed message in prime_env_iter: |%s| |
2789 | |
2790 | (W internal) A warning peculiar to VMS. Perl tried to read a logical name |
2791 | or CLI symbol definition when preparing to iterate over %ENV, and |
2792 | didn't see the expected delimiter between key and value, so the |
2793 | line was ignored. |
2794 | |
2795 | =item Illegal binary digit %s |
2796 | |
2797 | (F) You used a digit other than 0 or 1 in a binary number. |
2798 | |
2799 | =item Illegal binary digit %s ignored |
2800 | |
2801 | (W digit) You may have tried to use a digit other than 0 or 1 in a binary number. |
2802 | Interpretation of the binary number stopped before the offending digit. |
2803 | |
2804 | =item Illegal number of bits in vec |
2805 | |
2806 | (F) The number of bits in vec() (the third argument) must be a power of |
2807 | two from 1 to 32 (or 64, if your platform supports that). |
2808 | |
2809 | =item Integer overflow in %s number |
2810 | |
2811 | (W overflow) The hexadecimal, octal or binary number you have specified either |
2812 | as a literal or as an argument to hex() or oct() is too big for your |
2813 | architecture, and has been converted to a floating point number. On a |
2814 | 32-bit architecture the largest hexadecimal, octal or binary number |
2815 | representable without overflow is 0xFFFFFFFF, 037777777777, or |
2816 | 0b11111111111111111111111111111111 respectively. Note that Perl |
2817 | transparently promotes all numbers to a floating point representation |
2818 | internally--subject to loss of precision errors in subsequent |
2819 | operations. |
2820 | |
2821 | =item Invalid %s attribute: %s |
2822 | |
2823 | The indicated attribute for a subroutine or variable was not recognized |
2824 | by Perl or by a user-supplied handler. See L<attributes>. |
2825 | |
2826 | =item Invalid %s attributes: %s |
2827 | |
2828 | The indicated attributes for a subroutine or variable were not recognized |
2829 | by Perl or by a user-supplied handler. See L<attributes>. |
2830 | |
2831 | =item invalid [] range "%s" in regexp |
2832 | |
2833 | The offending range is now explicitly displayed. |
2834 | |
2835 | =item Invalid separator character %s in attribute list |
2836 | |
2837 | (F) Something other than a colon or whitespace was seen between the |
2838 | elements of an attribute list. If the previous attribute |
2839 | had a parenthesised parameter list, perhaps that list was terminated |
2840 | too soon. See L<attributes>. |
2841 | |
2842 | =item Invalid separator character %s in subroutine attribute list |
2843 | |
2844 | (F) Something other than a colon or whitespace was seen between the |
2845 | elements of a subroutine attribute list. If the previous attribute |
2846 | had a parenthesised parameter list, perhaps that list was terminated |
2847 | too soon. |
2848 | |
2849 | =item leaving effective %s failed |
2850 | |
2851 | (F) While under the C<use filetest> pragma, switching the real and |
2852 | effective uids or gids failed. |
2853 | |
2854 | =item Lvalue subs returning %s not implemented yet |
2855 | |
2856 | (F) Due to limitations in the current implementation, array and hash |
2857 | values cannot be returned in subroutines used in lvalue context. |
2858 | See L<perlsub/"Lvalue subroutines">. |
2859 | |
2860 | =item Method %s not permitted |
2861 | |
2862 | See Server error. |
2863 | |
2864 | =item Missing %sbrace%s on \N{} |
2865 | |
2866 | (F) Wrong syntax of character name literal C<\N{charname}> within |
2867 | double-quotish context. |
2868 | |
2869 | =item Missing command in piped open |
2870 | |
2871 | (W pipe) You used the C<open(FH, "| command")> or C<open(FH, "command |")> |
2872 | construction, but the command was missing or blank. |
2873 | |
2874 | =item Missing name in "my sub" |
2875 | |
2876 | (F) The reserved syntax for lexically scoped subroutines requires that they |
2877 | have a name with which they can be found. |
2878 | |
2879 | =item No %s specified for -%c |
2880 | |
2881 | (F) The indicated command line switch needs a mandatory argument, but |
2882 | you haven't specified one. |
2883 | |
2884 | =item No package name allowed for variable %s in "our" |
2885 | |
2886 | (F) Fully qualified variable names are not allowed in "our" declarations, |
2887 | because that doesn't make much sense under existing semantics. Such |
2888 | syntax is reserved for future extensions. |
2889 | |
2890 | =item No space allowed after -%c |
2891 | |
2892 | (F) The argument to the indicated command line switch must follow immediately |
2893 | after the switch, without intervening spaces. |
2894 | |
2895 | =item no UTC offset information; assuming local time is UTC |
2896 | |
2897 | (S) A warning peculiar to VMS. Perl was unable to find the local |
2898 | timezone offset, so it's assuming that local system time is equivalent |
2899 | to UTC. If it's not, define the logical name F<SYS$TIMEZONE_DIFFERENTIAL> |
2900 | to translate to the number of seconds which need to be added to UTC to |
2901 | get local time. |
2902 | |
2903 | =item Octal number > 037777777777 non-portable |
2904 | |
2905 | (W portable) The octal number you specified is larger than 2**32-1 (4294967295) |
2906 | and therefore non-portable between systems. See L<perlport> for more |
2907 | on portability concerns. |
2908 | |
2909 | See also L<perlport> for writing portable code. |
2910 | |
2911 | =item panic: del_backref |
2912 | |
2913 | (P) Failed an internal consistency check while trying to reset a weak |
2914 | reference. |
2915 | |
2916 | =item panic: kid popen errno read |
2917 | |
2918 | (F) forked child returned an incomprehensible message about its errno. |
2919 | |
2920 | =item panic: magic_killbackrefs |
2921 | |
2922 | (P) Failed an internal consistency check while trying to reset all weak |
2923 | references to an object. |
2924 | |
2925 | =item Parentheses missing around "%s" list |
2926 | |
2927 | (W parenthesis) You said something like |
2928 | |
2929 | my $foo, $bar = @_; |
2930 | |
2931 | when you meant |
2932 | |
2933 | my ($foo, $bar) = @_; |
2934 | |
2935 | Remember that "my", "our", and "local" bind tighter than comma. |
2936 | |
2937 | =item Possible unintended interpolation of %s in string |
2938 | |
2939 | (W ambiguous) It used to be that Perl would try to guess whether you |
2940 | wanted an array interpolated or a literal @. It no longer does this; |
2941 | arrays are now I<always> interpolated into strings. This means that |
2942 | if you try something like: |
2943 | |
2944 | print "fred@example.com"; |
2945 | |
2946 | and the array C<@example> doesn't exist, Perl is going to print |
2947 | C<fred.com>, which is probably not what you wanted. To get a literal |
2948 | C<@> sign in a string, put a backslash before it, just as you would |
2949 | to get a literal C<$> sign. |
2950 | |
2951 | =item Possible Y2K bug: %s |
2952 | |
2953 | (W y2k) You are concatenating the number 19 with another number, which |
2954 | could be a potential Year 2000 problem. |
2955 | |
2956 | =item pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead |
2957 | |
2958 | (W deprecated) You have written something like this: |
2959 | |
2960 | sub doit |
2961 | { |
2962 | use attrs qw(locked); |
2963 | } |
2964 | |
2965 | You should use the new declaration syntax instead. |
2966 | |
2967 | sub doit : locked |
2968 | { |
2969 | ... |
2970 | |
2971 | The C<use attrs> pragma is now obsolete, and is only provided for |
2972 | backward-compatibility. See L<perlsub/"Subroutine Attributes">. |
2973 | |
2974 | |
2975 | =item Premature end of script headers |
2976 | |
2977 | See Server error. |
2978 | |
2979 | =item Repeat count in pack overflows |
2980 | |
2981 | (F) You can't specify a repeat count so large that it overflows |
2982 | your signed integers. See L<perlfunc/pack>. |
2983 | |
2984 | =item Repeat count in unpack overflows |
2985 | |
2986 | (F) You can't specify a repeat count so large that it overflows |
2987 | your signed integers. See L<perlfunc/unpack>. |
2988 | |
2989 | =item realloc() of freed memory ignored |
2990 | |
2991 | (S) An internal routine called realloc() on something that had already |
2992 | been freed. |
2993 | |
2994 | =item Reference is already weak |
2995 | |
2996 | (W misc) You have attempted to weaken a reference that is already weak. |
2997 | Doing so has no effect. |
2998 | |
2999 | =item setpgrp can't take arguments |
3000 | |
3001 | (F) Your system has the setpgrp() from BSD 4.2, which takes no arguments, |
3002 | unlike POSIX setpgid(), which takes a process ID and process group ID. |
3003 | |
3004 | =item Strange *+?{} on zero-length expression |
3005 | |
3006 | (W regexp) You applied a regular expression quantifier in a place where it |
3007 | makes no sense, such as on a zero-width assertion. |
3008 | Try putting the quantifier inside the assertion instead. For example, |
3009 | the way to match "abc" provided that it is followed by three |
3010 | repetitions of "xyz" is C</abc(?=(?:xyz){3})/>, not C</abc(?=xyz){3}/>. |
3011 | |
3012 | =item switching effective %s is not implemented |
3013 | |
3014 | (F) While under the C<use filetest> pragma, we cannot switch the |
3015 | real and effective uids or gids. |
3016 | |
3017 | =item This Perl can't reset CRTL environ elements (%s) |
3018 | |
3019 | =item This Perl can't set CRTL environ elements (%s=%s) |
3020 | |
3021 | (W internal) Warnings peculiar to VMS. You tried to change or delete an element |
3022 | of the CRTL's internal environ array, but your copy of Perl wasn't |
3023 | built with a CRTL that contained the setenv() function. You'll need to |
3024 | rebuild Perl with a CRTL that does, or redefine F<PERL_ENV_TABLES> (see |
3025 | L<perlvms>) so that the environ array isn't the target of the change to |
3026 | %ENV which produced the warning. |
3027 | |
3028 | =item Too late to run %s block |
3029 | |
3030 | (W void) A CHECK or INIT block is being defined during run time proper, |
3031 | when the opportunity to run them has already passed. Perhaps you are |
3032 | loading a file with C<require> or C<do> when you should be using |
3033 | C<use> instead. Or perhaps you should put the C<require> or C<do> |
3034 | inside a BEGIN block. |
3035 | |
3036 | =item Unknown open() mode '%s' |
3037 | |
3038 | (F) The second argument of 3-argument open() is not among the list |
3039 | of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>, |
3040 | C<< +> >>, C<<< +>> >>>, C<-|>, C<|->. |
3041 | |
3042 | =item Unknown process %x sent message to prime_env_iter: %s |
3043 | |
3044 | (P) An error peculiar to VMS. Perl was reading values for %ENV before |
3045 | iterating over it, and someone else stuck a message in the stream of |
3046 | data Perl expected. Someone's very confused, or perhaps trying to |
3047 | subvert Perl's population of %ENV for nefarious purposes. |
3048 | |
3049 | =item Unrecognized escape \\%c passed through |
3050 | |
3051 | (W misc) You used a backslash-character combination which is not recognized |
3052 | by Perl. The character was understood literally. |
3053 | |
3054 | =item Unterminated attribute parameter in attribute list |
3055 | |
3056 | (F) The lexer saw an opening (left) parenthesis character while parsing an |
3057 | attribute list, but the matching closing (right) parenthesis |
3058 | character was not found. You may need to add (or remove) a backslash |
3059 | character to get your parentheses to balance. See L<attributes>. |
3060 | |
3061 | =item Unterminated attribute list |
3062 | |
3063 | (F) The lexer found something other than a simple identifier at the start |
3064 | of an attribute, and it wasn't a semicolon or the start of a |
3065 | block. Perhaps you terminated the parameter list of the previous attribute |
3066 | too soon. See L<attributes>. |
3067 | |
3068 | =item Unterminated attribute parameter in subroutine attribute list |
3069 | |
3070 | (F) The lexer saw an opening (left) parenthesis character while parsing a |
3071 | subroutine attribute list, but the matching closing (right) parenthesis |
3072 | character was not found. You may need to add (or remove) a backslash |
3073 | character to get your parentheses to balance. |
3074 | |
3075 | =item Unterminated subroutine attribute list |
3076 | |
3077 | (F) The lexer found something other than a simple identifier at the start |
3078 | of a subroutine attribute, and it wasn't a semicolon or the start of a |
3079 | block. Perhaps you terminated the parameter list of the previous attribute |
3080 | too soon. |
3081 | |
3082 | =item Value of CLI symbol "%s" too long |
3083 | |
3084 | (W misc) A warning peculiar to VMS. Perl tried to read the value of an %ENV |
3085 | element from a CLI symbol table, and found a resultant string longer |
3086 | than 1024 characters. The return value has been truncated to 1024 |
3087 | characters. |
3088 | |
3089 | =item Version number must be a constant number |
3090 | |
3091 | (P) The attempt to translate a C<use Module n.n LIST> statement into |
3092 | its equivalent C<BEGIN> block found an internal inconsistency with |
3093 | the version number. |
3094 | |
3095 | =back |
3096 | |
3097 | =head1 New tests |
3098 | |
3099 | =over 4 |
3100 | |
3101 | =item lib/attrs |
3102 | |
3103 | Compatibility tests for C<sub : attrs> vs the older C<use attrs>. |
3104 | |
3105 | =item lib/env |
3106 | |
3107 | Tests for new environment scalar capability (e.g., C<use Env qw($BAR);>). |
3108 | |
3109 | =item lib/env-array |
3110 | |
3111 | Tests for new environment array capability (e.g., C<use Env qw(@PATH);>). |
3112 | |
3113 | =item lib/io_const |
3114 | |
3115 | IO constants (SEEK_*, _IO*). |
3116 | |
3117 | =item lib/io_dir |
3118 | |
3119 | Directory-related IO methods (new, read, close, rewind, tied delete). |
3120 | |
3121 | =item lib/io_multihomed |
3122 | |
3123 | INET sockets with multi-homed hosts. |
3124 | |
3125 | =item lib/io_poll |
3126 | |
3127 | IO poll(). |
3128 | |
3129 | =item lib/io_unix |
3130 | |
3131 | UNIX sockets. |
3132 | |
3133 | =item op/attrs |
3134 | |
3135 | Regression tests for C<my ($x,@y,%z) : attrs> and <sub : attrs>. |
3136 | |
3137 | =item op/filetest |
3138 | |
3139 | File test operators. |
3140 | |
3141 | =item op/lex_assign |
3142 | |
3143 | Verify operations that access pad objects (lexicals and temporaries). |
3144 | |
3145 | =item op/exists_sub |
3146 | |
3147 | Verify C<exists &sub> operations. |
3148 | |
3149 | =back |
3150 | |
3151 | =head1 Incompatible Changes |
3152 | |
3153 | =head2 Perl Source Incompatibilities |
3154 | |
3155 | Beware that any new warnings that have been added or old ones |
3156 | that have been enhanced are B<not> considered incompatible changes. |
3157 | |
3158 | Since all new warnings must be explicitly requested via the C<-w> |
3159 | switch or the C<warnings> pragma, it is ultimately the programmer's |
3160 | responsibility to ensure that warnings are enabled judiciously. |
3161 | |
3162 | =over 4 |
3163 | |
3164 | =item CHECK is a new keyword |
3165 | |
3166 | All subroutine definitions named CHECK are now special. See |
3167 | C</"Support for CHECK blocks"> for more information. |
3168 | |
3169 | =item Treatment of list slices of undef has changed |
3170 | |
3171 | There is a potential incompatibility in the behavior of list slices |
3172 | that are comprised entirely of undefined values. |
3173 | See L</"Behavior of list slices is more consistent">. |
3174 | |
3175 | =item Format of $English::PERL_VERSION is different |
3176 | |
3177 | The English module now sets $PERL_VERSION to $^V (a string value) rather |
3178 | than C<$]> (a numeric value). This is a potential incompatibility. |
3179 | Send us a report via perlbug if you are affected by this. |
3180 | |
3181 | See L</"Improved Perl version numbering system"> for the reasons for |
3182 | this change. |
3183 | |
3184 | =item Literals of the form C<1.2.3> parse differently |
3185 | |
3186 | Previously, numeric literals with more than one dot in them were |
3187 | interpreted as a floating point number concatenated with one or more |
3188 | numbers. Such "numbers" are now parsed as strings composed of the |
3189 | specified ordinals. |
3190 | |
3191 | For example, C<print 97.98.99> used to output C<97.9899> in earlier |
3192 | versions, but now prints C<abc>. |
3193 | |
3194 | See L</"Support for strings represented as a vector of ordinals">. |
3195 | |
3196 | =item Possibly changed pseudo-random number generator |
3197 | |
3198 | Perl programs that depend on reproducing a specific set of pseudo-random |
3199 | numbers may now produce different output due to improvements made to the |
3200 | rand() builtin. You can use C<sh Configure -Drandfunc=rand> to obtain |
3201 | the old behavior. |
3202 | |
3203 | See L</"Better pseudo-random number generator">. |
3204 | |
3205 | =item Hashing function for hash keys has changed |
3206 | |
3207 | Even though Perl hashes are not order preserving, the apparently |
3208 | random order encountered when iterating on the contents of a hash |
3209 | is actually determined by the hashing algorithm used. Improvements |
3210 | in the algorithm may yield a random order that is B<different> from |
3211 | that of previous versions, especially when iterating on hashes. |
3212 | |
3213 | See L</"Better worst-case behavior of hashes"> for additional |
3214 | information. |
3215 | |
3216 | =item C<undef> fails on read only values |
3217 | |
3218 | Using the C<undef> operator on a readonly value (such as $1) has |
3219 | the same effect as assigning C<undef> to the readonly value--it |
3220 | throws an exception. |
3221 | |
3222 | =item Close-on-exec bit may be set on pipe and socket handles |
3223 | |
3224 | Pipe and socket handles are also now subject to the close-on-exec |
3225 | behavior determined by the special variable $^F. |
3226 | |
3227 | See L</"More consistent close-on-exec behavior">. |
3228 | |
3229 | =item Writing C<"$$1"> to mean C<"${$}1"> is unsupported |
3230 | |
3231 | Perl 5.004 deprecated the interpretation of C<$$1> and |
3232 | similar within interpolated strings to mean C<$$ . "1">, |
3233 | but still allowed it. |
3234 | |
3235 | In Perl 5.6.0 and later, C<"$$1"> always means C<"${$1}">. |
3236 | |
3237 | =item delete(), each(), values() and C<\(%h)> |
3238 | |
3239 | operate on aliases to values, not copies |
3240 | |
3241 | delete(), each(), values() and hashes (e.g. C<\(%h)>) |
3242 | in a list context return the actual |
3243 | values in the hash, instead of copies (as they used to in earlier |
3244 | versions). Typical idioms for using these constructs copy the |
3245 | returned values, but this can make a significant difference when |
3246 | creating references to the returned values. Keys in the hash are still |
3247 | returned as copies when iterating on a hash. |
3248 | |
3249 | See also L</"delete(), each(), values() and hash iteration are faster">. |
3250 | |
3251 | =item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS |
3252 | |
3253 | vec() generates a run-time error if the BITS argument is not |
3254 | a valid power-of-two integer. |
3255 | |
3256 | =item Text of some diagnostic output has changed |
3257 | |
3258 | Most references to internal Perl operations in diagnostics |
3259 | have been changed to be more descriptive. This may be an |
3260 | issue for programs that may incorrectly rely on the exact |
3261 | text of diagnostics for proper functioning. |
3262 | |
3263 | =item C<%@> has been removed |
3264 | |
3265 | The undocumented special variable C<%@> that used to accumulate |
3266 | "background" errors (such as those that happen in DESTROY()) |
3267 | has been removed, because it could potentially result in memory |
3268 | leaks. |
3269 | |
3270 | =item Parenthesized not() behaves like a list operator |
3271 | |
3272 | The C<not> operator now falls under the "if it looks like a function, |
3273 | it behaves like a function" rule. |
3274 | |
3275 | As a result, the parenthesized form can be used with C<grep> and C<map>. |
3276 | The following construct used to be a syntax error before, but it works |
3277 | as expected now: |
3278 | |
3279 | grep not($_), @things; |
3280 | |
3281 | On the other hand, using C<not> with a literal list slice may not |
3282 | work. The following previously allowed construct: |
3283 | |
3284 | print not (1,2,3)[0]; |
3285 | |
3286 | needs to be written with additional parentheses now: |
3287 | |
3288 | print not((1,2,3)[0]); |
3289 | |
3290 | The behavior remains unaffected when C<not> is not followed by parentheses. |
3291 | |
3292 | =item Semantics of bareword prototype C<(*)> have changed |
3293 | |
3294 | The semantics of the bareword prototype C<*> have changed. Perl 5.005 |
3295 | always coerced simple scalar arguments to a typeglob, which wasn't useful |
3296 | in situations where the subroutine must distinguish between a simple |
3297 | scalar and a typeglob. The new behavior is to not coerce bareword |
3298 | arguments to a typeglob. The value will always be visible as either |
3299 | a simple scalar or as a reference to a typeglob. |
3300 | |
3301 | See L</"More functional bareword prototype (*)">. |
3302 | |
3303 | =item Semantics of bit operators may have changed on 64-bit platforms |
3304 | |
3305 | If your platform is either natively 64-bit or if Perl has been |
3306 | configured to used 64-bit integers, i.e., $Config{ivsize} is 8, |
3307 | there may be a potential incompatibility in the behavior of bitwise |
3308 | numeric operators (& | ^ ~ << >>). These operators used to strictly |
3309 | operate on the lower 32 bits of integers in previous versions, but now |
3310 | operate over the entire native integral width. In particular, note |
3311 | that unary C<~> will produce different results on platforms that have |
3312 | different $Config{ivsize}. For portability, be sure to mask off |
3313 | the excess bits in the result of unary C<~>, e.g., C<~$x & 0xffffffff>. |
3314 | |
3315 | See L</"Bit operators support full native integer width">. |
3316 | |
3317 | =item More builtins taint their results |
3318 | |
3319 | As described in L</"Improved security features">, there may be more |
3320 | sources of taint in a Perl program. |
3321 | |
3322 | To avoid these new tainting behaviors, you can build Perl with the |
3323 | Configure option C<-Accflags=-DINCOMPLETE_TAINTS>. Beware that the |
3324 | ensuing perl binary may be insecure. |
3325 | |
3326 | =back |
3327 | |
3328 | =head2 C Source Incompatibilities |
3329 | |
3330 | =over 4 |
3331 | |
3332 | =item C<PERL_POLLUTE> |
3333 | |
3334 | Release 5.005 grandfathered old global symbol names by providing preprocessor |
3335 | macros for extension source compatibility. As of release 5.6.0, these |
3336 | preprocessor definitions are not available by default. You need to explicitly |
3337 | compile perl with C<-DPERL_POLLUTE> to get these definitions. For |
3338 | extensions still using the old symbols, this option can be |
3339 | specified via MakeMaker: |
3340 | |
3341 | perl Makefile.PL POLLUTE=1 |
3342 | |
3343 | =item C<PERL_IMPLICIT_CONTEXT> |
3344 | |
3345 | This new build option provides a set of macros for all API functions |
3346 | such that an implicit interpreter/thread context argument is passed to |
3347 | every API function. As a result of this, something like C<sv_setsv(foo,bar)> |
3348 | amounts to a macro invocation that actually translates to something like |
3349 | C<Perl_sv_setsv(my_perl,foo,bar)>. While this is generally expected |
3350 | to not have any significant source compatibility issues, the difference |
3351 | between a macro and a real function call will need to be considered. |
3352 | |
3353 | This means that there B<is> a source compatibility issue as a result of |
3354 | this if your extensions attempt to use pointers to any of the Perl API |
3355 | functions. |
3356 | |
3357 | Note that the above issue is not relevant to the default build of |
3358 | Perl, whose interfaces continue to match those of prior versions |
3359 | (but subject to the other options described here). |
3360 | |
3361 | See L<perlguts/"The Perl API"> for detailed information on the |
3362 | ramifications of building Perl with this option. |
3363 | |
3364 | NOTE: PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built |
3365 | with one of -Dusethreads, -Dusemultiplicity, or both. It is not |
3366 | intended to be enabled by users at this time. |
3367 | |
3368 | =item C<PERL_POLLUTE_MALLOC> |
3369 | |
3370 | Enabling Perl's malloc in release 5.005 and earlier caused the namespace of |
3371 | the system's malloc family of functions to be usurped by the Perl versions, |
3372 | since by default they used the same names. Besides causing problems on |
3373 | platforms that do not allow these functions to be cleanly replaced, this |
3374 | also meant that the system versions could not be called in programs that |
3375 | used Perl's malloc. Previous versions of Perl have allowed this behaviour |
3376 | to be suppressed with the HIDEMYMALLOC and EMBEDMYMALLOC preprocessor |
3377 | definitions. |
3378 | |
3379 | As of release 5.6.0, Perl's malloc family of functions have default names |
3380 | distinct from the system versions. You need to explicitly compile perl with |
3381 | C<-DPERL_POLLUTE_MALLOC> to get the older behaviour. HIDEMYMALLOC |
3382 | and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now |
3383 | the default. |
3384 | |
3385 | Note that these functions do B<not> constitute Perl's memory allocation API. |
3386 | See L<perlguts/"Memory Allocation"> for further information about that. |
3387 | |
3388 | =back |
3389 | |
3390 | =head2 Compatible C Source API Changes |
3391 | |
3392 | =over 4 |
3393 | |
3394 | =item C<PATCHLEVEL> is now C<PERL_VERSION> |
3395 | |
3396 | The cpp macros C<PERL_REVISION>, C<PERL_VERSION>, and C<PERL_SUBVERSION> |
3397 | are now available by default from perl.h, and reflect the base revision, |
3398 | patchlevel, and subversion respectively. C<PERL_REVISION> had no |
3399 | prior equivalent, while C<PERL_VERSION> and C<PERL_SUBVERSION> were |
3400 | previously available as C<PATCHLEVEL> and C<SUBVERSION>. |
3401 | |
3402 | The new names cause less pollution of the B<cpp> namespace and reflect what |
3403 | the numbers have come to stand for in common practice. For compatibility, |
3404 | the old names are still supported when F<patchlevel.h> is explicitly |
3405 | included (as required before), so there is no source incompatibility |
3406 | from the change. |
3407 | |
3408 | =back |
3409 | |
3410 | =head2 Binary Incompatibilities |
3411 | |
3412 | In general, the default build of this release is expected to be binary |
3413 | compatible for extensions built with the 5.005 release or its maintenance |
3414 | versions. However, specific platforms may have broken binary compatibility |
3415 | due to changes in the defaults used in hints files. Therefore, please be |
3416 | sure to always check the platform-specific README files for any notes to |
3417 | the contrary. |
3418 | |
3419 | The usethreads or usemultiplicity builds are B<not> binary compatible |
3420 | with the corresponding builds in 5.005. |
3421 | |
3422 | On platforms that require an explicit list of exports (AIX, OS/2 and Windows, |
3423 | among others), purely internal symbols such as parser functions and the |
3424 | run time opcodes are not exported by default. Perl 5.005 used to export |
3425 | all functions irrespective of whether they were considered part of the |
3426 | public API or not. |
3427 | |
3428 | For the full list of public API functions, see L<perlapi>. |
3429 | |
3430 | =head1 Known Problems |
3431 | |
3432 | =head2 Localizing a tied hash element may leak memory |
3433 | |
3434 | As of the 5.6.1 release, there is a known leak when code such as this |
3435 | is executed: |
3436 | |
3437 | use Tie::Hash; |
3438 | tie my %tie_hash => 'Tie::StdHash'; |
3439 | |
3440 | ... |
3441 | |
3442 | local($tie_hash{Foo}) = 1; # leaks |
3443 | |
3444 | =head2 Known test failures |
3445 | |
3446 | =over |
3447 | |
818c4caa |
3448 | =item * |
5cb3728c |
3449 | |
3450 | 64-bit builds |
493a87da |
3451 | |
3452 | Subtest #15 of lib/b.t may fail under 64-bit builds on platforms such |
3453 | as HP-UX PA64 and Linux IA64. The issue is still being investigated. |
3454 | |
3455 | The lib/io_multihomed test may hang in HP-UX if Perl has been |
3456 | configured to be 64-bit. Because other 64-bit platforms do not |
3457 | hang in this test, HP-UX is suspect. All other tests pass |
3458 | in 64-bit HP-UX. The test attempts to create and connect to |
3459 | "multihomed" sockets (sockets which have multiple IP addresses). |
3460 | |
3461 | Note that 64-bit support is still experimental. |
3462 | |
818c4caa |
3463 | =item * |
5cb3728c |
3464 | |
3465 | Failure of Thread tests |
493a87da |
3466 | |
3467 | The subtests 19 and 20 of lib/thr5005.t test are known to fail due to |
3468 | fundamental problems in the 5.005 threading implementation. These are |
3469 | not new failures--Perl 5.005_0x has the same bugs, but didn't have these |
3470 | tests. (Note that support for 5.005-style threading remains experimental.) |
3471 | |
818c4caa |
3472 | =item * |
5cb3728c |
3473 | |
3474 | NEXTSTEP 3.3 POSIX test failure |
493a87da |
3475 | |
3476 | In NEXTSTEP 3.3p2 the implementation of the strftime(3) in the |
3477 | operating system libraries is buggy: the %j format numbers the days of |
3478 | a month starting from zero, which, while being logical to programmers, |
3479 | will cause the subtests 19 to 27 of the lib/posix test may fail. |
3480 | |
818c4caa |
3481 | =item * |
5cb3728c |
3482 | |
3483 | Tru64 (aka Digital UNIX, aka DEC OSF/1) lib/sdbm test failure with gcc |
493a87da |
3484 | |
3485 | If compiled with gcc 2.95 the lib/sdbm test will fail (dump core). |
3486 | The cure is to use the vendor cc, it comes with the operating system |
3487 | and produces good code. |
3488 | |
3489 | =back |
3490 | |
3491 | =head2 EBCDIC platforms not fully supported |
3492 | |
3493 | In earlier releases of Perl, EBCDIC environments like OS390 (also |
3494 | known as Open Edition MVS) and VM-ESA were supported. Due to changes |
3495 | required by the UTF-8 (Unicode) support, the EBCDIC platforms are not |
3496 | supported in Perl 5.6.0. |
3497 | |
3498 | The 5.6.1 release improves support for EBCDIC platforms, but they |
3499 | are not fully supported yet. |
3500 | |
3501 | =head2 UNICOS/mk CC failures during Configure run |
3502 | |
3503 | In UNICOS/mk the following errors may appear during the Configure run: |
3504 | |
3505 | Guessing which symbols your C compiler and preprocessor define... |
3506 | CC-20 cc: ERROR File = try.c, Line = 3 |
3507 | ... |
3508 | bad switch yylook 79bad switch yylook 79bad switch yylook 79bad switch yylook 79#ifdef A29K |
3509 | ... |
3510 | 4 errors detected in the compilation of "try.c". |
3511 | |
3512 | The culprit is the broken awk of UNICOS/mk. The effect is fortunately |
3513 | rather mild: Perl itself is not adversely affected by the error, only |
3514 | the h2ph utility coming with Perl, and that is rather rarely needed |
3515 | these days. |
3516 | |
3517 | =head2 Arrow operator and arrays |
3518 | |
3519 | When the left argument to the arrow operator C<< -> >> is an array, or |
3520 | the C<scalar> operator operating on an array, the result of the |
3521 | operation must be considered erroneous. For example: |
3522 | |
3523 | @x->[2] |
3524 | scalar(@x)->[2] |
3525 | |
3526 | These expressions will get run-time errors in some future release of |
3527 | Perl. |
3528 | |
3529 | =head2 Experimental features |
3530 | |
3531 | As discussed above, many features are still experimental. Interfaces and |
3532 | implementation of these features are subject to change, and in extreme cases, |
3533 | even subject to removal in some future release of Perl. These features |
3534 | include the following: |
3535 | |
3536 | =over 4 |
3537 | |
3538 | =item Threads |
3539 | |
3540 | =item Unicode |
3541 | |
3542 | =item 64-bit support |
3543 | |
3544 | =item Lvalue subroutines |
3545 | |
3546 | =item Weak references |
3547 | |
3548 | =item The pseudo-hash data type |
3549 | |
3550 | =item The Compiler suite |
3551 | |
3552 | =item Internal implementation of file globbing |
3553 | |
3554 | =item The DB module |
3555 | |
3556 | =item The regular expression code constructs: |
3557 | |
3558 | C<(?{ code })> and C<(??{ code })> |
3559 | |
3560 | =back |
3561 | |
3562 | =head1 Obsolete Diagnostics |
3563 | |
3564 | =over 4 |
3565 | |
3566 | =item Character class syntax [: :] is reserved for future extensions |
3567 | |
3568 | (W) Within regular expression character classes ([]) the syntax beginning |
3569 | with "[:" and ending with ":]" is reserved for future extensions. |
3570 | If you need to represent those character sequences inside a regular |
3571 | expression character class, just quote the square brackets with the |
3572 | backslash: "\[:" and ":\]". |
3573 | |
3574 | =item Ill-formed logical name |%s| in prime_env_iter |
3575 | |
3576 | (W) A warning peculiar to VMS. A logical name was encountered when preparing |
3577 | to iterate over %ENV which violates the syntactic rules governing logical |
3578 | names. Because it cannot be translated normally, it is skipped, and will not |
3579 | appear in %ENV. This may be a benign occurrence, as some software packages |
3580 | might directly modify logical name tables and introduce nonstandard names, |
3581 | or it may indicate that a logical name table has been corrupted. |
3582 | |
3583 | =item In string, @%s now must be written as \@%s |
3584 | |
3585 | The description of this error used to say: |
3586 | |
3587 | (Someday it will simply assume that an unbackslashed @ |
3588 | interpolates an array.) |
3589 | |
3590 | That day has come, and this fatal error has been removed. It has been |
3591 | replaced by a non-fatal warning instead. |
3592 | See L</Arrays now always interpolate into double-quoted strings> for |
3593 | details. |
3594 | |
3595 | =item Probable precedence problem on %s |
3596 | |
3597 | (W) The compiler found a bareword where it expected a conditional, |
3598 | which often indicates that an || or && was parsed as part of the |
3599 | last argument of the previous construct, for example: |
3600 | |
3601 | open FOO || die; |
3602 | |
3603 | =item regexp too big |
3604 | |
3605 | (F) The current implementation of regular expressions uses shorts as |
3606 | address offsets within a string. Unfortunately this means that if |
3607 | the regular expression compiles to longer than 32767, it'll blow up. |
3608 | Usually when you want a regular expression this big, there is a better |
3609 | way to do it with multiple statements. See L<perlre>. |
3610 | |
3611 | =item Use of "$$<digit>" to mean "${$}<digit>" is deprecated |
3612 | |
3613 | (D) Perl versions before 5.004 misinterpreted any type marker followed |
3614 | by "$" and a digit. For example, "$$0" was incorrectly taken to mean |
3615 | "${$}0" instead of "${$0}". This bug is (mostly) fixed in Perl 5.004. |
3616 | |
3617 | However, the developers of Perl 5.004 could not fix this bug completely, |
3618 | because at least two widely-used modules depend on the old meaning of |
3619 | "$$0" in a string. So Perl 5.004 still interprets "$$<digit>" in the |
3620 | old (broken) way inside strings; but it generates this message as a |
3621 | warning. And in Perl 5.005, this special treatment will cease. |
3622 | |
3623 | =back |
3624 | |
3625 | =head1 Reporting Bugs |
3626 | |
3627 | If you find what you think is a bug, you might check the |
3628 | articles recently posted to the comp.lang.perl.misc newsgroup. |
f224927c |
3629 | There may also be information at http://www.perl.com/ , the Perl |
493a87da |
3630 | Home Page. |
3631 | |
3632 | If you believe you have an unreported bug, please run the B<perlbug> |
3633 | program included with your release. Be sure to trim your bug down |
3634 | to a tiny but sufficient test case. Your bug report, along with the |
3635 | output of C<perl -V>, will be sent off to perlbug@perl.org to be |
3636 | analysed by the Perl porting team. |
3637 | |
3638 | =head1 SEE ALSO |
3639 | |
3640 | The F<Changes> file for exhaustive details on what changed. |
3641 | |
3642 | The F<INSTALL> file for how to build Perl. |
3643 | |
3644 | The F<README> file for general stuff. |
3645 | |
3646 | The F<Artistic> and F<Copying> files for copyright information. |
3647 | |
3648 | =head1 HISTORY |
3649 | |
3650 | Written by Gurusamy Sarathy <F<gsar@ActiveState.com>>, with many |
3651 | contributions from The Perl Porters. |
3652 | |
3653 | Send omissions or corrections to <F<perlbug@perl.org>>. |
3654 | |
3655 | =cut |