This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Document the flags of pv_uni_display().
[perl5.git] / pod / perldelta.pod
1 =head1 NAME
2
3 perldelta - what is new for perl v5.8.0
4
5 =head1 DESCRIPTION
6
7 This document describes differences between the 5.6.0 release
8 and the 5.8.0 release.
9
10 Many of the bug fixes in 5.8.0 were already seen in the 5.6.1
11 maintenance release since the two releases were kept closely
12 coordinated.
13
14 If you are upgrading from Perl 5.005_03, you might also want
15 to read L<perl56delta>.
16
17 =head1 Highlights In 5.8.0
18
19 =over 4
20
21 =item *
22
23 Better Unicode support
24
25 =item *
26
27 New Thread Implementation
28
29 =item *
30
31 Many New Modules
32
33 =item *
34
35 Better Numeric Accuracy
36
37 =item *
38
39 Safe Signals
40
41 =item *
42
43 More Extensive Regression Testing
44
45 =back
46
47 =head1 Incompatible Changes
48
49 =head2 64-bit platforms and malloc
50
51 If your pointers are 64 bits wide, the Perl malloc is no longer being
52 used because it does not work well with 8-byte pointers.  Also,
53 usually the system mallocs on such platforms are much better optimized
54 for such large memory models than the Perl malloc.  Some memory-hungry
55 Perl applications like the PDL don't work well with Perl's malloc.
56 Finally, other applications than Perl (like modperl) tend to prefer
57 the system malloc.  Such platforms include Alpha and 64-bit HPPA,
58 MIPS, PPC, and Sparc.
59
60 =head2 AIX Dynaloading
61
62 The AIX dynaloading now uses in AIX releases 4.3 and newer the native
63 dlopen interface of AIX instead of the old emulated interface.  This
64 change will probably break backward compatibility with compiled
65 modules.  The change was made to make Perl more compliant with other
66 applications like modperl which are using the AIX native interface.
67
68 =head2 Attributes for C<my> variables now handled at run-time.
69
70 The C<my EXPR : ATTRS> syntax now applies variable attributes at
71 run-time.  (Subroutine and C<our> variables still get attributes applied
72 at compile-time.)  See L<attributes> for additional details.  In particular,
73 however, this allows variable attributes to be useful for C<tie> interfaces,
74 which was a deficiency of earlier releases.  Note that the new semantics
75 doesn't work with the Attribute::Handlers module (as of version 0.76).
76
77 =head2 Socket Extension Dynamic in VMS
78
79 The Socket extension is now dynamically loaded instead of being
80 statically built in.  This may or may not be a problem with ancient
81 TCP/IP stacks of VMS: we do not know since we weren't able to test
82 Perl in such configurations.
83
84 =head2 IEEE-format Floating Point Default on OpenVMS Alpha
85
86 Perl now uses IEEE format (T_FLOAT) as the default internal floating
87 point format on OpenVMS Alpha, potentially breaking binary compatibility
88 with external libraries or existing data.  G_FLOAT is still available as
89 a configuration option.  The default on VAX (D_FLOAT) has not changed.
90
91 =head2 Different Definition of the Unicode Character Classes \p{In...}
92
93 As suggested by the Unicode consortium, the Unicode character classes
94 now prefer I<scripts> as opposed to I<blocks> (as defined by Unicode);
95 in Perl, when the C<\p{In....}> and the C<\p{In....}> regular expression
96 constructs are used.  This has changed the definition of some of those
97 character classes.
98
99 The difference between scripts and blocks is that scripts are the
100 glyphs used by a language or a group of languages, while the blocks
101 are more artificial groupings of 256 characters based on the Unicode
102 numbering.
103
104 In general this change results in more inclusive Unicode character
105 classes, but changes to the other direction also do take place:
106 for example while the script C<Latin> includes all the Latin
107 characters and their various diacritic-adorned versions, it
108 does not include the various punctuation or digits (since they
109 are not solely C<Latin>).
110
111 Changes in the character class semantics may have happened if a script
112 and a block happen to have the same name, for example C<Hebrew>.
113 In such cases the script wins and C<\p{InHebrew}> now means the script
114 definition of Hebrew.  The block definition in still available,
115 though, by appending C<Block> to the name: C<\p{InHebrewBlock}> means
116 what C<\p{InHebrew}> meant in perl 5.6.0.  For the full list
117 of affected character classes, see L<perlunicode/Blocks>.
118
119 =head2 Perl Parser Stress Tested
120
121 The Perl parser has been stress tested using both random input and
122 Markov chain input and the few found crashes and lockups have been
123 fixed.
124
125 =head2 REF(...) Instead Of SCALAR(...)
126
127 A reference to a reference now stringifies as "REF(0x81485ec)" instead
128 of "SCALAR(0x81485ec)" in order to be more consistent with the return
129 value of ref().
130
131 =head2 Deprecations
132
133 =over 4
134
135 =item *
136
137 The semantics of bless(REF, REF) were unclear and until someone proves
138 it to make some sense, it is forbidden.
139
140 =item *
141
142 The obsolete chat2 library that should never have been allowed
143 to escape the laboratory has been decommissioned.
144
145 =item *
146
147 The very dusty examples in the eg/ directory have been removed.
148 Suggestions for new shiny examples welcome but the main issue is that
149 the examples need to be documented, tested and (most importantly)
150 maintained.
151
152 =item *
153
154 The (bogus) escape sequences \8 and \9 now give an optional warning
155 ("Unrecognized escape passed through").  There is no need to \-escape
156 any C<\w> character.
157
158 =item *
159
160 The list of filenames from glob() (or <...>) is now by default sorted
161 alphabetically to be csh-compliant (which is what happened before
162 in most UNIX platforms).  (bsd_glob() does still sort platform
163 natively, ASCII or EBCDIC, unless GLOB_ALPHASORT is specified.)
164
165 =item *
166
167 Spurious syntax errors generated in certain situations, when glob()
168 caused File::Glob to be loaded for the first time, have been fixed.
169
170 =item *
171
172 Although "you shouldn't do that", it was possible to write code that
173 depends on Perl's hashed key order (Data::Dumper does this).  The new
174 algorithm "One-at-a-Time" produces a different hashed key order.
175 More details are in L</"Performance Enhancements">.
176
177 =item *
178
179 lstat(FILEHANDLE) now gives a warning because the operation makes no sense.
180 In future releases this may become a fatal error.
181
182 =item *
183
184 The C<package;> syntax (C<package> without an argument) has been
185 deprecated.  Its semantics were never that clear and its
186 implementation even less so.  If you have used that feature to
187 disallow all but fully qualified variables, C<use strict;> instead.
188
189 =item *
190
191 The unimplemented POSIX regex features [[.cc.]] and [[=c=]] are still
192 recognised but now cause fatal errors.  The previous behaviour of
193 ignoring them by default and warning if requested was unacceptable
194 since it, in a way, falsely promised that the features could be used.
195
196 =item *
197
198 The current user-visible implementation of pseudo-hashes (the weird
199 use of the first array element) is deprecated starting from Perl 5.8.0
200 and will be removed in Perl 5.10.0, and the feature will be
201 implemented differently.  Not only is the current interface rather
202 ugly, but the current implementation slows down normal array and hash
203 use quite noticeably. The C<fields> pragma interface will remain
204 available.
205
206 =item *
207
208 The syntaxes C<< @a->[...] >> and  C<< %h->{...} >> have now been deprecated.
209
210 =item *
211
212 After years of trying the suidperl is considered to be too complex to
213 ever be considered truly secure.  The suidperl functionality is likely
214 to be removed in a future release.
215
216 =item *
217
218 The long deprecated uppercase aliases for the string comparison
219 operators (EQ, NE, LT, LE, GE, GT) have now been removed.
220
221 =item *
222
223 The tr///C and tr///U features have been removed and will not return;
224 the interface was a mistake.  Sorry about that.  For similar
225 functionality, see pack('U0', ...) and pack('C0', ...).
226
227 =item *
228
229 Earlier Perls treated "sub foo (@bar)" as equivalent to "sub foo (@)".
230 The prototypes are now checked at compile-time for invalid characters.
231 An optional warning is generated ("Illegal character in prototype...")
232 but this may be upgraded to a fatal error in a future release.
233
234 =back
235
236 =head1 Core Enhancements
237
238 =head2 PerlIO is Now The Default
239
240 =over 4
241
242 =item *
243
244 IO is now by default done via PerlIO rather than system's "stdio".
245 PerlIO allows "layers" to be "pushed" onto a file handle to alter the
246 handle's behaviour.  Layers can be specified at open time via 3-arg
247 form of open:
248
249    open($fh,'>:crlf :utf8', $path) || ...
250
251 or on already opened handles via extended C<binmode>:
252
253    binmode($fh,':encoding(iso-8859-7)');
254
255 The built-in layers are: unix (low level read/write), stdio (as in
256 previous Perls), perlio (re-implementation of stdio buffering in a
257 portable manner), crlf (does CRLF <=> "\n" translation as on Win32,
258 but available on any platform).  A mmap layer may be available if
259 platform supports it (mostly UNIXes).
260
261 Layers to be applied by default may be specified via the 'open' pragma.
262
263 See L</"Installation and Configuration Improvements"> for the effects
264 of PerlIO on your architecture name.
265
266 =item *
267
268 File handles can be marked as accepting Perl's internal encoding of Unicode
269 (UTF-8 or UTF-EBCDIC depending on platform) by a pseudo layer ":utf8" :
270
271    open($fh,">:utf8","Uni.txt");
272
273 Note for EBCDIC users: the pseudo layer ":utf8" is erroneously named
274 for you since it's not UTF-8 what you will be getting but instead
275 UTF-EBCDIC.  See L<perlunicode>, L<utf8>, and
276 http://www.unicode.org/unicode/reports/tr16/ for more information.
277 In future releases this naming may change.
278
279 =item *
280
281 File handles can translate character encodings from/to Perl's internal
282 Unicode form on read/write via the ":encoding()" layer.
283
284 =item *
285
286 File handles can be opened to "in memory" files held in Perl scalars via:
287
288    open($fh,'>', \$variable) || ...
289
290 =item *
291
292 Anonymous temporary files are available without need to
293 'use FileHandle' or other module via
294
295    open($fh,"+>", undef) || ...
296
297 That is a literal undef, not an undefined value.
298
299 =item *
300
301 The list form of C<open> is now implemented for pipes (at least on UNIX):
302
303    open($fh,"-|", 'cat', '/etc/motd')
304
305 creates a pipe, and runs the equivalent of exec('cat', '/etc/motd') in
306 the child process.
307
308 =back
309
310 =head2 Safe Signals
311
312 Perl used to be fragile in that signals arriving at inopportune moments
313 could corrupt Perl's internal state.  Now Perl postpones handling of
314 signals until it's safe (between opcodes).
315
316 This change may have surprising side effects because signals no more
317 interrupt Perl instantly.  Perl will now first finish whatever it was
318 doing, like finishing an internal operation (like sort()) or an
319 external operation (like an I/O operation), and only then look at any
320 arrived signals (and before starting the next operation).  No more corrupt
321 internal state since the current operation is always finished first,
322 but the signal may take more time to get heard.
323
324 =head2 Unicode Overhaul
325
326 Unicode in general should be now much more usable than in Perl 5.6.0
327 (or even in 5.6.1).  Unicode can be used in hash keys, Unicode in
328 regular expressions should work now, Unicode in tr/// should work now,
329 Unicode in I/O should work now.
330
331 =over 4
332
333 =item *
334
335 The Unicode Character Database coming with Perl has been upgraded
336 to Unicode 3.1.1.  For more information, see http://www.unicode.org/.
337
338 =item *
339
340 For developers interested in enhancing Perl's Unicode capabilities:
341 almost all the UCD files are included with the Perl distribution in
342 the lib/unicore subdirectory.  The most notable omission, for space
343 considerations, is the Unihan database.
344
345 =item *
346
347 The Unicode character classes \p{Blank} and \p{SpacePerl} have been
348 added.  "Blank" is like C isblank(), that is, it contains only
349 "horizontal whitespace" (the space character is, the newline isn't),
350 and the "SpacePerl" is the Unicode equivalent of C<\s> (\p{Space}
351 isn't, since that includes the vertical tabulator character, whereas
352 C<\s> doesn't.)
353
354 =back
355
356 =head2 Understanding of Numbers
357
358 In general a lot of fixing has happened in the area of Perl's
359 understanding of numbers, both integer and floating point.  Since in
360 many systems the standard number parsing functions like C<strtoul()>
361 and C<atof()> seem to have bugs, Perl tries to work around their
362 deficiencies.  This results hopefully in more accurate numbers.
363
364 Perl now tries internally to use integer values in numeric conversions
365 and basic arithmetics (+ - * /) if the arguments are integers, and
366 tries also to keep the results stored internally as integers.
367 This change leads to often slightly faster and always less lossy
368 arithmetics. (Previously Perl always preferred floating point numbers
369 in its math.)
370
371 =head2 Miscellaneous Enhancements
372
373 =over 4
374
375 =item *
376
377 AUTOLOAD is now lvaluable, meaning that you can add the :lvalue attribute
378 to AUTOLOAD subroutines and you can assign to the AUTOLOAD return value.
379
380 =item *
381
382 C<perl -d:Module=arg,arg,arg> now works (previously one couldn't pass
383 in multiple arguments.)
384
385 =item *
386
387 END blocks are now run even if you exit/die in a BEGIN block.
388 Internally, the execution of END blocks is now controlled by 
389 PL_exit_flags & PERL_EXIT_DESTRUCT_END. This enables the new
390 behaviour for Perl embedders. This will default in 5.10. See
391 L<perlembed>.
392
393 =item *
394
395 Formats now support zero-padded decimal fields.
396
397 =item *
398
399 Lvalue subroutines can now return C<undef> in list context.
400 However, the lvalue subroutine feature still remains experimental.
401
402 =item *
403
404 A new special regular expression variable has been introduced:
405 C<$^N>, which contains the most-recently closed group (submatch).
406
407 =item *
408
409 C<no Module;> now works even if there is no "sub unimport" in the Module.
410
411 =item *
412
413 The numerical comparison operators return C<undef> if either operand
414 is a NaN.  Previously the behaviour was unspecified.
415
416 =item *
417
418 The following builtin functions are now overridable: each(), keys(),
419 pop(), push(), shift(), splice(), unshift().
420
421 =item *
422
423 C<pack('U0a*', ...)> can now be used to force a string to UTF8.
424
425 =item *
426
427 my __PACKAGE__ $obj now works.
428
429 =item *
430
431 The printf() and sprintf() now support parameter reordering using the
432 C<%\d+\$> and C<*\d+\$> syntaxes.  For example
433
434     print "%2\$s %1\$s\n", "foo", "bar";
435
436 will print "bar foo\n".  This feature helps in writing
437 internationalised software, and in general when the order
438 of the parameters can vary.
439
440 =item *
441
442 prototype(\&) is now available.
443
444 =item *
445
446 prototype(\[$@%&]) is now available to implicitly create references
447 (useful for example if you want to emulate the tie() interface).
448
449 =item *
450
451 untie() will now call an UNTIE() hook if it exists.  See L<perltie>
452 for details.
453
454 =item *
455
456 L<utime> now supports C<utime undef, undef, @files> to change the
457 file timestamps to the current time.
458
459 =item *
460
461 The rules for allowing underscores (underbars) in numeric constants
462 have been relaxed and simplified: now you can have an underscore
463 simply B<between digits>.
464
465 =back
466
467 =head1 Modules and Pragmata
468
469 =head2 New Modules and Pragmata
470
471 =over 4
472
473 =item *
474
475 C<Attribute::Handlers> allows a class to define attribute handlers.
476
477     package MyPack;
478     use Attribute::Handlers;
479     sub Wolf :ATTR(SCALAR) { print "howl!\n" }
480
481     # later, in some package using or inheriting from MyPack...
482
483     my MyPack $Fluffy : Wolf; # the attribute handler Wolf will be called
484
485 Both variables and routines can have attribute handlers.  Handlers can
486 be specific to type (SCALAR, ARRAY, HASH, or CODE), or specific to the
487 exact compilation phase (BEGIN, CHECK, INIT, or END).
488
489 =item *
490
491 B<B::Concise> is a new compiler backend for walking the Perl syntax
492 tree, printing concise info about ops, from Stephen McCamant.  The
493 output is highly customisable.  See L<B::Concise>.
494
495 =item *
496
497 C<Class::ISA> for reporting the search path for a class's ISA tree,
498 by Sean Burke, has been added.  See L<Class::ISA>.
499
500 =item *
501
502 C<Cwd> has now a split personality: if possible, an XS extension is
503 used, (this will hopefully be faster, more secure, and more robust)
504 but if not possible, the familiar Perl implementation is used.
505
506 =item *
507
508 C<Devel::PPPort>, originally from Kenneth Albanowski and now
509 maintained by Paul Marquess, has been added.  It is primarily used
510 by C<h2xs> to enhance portability of of XS modules between different
511 versions of Perl.
512
513 =item *
514
515 C<Digest>, frontend module for calculating digests (checksums), from
516 Gisle Aas, has been added.  See L<Digest>.
517
518 =item *
519
520 C<Digest::MD5> for calculating MD5 digests (checksums) as defined in
521 RFC 1321, from Gisle Aas, has been added.  See L<Digest::MD5>.
522
523     use Digest::MD5 'md5_hex';
524
525     $digest = md5_hex("Thirsty Camel");
526
527     print $digest, "\n"; # 01d19d9d2045e005c3f1b80e8b164de1
528
529 NOTE: the C<MD5> backward compatibility module is deliberately not
530 included since its further use is discouraged.
531
532 =item *
533
534 C<Encode>, by Nick Ing-Simmons, provides a mechanism to translate
535 between different character encodings.  Support for Unicode,
536 ISO-8859-*, ASCII, CP*, KOI8-R, and three variants of EBCDIC are
537 compiled in to the module.  Several other encodings (like Japanese,
538 Chinese, and MacIntosh encodings) are included and will be loaded at
539 runtime.  See L<Encode>.
540
541 Any encoding supported by Encode module is also available to the
542 ":encoding()" layer if PerlIO is used.
543
544 =item *
545
546 C<I18N::Langinfo> can be use to query locale information.
547 See L<I18N::Langinfo>.
548
549 =item *
550
551 C<I18N::LangTags> has functions for dealing with RFC3066-style
552 language tags, by Sean Burke.  See L<I18N::LangTags>.
553
554 =item *
555
556 C<ExtUtils::Constant> is a new tool for extension writers for
557 generating XS code to import C header constants, by Nicholas Clark.
558 See L<ExtUtils::Constant>.
559
560 =item *
561
562 C<Filter::Simple> is an easy-to-use frontend to Filter::Util::Call,
563 from Damian Conway.  See L<Filter::Simple>.
564
565     # in MyFilter.pm:
566
567     package MyFilter;
568
569     use Filter::Simple sub {
570         while (my ($from, $to) = splice @_, 0, 2) {
571                 s/$from/$to/g;
572         }
573     };
574
575     1;
576
577     # in user's code:
578
579     use MyFilter qr/red/ => 'green';
580
581     print "red\n";   # this code is filtered, will print "green\n"
582     print "bored\n"; # this code is filtered, will print "bogreen\n"
583
584     no MyFilter;
585
586     print "red\n";   # this code is not filtered, will print "red\n"
587
588 =item *
589
590 C<File::Temp> allows one to create temporary files and directories in
591 an easy, portable, and secure way, by Tim Jenness.  See L<File::Temp>.
592
593 =item *
594
595 C<Filter::Util::Call> provides you with the framework to write
596 I<Source Filters> in Perl, from Paul Marquess.  For most uses the
597 frontend Filter::Simple is to be preferred.  See L<Filter::Util::Call>.
598
599 =item *
600
601 L<libnet> is a collection of perl5 modules related to network
602 programming, from Graham Barr.  See L<Net::FTP>, L<Net::NNTP>,
603 L<Net::Ping>, L<Net::POP3>, L<Net::SMTP>, and L<Net::Time>.
604
605 Perl installation leaves libnet unconfigured, use F<libnetcfg> to configure.
606
607 =item *
608
609 C<List::Util> is a selection of general-utility list subroutines, like
610 sum(), min(), first(), and shuffle(), by Graham Barr.  See L<List::Util>.
611
612 =item *
613
614 C<Locale::Constants>, C<Locale::Country>, C<Locale::Currency>, and
615 C<Locale::Language>, from Neil Bowers, have been added.  They provide the
616 codes for various locale standards, such as "fr" for France, "usd" for
617 US Dollar, and "jp" for Japanese.
618
619     use Locale::Country;
620
621     $country = code2country('jp');               # $country gets 'Japan'
622     $code    = country2code('Norway');           # $code gets 'no'
623
624 See L<Locale::Constants>, L<Locale::Country>, L<Locale::Currency>,
625 and L<Locale::Language>.
626
627 =item *
628
629 C<Locale::Maketext> is localization framework from Sean Burke.  See
630 L<Locale::Maketext>, and L<Locale::Maketext::TPJ13>.  The latter is an
631 article about software localization, originally published in The Perl
632 Journal #13, republished here with kind permission.
633
634 =item *
635
636 C<Memoize> can make your functions faster by trading space for time,
637 from Mark-Jason Dominus.  See L<Memoize>.
638
639 =item *
640
641 C<MIME::Base64> allows you to encode data in base64, from Gisle Aas,
642 as defined in RFC 2045 - I<MIME (Multipurpose Internet Mail
643 Extensions)>.
644
645     use MIME::Base64;
646
647     $encoded = encode_base64('Aladdin:open sesame');
648     $decoded = decode_base64($encoded);
649
650     print $encoded, "\n"; # "QWxhZGRpbjpvcGVuIHNlc2FtZQ=="
651
652 See L<MIME::Base64>.
653
654 =item *
655
656 C<MIME::QuotedPrint> allows you to encode data in quoted-printable
657 encoding, as defined in RFC 2045 - I<MIME (Multipurpose Internet Mail
658 Extensions)>, from Gisle Aas.
659
660     use MIME::QuotedPrint;
661
662     $encoded = encode_qp("Smiley in Unicode: \x{263a}");
663     $decoded = decode_qp($encoded);
664
665     print $encoded, "\n"; # "Smiley in Unicode: =263A"
666
667 MIME::QuotedPrint has been enhanced to provide the basic methods
668 necessary to use it with PerlIO::Via as in :
669
670     use MIME::QuotedPrint;
671     open($fh,">Via(MIME::QuotedPrint)",$path);
672
673 See L<MIME::QuotedPrint>.
674
675 =item *
676
677 C<NEXT> is pseudo-class for method redispatch, from Damian Conway.
678 See L<NEXT>.
679
680 =item *
681
682 C<open> is a new pragma for setting the default I/O disciplines
683 for open().
684
685 =item *
686
687 C<PerlIO::Scalar> provides the implementation of IO to "in memory"
688 Perl scalars as discussed above, from Nick Ing-Simmons.  It also
689 serves as an example of a loadable PerlIO layer.  Other future
690 possibilities include PerlIO::Array and PerlIO::Code.
691 See L<PerlIO::Scalar>.
692
693 =item *
694
695 C<PerlIO::Via> acts as a PerlIO layer and wraps PerlIO layer
696 functionality provided by a class (typically implemented in perl
697 code), from Nick Ing-Simmons.
698
699     use MIME::QuotedPrint;
700     open($fh,">Via(MIME::QuotedPrint)",$path);
701
702 This will automatically convert everything output to C<$fh>
703 to Quoted-Printable.  See L<PerlIO::Via>.
704
705 =item *
706
707 C<Pod::ParseLink>, by Russ Allbery, has been added,
708 to parse LZ<><> links in pods as described in the new
709 perlpodspec.
710
711 =item *
712
713 C<Pod::Text::Overstrike>, by Joe Smith, has been added.
714 It converts POD data to formatted overstrike text.
715 See L<Pod::Text::Overstrike>.
716
717 =item *
718
719 C<Scalar::Util> is a selection of general-utility scalar subroutines,
720 like blessed(), reftype(), and tainted().  See L<Scalar::Util>.
721
722 =item *
723
724 C<sort> is a new pragma for controlling the behaviour of sort().
725
726 =item *
727
728 C<Storable> gives persistence to Perl data structures by allowing the
729 storage and retrieval of Perl data to and from files in a fast and
730 compact binary format, from Raphael Manfredi.  See L<Storable>.
731
732 =item *
733
734 C<Switch>, from Damian Conway, has been added.  Just by saying
735
736     use Switch;
737
738 you have C<switch> and C<case> available in Perl.
739
740     use Switch;
741
742     switch ($val) {
743
744                 case 1          { print "number 1" }
745                 case "a"        { print "string a" }
746                 case [1..10,42] { print "number in list" }
747                 case (@array)   { print "number in list" }
748                 case /\w+/      { print "pattern" }
749                 case qr/\w+/    { print "pattern" }
750                 case (%hash)    { print "entry in hash" }
751                 case (\%hash)   { print "entry in hash" }
752                 case (\&sub)    { print "arg to subroutine" }
753                 else            { print "previous case not true" }
754     }
755
756 See L<Switch>.
757
758 =item *
759
760 C<Test::More> is yet another framework for writing test scripts,
761 more extensive than Test::Simple, by Michael Schwern.  See L<Test::More>.
762
763 =item *
764
765 C<Test::Simple> has basic utilities for writing tests, by Michael
766 Schwern.   See L<Test::Simple>.
767
768 =item *
769
770 C<Text::Balanced> has been added, for extracting delimited text
771 sequences from strings, from Damian Conway.
772
773     use Text::Balanced 'extract_delimited';
774
775     ($a, $b) = extract_delimited("'never say never', he never said", "'", '');
776
777 $a will be "'never say never'", $b will be ', he never said'.
778
779 In addition to extract_delimited() there are also extract_bracketed(),
780 extract_quotelike(), extract_codeblock(), extract_variable(),
781 extract_tagged(), extract_multiple(), gen_delimited_pat(), and
782 gen_extract_tagged().  With these you can implement rather advanced
783 parsing algorithms.  See L<Text::Balanced>.
784
785 =item *
786
787 C<threads> is an interface to interpreter threads, by Arthur Bergman.
788 Interpreter threads (ithreads) is the new thread model introduced in
789 Perl 5.6 but only available as an internal interface for extension
790 writers (and for Win32 Perl for C<fork()> emulation).  See L<threads>.
791
792 =item *
793
794 C<threads::shared> allows data sharing for interpreter threads, from
795 Arthur Bergman.  In the ithreads model any data sharing between
796 threads must be explicit, as opposed to the old 5.005 thread model
797 where data sharing was implicit.  See L<threads::shared>.
798
799 =item *
800
801 C<Tie::RefHash::Nestable>, by Edward Avis, allows storing hash
802 references (unlike the standard Tie::RefHash)  The module is contained
803 within Tie::RefHash, see L<Tie::RefHash>.
804
805 =item *
806
807 C<Time::HiRes> provides high resolution timing (ualarm, usleep,
808 and gettimeofday), from Douglas E. Wegscheid.  See L<Time::HiRes>.
809
810 =item *
811
812 C<Unicode::UCD> offers a querying interface to the Unicode Character
813 Database.  See L<Unicode::UCD>.
814
815 =item *
816
817 C<Unicode::Collate> implements the UCA (Unicode Collation Algorithm)
818 for sorting Unicode strings, by SADAHIRO Tomoyuki.  See L<Unicode::Collate>.
819
820 =item *
821
822 C<Unicode::Normalize> implements the various Unicode normalization
823 forms, by SADAHIRO Tomoyuki.  See L<Unicode::Normalize>.
824
825 =item *
826
827 C<XS::Typemap>, by Tim Jenness, is a test extension that exercises XS
828 typemaps.  Nothing gets installed but for extension writers the code
829 is worth studying.
830
831 =back
832
833 =head2 Updated And Improved Modules and Pragmata
834
835 =over 4
836
837 =item *
838
839 The following independently supported modules have been updated to the
840 newest versions from CPAN: CGI, CPAN, DB_File, File::Spec, File::Temp,
841 Getopt::Long, Math::BigFloat, Math::BigInt, the podlators bundle
842 (Pod::Man, Pod::Text), Pod::LaTeX, Pod::Parser, Storable,
843 Term::ANSIColor, Test, Text-Tabs+Wrap.
844
845 =item *
846
847 The attributes::reftype() now works on tied arguments.
848
849 =item *
850
851 AutoLoader can now be disabled with C<no AutoLoader;>.
852
853 =item *
854
855 B::Deparse has been significantly enhanced.  It now can deparse almost
856 all of the standard test suite (so that the tests still succeed).
857 There is a make target "test.deparse" for trying this out.
858
859 =item *
860
861 Class::Struct can now define the classes in compile time.
862
863 =item *
864
865 Class::Struct now assigns the array/hash element if the accessor
866 is called with an array/hash element as the B<sole> argument.
867
868 =item *
869
870 Data::Dumper has now an option to sort hashes.
871
872 =item *
873
874 Data::Dumper has now an option to dump code references
875 using B::Deparse.
876
877 =item *
878
879 DB_File now supports newer Berkeley DB versions, among
880 other improvements.
881
882 =item *
883
884 The English module can now be used without the infamous performance
885 hit by saying
886
887         use English '-no_performance_hit';
888
889 (Assuming, of course, that one doesn't need the troublesome variables
890 C<$`>, C<$&>, or C<$'>.)  Also, introduced C<@LAST_MATCH_START> and
891 C<@LAST_MATCH_END> English aliases for C<@-> and C<@+>.
892
893 =item *
894
895 Fcntl, Socket, and Sys::Syslog have been rewritten to use the
896 new-style constant dispatch section (see L<ExtUtils::Constant>).
897 This means that they will be more robust and hopefully faster.
898
899 =item *
900
901 File::Find now chdir()s correctly when chasing symbolic links.
902
903 =item *
904
905 File::Find now has pre- and post-processing callbacks.  It also
906 correctly changes directories when chasing symbolic links.  Callbacks
907 (naughtily) exiting with "next;" instead of "return;" now work.
908
909 =item *
910
911 File::Find is now (again) reentrant.  It also has been made
912 more portable.
913
914 =item *
915
916 File::Glob::glob() renamed to File::Glob::bsd_glob() to avoid
917 prototype mismatch with CORE::glob().
918
919 =item *
920
921 File::Glob now supports C<GLOB_LIMIT> constant to limit the size of
922 the returned list of filenames.
923
924 =item *
925
926 Devel::Peek now has an interface for the Perl memory statistics
927 (this works only if you are using perl's malloc, and if you have
928 compiled with debugging).
929
930 =item *
931
932 IPC::Open3 now allows the use of numeric file descriptors.
933
934 =item *
935
936 IO::Socket has now atmark() method, which returns true if the socket
937 is positioned at the out-of-band mark.  The method is also exportable
938 as a sockatmark() function.
939
940 =item *
941
942 IO::Socket::INET has support for ReusePort option (if your platform
943 supports it).  The Reuse option now has an alias, ReuseAddr.  For clarity
944 you may want to prefer ReuseAddr.
945
946 =item *
947
948 IO::Socket::INET now supports C<LocalPort> of zero (usually meaning
949 that the operating system will make one up.)
950
951 =item *
952
953 use lib now works identically to @INC.  Removing directories
954 with 'no lib' now works.
955
956 =item *
957
958 Math::BigFloat and Math::BigInt have undergone a full rewrite.
959 They are now magnitudes faster, and they support various
960 bignum libraries such as GMP and PARI as their backends.
961
962 =item *
963
964 Math::Complex handles inf, NaN etc., better.
965
966 =item *
967
968 Net::Ping has been enhanced.  There is now "external" protocol which
969 uses Net::Ping::External module which runs external ping(1) and parses
970 the output.  A version of Net::Ping::External is available in CPAN.
971
972 =item *
973
974 POSIX::sigaction() is now much more flexible and robust.
975 You can now install coderef handlers, 'DEFAULT', and 'IGNORE'
976 handlers, installing new handlers was not atomic.
977
978 =item *
979
980 In Safe the C<%INC> now localised in a Safe compartment so that
981 use/require work.
982
983 =item *
984
985 In SDBM_File on dosish platforms, some keys went missing because of
986 lack of support for files with "holes".  A workaround for the problem
987 has been added.
988
989 =item *
990
991 In Search::Dict one can now have a pre-processing hook for the
992 lines being searched.
993
994 =item *
995
996 The Shell module now has an OO interface.
997
998 =item *
999
1000 The Test module has been significantly enhanced.
1001
1002 =item *
1003
1004 The vars pragma now supports declaring fully qualified variables.
1005 (Something that C<our()> does not and will not support.)
1006
1007 =item *
1008
1009 The utf8:: name space (as in the pragma) provides various
1010 Perl-callable functions to provide low level access to Perl's
1011 internal Unicode representation.  At the moment only length()
1012 has been implemented.
1013
1014 =back
1015
1016 =head1 Utility Changes
1017
1018 =over 4
1019
1020 =item *
1021
1022 Emacs perl mode (emacs/cperl-mode.el) has been updated to version
1023 4.31.
1024
1025 =item *
1026
1027 F<emacs/e2ctags.pl> is now much faster.
1028
1029 =item *
1030
1031 C<h2ph> now supports C trigraphs.
1032
1033 =item *
1034
1035 C<h2xs> now produces a template README.
1036
1037 =item *
1038
1039 C<h2xs> now uses C<Devel::PPort> for better portability between
1040 different versions of Perl.
1041
1042 =item *
1043
1044 C<h2xs> uses the new L<ExtUtils::Constant> module which will affect
1045 newly created extensions that define constants.  Since the new code is
1046 more correct (if you have two constants where the first one is a
1047 prefix of the second one, the first constant B<never> gets defined),
1048 less lossy (it uses integers for integer constant, as opposed to the
1049 old code that used floating point numbers even for integer constants),
1050 and slightly faster, you might want to consider regenerating your
1051 extension code (the new scheme makes regenerating easy).
1052 L<h2xs> now also supports C trigraphs.
1053
1054 =item *
1055
1056 C<libnetcfg> has been added to configure the libnet.
1057
1058 =item *
1059
1060 C<perlbug> is now much more robust.  It also sends the bug report to
1061 perl.org, not perl.com.
1062
1063 =item *
1064
1065 C<perlcc> has been rewritten and its user interface (that is,
1066 command line) is much more like that of the UNIX C compiler, cc.
1067 (The perlbc tools has been removed.  Use C<perlcc -B> instead.)
1068
1069 =item *
1070
1071 C<perlivp> is a new Installation Verification Procedure utility
1072 for running any time after installing Perl.
1073
1074 =item *
1075
1076 C<pod2html> now allows specifying a cache directory.
1077
1078 =item *
1079
1080 C<s2p> has been completely rewritten in Perl.  (It is in fact a full
1081 implementation of sed in Perl: you can use the sed functionality by
1082 using the C<psed> utility.)
1083
1084 =item *
1085
1086 C<xsubpp> now understands POD documentation embedded in the *.xs files.
1087
1088 =item *
1089
1090 C<xsubpp> now supports OUT keyword.
1091
1092 =back
1093
1094 =head1 New Documentation
1095
1096 =over 4
1097
1098 =item *
1099
1100 perl56delta details the changes between the 5.005 release and the
1101 5.6.0 release.
1102
1103 =item *
1104
1105 perlclib documents the internal replacements for standard C library
1106 functions.  (Interesting only for extension writers and Perl core
1107 hackers.)
1108
1109 =item *
1110
1111 perldebtut is a Perl debugging tutorial.
1112
1113 =item *
1114
1115 perlebcdic contains considerations for running Perl on EBCDIC platforms.
1116
1117 =item *
1118
1119 perlintro is a gentle introduction to Perl.
1120
1121 =item *
1122
1123 perliol documents the internals of PerlIO with layers.
1124
1125 =item *
1126
1127 perlmodstyle is a style guide for writing modules.
1128
1129 =item *
1130
1131 perlnewmod tells about writing and submitting a new module.
1132
1133 =item *
1134
1135 perlpacktut is a pack() tutorial.
1136
1137 =item *
1138
1139 perlpod has been rewritten to be clearer and to record the best
1140 practices gathered over the years.
1141
1142 =item *
1143
1144 perlpodspec is a more formal specification of the pod format,
1145 mainly of interest for writers of pod applications, not to
1146 people writing in pod.
1147
1148 =item *
1149
1150 perlretut is a regular expression tutorial.
1151
1152 =item *
1153
1154 perlrequick is a regular expressions quick-start guide.
1155 Yes, much quicker than perlretut.
1156
1157 =item *
1158
1159 perltodo has been updated.
1160
1161 =item *
1162
1163 perltootc has been renamed as perltooc (to not to conflict
1164 with perltoot in filesystems restricted to "8.3" names)
1165
1166 =item *
1167
1168 perluniintro is an introduction to using Unicode in Perl
1169 (perlunicode is more of a reference)
1170
1171 =item *
1172
1173 perlutil explains the command line utilities packaged with the Perl
1174 distribution.
1175
1176 =back
1177
1178 The following platform-specific documents are available before
1179 the installation as README.I<platform>, and after the installation
1180 as perlI<platform>:
1181
1182     perlaix perlamiga perlapollo perlbeos perlbs2000
1183     perlce perlcygwin perldgux perldos perlepoc perlhpux
1184     perlhurd perlmachten perlmacos perlmint perlmpeix
1185     perlnetware perlos2 perlos390 perlplan9 perlqnx perlsolaris
1186     perltru64 perluts perlvmesa perlvms perlvos perlwin32
1187
1188 =over 4
1189
1190 =item *
1191
1192 The documentation for the POSIX-BC platform is called "BS2000", to avoid
1193 confusion with the Perl POSIX module.
1194
1195 =item *
1196
1197 The documentation for the WinCE platform is called "CE", to avoid
1198 confusion with the perlwin32 documentation on 8.3-restricted filesystems.
1199
1200 =back
1201
1202 =head1 Performance Enhancements
1203
1204 =over 4
1205
1206 =item *
1207
1208 map() could get pathologically slow when the result list it generates
1209 is larger than the source list.  The performance has been improved for
1210 common scenarios.
1211
1212 =item *
1213
1214 sort() has been changed to use primarily mergesort internally as
1215 opposed to the earlier quicksort.  For very small lists this may
1216 result in slightly slower sorting times, but in general the speedup
1217 should be at least 20%.  Additional bonuses are that the worst case
1218 behaviour of sort() is now better (in computer science terms it now
1219 runs in time O(N log N), as opposed to quicksort's Theta(N**2)
1220 worst-case run time behaviour), and that sort() is now stable
1221 (meaning that elements with identical keys will stay ordered as they
1222 were before the sort).  See the C<sort> pragma for information.
1223
1224 The story in more detail: suppose you want to serve yourself a little
1225 slice of Pi.
1226
1227     @digits = ( 3,1,4,1,5,9 );
1228
1229 A numerical sort of the digits will yield (1,1,3,4,5,9), as expected.
1230 Which C<1> comes first is hard to know, since one C<1> looks pretty
1231 much like any other.  You can regard this as totally trivial,
1232 or somewhat profound.  However, if you just want to sort the even
1233 digits ahead of the odd ones, then what will
1234
1235     sort { ($a % 2) <=> ($b % 2) } @digits;
1236
1237 yield?  The only even digit, C<4>, will come first.  But how about
1238 the odd numbers, which all compare equal?  With the quicksort algorithm
1239 used to implement Perl 5.6 and earlier, the order of ties is left up
1240 to the sort.  So, as you add more and more digits of Pi, the order
1241 in which the sorted even and odd digits appear will change.
1242 and, for sufficiently large slices of Pi, the quicksort algorithm
1243 in Perl 5.8 won't return the same results even if reinvoked with the
1244 same input.  The justification for this rests with quicksort's
1245 worst case behavior.  If you run
1246
1247    sort { $a <=> $b } ( 1 .. $N , 1 .. $N );
1248
1249 (something you might approximate if you wanted to merge two sorted
1250 arrays using sort), doubling $N doesn't just double the quicksort time,
1251 it I<quadruples> it.  Quicksort has a worst case run time that can
1252 grow like N**2, so-called I<quadratic> behaviour, and it can happen
1253 on patterns that may well arise in normal use.  You won't notice this
1254 for small arrays, but you I<will> notice it with larger arrays,
1255 and you may not live long enough for the sort to complete on arrays
1256 of a million elements.  So the 5.8 quicksort scrambles large arrays
1257 before sorting them, as a statistical defence against quadratic behaviour.
1258 But that means if you sort the same large array twice, ties may be
1259 broken in different ways.
1260
1261 Because of the unpredictability of tie-breaking order, and the quadratic
1262 worst-case behaviour, quicksort was I<almost> replaced completely with
1263 a stable mergesort.  I<Stable> means that ties are broken to preserve
1264 the original order of appearance in the input array.  So
1265
1266     sort { ($a % 2) <=> ($b % 2) } (3,1,4,1,5,9);
1267
1268 will yield (4,3,1,1,5,9), guaranteed.  The even and odd numbers
1269 appear in the output in the same order they appeared in the input.
1270 Mergesort has worst case O(NlogN) behaviour, the best value
1271 attainable.  And, ironically, this mergesort does particularly
1272 well where quicksort goes quadratic:  mergesort sorts (1..$N, 1..$N)
1273 in O(N) time.  But quicksort was rescued at the last moment because
1274 it is faster than mergesort on certain inputs and platforms.
1275 For example, if you really I<don't> care about the order of even
1276 and odd digits, quicksort will run in O(N) time; it's very good
1277 at sorting many repetitions of a small number of distinct elements.
1278 The quicksort divide and conquer strategy works well on platforms
1279 with relatively small, very fast, caches.  Eventually, the problem gets
1280 whittled down to one that fits in the cache, from which point it
1281 benefits from the increased memory speed.
1282
1283 Quicksort was rescued by implementing a sort pragma to control aspects
1284 of the sort.  The B<stable> subpragma forces stable behaviour,
1285 regardless of algorithm.  The B<_quicksort> and B<_mergesort>
1286 subpragmas are heavy-handed ways to select the underlying implementation.
1287 The leading C<_> is a reminder that these subpragmas may not survive
1288 beyond 5.8.  More appropriate mechanisms for selecting the implementation
1289 exist, but they wouldn't have arrived in time to save quicksort.
1290
1291 =item *
1292
1293 Hashes now use Bob Jenkins "One-at-a-Time" hashing key algorithm
1294 (http://burtleburtle.net/bob/hash/doobs.html).  This algorithm is
1295 reasonably fast while producing a much better spread of values than
1296 the old hashing algorithm (originally by Chris Torek, later tweaked by
1297 Ilya Zakharevich).  Hash values output from the algorithm on a hash of
1298 all 3-char printable ASCII keys comes much closer to passing the
1299 DIEHARD random number generation tests.  According to perlbench, this
1300 change has not affected the overall speed of Perl.
1301
1302 =item *
1303
1304 unshift() should now be noticeably faster.
1305
1306 =back
1307
1308 =head1 Installation and Configuration Improvements
1309
1310 =head2 Generic Improvements
1311
1312 =over 4
1313
1314 =item *
1315
1316 INSTALL now explains how you can configure Perl to use 64-bit
1317 integers even on non-64-bit platforms.
1318
1319 =item *
1320
1321 Policy.sh policy change: if you are reusing a Policy.sh file
1322 (see INSTALL) and you use Configure -Dprefix=/foo/bar and in the old
1323 Policy $prefix eq $siteprefix and $prefix eq $vendorprefix, all of
1324 them will now be changed to the new prefix, /foo/bar.  (Previously
1325 only $prefix changed.)  If you do not like this new behaviour,
1326 specify prefix, siteprefix, and vendorprefix explicitly.
1327
1328 =item *
1329
1330 A new optional location for Perl libraries, otherlibdirs, is available.
1331 It can be used for example for vendor add-ons without disturbing Perl's
1332 own library directories.
1333
1334 =item *
1335
1336 In many platforms the vendor-supplied 'cc' is too stripped-down to
1337 build Perl (basically, 'cc' doesn't do ANSI C).  If this seems
1338 to be the case and 'cc' does not seem to be the GNU C compiler
1339 'gcc', an automatic attempt is made to find and use 'gcc' instead.
1340
1341 =item *
1342
1343 gcc needs to closely track the operating system release to avoid
1344 build problems. If Configure finds that gcc was built for a different
1345 operating system release than is running, it now gives a clearly visible
1346 warning that there may be trouble ahead.
1347
1348 =item *
1349
1350 If binary compatibility with the 5.005 release is not wanted, Configure
1351 no longer suggests including the 5.005 modules in @INC.
1352
1353 =item *
1354
1355 Configure C<-S> can now run non-interactively.
1356
1357 =item *
1358
1359 Configure support for pdp11-style memory models has been removed due
1360 to obsolescence.
1361
1362 =item *
1363
1364 configure.gnu now works with options with whitespace in them.
1365
1366 =item *
1367
1368 installperl now outputs everything to STDERR.
1369
1370 =item *
1371
1372 $Config{byteorder} is now computed dynamically (this is more robust
1373 with "fat binaries" where an executable image contains binaries for
1374 more than one binary platform.)
1375
1376 =item *
1377
1378 Because PerlIO is now the default on most platforms, "-perlio" doesn't
1379 get appended to the $Config{archname} (also known as $^O) anymore.
1380 Instead, if you explicitly choose not to use perlio (Configure command
1381 line option -Uuseperlio), you will get "-stdio" appended.
1382
1383 =item *
1384
1385 Another change related to the architecture name is that "-64all"
1386 (-Duse64bitall, or "maximally 64-bit") is appended only if your
1387 pointers are 64 bits wide.  (To be exact, the use64bitall is ignored.)
1388
1389 =item *
1390
1391 In AFS installations one can configure the root of the AFS to be
1392 somewhere else than the default F</afs> by using the Configure
1393 parameter C<-Dafsroot=/some/where/else>.
1394
1395 =item *
1396
1397 APPLLIB_EXP, a less-know configuration-time definition, has been
1398 documented.  It can be used to prepend site-specific directories
1399 to Perl's default search path (@INC), see INSTALL for information.
1400
1401 =item *
1402
1403 The version of Berkeley DB used when the Perl (and, presumably, the
1404 DB_File extension) was built is now available as
1405 C<@Config{qw(db_version_major db_version_minor db_version_patch)}>
1406 from Perl and as C<DB_VERSION_MAJOR_CFG DB_VERSION_MINOR_CFG
1407 DB_VERSION_PATCH_CFG> from C.
1408
1409 =item *
1410
1411 Building Berkeley DB3 for compatibility modes for DB, NDBM, and ODBM
1412 has been documented in INSTALL.
1413
1414 =item *
1415
1416 If you have CPAN access (either network or a local copy such as a
1417 CD-ROM) you can during specify extra modules to Configure to build and
1418 install with Perl using the -Dextras=...  option.  See INSTALL for
1419 more details.
1420
1421 =item *
1422
1423 In addition to config.over a new override file, config.arch, is
1424 available.  That is supposed to be used by hints file writers for
1425 architecture-wide changes (as opposed to config.over which is for
1426 site-wide changes).
1427
1428 =item *
1429
1430 If your file system supports symbolic links you can build Perl outside
1431 of the source directory by
1432
1433         mkdir /tmp/perl/build/directory
1434         cd /tmp/perl/build/directory
1435         sh /path/to/perl/source/Configure -Dmksymlinks ...
1436
1437 This will create in /tmp/perl/build/directory a tree of symbolic links
1438 pointing to files in /path/to/perl/source.  The original files are left
1439 unaffected.  After Configure has finished you can just say
1440
1441         make all test
1442
1443 and Perl will be built and tested, all in /tmp/perl/build/directory.
1444
1445 =item *
1446
1447 For Perl developers several new make targets for profiling
1448 and debugging have been added, see L<perlhack>.
1449
1450 =over 8
1451
1452 =item *
1453
1454 Use of the F<gprof> tool to profile Perl has been documented in
1455 L<perlhack>.  There is a make target called "perl.gprof" for
1456 generating a gprofiled Perl executable.
1457
1458 =item *
1459
1460 If you have GCC 3, there is a make target called "perl.gcov" for
1461 creating a gcoved Perl executable for coverage analysis.  See
1462 L<perlhack>.
1463
1464 =item *
1465
1466 If you are on IRIX or Tru64 platforms, new profiling/debugging options
1467 have been added, see L<perlhack> for more information about pixie and
1468 Third Degree.
1469
1470 =back
1471
1472 =item *
1473
1474 Guidelines of how to construct minimal Perl installations have
1475 been added to INSTALL.
1476
1477 =item *
1478
1479 The Thread extension is now not built at all under ithreads
1480 (C<Configure -Duseithreads>) because it wouldn't work anyway (the
1481 Thread extension requires being Configured with C<-Duse5005threads>).
1482
1483 But note that the Thread.pm interface is now shared by both
1484 thread models.
1485
1486 =back
1487
1488 =head2 New Or Improved Platforms
1489
1490 For the list of platforms known to support Perl,
1491 see L<perlport/"Supported Platforms">.
1492
1493 =over 4
1494
1495 =item *
1496
1497 AIX dynamic loading should be now better supported.
1498
1499 =item *
1500
1501 AIX should now work better with gcc, threads, and 64-bitness.  Also the
1502 long doubles support in AIX should be better now.  See L<perlaix>.
1503
1504 =item *
1505
1506 After a long pause, AmigaOS has been verified to be happy with Perl.
1507
1508 =item *
1509
1510 AtheOS (http://www.atheos.cx/) is a new platform.
1511
1512 =item *
1513
1514 DG/UX platform now supports the 5.005-style threads.  See L<perldgux>.
1515
1516 =item *
1517
1518 DYNIX/ptx platform (a.k.a. dynixptx) is supported at or near osvers 4.5.2.
1519
1520 =item *
1521
1522 EBCDIC platforms (z/OS, also known as OS/390, POSIX-BC, and VM/ESA)
1523 have been regained.  Many test suite tests still fail and the
1524 co-existence of Unicode and EBCDIC isn't quite settled, but the
1525 situation is much better than with Perl 5.6.  See L<perlos390>,
1526 L<perlbs2000> (for POSIX-BC), and L<perlvmesa> for more information.
1527
1528 =item *
1529
1530 Building perl with -Duseithreads or -Duse5005threads now works under
1531 HP-UX 10.20 (previously it only worked under 10.30 or later). You will
1532 need a thread library package installed. See README.hpux.
1533
1534 =item *
1535
1536 MacOS Classic (MacPerl has of course been available since
1537 perl 5.004 but now the source code bases of standard Perl
1538 and MacPerl have been synchronised)
1539
1540 =item *
1541
1542 MacOS X (or Darwin) should now be able to build Perl even on HFS+
1543 filesystems.  (The case-insensitivity confused the Perl build process.)
1544
1545 =item *
1546
1547 NCR MP-RAS is now supported.
1548
1549 =item *
1550
1551 NetWare from Novell is now supported.  See L<perlnetware>.
1552
1553 =item *
1554
1555 NonStop-UX is now supported.
1556
1557 =item *
1558
1559 NEC SUPER-UX is now supported.
1560
1561 =item *
1562
1563 Amdahl UTS UNIX mainframe platform is now supported.
1564
1565 =item *
1566
1567 WinCE is now supported.  See L<perlce>.
1568
1569 =item *
1570
1571 z/OS (formerly known as OS/390, formerly known as MVS OE) has now
1572 support for dynamic loading.  This is not selected by default,
1573 however, you must specify -Dusedl in the arguments of Configure.
1574
1575 =back
1576
1577 =head1 Selected Bug Fixes
1578
1579 Numerous memory leaks and uninitialized memory accesses have been
1580 hunted down.  Most importantly anonymous subs used to leak quite
1581 a bit.
1582
1583 =over 4
1584
1585 =item *
1586
1587 The autouse pragma didn't work for Multi::Part::Function::Names.
1588
1589 =item *
1590
1591 caller() could cause core dumps in certain situations.  Carp was sometimes
1592 affected by this problem.
1593
1594 =item *
1595
1596 chop(@list) in list context returned the characters chopped in
1597 reverse order.  This has been reversed to be in the right order.
1598
1599 =item *
1600
1601 Configure no longer includes the DBM libraries (dbm, gdbm, db, ndbm)
1602 when building the Perl binary.  The only exception to this is SunOS 4.x,
1603 which needs them.
1604
1605 =item *
1606
1607 The behaviour of non-decimal but numeric string constants such as
1608 "0x23" was platform-dependent: in some platforms that was seen as 35,
1609 in some as 0, in some as a floating point number (don't ask).  This
1610 was caused by Perl using the operating system libraries in a situation
1611 where the result of the string to number conversion is undefined: now
1612 Perl consistently handles such strings as zero in numeric contexts.
1613
1614 =item *
1615
1616 The order of DESTROYs has been made more predictable.
1617
1618 =item *
1619
1620 Several debugger fixes: exit code now reflects the script exit code,
1621 condition C<"0"> now treated correctly, the C<d> command now checks
1622 line number, the C<$.> no longer gets corrupted, all debugger output
1623 now goes correctly to the socket if RemotePort is set.
1624
1625 =item *
1626
1627 Perl 5.6.0 could emit spurious warnings about redefinition of dl_error()
1628 when statically building extensions into perl.  This has been corrected.
1629
1630 =item *
1631
1632 L<dprofpp> -R didn't work.
1633
1634 =item *
1635
1636 C<*foo{FORMAT}> now works.
1637 =item *
1638
1639 Infinity is now recognized as a number.
1640
1641 =item *
1642
1643 UNIVERSAL::isa no longer caches methods incorrectly.  (This broke
1644 the Tk extension with 5.6.0.)
1645
1646 =item *
1647
1648 Lexicals I: lexicals outside an eval "" weren't resolved
1649 correctly inside a subroutine definition inside the eval "" if they
1650 were not already referenced in the top level of the eval""ed code.
1651
1652 =item *
1653
1654 Lexicals II: lexicals leaked at file scope into subroutines that
1655 were declared before the lexicals.
1656
1657 =item *
1658
1659 Lexical warnings now propagating correctly between scopes
1660 and into C<eval "...">.
1661
1662 =item *
1663
1664 C<use warnings qw(FATAL all)> did not work as intended.  This has been
1665 corrected.
1666
1667 =item *
1668
1669 warnings::enabled() now reports the state of $^W correctly if the caller
1670 isn't using lexical warnings.
1671
1672 =item *
1673
1674 Line renumbering with eval and C<#line> now works.
1675
1676 =item *
1677
1678 Fixed numerous memory leaks, especially in eval "".
1679
1680 =item *
1681
1682 mkdir() now ignores trailing slashes in the directory name,
1683 as mandated by POSIX.
1684
1685 =item *
1686
1687 Some versions of glibc have a broken modfl().  This affects builds
1688 with C<-Duselongdouble>.  This version of Perl detects this brokenness
1689 and has a workaround for it.  The glibc release 2.2.2 is known to have
1690 fixed the modfl() bug.
1691
1692 =item *
1693
1694 Modulus of unsigned numbers now works (4063328477 % 65535 used to
1695 return 27406, instead of 27047).
1696
1697 =item *
1698
1699 Some "not a number" warnings introduced in 5.6.0 eliminated to be
1700 more compatible with 5.005.  Infinity is now recognised as a number.
1701
1702 =item *
1703
1704 Numeric conversions did not recognize changes in the string value
1705 properly in certain circumstances.
1706
1707 =item *
1708
1709 Attributes (like :shared) didn't work with our().
1710
1711 =item *
1712
1713 our() variables will not cause "will not stay shared" warnings.
1714
1715 =item *
1716
1717 "our" variables of the same name declared in two sibling blocks
1718 resulted in bogus warnings about "redeclaration" of the variables.
1719 The problem has been corrected.
1720
1721 =item *
1722
1723 pack "Z" now correctly terminates the string with "\0".
1724
1725 =item *
1726
1727 Fix password routines which in some shadow password platforms
1728 (e.g. HP-UX) caused getpwent() to return every other entry.
1729
1730 =item *
1731
1732 The PERL5OPT environment variable (for passing command line arguments
1733 to Perl) didn't work for more than a single group of options.
1734
1735 =item *
1736
1737 PERL5OPT with embedded spaces didn't work.
1738
1739 =item *
1740
1741 printf() no longer resets the numeric locale to "C".
1742
1743 =item *
1744
1745 C<qw(a\\b)> now parses correctly as C<'a\\b'>.
1746
1747 =item *
1748
1749 pos() did not return the correct value within s///ge in earlier
1750 versions.  This is now handled correctly.
1751
1752 =item *
1753
1754 Printing quads (64-bit integers) with printf/sprintf now works
1755 without the q L ll prefixes (assuming you are on a quad-capable platform).
1756
1757 =item *
1758
1759 Regular expressions on references and overloaded scalars now work.
1760
1761 =item *
1762
1763 Right-hand side magic (GMAGIC) could in many cases such as string
1764 concatenation be invoked too many times.
1765
1766 =item *
1767
1768 scalar() now forces scalar context even when used in void context.
1769
1770 =item *
1771
1772 SOCKS support is now much more robust.
1773
1774 =item *
1775
1776 sort() arguments are now compiled in the right wantarray context
1777 (they were accidentally using the context of the sort() itself).
1778 The comparison block is now run in scalar context, and the arguments
1779 to be sorted are always provided list context.
1780
1781 =item *
1782
1783 Changed the POSIX character class C<[[:space:]]> to include the (very
1784 rarely used) vertical tab character.  Added a new POSIX-ish character
1785 class C<[[:blank:]]> which stands for horizontal whitespace
1786 (currently, the space and the tab).
1787
1788 =item *
1789
1790 The tainting behaviour of sprintf() has been rationalized.  It does
1791 not taint the result of floating point formats anymore, making the
1792 behaviour consistent with that of string interpolation.
1793
1794 =item *
1795
1796 Some cases of inconsistent taint propagation (such as within hash
1797 values) have been fixed.
1798
1799 =item *
1800
1801 The RE engine found in Perl 5.6.0 accidentally pessimised certain kinds
1802 of simple pattern matches.  These are now handled better.
1803
1804 =item *
1805
1806 Regular expression debug output (whether through C<use re 'debug'>
1807 or via C<-Dr>) now looks better.
1808
1809 =item *
1810
1811 Multi-line matches like C<"a\nxb\n" =~ /(?!\A)x/m> were flawed.  The
1812 bug has been fixed.
1813
1814 =item *
1815
1816 Use of $& could trigger a core dump under some situations.  This
1817 is now avoided.
1818
1819 =item *
1820
1821 The regular expression captured submatches ($1, $2, ...) are now
1822 more consistently unset if the match fails, instead of leaving false
1823 data lying around in them.
1824
1825 =item *
1826
1827 readline() on files opened in "slurp" mode could return an extra "" at
1828 the end in certain situations.  This has been corrected.
1829
1830 =item *
1831
1832 Autovivification of symbolic references of special variables described
1833 in L<perlvar> (as in C<${$num}>) was accidentally disabled.  This works
1834 again now.
1835
1836 =item *
1837
1838 Sys::Syslog ignored the C<LOG_AUTH> constant.
1839
1840 =item *
1841
1842 All but the first argument of the IO syswrite() method are now optional.
1843
1844 =item *
1845
1846 $AUTOLOAD, sort(), lock(), and spawning subprocesses
1847 in multiple threads simultaneously are now thread-safe.
1848
1849 =item *
1850
1851 Tie::ARRAY SPLICE method was broken.
1852
1853 =item *
1854
1855 Allow read-only string on left hand side of non-modifying tr///.
1856
1857 =item *
1858
1859 Several Unicode fixes.
1860
1861 =over 8
1862
1863 =item *
1864
1865 BOMs (byte order marks) in the beginning of Perl files
1866 (scripts, modules) should now be transparently skipped.
1867 UTF-16 (UCS-2) encoded Perl files should now be read correctly.
1868
1869 =item *
1870
1871 The character tables have been updated to Unicode 3.1.1.
1872
1873 =item *
1874
1875 Comparing with utf8 data does not magically upgrade non-utf8 data
1876 into utf8.
1877
1878 =item *
1879
1880 C<IsAlnum>, C<IsAlpha>, and C<IsWord> now match titlecase.
1881
1882 =item *
1883
1884 Concatenation with the C<.> operator or via variable interpolation,
1885 C<eq>, C<substr>, C<reverse>, C<quotemeta>, the C<x> operator,
1886 substitution with C<s///>, single-quoted UTF8, should now work.
1887
1888 =item *
1889
1890 The C<tr///> operator now works.  Note that the C<tr///CU>
1891 functionality has been removed (but see pack('U0', ...)).
1892
1893 =item *
1894
1895 C<eval "v200"> now works.
1896
1897 =item *
1898
1899 Perl 5.6.0 parsed m/\x{ab}/ incorrectly, leading to spurious warnings.
1900 This has been corrected.
1901
1902 =item *
1903
1904 Zero entries were missing from the Unicode classes like C<IsDigit>.
1905
1906 =back
1907
1908 =item *
1909
1910 Large unsigned numbers (those above 2**31) could sometimes lose their
1911 unsignedness, causing bogus results in arithmetic operations.
1912
1913 =back
1914
1915 =head2 Platform Specific Changes and Fixes
1916
1917 =over 4
1918
1919 =item *
1920
1921 BSDI 4.*
1922
1923 Perl now works on post-4.0 BSD/OSes.
1924
1925 =item *
1926
1927 All BSDs
1928
1929 Setting C<$0> now works (as much as possible; see L<perlvar> for details).
1930
1931 =item *
1932
1933 Cygwin
1934
1935 Numerous updates; currently synchronised with Cygwin 1.1.4.
1936
1937 =item *
1938
1939 Previously DYNIX/ptx had problems in its Configure probe for non-blocking I/O.
1940
1941 =item *
1942
1943 EPOC
1944
1945 EPOC update after Perl 5.6.0.  See README.epoc.
1946
1947 =item *
1948
1949 FreeBSD 3.*
1950
1951 Perl now works on post-3.0 FreeBSDs.
1952
1953 =item *
1954
1955 HP-UX
1956
1957 README.hpux updated; C<Configure -Duse64bitall> now almost works.
1958
1959 =item *
1960
1961 IRIX
1962
1963 Numerous compilation flag and hint enhancements; accidental mixing
1964 of 32-bit and 64-bit libraries (a doomed attempt) made much harder.
1965
1966 =item *
1967
1968 Linux
1969
1970 =over 8
1971
1972 =item *
1973
1974 Long doubles should now work (see INSTALL).
1975
1976 =item *
1977
1978 Linux previously had problems related to sockaddrlen when using
1979 accept(), revcfrom() (in Perl: recv()), getpeername(), and getsockname().
1980
1981 =back
1982
1983 =item *
1984
1985 MacOS Classic
1986
1987 Compilation of the standard Perl distribution in MacOS Classic should
1988 now work if you have the Metrowerks development environment and
1989 the missing Mac-specific toolkit bits.  Contact the macperl mailing
1990 list for details.
1991
1992 =item *
1993
1994 MPE/iX
1995
1996 MPE/iX update after Perl 5.6.0.  See README.mpeix.
1997
1998 =item *
1999
2000 NetBSD/sparc
2001
2002 Perl now works on NetBSD/sparc.
2003
2004 =item *
2005
2006 OS/2
2007
2008 Now works with usethreads (see INSTALL).
2009
2010 =item *
2011
2012 Solaris
2013
2014 64-bitness using the Sun Workshop compiler now works.
2015
2016 =item *
2017
2018 Tru64 (aka Digital UNIX, aka DEC OSF/1)
2019
2020 The operating system version letter now recorded in $Config{osvers}.
2021 Allow compiling with gcc (previously explicitly forbidden).  Compiling
2022 with gcc still not recommended because buggy code results, even with
2023 gcc 2.95.2.
2024
2025 =item *
2026
2027 Unicos
2028
2029 Fixed various alignment problems that lead into core dumps either
2030 during build or later; no longer dies on math errors at runtime;
2031 now using full quad integers (64 bits), previously was using 
2032 only 46 bit integers for speed.
2033
2034 =item *
2035
2036 VMS
2037
2038 chdir() now works better despite a CRT bug; now works with MULTIPLICITY
2039 (see INSTALL); now works with Perl's malloc.
2040
2041 The tainting of C<%ENV> elements via C<keys> or C<values> was previously
2042 unimplemented.  It now works as documented.
2043
2044 The C<waitpid> emulation has been improved.  The worst bug (now fixed)
2045 was that a pid of -1 would cause a wildcard search of all processes on
2046 the system.  The most significant enhancement is that we can now
2047 usually get the completion status of a terminated process.
2048
2049 POSIX-style signals are now emulated much better on VMS versions prior
2050 to 7.0.
2051
2052 The C<system> function and backticks operator have improved
2053 functionality and better error handling.
2054
2055 =item *
2056
2057 Windows
2058
2059 =over 8
2060
2061 =item *
2062
2063 accept() no longer leaks memory.
2064
2065 =item *
2066
2067 Borland C++ v5.5 is now a supported compiler that can build Perl.
2068 However, the generated binaries continue to be incompatible with those
2069 generated by the other supported compilers (GCC and Visual C++).
2070
2071 =item *
2072
2073 Better chdir() return value for a non-existent directory.
2074
2075 =item *
2076
2077 Duping socket handles with open(F, ">&MYSOCK") now works under Windows 9x.
2078
2079 =item *
2080
2081 New %ENV entries now propagate to subprocesses.
2082
2083 =item *
2084
2085 Current directory entries in %ENV are now correctly propagated to child
2086 processes.
2087
2088 =item *
2089
2090 $ENV{LIB} now used to search for libs under Visual C.
2091
2092 =item *
2093
2094 fork() emulation has been improved in various ways, but still continues
2095 to be experimental.  See L<perlfork> for known bugs and caveats.
2096
2097 =item *
2098
2099 A failed (pseudo)fork now returns undef and sets errno to EAGAIN.
2100
2101 =item *
2102
2103 Win32::GetCwd() correctly returns C:\ instead of C: when at the drive root.
2104 Other bugs in chdir() and Cwd::cwd() have also been fixed.
2105
2106 =item *
2107
2108 HTML files will be installed in c:\perl\html instead of c:\perl\lib\pod\html
2109
2110 =item *
2111
2112 The makefiles now provide a single switch to bulk-enable all the features
2113 enabled in ActiveState ActivePerl (a popular Win32 binary distribution).
2114
2115 =item *
2116
2117 Allow REG_EXPAND_SZ keys in the registry.
2118
2119 =item *
2120
2121 Can now send() from all threads, not just the first one.
2122
2123 =item *
2124
2125 Fake signal handling reenabled, bugs and all.
2126
2127 =item *
2128
2129 %SIG has been enabled under USE_ITHREADS, but its use is completely
2130 unsupported under all configurations.
2131
2132 =item *
2133
2134 Less stack reserved per thread so that more threads can run
2135 concurrently. (Still 16M per thread.)
2136
2137 =item *
2138
2139 C<File::Spec-&gt;tmpdir()> now prefers C:/temp over /tmp
2140 (works better when perl is running as service).
2141
2142 =item *
2143
2144 Better UNC path handling under ithreads.
2145
2146 =item *
2147
2148 wait(), waitpid() and backticks now return the correct exit status under
2149 Windows 9x.
2150
2151 =item *
2152
2153 winsock handle leak fixed.
2154
2155 =back
2156
2157 =back
2158
2159 =head1 New or Changed Diagnostics
2160
2161 =over 4
2162
2163 =item *
2164
2165 All regular expression compilation error messages are now hopefully
2166 easier to understand both because the error message now comes before
2167 the failed regex and because the point of failure is now clearly
2168 marked by a C<E<lt>-- HERE> marker.
2169
2170 =item *
2171
2172 The various "opened only for", "on closed", "never opened" warnings
2173 drop the C<main::> prefix for filehandles in the C<main> package,
2174 for example C<STDIN> instead of C<main::STDIN>. 
2175
2176 =item *
2177
2178 The "Unrecognized escape" warning has been extended to include C<\8>,
2179 C<\9>, and C<\_>.  There is no need to escape any of the C<\w> characters.
2180
2181 =item *
2182
2183 Two new debugging options have been added: if you have compiled your
2184 Perl with debugging, you can use the -DT and -DR options to trace
2185 tokenising and to add reference counts to displaying variables,
2186 respectively.
2187
2188 =item *
2189
2190 If an attempt to use a (non-blessed) reference as an array index
2191 is made, a warning is given.
2192
2193 =item *
2194
2195 C<push @a;> and C<unshift @a;> (with no values to push or unshift)
2196 now give a warning.  This may be a problem for generated and evaled
2197 code.
2198
2199 =item *
2200
2201 If you try to L<perlfunc/pack> a number less than 0 or larger than 255
2202 using the C<"C"> format you will get an optional warning.  Similarly
2203 for the C<"c"> format and a number less than -128 or more than 127.
2204
2205 =item *
2206
2207 Certain regex modifiers such as C<(?o)> make sense only if applied to
2208 the entire regex.  You will an optional warning if you try to do otherwise.
2209
2210 =item *
2211
2212 Using arrays or hashes as references (e.g. C<< %foo-&gt;{bar} >>
2213 has been deprecated for a while.  Now you will get an optional warning.
2214
2215 =back
2216
2217 =head1 Changed Internals
2218
2219 =over 4
2220
2221 =item *
2222
2223 perlapi.pod (a companion to perlguts) now attempts to document the
2224 internal API.
2225
2226 =item *
2227
2228 You can now build a really minimal perl called microperl.
2229 Building microperl does not require even running Configure;
2230 C<make -f Makefile.micro> should be enough.  Beware: microperl makes
2231 many assumptions, some of which may be too bold; the resulting
2232 executable may crash or otherwise misbehave in wondrous ways.
2233 For careful hackers only.
2234
2235 =item *
2236
2237 Added rsignal(), whichsig(), do_join(), op_clear, op_null,
2238 ptr_table_clear(), ptr_table_free(), sv_setref_uv(), and several UTF-8
2239 interfaces to the publicised API.  For the full list of the available
2240 APIs see L<perlapi>.
2241
2242 =item *
2243
2244 Made possible to propagate customised exceptions via croak()ing.
2245
2246 =item *
2247
2248 Now xsubs can have attributes just like subs.  (Well, at least the
2249 built-in attributes.)
2250
2251 =item *
2252
2253 dTHR and djSP have been obsoleted; the former removed (because it's
2254 a no-op) and the latter replaced with dSP.
2255
2256 =item *
2257
2258 PERL_OBJECT has been completely removed.
2259
2260 =item *
2261
2262 The MAGIC constants (e.g. C<'P'>) have been macrofied
2263 (e.g. C<PERL_MAGIC_TIED>) for better source code readability
2264 and maintainability.
2265
2266 =item *
2267
2268 The regex compiler now maintains a structure that identifies nodes in
2269 the compiled bytecode with the corresponding syntactic features of the
2270 original regex expression.  The information is attached to the new
2271 C<offsets> member of the C<struct regexp>. See L<perldebguts> for more
2272 complete information.
2273
2274 =item *
2275
2276 The C code has been made much more C<gcc -Wall> clean.  Some warning
2277 messages still remain in some platforms, so if you are compiling with
2278 gcc you may see some warnings about dubious practices.  The warnings
2279 are being worked on.
2280
2281 =item *
2282
2283 F<perly.c>, F<sv.c>, and F<sv.h> have now been extensively commented.
2284
2285 =item *
2286
2287 Documentation on how to use the Perl source repository has been added
2288 to F<Porting/repository.pod>.
2289
2290 =item *
2291
2292 There are now several profiling make targets.
2293
2294 =back
2295
2296 =head1 Security Vulnerability Closed
2297
2298 (This change was already made in 5.7.0 but bears repeating here.)
2299
2300 A potential security vulnerability in the optional suidperl component
2301 of Perl was identified in August 2000.  suidperl is neither built nor
2302 installed by default.  As of November 2001 the only known vulnerable
2303 platform is Linux, most likely all Linux distributions.  CERT and
2304 various vendors and distributors have been alerted about the vulnerability.
2305 See http://www.cpan.org/src/5.0/sperl-2000-08-05/sperl-2000-08-05.txt
2306 for more information.
2307
2308 The problem was caused by Perl trying to report a suspected security
2309 exploit attempt using an external program, /bin/mail.  On Linux
2310 platforms the /bin/mail program had an undocumented feature which
2311 when combined with suidperl gave access to a root shell, resulting in
2312 a serious compromise instead of reporting the exploit attempt.  If you
2313 don't have /bin/mail, or if you have 'safe setuid scripts', or if
2314 suidperl is not installed, you are safe.
2315
2316 The exploit attempt reporting feature has been completely removed from
2317 Perl 5.8.0 (and the maintenance release 5.6.1, and it was removed also
2318 from all the Perl 5.7 releases), so that particular vulnerability
2319 isn't there anymore.  However, further security vulnerabilities are,
2320 unfortunately, always possible.  The suidperl functionality is most
2321 probably going to be removed in Perl 5.10.  In any case, suidperl
2322 should only be used by security experts who know exactly what they are
2323 doing and why they are using suidperl instead of some other solution
2324 such as sudo (see http://www.courtesan.com/sudo/).
2325
2326 =head1 New Tests
2327
2328 Several new tests have been added, especially for the F<lib>
2329 subsection.  There are now about 34 000 individual tests (spread over
2330 about 530 test scripts), in the regression suite (5.6.1 has about
2331 11700 tests, in 258 test scripts) Many of the new tests are introduced
2332 by the new modules, but still in general Perl is now more thoroughly
2333 tested.
2334
2335 Because of the large number of tests, running the regression suite
2336 will take considerably longer time than it used to: expect the suite
2337 to take up to 4-5 times longer to run than in perl 5.6.  In a really
2338 fast machine you can hope to finish the suite in about 5 minutes
2339 (wallclock time).
2340
2341 The tests are now reported in a different order than in earlier Perls.
2342 (This happens because the test scripts from under t/lib have been moved
2343 to be closer to the library/extension they are testing.)
2344
2345 =head1 Known Problems
2346
2347 =head2 AIX
2348
2349 =over 4
2350
2351 =item *
2352
2353 In AIX 4.2 Perl extensions that use C++ functions that use statics
2354 may have problems in that the statics are not getting initialized.
2355 In newer AIX releases this has been solved by linking Perl with
2356 the libC_r library, but unfortunately in AIX 4.2 the said library
2357 has an obscure bug where the various functions related to time
2358 (such as time() and gettimeofday()) return broken values, and
2359 therefore in AIX 4.2 Perl is not linked against the libC_r.
2360
2361 =item *
2362
2363 vac 5.0.0.0 May Produce Buggy Code For Perl
2364
2365 The AIX C compiler vac version 5.0.0.0 may produce buggy code,
2366 resulting in few random tests failing, but when the failing tests
2367 are run by hand, they succeed.  We suggest upgrading to at least
2368 vac version 5.0.1.0, that has been known to compile Perl correctly.
2369 "lslpp -L|grep vac.C" will tell you the vac version.
2370
2371 =back
2372
2373 =head2 Amiga Perl Invoking Mystery
2374
2375 One cannot call Perl using the C<volume:> syntax, that is, C<perl -v>
2376 works, but for example C<bin:perl -v> doesn't.  The exact reason isn't
2377 known but the current suspect is the F<ixemul> library.
2378
2379 =head2 lib/ftmp-security tests warn 'system possibly insecure'
2380
2381 Don't panic.  Read INSTALL 'make test' section instead.
2382
2383 =head2 Cygwin intermittent failures of lib/Memoize/t/expire_file 11 and 12
2384
2385 The subtests 11 and 12 sometimes fail and sometimes work.
2386
2387 =head2 HP-UX lib/io_multihomed Fails When LP64-Configured
2388
2389 The lib/io_multihomed test may hang in HP-UX if Perl has been
2390 configured to be 64-bit. Because other 64-bit platforms do not hang in
2391 this test, HP-UX is suspect. All other tests pass in 64-bit HP-UX. The
2392 test attempts to create and connect to "multihomed" sockets (sockets
2393 which have multiple IP addresses).
2394
2395 =head2  HP-UX lib/posix Subtest 9 Fails When LP64-Configured
2396
2397 If perl is configured with -Duse64bitall, the successful result of the
2398 subtest 10 of lib/posix may arrive before the successful result of the
2399 subtest 9, which confuses the test harness so much that it thinks the
2400 subtest 9 failed.
2401
2402 =head2 Linux With Sfio Fails op/misc Test 48
2403
2404 No known fix.
2405
2406 =head2 Mac OS X
2407
2408 The following tests are known to fail:
2409
2410  Failed Test                 Stat Wstat Total Fail  Failed  List of Failed
2411  -------------------------------------------------------------------------
2412  ../ext/DB_File/t/db-btree.t    0    11    ??   ??       %  ??
2413  ../ext/DB_File/t/db-recno.t              149    3   2.01%  61 63 65
2414  ../ext/POSIX/t/posix.t                    31    1   3.23%  10
2415  ../lib/warnings.t                        450    1   0.22%  316
2416
2417 =head2 OS/390
2418
2419 OS/390 has rather many test failures but the situation is actually
2420 better than it was in 5.6.0, it's just that so many new modules and
2421 tests have been added.
2422
2423  Failed Test                     Stat Wstat Total Fail  Failed  List of Failed
2424  -----------------------------------------------------------------------------
2425  ../ext/B/Deparse.t                            14    1   7.14%  14
2426  ../ext/B/Showlex.t                             1    1 100.00%  1
2427  ../ext/Encode/Encode/Tcl.t                   610   13   2.13%  592 594 596 598
2428                                                                 600 602 604-610
2429  ../ext/IO/lib/IO/t/io_unix.t     113 28928     5    3  60.00%  3-5
2430  ../ext/POSIX/POSIX.t                          29    1   3.45%  14
2431  ../ext/Storable/t/lock.t         255 65280     5    3  60.00%  3-5
2432  ../lib/locale.t                  129 33024   117   19  16.24%  99-117
2433  ../lib/warnings.t                            434    1   0.23%  75
2434  ../lib/ExtUtils.t                             27    1   3.70%  25
2435  ../lib/Math/BigInt/t/bigintpm.t             1190    1   0.08%  1145
2436  ../lib/Unicode/UCD.t                          81   48  59.26%  1-16 49-64 66-81
2437  ../lib/User/pwent.t                            9    1  11.11%  4
2438  op/pat.t                                     660    6   0.91%  242-243 424-425
2439                                                                 626-627
2440  op/split.t                         0     9    ??   ??       %  ??
2441  op/taint.t                                   174    3   1.72%  156 162 168
2442  op/tr.t                                       70    3   4.29%  50 58-59
2443  Failed 16/422 test scripts, 96.21% okay. 105/23251 subtests failed, 99.55% okay.
2444
2445 =head2 op/sprintf tests 129 and 130
2446
2447 The op/sprintf tests 129 and 130 are known to fail on some platforms.
2448 Examples include any platform using sfio, and Compaq/Tandem's NonStop-UX.
2449 The failing platforms do not comply with the ANSI C Standard, line
2450 19ff on page 134 of ANSI X3.159 1989 to be exact.  (They produce
2451 something other than "1" and "-1" when formatting 0.6 and -0.6 using
2452 the printf format "%.0f", most often they produce "0" and "-0".)
2453
2454 =head2  Failure of Thread tests
2455
2456 B<Note that support for 5.005-style threading remains experimental
2457 and practically unsupported.>
2458
2459 The following tests are known to fail due to fundamental problems in
2460 the 5.005 threading implementation. These are not new failures--Perl
2461 5.005_0x has the same bugs, but didn't have these tests.
2462
2463   ext/List/Util/t/first         2
2464   lib/autouse                   4
2465   ext/Thread/thr5005            19-20
2466
2467 These failures are unlikely to get fixed.
2468
2469 =head2 UNICOS
2470
2471 =over 4
2472
2473 =item *
2474
2475 ext/POSIX/sigaction subtests 6 and 13 may fail.
2476
2477 =item *
2478
2479 lib/ExtUtils may spuriously claim that subtest 28 failed,
2480 which is interesting since the test only has 27 tests.
2481
2482 =item *
2483
2484 Numerous numerical test failures
2485
2486   op/numconvert                 209,210,217,218
2487   op/override                   7
2488   ext/Time/HiRes/HiRes          9
2489   lib/Math/BigInt/t/bigintpm    1145
2490   lib/Math/Trig                 25
2491
2492 These tests fail because of yet unresolved floating point inaccuracies.
2493
2494 =back
2495
2496 =head2 UTS
2497
2498 There are a few known test failures, see L<perluts>.
2499
2500 =head2 VMS
2501
2502 There is one known test failure with a default configuration:
2503
2504   [.run]switches..........................FAILED on test 1
2505
2506 =head2 Win32
2507
2508 In multi-CPU boxes there are some problems with the I/O buffering:
2509 some output may appear twice.
2510
2511 =head2 Localising a Tied Variable Leaks Memory
2512
2513     use Tie::Hash;
2514     tie my %tie_hash => 'Tie::StdHash';
2515
2516     ...
2517
2518     local($tie_hash{Foo}) = 1; # leaks
2519
2520 Code like the above is known to leak memory every time the local()
2521 is executed.
2522
2523 =head2 Localising Tied Arrays and Hashes Is Broken
2524
2525     local %tied_array;
2526
2527 doesn't work as one would expect: the old value is restored
2528 incorrectly.
2529
2530 =head2 Self-tying of Arrays and Hashes Is Forbidden
2531
2532 Self-tying of arrays and hashes is broken in rather deep and
2533 hard-to-fix ways.  As a stop-gap measure to avoid people from getting
2534 frustrated at the mysterious results (core dumps, most often) it is
2535 for now forbidden (you will get a fatal error even from an attempt).
2536
2537 =head2 Building Extensions Can Fail Because Of Largefiles
2538
2539 Some extensions like mod_perl are known to have issues with
2540 `largefiles', a change brought by Perl 5.6.0 in which file offsets
2541 default to 64 bits wide, where supported.  Modules may fail to compile
2542 at all or compile and work incorrectly.  Currently there is no good
2543 solution for the problem, but Configure now provides appropriate
2544 non-largefile ccflags, ldflags, libswanted, and libs in the %Config
2545 hash (e.g., $Config{ccflags_nolargefiles}) so the extensions that are
2546 having problems can try configuring themselves without the
2547 largefileness.  This is admittedly not a clean solution, and the
2548 solution may not even work at all.  One potential failure is whether
2549 one can (or, if one can, whether it's a good idea) link together at
2550 all binaries with different ideas about file offsets, all this is
2551 platform-dependent.
2552
2553 =head2 Unicode Support on EBCDIC Still Spotty
2554
2555 Though mostly working, Unicode support still has problem spots on
2556 EBCDIC platforms.  One such known spot are the C<\p{}> and C<\P{}>
2557 regular expression constructs for code points less than 256: the
2558 pP are testing for Unicode code points, not knowing about EBCDIC.
2559
2560 =head2 The Compiler Suite Is Still Experimental
2561
2562 The compiler suite is slowly getting better but it continues to be
2563 highly experimental.  Use in production environments is discouraged.
2564
2565 =head2 The Long Double Support Is Still Experimental
2566
2567 The ability to configure Perl's numbers to use "long doubles",
2568 floating point numbers of hopefully better accuracy, is still
2569 experimental.  The implementations of long doubles are not yet
2570 widespread and the existing implementations are not quite mature
2571 or standardised, therefore trying to support them is a rare
2572 and moving target.  The gain of more precision may also be offset
2573 by slowdown in computations (more bits to move around, and the
2574 operations are more likely to be executed by less optimised
2575 libraries).
2576
2577 =head2 Seen In Perl 5.7 But Gone Now
2578
2579 Some modules were seen in the Perl 5.7 development releases
2580 but are not present in 5.8.0.
2581
2582 =over 4
2583
2584 =item *
2585
2586 C<Attribute::Handlers> was removed because the implementation of C<my>
2587 variable attributes changed so much that the Attribute::Handlers will
2588 require a major rewrite.  (This means that you can't use
2589 Attribute::Handler 0.76 with Perl 5.8.0.)
2590
2591 =item *
2592
2593 C<Time::Piece> (previously known as C<Time::Object>) was removed
2594 because it was felt that it didn't have enough value in it to be a
2595 core module.  It is still a useful module, though, and is available
2596 from the CPAN.
2597
2598 =back
2599
2600 =head1 Reporting Bugs
2601
2602 If you find what you think is a bug, you might check the articles
2603 recently posted to the comp.lang.perl.misc newsgroup and the perl
2604 bug database at http://bugs.perl.org.  There may also be
2605 information at http://www.perl.com/, the Perl Home Page.
2606
2607 If you believe you have an unreported bug, please run the B<perlbug>
2608 program included with your release.  Be sure to trim your bug down
2609 to a tiny but sufficient test case.  Your bug report, along with the
2610 output of C<perl -V>, will be sent off to perlbug@perl.org to be
2611 analysed by the Perl porting team.
2612
2613 =head1 SEE ALSO
2614
2615 The F<Changes> file for exhaustive details on what changed.
2616
2617 The F<INSTALL> file for how to build Perl.
2618
2619 The F<README> file for general stuff.
2620
2621 The F<Artistic> and F<Copying> files for copyright information.
2622
2623 =head1 HISTORY
2624
2625 Written by Jarkko Hietaniemi <F<jhi@iki.fi>>.
2626
2627 =cut