begin filling the 5.16.0 delta from 5.15.2
[perl.git] / Porting / perl5160delta.pod
1 =encoding utf8
2
3 =head1 NAME
4
5 perl5160delta - what is new for perl v5.16.0
6
7 =head1 DESCRIPTION
8
9 This document describes differences between the 5.14.0 release and
10 the 5.16.0 release.
11
12 If you are upgrading from an earlier release such as 5.12.0, first read
13 L<perl5140delta>, which describes differences between 5.12.0 and
14 5.14.0.
15
16 =head1 Notice
17
18 XXX Any important notices here
19
20 =head1 Core Enhancements
21
22 =head2 C<CORE::> works on all keywords
23
24 The C<CORE::> prefix can now be used on keywords enabled by
25 L<feature.pm|feature>, even outside the scope of C<use feature>.  Relevant
26 documentation files L<CORE>, L<feature>, L<perlfunc>, L<perlsub>, and
27 L<perlsyn> have been updated.
28
29 =head2 C<continue> no longer requires the "switch" feature
30
31 The C<continue> keyword has two meanings.  It can introduce a C<continue>
32 block after a loop, or it can exit the current C<when> block.  Up till now,
33 the latter meaning was only valid with the "switch" feature enabled, and
34 was a syntax error otherwise.  Since the main purpose of feature.pm is to
35 avoid conflicts with user-defined subroutines, there is no reason for
36 C<continue> to depend on it.
37
38 =head2 C<$$> can be assigned to
39
40 C<$$> was made read-only in Perl 5.8.0.  But only sometimes: C<local $$>
41 would make it writable again.  Some CPAN modules were using C<local $$> or
42 XS code to bypass the read-only check, so there is no reason to keep C<$$>
43 read-only.  (This change also allowed a bug to be fixed while maintaining
44 backward compatibility.)
45
46 =head2 Features inside the debugger
47
48 The current Perl's feature bundle is now enabled for commands entered in
49 the interactive debugger.
50
51 =head2 C<\N{...}> can now have Unicode loose name matching
52
53 This is described in the C<charnames> item in
54 L</Updated Modules and Pragmata> below.
55
56 =head2 Breakpoints with file names
57
58 The debugger's "b" command for setting breakpoints now allows a line number
59 to be prefixed with a file name.  See
60 L<perldebug/"b [file]:[line] [condition]">.
61
62 =head2 C<splice()> doesn't warn when truncating
63
64 You can now limit the size of an array using C<splice(@a,MAX_LEN)> without
65 worrying about warnings.
66
67 =head2 The C<\$> prototype accepts any scalar lvalue
68
69 The C<\$> and C<\[$]> subroutine prototypes now accept any scalar lvalue
70 argument.  Previously they only accepted scalars beginning with C<$> and
71 hash and array elements.  This change makes them consistent with the way
72 the built-in C<read> and C<recv> functions (among others) parse their
73 arguments. This means that one can override the built-in functions with
74 custom subroutines that parse their arguments the same way.
75
76 =head2 You can now C<study> more than one string
77
78 The restriction that you can only have one C<study> active at a time has been
79 removed. You can now usefully C<study> as many strings as you want (until you
80 exhaust memory).
81
82 =head2 The Unicode C<Script_Extensions> property is now supported.
83
84 New in Unicode 6.0, this is an improved C<Script> property.  Details
85 are in L<perlunicode/Scripts>.
86
87 =head2 DTrace probes for interpreter phase change
88
89 The C<phase-change> probes will fire when the interpreter's phase
90 changes, which tracks the C<${^GLOBAL_PHASE}> variable. C<arg0> is
91 the new phase name; C<arg1> is the old one. This is useful mostly
92 for limiting your instrumentation to one or more of: compile time,
93 run time, destruct time.
94
95 =head2 New Pad API
96
97 Many new functions have been added to the API for manipulating lexical
98 pads.  See L<perlapi/Pad Data Structures> for more information.
99
100 =head2 Subroutines in the CORE namespace
101
102 Many Perl keywords are now available as subroutines in the CORE namespace.
103 Most of these cannot be called through references or via C<&foo> syntax
104 yet, but must be called as barewords.  In other words, you can now do
105 this:
106
107     BEGIN { *entangle = \&CORE::tie }
108     entangle $variable, $package, @args;
109
110 This currently works for overridable keywords other than C<dump> and the
111 infix operators.  Calling through references only works for functions that
112 take no arguments (like C<wantarray>).
113
114 Work is under way to allow more of these subroutines to be called through
115 references.
116
117 =head2 C<__FILE__()> Syntax
118
119 The C<__FILE__>, C<__LINE__> and C<__PACKAGE__> tokens can now be written
120 with an empty pair of parentheses after them.  This makes them parse the
121 same way as C<time>, C<fork> and other built-in functions.
122
123 =head1 Security
124
125 XXX Any security-related notices go here.  In particular, any security
126 vulnerabilities closed should be noted here rather than in the
127 L</Selected Bug Fixes> section.
128
129 [ List each security issue as a =head2 entry ]
130
131 =head1 Incompatible Changes
132
133 =head2 Tying scalars that hold typeglobs
134
135 Attempting to tie a scalar after a typeglob was assigned to it would
136 instead tie the handle in the typeglob's IO slot.  This meant that it was
137 impossible to tie the scalar itself.  Similar problems affected C<tied> and
138 C<untie>: C<tied $scalar> would return false on a tied scalar if the last
139 thing returned was a typeglob, and C<untie $scalar> on such a tied scalar
140 would do nothing.
141
142 We fixed this problem before Perl 5.14.0, but it caused problems with some
143 CPAN modules, so we put in a deprecation cycle instead.
144
145 Now the deprecation has been removed and this bug has been fixed.  So
146 C<tie $scalar> will always tie the scalar, not the handle it holds.  To tie
147 the handle, use C<tie *$scalar> (with an explicit asterisk).  The same
148 applies to C<tied *$scalar> and C<untie *$scalar>.
149
150 =head2 IPC::Open3 no longer provides C<xfork()>, C<xclose_on_exec()>
151 and C<xpipe_anon()>
152
153 All three functions were private, undocumented and unexported.  They do
154 not appear to be used by any code on CPAN.  Two have been inlined and one
155 deleted entirely.
156
157 =head2 C<$$> no longer caches PID
158
159 Previously, if one embeds Perl or uses XS and calls fork(3) from C, Perls
160 notion of C<$$> could go out of sync with what getpid() returns. By always
161 fetching the value of C<$$> via getpid(), this potential bug is eliminated.
162 Code that depends on the caching behavior will break.  As described in
163 L</Core Enhancements>, C<$$> is now writable, but it will be reset during a
164 fork.
165
166 =head1 Deprecations
167
168 XXX Any deprecated features, syntax, modules etc. should be listed here.
169 In particular, deprecated modules should be listed here even if they are
170 listed as an updated module in the L</Modules and Pragmata> section.
171
172 [ List each deprecation as a =head2 entry ]
173
174 =head1 Future Deprecations
175
176 This section serves as a notice of feature that are I<likely> to be
177 L<deprecated|perlpolicy/deprecated> in the next release of perl (5.18.0).  If
178 your code depends on these features, you should contact the Perl 5 Porters via
179 the L<mailing list|http://lists.perl.org/list/perl5-porters.html> or L<perlbug>
180 to explain your use case and inform the deprecation process.
181
182 =head1 Performance Enhancements
183
184 =over 4
185
186 =item *
187
188 The short-circuiting operators C<&&>, C<||>, and C<//>, when chained
189 (such as C<$a || $b || $c>), are now considerably faster to short-circuit,
190 due to reduced optree traversal.
191
192 =item *
193
194 The implementation of C<s///r> makes one fewer copy of the scalar's value.
195
196 =item *
197
198 If a studied scalar is C<split> with a regex, the engine will now take
199 advantage of the C<study> data.
200
201 =item *
202
203 C<study> now uses considerably less memory for shorter strings. Strings shorter
204 than 65535 characters use roughly half the memory than previously, strings
205 shorter than 255 characters use roughly one quarter of the memory.
206
207 =item *
208
209 Recursive calls to lvalue subroutines in lvalue scalar context use less
210 memory.
211
212 =back
213
214 =head1 Modules and Pragmata
215
216 XXX All changes to installed files in F<cpan/>, F<dist/>, F<ext/> and F<lib/>
217 go here.  If Module::CoreList is updated, generate an initial draft of the
218 following sections using F<Porting/corelist-perldelta.pl>, which prints stub
219 entries to STDOUT.  Results can be pasted in place of the '=head2' entries
220 below.  A paragraph summary for important changes should then be added by hand.
221 In an ideal world, dual-life modules would have a F<Changes> file that could be
222 cribbed.
223
224 [ Within each section, list entries as a =item entry ]
225
226 =head2 New Modules and Pragmata
227
228 =over 4
229
230 =item *
231
232 XXX
233
234 =back
235
236 =head2 Updated Modules and Pragmata
237
238 =over 4
239
240 =item *
241
242 L<XXX> has been upgraded from version 0.69 to version 0.70.
243
244 =back
245
246 =head2 Removed Modules and Pragmata
247
248 As promised in Perl 5.14.0's release notes, the following modules have
249 been removed from the core distribution, and if needed should be installed
250 from CPAN instead.
251
252 =over
253
254 =item *
255
256 C<Devel::DProf> has been removed from the Perl core.  Prior version was 20110228.00.
257
258 =item *
259
260 C<Shell> has been removed from the Perl core.  Prior version was 0.72_01.
261
262 =back
263
264 =head1 Documentation
265
266 =head2 New Documentation
267
268 =head3 L<perldtrace>
269
270 L<perldtrace> describes Perl's DTrace support, listing the provided probes
271 and gives examples of their use.
272
273 =head3 L<perlexperiment>
274
275 This document is intended to provide a list of experimental features in
276 Perl.  It is still a work in progress.
277
278 =head2 Changes to Existing Documentation
279
280 =head3 L<perlguts>
281
282 =over
283
284 =item *
285
286 Some of the function descriptions in L<perlguts> were confusing, as it was
287 not clear whether they referred to the function above or below the
288 description.  This has been clarified [perl #91790].
289
290 =back
291
292 =head3 L<perllol>
293
294 =over
295
296 =item *
297
298 L<perllol> has been expanded with examples using the new C<push $scalar>
299 syntax introduced in Perl 5.14.0 (5.14.1).
300
301 =back
302
303 =head3 L<perlmod>
304
305 =over
306
307 =item *
308
309 L<perlmod> now states explicitly that some types of explicit symbol table
310 manipulation are not supported.  This codifies what was effectively already
311 the case [perl #78074].
312
313 =back
314
315 =head3 L<perlop>
316
317 =over 4
318
319 =item *
320
321 The explanation of bitwise operators has been expanded to explain how they
322 work on Unicode strings (5.14.1).
323
324 =item *
325
326 The section on the triple-dot or yada-yada operator has been moved up, as
327 it used to separate two closely related sections about the comma operator
328 (5.14.1).
329
330 =item *
331
332 More examples for C<m//g> have been added (5.14.1).
333
334 =item *
335
336 The C<<< <<\FOO >>> here-doc syntax has been documented (5.14.1).
337
338 =back
339
340 =head3 L<perlpodstyle>
341
342 =over 4
343
344 =item *
345
346 The tips on which formatting codes to use have been corrected and greatly
347 expanded.
348
349 =item *
350
351 There are now a couple of example one-liners for previewing POD files after
352 they have been edited.
353
354 =back
355
356 =head3 L<perlsub>
357
358 =over
359
360 =item *
361
362 The L<perlsub/"Lvalue subroutines"> section has been amended to reflect
363 changes and bug fixes introduced in Perl 5.15.0.
364
365 =item *
366
367 The ($;) prototype syntax, which has existed for rather a long time, is now
368 documented in L<perlsub>.  It allows a unary function to have the same
369 precedence as a list operator.
370
371 =back
372
373 =head3 L<perlre>
374
375 =over
376
377 =item *
378
379 The C<(*COMMIT)> directive is now listed in the right section
380 (L<Verbs without an argument|perlre/Verbs without an argument>).
381
382 =back
383
384 =head3 L<perlrun>
385
386 =over
387
388 =item *
389
390 L<perlrun> has undergone a significant clean-up.  Most notably, the
391 B<-0x...> form of the B<-0> flag has been clarified, and the final section
392 on environment variables has been corrected and expanded (5.14.1).
393
394 =back
395
396 =head3 L<perltie>
397
398 =over
399
400 =item *
401
402 Documented the required syntax for tying handles.
403
404 =back
405
406 =head3 L<perlvar>
407
408 =over
409
410 =item *
411
412 The documentation for L<$!|perlvar/$!> has been corrected and clarified.
413 It used to state that $! could be C<undef>, which is not the case.  It was
414 also unclear as to whether system calls set C's C<errno> or Perl's C<$!>
415 [perl #91614].
416
417 =item *
418
419 Documentation for L<$$|perlvar/$$> has been amended with additional
420 cautions regarding changing the process ID.
421
422 =back
423
424 =over 4
425
426 =item *
427
428 L<perlxs> was extended with documentation on inline typemaps.
429
430 =item *
431
432 L<perlref> has a new L<Circular References|perlref/Circular References>
433 section explaining how circularities may not be freed and how to solve that
434 with weak references.
435
436 =item *
437
438 The documentation for smart match in L<perlsyn> has been corrected for the
439 case of C<undef> on the left-hand side.  The list of different smart match
440 behaviours had an item in the wrong place.
441
442 =item *
443
444 Parts of L<perlapi> were clarified, and Perl equivalents of some C
445 functions have been added as an additional mode of exposition.
446
447 =item *
448
449 A few parts of L<perlre> and L<perlrecharclass> were clarified.
450
451 =back
452
453 =head1 Diagnostics
454
455 The following additions or changes have been made to diagnostic output,
456 including warnings and fatal error messages.  For the complete list of
457 diagnostic messages, see L<perldiag>.
458
459 XXX New or changed warnings emitted by the core's C<C> code go here. Also
460 include any changes in L<perldiag> that reconcile it to the C<C> code.
461
462 [ Within each section, list entries as a =item entry that links to perldiag,
463   e.g.
464
465   =item *
466
467   L<Invalid version object|perldiag/"Invalid version object">
468 ]
469
470 =head2 New Diagnostics
471
472 XXX Newly added diagnostic messages go here
473
474 =head3 New Errors
475
476 =over 4
477
478 =item *
479
480 L<&CORE::%s cannot be called directly|perldiag/"&CORE::%s cannot be called directly">
481
482 (F) You tried to call a subroutine in the C<CORE::> namespace
483 with C<&foo> syntax or through a reference.  The subroutines
484 in this package cannot yet be called that way, but must be
485 called as barewords.  Something like this will work:
486
487     BEGIN { *shove = \&CORE::push; }
488     shove @array, 1,2,3; # pushes on to @array
489
490 =back
491
492 =head3 New Warnings
493
494 =over 4
495
496 =item L<Useless assignment to a temporary|perldiag/"Useless assignment to a temporary">
497
498 Assigning to a temporary returned from an XS lvalue subroutine now produces a
499 warning [perl #31946].
500
501 =back
502
503 =head2 Changes to Existing Diagnostics
504
505 =over 4
506
507 =item *
508
509 The L<Invalid version format|perldiag/"Invalid version format (%s)">
510 error message now says "negative version number" within the parentheses,
511 rather than "non-numeric data", for negative numbers.
512
513 =item *
514
515 The two warnings
516 L<Possible attempt to put comments in qw() list|perldiag/"Possible attempt to put comments in qw() list">
517 and
518 L<Possible attempt to separate words with commas|perldiag/"Possible attempt to separate words with commas">
519 are no longer mutually exclusive: the same C<qw> construct may produce
520 both.
521
522 =item *
523
524 Warnings that mention the names of lexical (C<my>) variables with Unicode
525 characters in them now respect the presence or absence of the C<:utf8>
526 layer on the output handle, instead of outputting UTF8 regardless.  Also,
527 the correct names are included in the strings passed to C<$SIG{__WARN__}>
528 handlers, rather than the raw UTF8 bytes.
529
530 =back
531
532 =over 4
533
534 =item *
535
536 XXX Describe change here
537
538 =back
539
540 =head1 Utility Changes
541
542 XXX Changes to installed programs such as F<perlbug> and F<xsubpp> go
543 here. Most of these are built within the directories F<utils> and F<x2p>.
544
545 [ List utility changes as a =head3 entry for each utility and =item
546 entries for each change
547 Use L<XXX> with program names to get proper documentation linking. ]
548
549 =head3 L<XXX>
550
551 =over 4
552
553 =item *
554
555 XXX
556
557 =back
558
559 =head1 Configuration and Compilation
560
561 =over 4
562
563 =item *
564
565 F<regexp.h> has been modified for compatibility with GCC's B<-Werror>
566 option, as used by some projects that include perl's header files (5.14.1).
567
568 =item *
569
570 C<USE_LOCALE{,_COLLATE,_CTYPE,_NUMERIC}> have been added the output of perl -V
571 as they have affect the behaviour of the interpreter binary (albeit only
572 in a small area).
573
574 =item *
575
576 The code and tests for L<IPC::Open2> have been moved from F<ext/IPC-Open2>
577 into F<ext/IPC-Open3>, as C<IPC::Open2::open2()> is implemented as a thin
578 wrapper around C<IPC::Open3::_open3()>, and hence is very tightly coupled to
579 it.
580
581 =item *
582
583 The magic types and magic vtables are now generated from data in a new script
584 F<regen/mg_vtable.pl>, instead of being maintained by hand. As different EBCDIC
585 variants can't agree on the code point for '~', the character to code point
586 conversion is done at build time by F<generate_uudmap> to a new generated header
587 F<mg_data.h>. C<PL_vtbl_bm> and C<PL_vtbl_fm> are now defined by the
588 pre-processor as C<PL_vtbl_regexp>, instead of being distinct C variables.
589 C<PL_vtbl_sig> has been removed.
590
591 =item *
592
593 Building with C<-DPERL_GLOBAL_STRUCT> works again. This configuration is not
594 generally used.
595
596 =item *
597
598 Perl configured with I<MAD> now correctly frees C<MADPROP> structures when
599 OPs are freed. C<MADPROP>s are now allocated with C<PerlMemShared_malloc()>
600
601 =back
602
603 =head1 Testing
604
605 XXX Any significant changes to the testing of a freshly built perl should be
606 listed here.  Changes which create B<new> files in F<t/> go here as do any
607 large changes to the testing harness (e.g. when parallel testing was added).
608 Changes to existing files in F<t/> aren't worth summarising, although the bugs
609 that they represent may be covered elsewhere.
610
611 [ List each test improvement as a =item entry ]
612
613 =over 4
614
615 =item *
616
617 XXX
618
619 =back
620
621 =head1 Platform Support
622
623 XXX Any changes to platform support should be listed in the sections below.
624
625 [ Within the sections, list each platform as a =item entry with specific
626 changes as paragraphs below it. ]
627
628 =head2 New Platforms
629
630 XXX List any platforms that this version of perl compiles on, that previous
631 versions did not. These will either be enabled by new files in the F<hints/>
632 directories, or new subdirectories and F<README> files at the top level of the
633 source tree.
634
635 =over 4
636
637 =item XXX-some-platform
638
639 XXX
640
641 =back
642
643 =head2 Discontinued Platforms
644
645 XXX List any platforms that this version of perl no longer compiles on.
646
647 =over 4
648
649 =item XXX-some-platform
650
651 XXX
652
653 =back
654
655 =head2 Platform-Specific Notes
656
657 XXX List any changes for specific platforms. This could include configuration
658 and compilation changes or changes in portability/compatibility.  However,
659 changes within modules for platforms should generally be listed in the
660 L</Modules and Pragmata> section.
661
662 =over 4
663
664 =item XXX-some-platform
665
666 XXX
667
668 =back
669
670 =head1 Internal Changes
671
672 XXX Changes which affect the interface available to C<XS> code go here.
673 Other significant internal changes for future core maintainers should
674 be noted as well.
675
676 [ List each change as a =item entry ]
677
678 =over 4
679
680 =item *
681
682 XXX
683
684 =back
685
686 =head1 Selected Bug Fixes
687
688 =head2 Regular expressions and character classes
689
690 =over 4
691
692 =item *
693
694 The new (in 5.14.0) regular expression modifier C</a> when repeated like
695 C</aa> forbids the characters outside the ASCII range that match
696 characters inside that range from matching under C</i>.  This did not
697 work under some circumstances, all involving alternation, such as:
698
699  "\N{KELVIN SIGN}" =~ /k|foo/iaa;
700
701 succeeded inappropriately.  This is now fixed.
702
703 =item *
704
705 5.14.0 introduced some memory leaks in regular expression character
706 classes such as C<[\w\s]>, which have now been fixed (5.14.1)
707
708 =item *
709
710 An edge case in regular expression matching could potentially loop.
711 This happened only under C</i> in bracketed character classes that have
712 characters with multi-character folds, and the target string to match
713 against includes the first portion of the fold, followed by another
714 character that has a multi-character fold that begins with the remaining
715 portion of the fold, plus some more.
716
717  "s\N{U+DF}" =~ /[\x{DF}foo]/i
718
719 is one such case.  C<\xDF> folds to C<"ss">. (5.14.1)
720
721 =item *
722
723 A few characters in regular expression pattern matches did not
724 match correctly in some circumstances, all involving C</i>.  The
725 affected characters are:
726 COMBINING GREEK YPOGEGRAMMENI,
727 GREEK CAPITAL LETTER IOTA,
728 GREEK CAPITAL LETTER UPSILON,
729 GREEK PROSGEGRAMMENI,
730 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA,
731 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS,
732 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA,
733 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS,
734 LATIN SMALL LETTER LONG S,
735 LATIN SMALL LIGATURE LONG S T,
736 and
737 LATIN SMALL LIGATURE ST.
738
739 =item *
740
741 Fixed memory leak regression in regular expression compilation
742 under threading
743
744 =back
745
746 =head2 Formats
747
748 =over
749
750 =item *
751
752 A number of edge cases have been fixed with formats and C<formline>;
753 in particular, where the format itself is potentially variable (such as
754 with ties and overloading), and where the format and data differ in their
755 encoding. In both these cases, it used to possible for the output to be
756 corrupted [perl #91032].
757
758 =item *
759
760 C<formline> no longer converts its argument into a string in-place.  So
761 passing a reference to C<formline> no longer destroys the reference
762 [perl #79532].
763
764 =back
765
766 =head2 Copy-on-write scalars
767
768 Copy-on-write scalars were introduced in 5.8.0, but most Perl code
769 did not encounter them (they were used mostly internally).  Perl
770 5.10.0 extended them, such that assigning C<__PACKAGE__> or a
771 hash key to a scalar would make it copy-on-write.  Several parts
772 of Perl were not updated to account for them, but have now been fixed.
773
774 =over
775
776 =item *
777
778 C<utf8::decode> had a nasty bug that would modify copy-on-write scalars'
779 string buffers in place (i.e., skipping the copy).  This could result in
780 hashes having two elements with the same key [perl #91834].
781
782 =item *
783
784 Lvalue subroutines were not allowing COW scalars to be returned.  This was
785 fixed for lvalue scalar context in Perl 5.12.3 and 5.14.0, but list context
786 was not fixed until this release.
787
788 =item *
789
790 Elements of restricted hashes (see the L<fields> pragma) containing
791 copy-on-write values couldn't be deleted, nor could such hashes be cleared
792 (C<%hash = ()>).
793
794 =item *
795
796 Localising a tied variable used to make it read-only if it contained a
797 copy-on-write string.
798
799 =item *
800
801 L<Storable>, L<Devel::Peek> and L<PerlIO::scalar> had similar problems.
802 See L</Updated Modules and Pragmata>, above.
803
804 =back
805
806 =head2 lvalue subroutines
807
808 There have been various fixes to lvalue subroutines.
809
810 =over
811
812 =item *
813
814 Explicit return now returns the actual argument passed to return, instead
815 of copying it [perl #72724] [perl #72706].
816
817 B<Note:> There are still some discrepancies between explicit and implicit
818 return, which will hopefully be resolved soon.  So the exact behaviour is
819 not set in stone yet.
820
821 =item *
822
823 Lvalue subroutines used to enforce lvalue syntax (i.e., whatever can go on
824 the left-hand side of C<=>) for the last statement and the arguments to
825 return.  Since lvalue subroutines are not always called in lvalue context,
826 this restriction has been lifted.
827
828 =item *
829
830 Lvalue subroutines are less restrictive as to what values can be returned.
831 It used to croak on values returned by C<shift> and C<delete> and from
832 other subroutines, but no longer does so [perl #71172].
833
834 =item *
835
836 Empty lvalue subroutines (C<sub :lvalue {}>) used to return C<@_> in list
837 context.  In fact, all subroutines used to, but regular subs were fixed in
838 Perl 5.8.2.  Now lvalue subroutines have been likewise fixed.
839
840 =item *
841
842 Lvalue subroutines used to copy their return values in rvalue context.  Not
843 only was this a waste of CPU cycles, but it also caused bugs.  A C<($)>
844 prototype would cause an lvalue sub to copy its return value [perl #51408],
845 and C<while(lvalue_sub() =~ m/.../g) { ... }> would loop endlessly
846 [perl #78680].
847
848 =item *
849
850 Autovivification now works on values returned from lvalue subroutines
851 [perl #7946].
852
853 =item *
854
855 When called in pass-by-reference context (e.g., subroutine arguments or a list
856 passed to C<for>), an lvalue subroutine returning arrays or hashes used to bind
857 the arrays (or hashes) to scalar variables--something that is not supposed to
858 happen.  This could result in "Bizarre copy of ARRAY" errors or C<print>
859 ignoring its arguments.  It also made nonsensical code like C<@{\$_}> "work".
860 This was fixed in 5.14.0 if an array were the first thing returned from the
861 subroutine (but not for C<$scalar, @array> or hashes being returned).  Now a
862 more general fix has been applied [perl #23790].
863
864 =item *
865
866 When called in pass-by-reference context, lvalue subroutines used to copy
867 any read-only value that was returned.  E.g., C< sub :lvalue { $] } >
868 would not return C<$]>, but a copy of it.
869
870 =item *
871
872 Assignment to C<keys> returned from an lvalue sub used not to work, but now
873 it does.
874
875 =item *
876
877 Applying the C<:lvalue> attribute to an XSUB or to an aliased subroutine
878 stub with C<< sub foo :lvalue; >> syntax stopped working in Perl 5.12.
879 This has been fixed.
880
881 =back
882
883 =head2 Fixes related to hashes
884
885 =over
886
887 =item *
888
889 A bug has been fixed that would cause a "Use of freed value in iteration"
890 error if the next two hash elements that would be iterated over are
891 deleted [perl #85026]. (5.14.1)
892
893 =item *
894
895 Freeing deeply nested hashes no longer crashes [perl #44225].
896
897 =item *
898
899 Deleting the current hash iterator (the hash element that would be returend
900 by the next call to C<each>) in void context used not to free it.  The hash
901 would continue to reference it until the next iteration.  This has been
902 fixed [perl #85026].
903
904 =back
905
906 =head2 Other notable fixes
907
908 =over
909
910 =item *
911
912 Passing the same constant subroutine to both C<index> and C<formline> no
913 longer causes one or the other to fail [perl #89218]. (5.14.1)
914
915 =item *
916
917 List assignment to lexical variables declared with attributes in the same
918 statement (C<my ($x,@y) : blimp = (72,94)>) stopped working in Perl 5.8.0.
919 It has now been fixed.
920
921 =item *
922
923 Perl 5.10.0 introduced some faulty logic that made "U*" in the middle of
924 a pack template equivalent to "U0" if the input string was empty.  This has
925 been fixed [perl #90160].
926
927 =item *
928
929 Destructors on objects were not called during global destruction on objects
930 that were not referenced by any scalars.  This could happen if an array
931 element were blessed (e.g., C<bless \$a[0]>) or if a closure referenced a
932 blessed variable (C<bless \my @a; sub foo { @a }>).
933
934 Now there is an extra pass during global destruction to fire destructors on
935 any objects that might be left after the usual passes that check for
936 objects referenced by scalars [perl #36347].
937
938 This bug fix was added in Perl 5.13.9, but caused problems with some CPAN
939 modules that were relying on the bug.  Since it was so close to Perl
940 5.14.0, the fix was reverted in 5.13.10, to allow more time for the modules
941 to adapt.  Hopefully they will be fixed soon (see L</Known Problems>,
942 below).
943
944 =item *
945
946 C<given> was not calling set-magic on the implicit lexical C<$_> that it
947 uses.  This meant, for example, that C<pos> would be remembered from one
948 execution of the same C<given> block to the next, even if the input were a
949 different variable [perl #84526].
950
951 =item *
952
953 The "R" command for restarting a debugger session has been fixed to work on
954 Windows, or any other system lacking a C<POSIX::_SC_OPEN_MAX> constant
955 [perl #87740].
956
957 =item *
958
959 Fixed a case where it was possible that a freed buffer may have been read
960 from when parsing a here document [perl #90128]. (5.14.1)
961
962 =item *
963
964 The C<study> function could become confused if fed a string longer than
965 2**31 characters.  Now it simply skips such strings.
966
967 =item *
968
969 C<each(I<ARRAY>)> is now wrapped in C<defined(...)>, like C<each(I<HASH>)>,
970 inside a C<while> condition [perl #90888].
971
972 =item *
973
974 In @INC filters (subroutines returned by subroutines in @INC), $_ used to
975 misbehave: If returned from a subroutine, it would not be copied, but the
976 variable itself would be returned; and freeing $_ (e.g., with C<undef *_>)
977 would cause perl to crash.  This has been fixed [perl #91880].
978
979 =item *
980
981 An ASCII single quote (') in a symbol name is meant to be equivalent to a
982 double colon (::) except at the end of the name.  It was not equivalent if
983 followed by a null character, but now it is [perl #88138].
984
985 =item *
986
987 The abbreviations for four C1 control characters
988 C<MW>
989 C<PM>,
990 C<RI>,
991 and
992 C<ST>
993 were previously unrecognized by C<\N{}>,
994 vianame(), and string_vianame().
995
996 =item *
997
998 Some cases of threads crashing due to memory allocation during cloning have
999 been fixed [perl #90006].
1000
1001 =item *
1002
1003 Attempting to C<goto> out of a tied handle method used to cause memory
1004 corruption or crashes.  Now it produces an error message instead
1005 [perl #8611].
1006
1007 =item *
1008
1009 Perl skips copying values returned from a subroutine if it thinks the value
1010 is not in use elsewhere.  Due to faulty logic, this would happen with the
1011 result of C<delete>, C<shift> or C<splice>, even if the result was
1012 referenced elsewhere.  So C<< \sub { delete $_[0] }->($x) >> would return a
1013 reference to C<$x>.  This has been fixed [perl #91844].
1014
1015 =item *
1016
1017 Applying the :lvalue attribute to subroutine that is already defined does
1018 not work properly, as the attribute changes the way the sub is compiled.
1019 Hence, Perl 5.12 began warning when an attempt is made to apply the
1020 attribute to an already defined sub.  In such cases, the attribute is
1021 discarded.
1022
1023 But the change in 5.12 missed the case where custom attributes are also
1024 present: that case still silently and ineffectively applied the attribute.
1025 That omission has now been corrected.  C<sub foo :lvalue :Whatever> (when
1026 C<foo> is already defined) now warns about the :lvalue attribute, and does
1027 not apply it.
1028
1029 L<attributes.pm|attributes> has likewise been updated to warn and not apply
1030 the attribute.
1031
1032 =item *
1033
1034 The remaining discrepancies between explicit and implicit return from
1035 lvalue subroutines have been resolved.  They mainly involved which error
1036 message to display when a read-only value is returned in lvalue context.
1037 Also, returning a PADTMP (the result of most built-ins, like C<index>) in
1038 lvalue context is now forbidden for explicit return, as it always has been
1039 for implicit return.  This is not a regression from 5.14, as all the cases
1040 in which it could happen where previously syntax errors.
1041
1042 =item *
1043
1044 Explicitly returning a tied C<my> variable from an lvalue subroutine in
1045 list lvalue context used to clear the variable before the assignment could
1046 happen.  This is something that was missed when explicit return was made to
1047 work in 5.15.0.
1048
1049 =item *
1050
1051 A minor memory leak, introduced in 5.15.0, has been fixed.  It would occur
1052 when a hash is freed that has had its current iterator deleted
1053 [perl #93454].
1054
1055 =item *
1056
1057 The C<prototype> function no longer dies for the C<__FILE__>, C<__LINE__>
1058 and C<__PACKAGE__> directives.  It now returns an empty-string prototype
1059 for them, because they are syntactically very similar to nullary functions
1060 like C<time>.
1061
1062 =item *
1063
1064 C<prototype> now returns C<undef> for all overridable infix operators,
1065 such as C<eq>, which are not callable in any way resembling functions.
1066 It used to return incorrect prototypes for some and die for others
1067 [perl #94984].
1068
1069 =item *
1070
1071 A bug affecting lvalue context propagation through nested lvalue subroutine
1072 calls has been fixed.  Previously, returning a value in nested rvalue
1073 context would be treated as lvalue context by the inner subroutine call,
1074 resulting in some values (such as read-only values) being rejected.
1075
1076 =item *
1077
1078 Some core bugs affecting L<Hash::Util> have been fixed: locking a hash
1079 element that is a glob copy no longer causes subsequent assignment to it to
1080 corrupt the glob, and unlocking a hash element that holds a copy-on-write
1081 scalar no longer causes modifications to that scalar to modify other
1082 scalars that were sharing the same string buffer.
1083
1084 =item *
1085
1086 C<when> blocks are now capable of returning variables declared inside the
1087 enclosing C<given> block [perl #93548].
1088
1089 =item *
1090
1091 A problem with context propagation when a C<do> block is an argument to
1092 C<return> has been fixed.  It used to cause C<undef> to be returned in
1093 some cases of a C<return> inside an C<if> block which itself is followed by
1094 another C<return>.
1095
1096 =item *
1097
1098 Calling C<index> with a tainted constant no longer causes constants in
1099 subsequently compiled code to become tainted [perl #64804].
1100
1101 =item *
1102
1103 Use of lexical (C<my>) variables in code blocks embedded in regular
1104 expressions will no longer result in memory corruption or crashes.
1105
1106 Nevertheless, these code blocks are still experimental, as there are still
1107 problems with the wrong variables being closed over (in loops for instance)
1108 and with abnormal exiting (e.g., C<die>) causing memory corruption.
1109
1110 =item *
1111
1112 The C<SvIsCOW> C macro now returns false for read-only copies of typeglobs,
1113 such as those created by:
1114
1115   $hash{elem} = *foo;
1116   Hash::Util::lock_value %hash, 'elem';
1117
1118 It used to return true.
1119
1120 =item *
1121
1122 Assignment to C<$^A> (the format output accumulator) now recalculates
1123 the number of lines output.
1124
1125 =item *
1126
1127 The regexp optimiser no longer crashes on debugging builds when merging
1128 fixed-string nodes with inconvenient contents.
1129
1130 =item *
1131
1132 Locking a subroutine (via C<lock &sub>) is no longer a compile-time error
1133 for regular subs.  For lvalue subroutines, it no longer tries to return the
1134 sub as a scalar, resulting in strange side effects like C<ref \$_>
1135 returning "CODE" in some instances.
1136
1137 C<lock &sub> is now a run-time error if L<threads::shared> is loaded (a
1138 no-op otherwise), but that may be rectified in a future version.
1139
1140 =item *
1141
1142 The prototypes of several built-in functions--C<getprotobynumber>, C<lock>,
1143 C<not> and C<select>--have been corrected, or at least are now closer to
1144 reality than before.
1145
1146 =item *
1147
1148 Most dereferencing operators (C<${}>, etc.) used to call C<FETCH> twice on
1149 a tied operand when doing a symbolic dereference (looking up a variable by
1150 name, which is not permitted under C<use strict 'refs'>).  Only C<&{}> did
1151 not have this problem.  This has been fixed.
1152
1153 =item *
1154
1155 A minor regression introduced in 5.15.0 has been fixed.  Dereferencing a
1156 magical mortal (e.g., the return value of C<delete> on a tied hash element)
1157 explicitly returned from a subroutine called recursively was not calling
1158 C<FETCH>.  This would affect code like C<@{ foo() }> where the C<foo> sub
1159 contains C<return delete $hash{elem}> and is calling itself.
1160
1161 =item *
1162
1163 A panic involving the combination of the regular expression modifiers
1164 C</aa> and the C<\b> escape sequence introduced in 5.14.0 has been
1165 fixed [perl #95964].
1166
1167 =item *
1168
1169 stat() would always return the inode number as an IV, even when the
1170 original was unsigned, or too large to fit in an IV.  stat() now
1171 returns the inode number as the type that would best preserve the
1172 original value. [perl #84590]
1173
1174 =item *
1175
1176 The combination of the regular expression modifiers C</aa> and the C<\b>
1177 and C<\B> escape sequences did not work properly on UTF-8 encoded
1178 strings.  All non-ASCII characters under C</aa> should be treated as
1179 non-word characters, but what was happening was that Unicode rules were
1180 used to determine wordness/non-wordness for non-ASCII characters.  This
1181 is now fixed [perl #95968].
1182
1183 =item *
1184
1185 Infinite loops like C<1 while 1> used to stop C<strict 'subs'> mode from
1186 working for the rest of the block.t
1187
1188 =item *
1189
1190 The C<\h>, C<\H>, C<\v> and C<\V> regular expression metacharacters used to
1191 cause a panic error message when attempting to match at the end of the
1192 string [perl #96354].
1193
1194 =item *
1195
1196 For list assignments like C<($a,$b) = ($b,$a)>, Perl has to make a copy of
1197 the items on the right-hand side before assignment them to the left.  For
1198 efficiency's sake, it assigns the values on the right straight to the items
1199 on the left no variable is mentioned on both sides, as in
1200 C<($a,$b) = ($c,$d)>.  The logic for determining when it can cheat was
1201 faulty, in that C<&&> and C<||> on the right-hand side could fool it.  So
1202 C<($a,$b) = $some_true_value && ($b,$a)> would end up assigning the value
1203 of C<$b> to both scalars.
1204
1205 =item *
1206
1207 Perl no longer tries to apply lvalue context to the string in
1208 C<("string", $variable) ||= 1> (which used to be an error).  Since the
1209 left-hand side of C<||=> is evaluated in scalar context, that's a scalar
1210 comma operator, which gives all but the last item void context.  There is
1211 no such thing as void lvalue context, so it was a mistake for Perl to try
1212 to force it [perl #96942].
1213
1214 =item *
1215
1216 Every subroutine has a filename associated with it, that the debugger uses.
1217 The one associated with constant subroutines used to be misallocated when
1218 cloned under threads.  Consequently, debugging threaded applications could
1219 result in memory corruption [perl #96126].
1220
1221 =item *
1222
1223 C<caller> no longer leaks memory when called from the DB package if
1224 C<@DB::args> was assigned to after the first call to C<caller>.  L<Carp>
1225 was triggering this bug [perl #97010].
1226
1227 =back
1228
1229 =head1 Known Problems
1230
1231 XXX Descriptions of platform agnostic bugs we know we can't fix go here. Any
1232 tests that had to be C<TODO>ed for the release would be noted here, unless
1233 they were specific to a particular platform (see below).
1234
1235 This is a list of some significant unfixed bugs, which are regressions
1236 from either 5.XXX.XXX or 5.XXX.XXX.
1237
1238 [ List each fix as a =item entry ]
1239
1240 =over 4
1241
1242 =item *
1243
1244 XXX
1245
1246 =back
1247
1248 =head1 Obituary
1249
1250 XXX If any significant core contributor has died, we've added a short obituary
1251 here.
1252
1253 =head1 Acknowledgements
1254
1255 XXX Generate this with:
1256
1257   perl Porting/acknowledgements.pl v5.15.7..HEAD
1258
1259 =head1 Reporting Bugs
1260
1261 If you find what you think is a bug, you might check the articles
1262 recently posted to the comp.lang.perl.misc newsgroup and the perl
1263 bug database at http://rt.perl.org/perlbug/ .  There may also be
1264 information at http://www.perl.org/ , the Perl Home Page.
1265
1266 If you believe you have an unreported bug, please run the L<perlbug>
1267 program included with your release.  Be sure to trim your bug down
1268 to a tiny but sufficient test case.  Your bug report, along with the
1269 output of C<perl -V>, will be sent off to perlbug@perl.org to be
1270 analysed by the Perl porting team.
1271
1272 If the bug you are reporting has security implications, which make it
1273 inappropriate to send to a publicly archived mailing list, then please send
1274 it to perl5-security-report@perl.org. This points to a closed subscription
1275 unarchived mailing list, which includes
1276 all the core committers, who will be able
1277 to help assess the impact of issues, figure out a resolution, and help
1278 co-ordinate the release of patches to mitigate or fix the problem across all
1279 platforms on which Perl is supported. Please only use this address for
1280 security issues in the Perl core, not for modules independently
1281 distributed on CPAN.
1282
1283 =head1 SEE ALSO
1284
1285 The F<Changes> file for an explanation of how to view exhaustive details
1286 on what changed.
1287
1288 The F<INSTALL> file for how to build Perl.
1289
1290 The F<README> file for general stuff.
1291
1292 The F<Artistic> and F<Copying> files for copyright information.
1293
1294 =cut