This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
pod/perl5180delta.pod: Clarify %ENV Changes
[perl5.git] / pod / perl5180delta.pod
CommitLineData
e9912eaa
RS
1=encoding utf8
2
3=head1 NAME
4
5perl5180delta - what is new for perl v5.18.0
6
7=head1 DESCRIPTION
8
9This document describes differences between the v5.16.0 release and the v5.18.0
10release.
11
12If you are upgrading from an earlier release such as v5.14.0, first read
13L<perl5160delta>, which describes differences between v5.14.0 and v5.16.0.
14
15=head1 Core Enhancements
16
17=head2 New mechanism for experimental features
18
19Newly-added experimental features will now require this incantation:
20
21 no warnings "experimental::feature_name";
22 use feature "feature_name"; # would warn without the prev line
23
24There is a new warnings category, called "experimental", containing
25warnings that the L<feature> pragma emits when enabling experimental
26features.
27
28Newly-added experimental features will also be given special warning IDs,
29which consist of "experimental::" followed by the name of the feature. (The
30plan is to extend this mechanism eventually to all warnings, to allow them
31to be enabled or disabled individually, and not just by category.)
32
33By saying
34
35 no warnings "experimental::feature_name";
36
37you are taking responsibility for any breakage that future changes to, or
38removal of, the feature may cause.
39
40Since some features (like C<~~> or C<my $_>) now emit experimental warnings,
41and you may want to disable them in code that is also run on perls that do not
42recognize these warning categories, consider using the C<if> pragma like this:
43
2153ce53 44 no if $] >= 5.018, warnings => "experimental::feature_name";
e9912eaa
RS
45
46Existing experimental features may begin emitting these warnings, too. Please
47consult L<perlexperiment> for information on which features are considered
48experimental.
49
50=head2 Hash overhaul
51
52Changes to the implementation of hashes in perl v5.18.0 will be one of the most
53visible changes to the behavior of existing code.
54
55By default, two distinct hash variables with identical keys and values may now
56provide their contents in a different order where it was previously identical.
57
58When encountering these changes, the key to cleaning up from them is to accept
59that B<hashes are unordered collections> and to act accordingly.
60
61=head3 Hash randomization
62
63The seed used by Perl's hash function is now random. This means that the
64order which keys/values will be returned from functions like C<keys()>,
65C<values()>, and C<each()> will differ from run to run.
66
67This change was introduced to make Perl's hashes more robust to algorithmic
68complexity attacks, and also because we discovered that it exposes hash
69ordering dependency bugs and makes them easier to track down.
70
71Toolchain maintainers might want to invest in additional infrastructure to
72test for things like this. Running tests several times in a row and then
73comparing results will make it easier to spot hash order dependencies in
74code. Authors are strongly encouraged not to expose the key order of
75Perl's hashes to insecure audiences.
76
77Further, every hash has its own iteration order, which should make it much
78more difficult to determine what the current hash seed is.
79
80=head3 New hash functions
81
82Perl v5.18 includes support for multiple hash functions, and changed
83the default (to ONE_AT_A_TIME_HARD), you can choose a different
84algorithm by defining a symbol at compile time. For a current list,
85consult the F<INSTALL> document. Note that as of Perl v5.18 we can
86only recommend use of the default or SIPHASH. All the others are
87known to have security issues and are for research purposes only.
88
89=head3 PERL_HASH_SEED environment variable now takes a hex value
90
91C<PERL_HASH_SEED> no longer accepts an integer as a parameter;
92instead the value is expected to be a binary value encoded in a hex
93string, such as "0xf5867c55039dc724". This is to make the
94infrastructure support hash seeds of arbitrary lengths, which might
95exceed that of an integer. (SipHash uses a 16 byte seed.)
96
97=head3 PERL_PERTURB_KEYS environment variable added
98
99The C<PERL_PERTURB_KEYS> environment variable allows one to control the level of
100randomization applied to C<keys> and friends.
101
102When C<PERL_PERTURB_KEYS> is 0, perl will not randomize the key order at all. The
103chance that C<keys> changes due to an insert will be the same as in previous
104perls, basically only when the bucket size is changed.
105
106When C<PERL_PERTURB_KEYS> is 1, perl will randomize keys in a non-repeatable
107way. The chance that C<keys> changes due to an insert will be very high. This
108is the most secure and default mode.
109
110When C<PERL_PERTURB_KEYS> is 2, perl will randomize keys in a repeatable way.
111Repeated runs of the same program should produce the same output every time.
112
113C<PERL_HASH_SEED> implies a non-default C<PERL_PERTURB_KEYS> setting. Setting
114C<PERL_HASH_SEED=0> (exactly one 0) implies C<PERL_PERTURB_KEYS=0> (hash key
12b4b02f 115randomization disabled); setting C<PERL_HASH_SEED> to any other value implies
e9912eaa
RS
116C<PERL_PERTURB_KEYS=2> (deterministic and repeatable hash key randomization).
117Specifying C<PERL_PERTURB_KEYS> explicitly to a different level overrides this
118behavior.
119
120=head3 Hash::Util::hash_seed() now returns a string
121
122Hash::Util::hash_seed() now returns a string instead of an integer. This
123is to make the infrastructure support hash seeds of arbitrary lengths
124which might exceed that of an integer. (SipHash uses a 16 byte seed.)
125
126=head3 Output of PERL_HASH_SEED_DEBUG has been changed
127
128The environment variable PERL_HASH_SEED_DEBUG now makes perl show both the
129hash function perl was built with, I<and> the seed, in hex, in use for that
130process. Code parsing this output, should it exist, must change to accommodate
131the new format. Example of the new format:
132
133 $ PERL_HASH_SEED_DEBUG=1 ./perl -e1
134 HASH_FUNCTION = MURMUR3 HASH_SEED = 0x1476bb9f
135
136=head2 Upgrade to Unicode 6.2
137
138Perl now supports Unicode 6.2. A list of changes from Unicode
1396.1 is at L<http://www.unicode.org/versions/Unicode6.2.0>.
140
141=head2 Character name aliases may now include non-Latin1-range characters
142
143It is possible to define your own names for characters for use in
144C<\N{...}>, C<charnames::vianame()>, etc. These names can now be
145comprised of characters from the whole Unicode range. This allows for
146names to be in your native language, and not just English. Certain
147restrictions apply to the characters that may be used (you can't define
148a name that has punctuation in it, for example). See L<charnames/CUSTOM
149ALIASES>.
150
151=head2 New DTrace probes
152
153The following new DTrace probes have been added:
154
155=over 4
156
157=item *
158
159C<op-entry>
160
161=item *
162
163C<loading-file>
164
165=item *
166
167C<loaded-file>
168
169=back
170
171=head2 C<${^LAST_FH}>
172
173This new variable provides access to the filehandle that was last read.
174This is the handle used by C<$.> and by C<tell> and C<eof> without
175arguments.
176
177=head2 Regular Expression Set Operations
178
179This is an B<experimental> feature to allow matching against the union,
180intersection, etc., of sets of code points, similar to
181L<Unicode::Regex::Set>. It can also be used to extend C</x> processing
182to [bracketed] character classes, and as a replacement of user-defined
183properties, allowing more complex expressions than they do. See
184L<perlrecharclass/Extended Bracketed Character Classes>.
185
186=head2 Lexical subroutines
187
188This new feature is still considered B<experimental>. To enable it:
189
190 use 5.018;
191 no warnings "experimental::lexical_subs";
192 use feature "lexical_subs";
193
194You can now declare subroutines with C<state sub foo>, C<my sub foo>, and
195C<our sub foo>. (C<state sub> requires that the "state" feature be
196enabled, unless you write it as C<CORE::state sub foo>.)
197
198C<state sub> creates a subroutine visible within the lexical scope in which
199it is declared. The subroutine is shared between calls to the outer sub.
200
201C<my sub> declares a lexical subroutine that is created each time the
202enclosing block is entered. C<state sub> is generally slightly faster than
203C<my sub>.
204
205C<our sub> declares a lexical alias to the package subroutine of the same
206name.
207
208For more information, see L<perlsub/Lexical Subroutines>.
209
210=head2 Computed Labels
211
212The loop controls C<next>, C<last> and C<redo>, and the special C<dump>
213operator, now allow arbitrary expressions to be used to compute labels at run
214time. Previously, any argument that was not a constant was treated as the
215empty string.
216
217=head2 More CORE:: subs
218
219Several more built-in functions have been added as subroutines to the
220CORE:: namespace - namely, those non-overridable keywords that can be
221implemented without custom parsers: C<defined>, C<delete>, C<exists>,
222C<glob>, C<pos>, C<protoytpe>, C<scalar>, C<split>, C<study>, and C<undef>.
223
224As some of these have prototypes, C<prototype('CORE::...')> has been
225changed to not make a distinction between overridable and non-overridable
226keywords. This is to make C<prototype('CORE::pos')> consistent with
227C<prototype(&CORE::pos)>.
228
229=head2 C<kill> with negative signal names
230
231C<kill> has always allowed a negative signal number, which kills the
232process group instead of a single process. It has also allowed signal
233names. But it did not behave consistently, because negative signal names
234were treated as 0. Now negative signals names like C<-INT> are supported
235and treated the same way as -2 [perl #112990].
236
237=head1 Security
238
239=head2 See also: hash overhaul
240
241Some of the changes in the L<hash overhaul|/"Hash overhaul"> were made to
242enhance security. Please read that section.
243
244=head2 C<Storable> security warning in documentation
245
246The documentation for C<Storable> now includes a section which warns readers
247of the danger of accepting Storable documents from untrusted sources. The
248short version is that deserializing certain types of data can lead to loading
249modules and other code execution. This is documented behavior and wanted
250behavior, but this opens an attack vector for malicious entities.
251
252=head2 C<Locale::Maketext> allowed code injection via a malicious template
253
254If users could provide a translation string to Locale::Maketext, this could be
255used to invoke arbitrary Perl subroutines available in the current process.
256
257This has been fixed, but it is still possible to invoke any method provided by
258C<Locale::Maketext> itself or a subclass that you are using. One of these
259methods in turn will invoke the Perl core's C<sprintf> subroutine.
260
261In summary, allowing users to provide translation strings without auditing
262them is a bad idea.
263
264This vulnerability is documented in CVE-2012-6329.
265
266=head2 Avoid calling memset with a negative count
267
268Poorly written perl code that allows an attacker to specify the count to perl's
269C<x> string repeat operator can already cause a memory exhaustion
270denial-of-service attack. A flaw in versions of perl before v5.15.5 can escalate
271that into a heap buffer overrun; coupled with versions of glibc before 2.16, it
272possibly allows the execution of arbitrary code.
273
274The flaw addressed to this commit has been assigned identifier CVE-2012-5195
275and was researched by Tim Brown.
276
277=head1 Incompatible Changes
278
279=head2 See also: hash overhaul
280
281Some of the changes in the L<hash overhaul|/"Hash overhaul"> are not fully
282compatible with previous versions of perl. Please read that section.
283
284=head2 An unknown character name in C<\N{...}> is now a syntax error
285
286Previously, it warned, and the Unicode REPLACEMENT CHARACTER was
287substituted. Unicode now recommends that this situation be a syntax
288error. Also, the previous behavior led to some confusing warnings and
289behaviors, and since the REPLACEMENT CHARACTER has no use other than as
290a stand-in for some unknown character, any code that has this problem is
291buggy.
292
293=head2 Formerly deprecated characters in C<\N{}> character name aliases are now errors.
294
295Since v5.12.0, it has been deprecated to use certain characters in
296user-defined C<\N{...}> character names. These now cause a syntax
297error. For example, it is now an error to begin a name with a digit,
298such as in
299
300 my $undraftable = "\N{4F}"; # Syntax error!
301
302or to have commas anywhere in the name. See L<charnames/CUSTOM ALIASES>.
303
304=head2 C<\N{BELL}> now refers to U+1F514 instead of U+0007
305
306Unicode 6.0 reused the name "BELL" for a different code point than it
307traditionally had meant. Since Perl v5.14, use of this name still
308referred to U+0007, but would raise a deprecation warning. Now, "BELL"
309refers to U+1F514, and the name for U+0007 is "ALERT". All the
310functions in L<charnames> have been correspondingly updated.
311
312=head2 New Restrictions in Multi-Character Case-Insensitive Matching in Regular Expression Bracketed Character Classes
313
314Unicode has now withdrawn their previous recommendation for regular
315expressions to automatically handle cases where a single character can
316match multiple characters case-insensitively, for example, the letter
317LATIN SMALL LETTER SHARP S and the sequence C<ss>. This is because
318it turns out to be impracticable to do this correctly in all
319circumstances. Because Perl has tried to do this as best it can, it
320will continue to do so. (We are considering an option to turn it off.)
321However, a new restriction is being added on such matches when they
322occur in [bracketed] character classes. People were specifying
323things such as C</[\0-\xff]/i>, and being surprised that it matches the
324two character sequence C<ss> (since LATIN SMALL LETTER SHARP S occurs in
325this range). This behavior is also inconsistent with using a
326property instead of a range: C<\p{Block=Latin1}> also includes LATIN
327SMALL LETTER SHARP S, but C</[\p{Block=Latin1}]/i> does not match C<ss>.
328The new rule is that for there to be a multi-character case-insensitive
329match within a bracketed character class, the character must be
330explicitly listed, and not as an end point of a range. This more
331closely obeys the Principle of Least Astonishment. See
332L<perlrecharclass/Bracketed Character Classes>. Note that a bug [perl
333#89774], now fixed as part of this change, prevented the previous
334behavior from working fully.
335
336=head2 Explicit rules for variable names and identifiers
337
338Due to an oversight, single character variable names in v5.16 were
339completely unrestricted. This opened the door to several kinds of
340insanity. As of v5.18, these now follow the rules of other identifiers,
341in addition to accepting characters that match the C<\p{POSIX_Punct}>
342property.
343
344There is no longer any difference in the parsing of identifiers
345specified by using braces versus without braces. For instance, perl
346used to allow C<${foo:bar}> (with a single colon) but not C<$foo:bar>.
347Now that both are handled by a single code path, they are both treated
348the same way: both are forbidden. Note that this change is about the
349range of permissible literal identifiers, not other expressions.
350
351=head2 Vertical tabs are now whitespace
352
353No one could recall why C<\s> didn't match C<\cK>, the vertical tab.
354Now it does. Given the extreme rarity of that character, very little
355breakage is expected. That said, here's what it means:
356
357C<\s> in a regex now matches a vertical tab in all circumstances.
358
359Literal vertical tabs in a regex literal are ignored when the C</x>
360modifier is used.
361
362Leading vertical tabs, alone or mixed with other whitespace, are now
363ignored when interpreting a string as a number. For example:
364
365 $dec = " \cK \t 123";
366 $hex = " \cK \t 0xF";
367
368 say 0 + $dec; # was 0 with warning, now 123
369 say int $dec; # was 0, now 123
370 say oct $hex; # was 0, now 15
371
372=head2 C</(?{})/> and C</(??{})/> have been heavily reworked
373
374The implementation of this feature has been almost completely rewritten.
375Although its main intent is to fix bugs, some behaviors, especially
376related to the scope of lexical variables, will have changed. This is
377described more fully in the L</Selected Bug Fixes> section.
378
379=head2 Stricter parsing of substitution replacement
380
381It is no longer possible to abuse the way the parser parses C<s///e> like
382this:
383
384 %_=(_,"Just another ");
385 $_="Perl hacker,\n";
386 s//_}->{_/e;print
387
388=head2 C<given> now aliases the global C<$_>
389
390Instead of assigning to an implicit lexical C<$_>, C<given> now makes the
391global C<$_> an alias for its argument, just like C<foreach>. However, it
392still uses lexical C<$_> if there is lexical C<$_> in scope (again, just like
393C<foreach>) [perl #114020].
394
395=head2 The smartmatch family of features are now experimental
396
397Smart match, added in v5.10.0 and significantly revised in v5.10.1, has been
398a regular point of complaint. Although there are a number of ways in which
399it is useful, it has also proven problematic and confusing for both users and
400implementors of Perl. There have been a number of proposals on how to best
401address the problem. It is clear that smartmatch is almost certainly either
402going to change or go away in the future. Relying on its current behavior
403is not recommended.
404
405Warnings will now be issued when the parser sees C<~~>, C<given>, or C<when>.
406To disable these warnings, you can add this line to the appropriate scope:
407
2153ce53 408 no if $] >= 5.018, warnings => "experimental::smartmatch";
e9912eaa
RS
409
410Consider, though, replacing the use of these features, as they may change
411behavior again before becoming stable.
412
413=head2 Lexical C<$_> is now experimental
414
415Since it was introduced in Perl v5.10, it has caused much confusion with no
416obvious solution:
417
418=over
419
420=item *
421
422Various modules (e.g., List::Util) expect callback routines to use the
423global C<$_>. C<use List::Util 'first'; my $_; first { $_ == 1 } @list>
424does not work as one would expect.
425
426=item *
427
428A C<my $_> declaration earlier in the same file can cause confusing closure
429warnings.
430
431=item *
432
433The "_" subroutine prototype character allows called subroutines to access
434your lexical C<$_>, so it is not really private after all.
435
436=item *
437
438Nevertheless, subroutines with a "(@)" prototype and methods cannot access
439the caller's lexical C<$_>, unless they are written in XS.
440
441=item *
442
443But even XS routines cannot access a lexical C<$_> declared, not in the
444calling subroutine, but in an outer scope, iff that subroutine happened not
445to mention C<$_> or use any operators that default to C<$_>.
446
447=back
448
449It is our hope that lexical C<$_> can be rehabilitated, but this may
450cause changes in its behavior. Please use it with caution until it
451becomes stable.
452
453=head2 readline() with C<$/ = \N> now reads N characters, not N bytes
454
455Previously, when reading from a stream with I/O layers such as
456C<encoding>, the readline() function, otherwise known as the C<< <> >>
457operator, would read I<N> bytes from the top-most layer. [perl #79960]
458
459Now, I<N> characters are read instead.
460
461There is no change in behaviour when reading from streams with no
462extra layers, since bytes map exactly to characters.
463
464=head2 Overridden C<glob> is now passed one argument
465
466C<glob> overrides used to be passed a magical undocumented second argument
467that identified the caller. Nothing on CPAN was using this, and it got in
468the way of a bug fix, so it was removed. If you really need to identify
469the caller, see L<Devel::Callsite> on CPAN.
470
471=head2 Here doc parsing
472
473The body of a here document inside a quote-like operator now always begins
474on the line after the "<<foo" marker. Previously, it was documented to
475begin on the line following the containing quote-like operator, but that
476was only sometimes the case [perl #114040].
477
478=head2 Alphanumeric operators must now be separated from the closing
479delimiter of regular expressions
480
481You may no longer write something like:
482
483 m/a/and 1
484
485Instead you must write
486
487 m/a/ and 1
488
489with whitespace separating the operator from the closing delimiter of
490the regular expression. Not having whitespace has resulted in a
491deprecation warning since Perl v5.14.0.
492
493=head2 qw(...) can no longer be used as parentheses
494
495C<qw> lists used to fool the parser into thinking they were always
496surrounded by parentheses. This permitted some surprising constructions
497such as C<foreach $x qw(a b c) {...}>, which should really be written
498C<foreach $x (qw(a b c)) {...}>. These would sometimes get the lexer into
499the wrong state, so they didn't fully work, and the similar C<foreach qw(a
500b c) {...}> that one might expect to be permitted never worked at all.
501
502This side effect of C<qw> has now been abolished. It has been deprecated
503since Perl v5.13.11. It is now necessary to use real parentheses
504everywhere that the grammar calls for them.
505
506=head2 Interaction of lexical and default warnings
507
508Turning on any lexical warnings used first to disable all default warnings
509if lexical warnings were not already enabled:
510
511 $*; # deprecation warning
512 use warnings "void";
513 $#; # void warning; no deprecation warning
514
515Now, the C<debugging>, C<deprecated>, C<glob>, C<inplace> and C<malloc> warnings
516categories are left on when turning on lexical warnings (unless they are
517turned off by C<no warnings>, of course).
518
519This may cause deprecation warnings to occur in code that used to be free
520of warnings.
521
522Those are the only categories consisting only of default warnings. Default
523warnings in other categories are still disabled by C<< use warnings "category" >>,
524as we do not yet have the infrastructure for controlling
525individual warnings.
526
527=head2 C<state sub> and C<our sub>
528
529Due to an accident of history, C<state sub> and C<our sub> were equivalent
530to a plain C<sub>, so one could even create an anonymous sub with
531C<our sub { ... }>. These are now disallowed outside of the "lexical_subs"
532feature. Under the "lexical_subs" feature they have new meanings described
533in L<perlsub/Lexical Subroutines>.
534
535=head2 Defined values stored in environment are forced to byte strings
536
f2b58637
KF
537A value stored in an environment variable has always been stringified when
538inherited by child processes.
539
540In this release, when assigning to C<%ENV>, values are immediately stringified,
541and converted to be only a byte string.
542
543First, it is forced to be a only a string. Then if the string is utf8 and the
544equivalent of C<utf8::downgrade()> works, that result is used; otherwise, the
545equivalent of C<utf8::encode()> is used, and a warning is issued about wide
546characters (L</Diagnostics>).
e9912eaa
RS
547
548=head2 C<require> dies for unreadable files
549
550When C<require> encounters an unreadable file, it now dies. It used to
551ignore the file and continue searching the directories in C<@INC>
552[perl #113422].
553
554=head2 C<gv_fetchmeth_*> and SUPER
555
556The various C<gv_fetchmeth_*> XS functions used to treat a package whose
557named ended with C<::SUPER> specially. A method lookup on the C<Foo::SUPER>
558package would be treated as a C<SUPER> method lookup on the C<Foo> package. This
559is no longer the case. To do a C<SUPER> lookup, pass the C<Foo> stash and the
560C<GV_SUPER> flag.
561
562=head2 C<split>'s first argument is more consistently interpreted
563
564After some changes earlier in v5.17, C<split>'s behavior has been
565simplified: if the PATTERN argument evaluates to a string
566containing one space, it is treated the way that a I<literal> string
567containing one space once was.
568
569=head1 Deprecations
570
571=head2 Module removals
572
573The following modules will be removed from the core distribution in a future
574release, and will at that time need to be installed from CPAN. Distributions
575on CPAN which require these modules will need to list them as prerequisites.
576
577The core versions of these modules will now issue C<"deprecated">-category
578warnings to alert you to this fact. To silence these deprecation warnings,
579install the modules in question from CPAN.
580
581Note that these are (with rare exceptions) fine modules that you are encouraged
582to continue to use. Their disinclusion from core primarily hinges on their
583necessity to bootstrapping a fully functional, CPAN-capable Perl installation,
584not usually on concerns over their design.
585
586=over
587
588=item L<encoding>
589
590The use of this pragma is now strongly discouraged. It conflates the encoding
591of source text with the encoding of I/O data, reinterprets escape sequences in
592source text (a questionable choice), and introduces the UTF-8 bug to all runtime
593handling of character strings. It is broken as designed and beyond repair.
594
595For using non-ASCII literal characters in source text, please refer to L<utf8>.
596For dealing with textual I/O data, please refer to L<Encode> and L<open>.
597
598=item L<Archive::Extract>
599
600=item L<B::Lint>
601
602=item L<B::Lint::Debug>
603
604=item L<CPANPLUS> and all included C<CPANPLUS::*> modules
605
606=item L<Devel::InnerPackage>
607
608=item L<Log::Message>
609
610=item L<Log::Message::Config>
611
612=item L<Log::Message::Handlers>
613
614=item L<Log::Message::Item>
615
616=item L<Log::Message::Simple>
617
618=item L<Module::Pluggable>
619
620=item L<Module::Pluggable::Object>
621
622=item L<Object::Accessor>
623
624=item L<Pod::LaTeX>
625
626=item L<Term::UI>
627
628=item L<Term::UI::History>
629
630=back
631
632=head2 Deprecated Utilities
633
634The following utilities will be removed from the core distribution in a
635future release as their associated modules have been deprecated. They
636will remain available with the applicable CPAN distribution.
637
638=over
639
640=item L<cpanp>
641
642=item C<cpanp-run-perl>
643
644=item L<cpan2dist>
645
646These items are part of the C<CPANPLUS> distribution.
647
648=item L<pod2latex>
649
650This item is part of the C<Pod::LaTeX> distribution.
651
652=back
653
654=head2 PL_sv_objcount
655
656This interpreter-global variable used to track the total number of
657Perl objects in the interpreter. It is no longer maintained and will
658be removed altogether in Perl v5.20.
659
660=head2 Five additional characters should be escaped in patterns with C</x>
661
662When a regular expression pattern is compiled with C</x>, Perl treats 6
663characters as white space to ignore, such as SPACE and TAB. However,
664Unicode recommends 11 characters be treated thusly. We will conform
665with this in a future Perl version. In the meantime, use of any of the
666missing characters will raise a deprecation warning, unless turned off.
667The five characters are:
668
669 U+0085 NEXT LINE
670 U+200E LEFT-TO-RIGHT MARK
671 U+200F RIGHT-TO-LEFT MARK
672 U+2028 LINE SEPARATOR
673 U+2029 PARAGRAPH SEPARATOR
674
675=head2 User-defined charnames with surprising whitespace
676
677A user-defined character name with trailing or multiple spaces in a row is
678likely a typo. This now generates a warning when defined, on the assumption
679that uses of it will be unlikely to include the excess whitespace.
680
681=head2 Various XS-callable functions are now deprecated
682
683All the functions used to classify characters will be removed from a
684future version of Perl, and should not be used. With participating C
685compilers (e.g., gcc), compiling any file that uses any of these will
686generate a warning. These were not intended for public use; there are
687equivalent, faster, macros for most of them.
688
689See L<perlapi/Character classes>. The complete list is:
690
691C<is_uni_alnum>, C<is_uni_alnumc>, C<is_uni_alnumc_lc>,
692C<is_uni_alnum_lc>, C<is_uni_alpha>, C<is_uni_alpha_lc>,
693C<is_uni_ascii>, C<is_uni_ascii_lc>, C<is_uni_blank>,
694C<is_uni_blank_lc>, C<is_uni_cntrl>, C<is_uni_cntrl_lc>,
695C<is_uni_digit>, C<is_uni_digit_lc>, C<is_uni_graph>,
696C<is_uni_graph_lc>, C<is_uni_idfirst>, C<is_uni_idfirst_lc>,
697C<is_uni_lower>, C<is_uni_lower_lc>, C<is_uni_print>,
698C<is_uni_print_lc>, C<is_uni_punct>, C<is_uni_punct_lc>,
699C<is_uni_space>, C<is_uni_space_lc>, C<is_uni_upper>,
700C<is_uni_upper_lc>, C<is_uni_xdigit>, C<is_uni_xdigit_lc>,
701C<is_utf8_alnum>, C<is_utf8_alnumc>, C<is_utf8_alpha>,
702C<is_utf8_ascii>, C<is_utf8_blank>, C<is_utf8_char>,
703C<is_utf8_cntrl>, C<is_utf8_digit>, C<is_utf8_graph>,
704C<is_utf8_idcont>, C<is_utf8_idfirst>, C<is_utf8_lower>,
705C<is_utf8_mark>, C<is_utf8_perl_space>, C<is_utf8_perl_word>,
706C<is_utf8_posix_digit>, C<is_utf8_print>, C<is_utf8_punct>,
707C<is_utf8_space>, C<is_utf8_upper>, C<is_utf8_xdigit>,
708C<is_utf8_xidcont>, C<is_utf8_xidfirst>.
709
710In addition these three functions that have never worked properly are
711deprecated:
712C<to_uni_lower_lc>, C<to_uni_title_lc>, and C<to_uni_upper_lc>.
713
714=head2 Certain rare uses of backslashes within regexes are now deprecated
715
716There are three pairs of characters that Perl recognizes as
717metacharacters in regular expression patterns: C<{}>, C<[]>, and C<()>.
718These can be used as well to delimit patterns, as in:
719
720 m{foo}
721 s(foo)(bar)
722
723Since they are metacharacters, they have special meaning to regular
724expression patterns, and it turns out that you can't turn off that
725special meaning by the normal means of preceding them with a backslash,
726if you use them, paired, within a pattern delimited by them. For
727example, in
728
729 m{foo\{1,3\}}
730
731the backslashes do not change the behavior, and this matches
732S<C<"f o">> followed by one to three more occurrences of C<"o">.
733
734Usages like this, where they are interpreted as metacharacters, are
735exceedingly rare; we think there are none, for example, in all of CPAN.
736Hence, this deprecation should affect very little code. It does give
737notice, however, that any such code needs to change, which will in turn
738allow us to change the behavior in future Perl versions so that the
739backslashes do have an effect, and without fear that we are silently
740breaking any existing code.
741
742=head2 Splitting the tokens C<(?> and C<(*> in regular expressions
743
744A deprecation warning is now raised if the C<(> and C<?> are separated
745by white space or comments in C<(?...)> regular expression constructs.
746Similarly, if the C<(> and C<*> are separated in C<(*VERB...)>
747constructs.
748
749=head2 Pre-PerlIO IO implementations
750
751In theory, you can currently build perl without PerlIO. Instead, you'd use a
752wrapper around stdio or sfio. In practice, this isn't very useful. It's not
753well tested, and without any support for IO layers or (thus) Unicode, it's not
754much of a perl. Building without PerlIO will most likely be removed in the
755next version of perl.
756
757PerlIO supports a C<stdio> layer if stdio use is desired. Similarly a
758sfio layer could be produced in the future, if needed.
759
760=head1 Future Deprecations
761
762=over
763
764=item *
765
766Platforms without support infrastructure
767
768Both Windows CE and z/OS have been historically under-maintained, and are
769currently neither successfully building nor regularly being smoke tested.
770Efforts are underway to change this situation, but it should not be taken for
771granted that the platforms are safe and supported. If they do not become
772buildable and regularly smoked, support for them may be actively removed in
773future releases. If you have an interest in these platforms and you can lend
774your time, expertise, or hardware to help support these platforms, please let
775the perl development effort know by emailing C<perl5-porters@perl.org>.
776
777Some platforms that appear otherwise entirely dead are also on the short list
778for removal between now and v5.20.0:
779
780=over
781
782=item DG/UX
783
784=item NeXT
785
786=back
787
788We also think it likely that current versions of Perl will no longer
789build AmigaOS, DJGPP, NetWare (natively), OS/2 and Plan 9. If you
790are using Perl on such a platform and have an interest in ensuring
791Perl's future on them, please contact us.
792
793We believe that Perl has long been unable to build on mixed endian
794architectures (such as PDP-11s), and intend to remove any remaining
795support code. Similarly, code supporting the long umaintained GNU
796dld will be removed soon if no-one makes themselves known as an
797active user.
798
799=item *
800
801Swapping of $< and $>
802
803Perl has supported the idiom of swapping $< and $> (and likewise $( and
804$)) to temporarily drop permissions since 5.0, like this:
805
806 ($<, $>) = ($>, $<);
807
808However, this idiom modifies the real user/group id, which can have
809undesirable side-effects, is no longer useful on any platform perl
810supports and complicates the implementation of these variables and list
811assignment in general.
812
813As an alternative, assignment only to C<< $> >> is recommended:
814
815 local $> = $<;
816
817See also: L<Setuid Demystified|http://www.cs.berkeley.edu/~daw/papers/setuid-usenix02.pdf>.
818
819=item *
820
821C<microperl>, long broken and of unclear present purpose, will be removed.
822
823=item *
824
825Revamping C<< "\Q" >> semantics in double-quotish strings when combined with
826other escapes.
827
828There are several bugs and inconsistencies involving combinations
829of C<\Q> and escapes like C<\x>, C<\L>, etc., within a C<\Q...\E> pair.
830These need to be fixed, and doing so will necessarily change current
831behavior. The changes have not yet been settled.
832
833=item *
834
835Use of C<$x>, where C<x> stands for any actual (non-printing) C0 control
836character will be disallowed in a future Perl version. Use C<${x}>
837instead (where again C<x> stands for a control character),
838or better, C<$^A> , where C<^> is a caret (CIRCUMFLEX ACCENT),
839and C<A> stands for any of the characters listed at the end of
840L<perlebcdic/OPERATOR DIFFERENCES>.
841
842=back
843
844=head1 Performance Enhancements
845
846=over 4
847
848=item *
849
850Lists of lexical variable declarations (C<my($x, $y)>) are now optimised
851down to a single op and are hence faster than before.
852
853=item *
854
855A new C preprocessor define C<NO_TAINT_SUPPORT> was added that, if set,
856disables Perl's taint support altogether. Using the -T or -t command
857line flags will cause a fatal error. Beware that both core tests as
858well as many a CPAN distribution's tests will fail with this change. On
859the upside, it provides a small performance benefit due to reduced
860branching.
861
862B<Do not enable this unless you know exactly what you are getting yourself
863into.>
864
865=item *
866
867C<pack> with constant arguments is now constant folded in most cases
868[perl #113470].
869
870=item *
871
872Speed up in regular expression matching against Unicode properties. The
873largest gain is for C<\X>, the Unicode "extended grapheme cluster." The
874gain for it is about 35% - 40%. Bracketed character classes, e.g.,
875C<[0-9\x{100}]> containing code points above 255 are also now faster.
876
877=item *
878
879On platforms supporting it, several former macros are now implemented as static
880inline functions. This should speed things up slightly on non-GCC platforms.
881
882=item *
883
884The optimisation of hashes in boolean context has been extended to
885affect C<scalar(%hash)>, C<%hash ? ... : ...>, and C<sub { %hash || ... }>.
886
887=item *
888
889Filetest operators manage the stack in a fractionally more efficient manner.
890
891=item *
892
893Globs used in a numeric context are now numified directly in most cases,
894rather than being numified via stringification.
895
896=item *
897
898The C<x> repetition operator is now folded to a single constant at compile
899time if called in scalar context with constant operands and no parentheses
900around the left operand.
901
902=back
903
904=head1 Modules and Pragmata
905
906=head2 New Modules and Pragmata
907
908=over 4
909
910=item *
911
912L<Config::Perl::V> version 0.16 has been added as a dual-lifed module.
913It provides structured data retrieval of C<perl -V> output including
914information only known to the C<perl> binary and not available via L<Config>.
915
916=back
917
918=head2 Updated Modules and Pragmata
919
920For a complete list of updates, run:
921
922 $ corelist --diff 5.16.0 5.18.0
923
924You can substitute your favorite version in place of C<5.16.0>, too.
925
926=over
927
928=item *
929
930L<Archive::Extract> has been upgraded to 0.68.
931
932Work around an edge case on Linux with Busybox's unzip.
933
934=item *
935
936L<Archive::Tar> has been upgraded to 1.90.
937
938ptar now supports the -T option as well as dashless options
939[rt.cpan.org #75473], [rt.cpan.org #75475].
940
941Auto-encode filenames marked as UTF-8 [rt.cpan.org #75474].
942
943Don't use C<tell> on L<IO::Zlib> handles [rt.cpan.org #64339].
944
945Don't try to C<chown> on symlinks.
946
947=item *
948
949L<autodie> has been upgraded to 2.13.
950
951C<autodie> now plays nicely with the 'open' pragma.
952
953=item *
954
955L<B> has been upgraded to 1.42.
956
957The C<stashoff> method of COPs has been added. This provides access to an
958internal field added in perl 5.16 under threaded builds [perl #113034].
959
960C<B::COP::stashpv> now supports UTF-8 package names and embedded NULs.
961
962All C<CVf_*> and C<GVf_*>
963and more SV-related flag values are now provided as constants in the C<B::>
964namespace and available for export. The default export list has not changed.
965
966This makes the module work with the new pad API.
967
968=item *
969
970L<B::Concise> has been upgraded to 0.95.
971
972The C<-nobanner> option has been fixed, and C<format>s can now be dumped.
973When passed a sub name to dump, it will check also to see whether it
974is the name of a format. If a sub and a format share the same name,
975it will dump both.
976
977This adds support for the new C<OpMAYBE_TRUEBOOL> and C<OPpTRUEBOOL> flags.
978
979=item *
980
981L<B::Debug> has been upgraded to 1.18.
982
983This adds support (experimentally) for C<B::PADLIST>, which was
984added in Perl 5.17.4.
985
986=item *
987
988L<B::Deparse> has been upgraded to 1.20.
989
990Avoid warning when run under C<perl -w>.
991
992It now deparses
993loop controls with the correct precedence, and multiple statements in a
994C<format> line are also now deparsed correctly.
995
996This release suppresses trailing semicolons in formats.
997
998This release adds stub deparsing for lexical subroutines.
999
1000It no longer dies when deparsing C<sort> without arguments. It now
1001correctly omits the comma for C<system $prog @args> and C<exec $prog
1002@args>.
1003
1004=item *
1005
1006L<bignum>, L<bigint> and L<bigrat> have been upgraded to 0.33.
1007
1008The overrides for C<hex> and C<oct> have been rewritten, eliminating
1009several problems, and making one incompatible change:
1010
1011=over
1012
1013=item *
1014
1015Formerly, whichever of C<use bigint> or C<use bigrat> was compiled later
1016would take precedence over the other, causing C<hex> and C<oct> not to
1017respect the other pragma when in scope.
1018
1019=item *
1020
1021Using any of these three pragmata would cause C<hex> and C<oct> anywhere
1022else in the program to evalute their arguments in list context and prevent
1023them from inferring $_ when called without arguments.
1024
1025=item *
1026
1027Using any of these three pragmata would make C<oct("1234")> return 1234
1028(for any number not beginning with 0) anywhere in the program. Now "1234"
1029is translated from octal to decimal, whether within the pragma's scope or
1030not.
1031
1032=item *
1033
1034The global overrides that facilitate lexical use of C<hex> and C<oct> now
1035respect any existing overrides that were in place before the new overrides
1036were installed, falling back to them outside of the scope of C<use bignum>.
1037
1038=item *
1039
1040C<use bignum "hex">, C<use bignum "oct"> and similar invocations for bigint
1041and bigrat now export a C<hex> or C<oct> function, instead of providing a
1042global override.
1043
1044=back
1045
1046=item *
1047
1048L<Carp> has been upgraded to 1.29.
1049
1050Carp is no longer confused when C<caller> returns undef for a package that
1051has been deleted.
1052
1053The C<longmess()> and C<shortmess()> functions are now documented.
1054
1055=item *
1056
1057L<CGI> has been upgraded to 3.63.
1058
1059Unrecognized HTML escape sequences are now handled better, problematic
1060trailing newlines are no longer inserted after E<lt>formE<gt> tags
1061by C<startform()> or C<start_form()>, and bogus "Insecure Dependency"
1062warnings appearing with some versions of perl are now worked around.
1063
1064=item *
1065
1066L<Class::Struct> has been upgraded to 0.64.
1067
1068The constructor now respects overridden accessor methods [perl #29230].
1069
1070=item *
1071
1072L<Compress::Raw::Bzip2> has been upgraded to 2.060.
1073
1074The misuse of Perl's "magic" API has been fixed.
1075
1076=item *
1077
1078L<Compress::Raw::Zlib> has been upgraded to 2.060.
1079
1080Upgrade bundled zlib to version 1.2.7.
1081
1082Fix build failures on Irix, Solaris, and Win32, and also when building as C++
1083[rt.cpan.org #69985], [rt.cpan.org #77030], [rt.cpan.org #75222].
1084
1085The misuse of Perl's "magic" API has been fixed.
1086
1087C<compress()>, C<uncompress()>, C<memGzip()> and C<memGunzip()> have
1088been speeded up by making parameter validation more efficient.
1089
1090=item *
1091
1092L<CPAN::Meta::Requirements> has been upgraded to 2.122.
1093
1094Treat undef requirements to C<from_string_hash> as 0 (with a warning).
1095
1096Added C<requirements_for_module> method.
1097
1098=item *
1099
1100L<CPANPLUS> has been upgraded to 0.9135.
1101
1102Allow adding F<blib/script> to PATH.
1103
1104Save the history between invocations of the shell.
1105
1106Handle multiple C<makemakerargs> and C<makeflags> arguments better.
1107
1108This resolves issues with the SQLite source engine.
1109
1110=item *
1111
1112L<Data::Dumper> has been upgraded to 2.145.
1113
1114It has been optimized to only build a seen-scalar hash as necessary,
1115thereby speeding up serialization drastically.
1116
1117Additional tests were added in order to improve statement, branch, condition
1118and subroutine coverage. On the basis of the coverage analysis, some of the
1119internals of Dumper.pm were refactored. Almost all methods are now
1120documented.
1121
1122=item *
1123
1124L<DB_File> has been upgraded to 1.827.
1125
1126The main Perl module no longer uses the C<"@_"> construct.
1127
1128=item *
1129
1130L<Devel::Peek> has been upgraded to 1.11.
1131
1132This fixes compilation with C++ compilers and makes the module work with
1133the new pad API.
1134
1135=item *
1136
1137L<Digest::MD5> has been upgraded to 2.52.
1138
1139Fix C<Digest::Perl::MD5> OO fallback [rt.cpan.org #66634].
1140
1141=item *
1142
1143L<Digest::SHA> has been upgraded to 5.84.
1144
1145This fixes a double-free bug, which might have caused vulnerabilities
1146in some cases.
1147
1148=item *
1149
1150L<DynaLoader> has been upgraded to 1.18.
1151
1152This is due to a minor code change in the XS for the VMS implementation.
1153
1154This fixes warnings about using C<CODE> sections without an C<OUTPUT>
1155section.
1156
1157=item *
1158
1159L<Encode> has been upgraded to 2.49.
1160
1161The Mac alias x-mac-ce has been added, and various bugs have been fixed
1162in Encode::Unicode, Encode::UTF7 and Encode::GSM0338.
1163
1164=item *
1165
1166L<Env> has been upgraded to 1.04.
1167
1168Its SPLICE implementation no longer misbehaves in list context.
1169
1170=item *
1171
1172L<ExtUtils::CBuilder> has been upgraded to 0.280210.
1173
1174Manifest files are now correctly embedded for those versions of VC++ which
1175make use of them. [perl #111782, #111798].
1176
1177A list of symbols to export can now be passed to C<link()> when on
1178Windows, as on other OSes [perl #115100].
1179
1180=item *
1181
1182L<ExtUtils::ParseXS> has been upgraded to 3.18.
1183
1184The generated C code now avoids unnecessarily incrementing
1185C<PL_amagic_generation> on Perl versions where it's done automatically
1186(or on current Perl where the variable no longer exists).
1187
1188This avoids a bogus warning for initialised XSUB non-parameters [perl
1189#112776].
1190
1191=item *
1192
1193L<File::Copy> has been upgraded to 2.26.
1194
1195C<copy()> no longer zeros files when copying into the same directory,
1196and also now fails (as it has long been documented to do) when attempting
1197to copy a file over itself.
1198
1199=item *
1200
1201L<File::DosGlob> has been upgraded to 1.10.
1202
1203The internal cache of file names that it keeps for each caller is now
1204freed when that caller is freed. This means
1205C<< use File::DosGlob 'glob'; eval 'scalar <*>' >> no longer leaks memory.
1206
1207=item *
1208
1209L<File::Fetch> has been upgraded to 0.38.
1210
1211Added the 'file_default' option for URLs that do not have a file
1212component.
1213
1214Use C<File::HomeDir> when available, and provide C<PERL5_CPANPLUS_HOME> to
1215override the autodetection.
1216
1217Always re-fetch F<CHECKSUMS> if C<fetchdir> is set.
1218
1219=item *
1220
1221L<File::Find> has been upgraded to 1.23.
1222
1223This fixes inconsistent unixy path handling on VMS.
1224
1225Individual files may now appear in list of directories to be searched
1226[perl #59750].
1227
1228=item *
1229
1230L<File::Glob> has been upgraded to 1.20.
1231
1232File::Glob has had exactly the same fix as File::DosGlob. Since it is
1233what Perl's own C<glob> operator itself uses (except on VMS), this means
1234C<< eval 'scalar <*>' >> no longer leaks.
1235
1236A space-separated list of patterns return long lists of results no longer
1237results in memory corruption or crashes. This bug was introduced in
1238Perl 5.16.0. [perl #114984]
1239
1240=item *
1241
1242L<File::Spec::Unix> has been upgraded to 3.40.
1243
1244C<abs2rel> could produce incorrect results when given two relative paths or
1245the root directory twice [perl #111510].
1246
1247=item *
1248
1249L<File::stat> has been upgraded to 1.07.
1250
1251C<File::stat> ignores the L<filetest> pragma, and warns when used in
1252combination therewith. But it was not warning for C<-r>. This has been
1253fixed [perl #111640].
1254
1255C<-p> now works, and does not return false for pipes [perl #111638].
1256
1257Previously C<File::stat>'s overloaded C<-x> and C<-X> operators did not give
1258the correct results for directories or executable files when running as
1259root. They had been treating executable permissions for root just like for
1260any other user, performing group membership tests I<etc> for files not owned
1261by root. They now follow the correct Unix behaviour - for a directory they
1262are always true, and for a file if any of the three execute permission bits
1263are set then they report that root can execute the file. Perl's builtin
1264C<-x> and C<-X> operators have always been correct.
1265
1266=item *
1267
1268L<File::Temp> has been upgraded to 0.23
1269
1270Fixes various bugs involving directory removal. Defers unlinking tempfiles if
1271the initial unlink fails, which fixes problems on NFS.
1272
1273=item *
1274
1275L<GDBM_File> has been upgraded to 1.15.
1276
1277The undocumented optional fifth parameter to C<TIEHASH> has been
1278removed. This was intended to provide control of the callback used by
1279C<gdbm*> functions in case of fatal errors (such as filesystem problems),
1280but did not work (and could never have worked). No code on CPAN even
1281attempted to use it. The callback is now always the previous default,
1282C<croak>. Problems on some platforms with how the C<C> C<croak> function
1283is called have also been resolved.
1284
1285=item *
1286
1287L<Hash::Util> has been upgraded to 0.15.
1288
1289C<hash_unlocked> and C<hashref_unlocked> now returns true if the hash is
1290unlocked, instead of always returning false [perl #112126].
1291
1292C<hash_unlocked>, C<hashref_unlocked>, C<lock_hash_recurse> and
1293C<unlock_hash_recurse> are now exportable [perl #112126].
1294
1295Two new functions, C<hash_locked> and C<hashref_locked>, have been added.
1296Oddly enough, these two functions were already exported, even though they
1297did not exist [perl #112126].
1298
1299=item *
1300
1301L<HTTP::Tiny> has been upgraded to 0.025.
1302
1303Add SSL verification features [github #6], [github #9].
1304
1305Include the final URL in the response hashref.
1306
1307Add C<local_address> option.
1308
1309This improves SSL support.
1310
1311=item *
1312
1313L<IO> has been upgraded to 1.28.
1314
1315C<sync()> can now be called on read-only file handles [perl #64772].
1316
1317L<IO::Socket> tries harder to cache or otherwise fetch socket
1318information.
1319
1320=item *
1321
1322L<IPC::Cmd> has been upgraded to 0.80.
1323
1324Use C<POSIX::_exit> instead of C<exit> in C<run_forked> [rt.cpan.org #76901].
1325
1326=item *
1327
1328L<IPC::Open3> has been upgraded to 1.13.
1329
1330The C<open3()> function no longer uses C<POSIX::close()> to close file
1331descriptors since that breaks the ref-counting of file descriptors done by
1332PerlIO in cases where the file descriptors are shared by PerlIO streams,
1333leading to attempts to close the file descriptors a second time when
1334any such PerlIO streams are closed later on.
1335
1336=item *
1337
1338L<Locale::Codes> has been upgraded to 3.25.
1339
1340It includes some new codes.
1341
1342=item *
1343
1344L<Memoize> has been upgraded to 1.03.
1345
1346Fix the C<MERGE> cache option.
1347
1348=item *
1349
1350L<Module::Build> has been upgraded to 0.4003.
1351
1352Fixed bug where modules without C<$VERSION> might have a version of '0' listed
1353in 'provides' metadata, which will be rejected by PAUSE.
1354
1355Fixed bug in PodParser to allow numerals in module names.
1356
1357Fixed bug where giving arguments twice led to them becoming arrays, resulting
1358in install paths like F<ARRAY(0xdeadbeef)/lib/Foo.pm>.
1359
1360A minor bug fix allows markup to be used around the leading "Name" in
1361a POD "abstract" line, and some documentation improvements have been made.
1362
1363=item *
1364
1365L<Module::CoreList> has been upgraded to 2.90
1366
1367Version information is now stored as a delta, which greatly reduces the
1368size of the F<CoreList.pm> file.
1369
1370This restores compatibility with older versions of perl and cleans up
1371the corelist data for various modules.
1372
1373=item *
1374
1375L<Module::Load::Conditional> has been upgraded to 0.54.
1376
1377Fix use of C<requires> on perls installed to a path with spaces.
1378
1379Various enhancements include the new use of Module::Metadata.
1380
1381=item *
1382
1383L<Module::Metadata> has been upgraded to 1.000011.
1384
1385The creation of a Module::Metadata object for a typical module file has
1386been sped up by about 40%, and some spurious warnings about C<$VERSION>s
1387have been suppressed.
1388
1389=item *
1390
1391L<Module::Pluggable> has been upgraded to 4.7.
1392
1393Amongst other changes, triggers are now allowed on events, which gives
1394a powerful way to modify behaviour.
1395
1396=item *
1397
1398L<Net::Ping> has been upgraded to 2.41.
1399
1400This fixes some test failures on Windows.
1401
1402=item *
1403
1404L<Opcode> has been upgraded to 1.25.
1405
1406Reflect the removal of the boolkeys opcode and the addition of the
1407clonecv, introcv and padcv opcodes.
1408
1409=item *
1410
1411L<overload> has been upgraded to 1.22.
1412
1413C<no overload> now warns for invalid arguments, just like C<use overload>.
1414
1415=item *
1416
1417L<PerlIO::encoding> has been upgraded to 0.16.
1418
1419This is the module implementing the ":encoding(...)" I/O layer. It no
1420longer corrupts memory or crashes when the encoding back-end reallocates
1421the buffer or gives it a typeglob or shared hash key scalar.
1422
1423=item *
1424
1425L<PerlIO::scalar> has been upgraded to 0.16.
1426
1427The buffer scalar supplied may now only contain code pounts 0xFF or
1428lower. [perl #109828]
1429
1430=item *
1431
1432L<Perl::OSType> has been upgraded to 1.003.
1433
1434This fixes a bug detecting the VOS operating system.
1435
1436=item *
1437
1438L<Pod::Html> has been upgraded to 1.18.
1439
1440The option C<--libpods> has been reinstated. It is deprecated, and its use
1441does nothing other than issue a warning that it is no longer supported.
1442
1443Since the HTML files generated by pod2html claim to have a UTF-8 charset,
1444actually write the files out using UTF-8 [perl #111446].
1445
1446=item *
1447
1448L<Pod::Simple> has been upgraded to 3.28.
1449
1450Numerous improvements have been made, mostly to Pod::Simple::XHTML,
1451which also has a compatibility change: the C<codes_in_verbatim> option
1452is now disabled by default. See F<cpan/Pod-Simple/ChangeLog> for the
1453full details.
1454
1455=item *
1456
1457L<re> has been upgraded to 0.23
1458
1459Single character [class]es like C</[s]/> or C</[s]/i> are now optimized
1460as if they did not have the brackets, i.e. C</s/> or C</s/i>.
1461
1462See note about C<op_comp> in the L</Internal Changes> section below.
1463
1464=item *
1465
1466L<Safe> has been upgraded to 2.35.
1467
1468Fix interactions with C<Devel::Cover>.
1469
1470Don't eval code under C<no strict>.
1471
1472=item *
1473
1474L<Scalar::Util> has been upgraded to version 1.27.
1475
1476Fix an overloading issue with C<sum>.
1477
1478C<first> and C<reduce> now check the callback first (so C<&first(1)> is
1479disallowed).
1480
1481Fix C<tainted> on magical values [rt.cpan.org #55763].
1482
1483Fix C<sum> on previously magical values [rt.cpan.org #61118].
1484
1485Fix reading past the end of a fixed buffer [rt.cpan.org #72700].
1486
1487=item *
1488
1489L<Search::Dict> has been upgraded to 1.07.
1490
1491No longer require C<stat> on filehandles.
1492
1493Use C<fc> for casefolding.
1494
1495=item *
1496
1497L<Socket> has been upgraded to 2.009.
1498
1499Constants and functions required for IP multicast source group membership
1500have been added.
1501
1502C<unpack_sockaddr_in()> and C<unpack_sockaddr_in6()> now return just the IP
1503address in scalar context, and C<inet_ntop()> now guards against incorrect
1504length scalars being passed in.
1505
1506This fixes an uninitialized memory read.
1507
1508=item *
1509
1510L<Storable> has been upgraded to 2.41.
1511
1512Modifying C<$_[0]> within C<STORABLE_freeze> no longer results in crashes
1513[perl #112358].
1514
1515An object whose class implements C<STORABLE_attach> is now thawed only once
1516when there are multiple references to it in the structure being thawed
1517[perl #111918].
1518
1519Restricted hashes were not always thawed correctly [perl #73972].
1520
1521Storable would croak when freezing a blessed REF object with a
1522C<STORABLE_freeze()> method [perl #113880].
1523
1524It can now freeze and thaw vstrings correctly. This causes a slight
1525incompatible change in the storage format, so the format version has
1526increased to 2.9.
1527
1528This contains various bugfixes, including compatibility fixes for older
1529versions of Perl and vstring handling.
1530
1531=item *
1532
1533L<Sys::Syslog> has been upgraded to 0.32.
1534
1535This contains several bug fixes relating to C<getservbyname()>,
1536C<setlogsock()>and log levels in C<syslog()>, together with fixes for
1537Windows, Haiku-OS and GNU/kFreeBSD. See F<cpan/Sys-Syslog/Changes>
1538for the full details.
1539
1540=item *
1541
1542L<Term::ANSIColor> has been upgraded to 4.02.
1543
1544Add support for italics.
1545
1546Improve error handling.
1547
1548=item *
1549
1550L<Term::ReadLine> has been upgraded to 1.10. This fixes the
1551use of the B<cpan> and B<cpanp> shells on Windows in the event that the current
1552drive happens to contain a F<\dev\tty> file.
1553
1554=item *
1555
1556L<Test::Harness> has been upgraded to 3.26.
1557
1558Fix glob semantics on Win32 [rt.cpan.org #49732].
1559
1560Don't use C<Win32::GetShortPathName> when calling perl [rt.cpan.org #47890].
1561
1562Ignore -T when reading shebang [rt.cpan.org #64404].
1563
1564Handle the case where we don't know the wait status of the test more
1565gracefully.
1566
1567Make the test summary 'ok' line overridable so that it can be changed to a
1568plugin to make the output of prove idempotent.
1569
1570Don't run world-writable files.
1571
1572=item *
1573
1574L<Text::Tabs> and L<Text::Wrap> have been upgraded to
15752012.0818. Support for Unicode combining characters has been added to them
1576both.
1577
1578=item *
1579
1580L<threads::shared> has been upgraded to 1.31.
1581
1582This adds the option to warn about or ignore attempts to clone structures
1583that can't be cloned, as opposed to just unconditionally dying in
1584that case.
1585
1586This adds support for dual-valued values as created by
1587L<Scalar::Util::dualvar|Scalar::Util/"dualvar NUM, STRING">.
1588
1589=item *
1590
1591L<Tie::StdHandle> has been upgraded to 4.3.
1592
1593C<READ> now respects the offset argument to C<read> [perl #112826].
1594
1595=item *
1596
1597L<Time::Local> has been upgraded to 1.2300.
1598
1599Seconds values greater than 59 but less than 60 no longer cause
1600C<timegm()> and C<timelocal()> to croak.
1601
1602=item *
1603
1604L<Unicode::UCD> has been upgraded to 0.53.
1605
1606This adds a function L<all_casefolds()|Unicode::UCD/all_casefolds()>
1607that returns all the casefolds.
1608
1609=item *
1610
1611L<Win32> has been upgraded to 0.47.
1612
1613New APIs have been added for getting and setting the current code page.
1614
1615=back
1616
1617
1618=head2 Removed Modules and Pragmata
1619
1620=over
1621
1622=item *
1623
1624L<Version::Requirements> has been removed from the core distribution. It is
1625available under a different name: L<CPAN::Meta::Requirements>.
1626
1627=back
1628
1629=head1 Documentation
1630
1631=head2 Changes to Existing Documentation
1632
1633=head3 L<perlcheat>
1634
1635=over 4
1636
1637=item *
1638
1639L<perlcheat> has been reorganized, and a few new sections were added.
1640
1641=back
1642
1643=head3 L<perldata>
1644
1645=over 4
1646
1647=item *
1648
1649Now explicitly documents the behaviour of hash initializer lists that
1650contain duplicate keys.
1651
1652=back
1653
1654=head3 L<perldiag>
1655
1656=over 4
1657
1658=item *
1659
1660The explanation of symbolic references being prevented by "strict refs"
1661now doesn't assume that the reader knows what symbolic references are.
1662
1663=back
1664
1665=head3 L<perlfaq>
1666
1667=over 4
1668
1669=item *
1670
1671L<perlfaq> has been synchronized with version 5.0150040 from CPAN.
1672
1673=back
1674
1675=head3 L<perlfunc>
1676
1677=over 4
1678
1679=item *
1680
1681The return value of C<pipe> is now documented.
1682
1683=item *
1684
1685Clarified documentation of C<our>.
1686
1687=back
1688
1689=head3 L<perlop>
1690
1691=over 4
1692
1693=item *
1694
1695Loop control verbs (C<dump>, C<goto>, C<next>, C<last> and C<redo>) have always
1696had the same precedence as assignment operators, but this was not documented
1697until now.
1698
1699=back
1700
1701=head3 Diagnostics
1702
1703The following additions or changes have been made to diagnostic output,
1704including warnings and fatal error messages. For the complete list of
1705diagnostic messages, see L<perldiag>.
1706
1707=head2 New Diagnostics
1708
1709=head3 New Errors
1710
1711=over 4
1712
1713=item *
1714
1715L<Unterminated delimiter for here document|perldiag/"Unterminated delimiter for here document">
1716
1717This message now occurs when a here document label has an initial quotation
1718mark but the final quotation mark is missing.
1719
1720This replaces a bogus and misleading error message about not finding the label
1721itself [perl #114104].
1722
1723=item *
1724
1725L<panic: child pseudo-process was never scheduled|perldiag/"panic: child pseudo-process was never scheduled">
1726
1727This error is thrown when a child pseudo-process in the ithreads implementation
1728on Windows was not scheduled within the time period allowed and therefore was
1729not able to initialize properly [perl #88840].
1730
1731=item *
1732
1733L<Group name must start with a non-digit word character in regex; marked by <-- HERE in mE<sol>%sE<sol>|perldiag/"Group name must start with a non-digit word character in regex; marked by <-- HERE in m/%s/">
1734
1735This error has been added for C<(?&0)>, which is invalid. It used to
1736produce an incomprehensible error message [perl #101666].
1737
1738=item *
1739
1740L<Can't use an undefined value as a subroutine reference|perldiag/"Can't use an undefined value as %s reference">
1741
1742Calling an undefined value as a subroutine now produces this error message.
1743It used to, but was accidentally disabled, first in Perl 5.004 for
1744non-magical variables, and then in Perl v5.14 for magical (e.g., tied)
1745variables. It has now been restored. In the mean time, undef was treated
1746as an empty string [perl #113576].
1747
1748=item *
1749
1750L<Experimental "%s" subs not enabled|perldiag/"Experimental "%s" subs not enabled">
1751
1752To use lexical subs, you must first enable them:
1753
1754 no warnings 'experimental::lexical_subs';
1755 use feature 'lexical_subs';
1756 my sub foo { ... }
1757
1758=back
1759
1760=head3 New Warnings
1761
1762=over 4
1763
1764=item *
1765
1766L<'Strings with code points over 0xFF may not be mapped into in-memory file handles'|perldiag/"Strings with code points over 0xFF may not be mapped into in-memory file handles">
1767
1768=item *
1769
1770L<'%s' resolved to '\o{%s}%d'|perldiag/"'%s' resolved to '\o{%s}%d'">
1771
1772=item *
1773
1774L<'Trailing white-space in a charnames alias definition is deprecated'|perldiag/"Trailing white-space in a charnames alias definition is deprecated">
1775
1776=item *
1777
1778L<'A sequence of multiple spaces in a charnames alias definition is deprecated'|perldiag/"A sequence of multiple spaces in a charnames alias definition is deprecated">
1779
1780=item *
1781
1782L<'Passing malformed UTF-8 to "%s" is deprecated'|perldiag/"Passing malformed UTF-8 to "%s" is deprecated">
1783
1784=item *
1785
1786L<Subroutine "&%s" is not available|perldiag/"Subroutine "&%s" is not available">
1787
1788(W closure) During compilation, an inner named subroutine or eval is
1789attempting to capture an outer lexical subroutine that is not currently
1790available. This can happen for one of two reasons. First, the lexical
1791subroutine may be declared in an outer anonymous subroutine that has not
1792yet been created. (Remember that named subs are created at compile time,
1793while anonymous subs are created at run-time.) For example,
1794
1795 sub { my sub a {...} sub f { \&a } }
1796
1797At the time that f is created, it can't capture the current the "a" sub,
1798since the anonymous subroutine hasn't been created yet. Conversely, the
1799following won't give a warning since the anonymous subroutine has by now
1800been created and is live:
1801
1802 sub { my sub a {...} eval 'sub f { \&a }' }->();
1803
1804The second situation is caused by an eval accessing a variable that has
1805gone out of scope, for example,
1806
1807 sub f {
1808 my sub a {...}
1809 sub { eval '\&a' }
1810 }
1811 f()->();
1812
1813Here, when the '\&a' in the eval is being compiled, f() is not currently
1814being executed, so its &a is not available for capture.
1815
1816=item *
1817
1818L<"%s" subroutine &%s masks earlier declaration in same %s|perldiag/"%s" subroutine &%s masks earlier declaration in same %s>
1819
1820(W misc) A "my" or "state" subroutine has been redeclared in the
1821current scope or statement, effectively eliminating all access to
1822the previous instance. This is almost always a typographical error.
1823Note that the earlier subroutine will still exist until the end of
1824the scope or until all closure references to it are destroyed.
1825
1826=item *
1827
1828L<The %s feature is experimental|perldiag/"The %s feature is experimental">
1829
1830(S experimental) This warning is emitted if you enable an experimental
1831feature via C<use feature>. Simply suppress the warning if you want
1832to use the feature, but know that in doing so you are taking the risk
1833of using an experimental feature which may change or be removed in a
1834future Perl version:
1835
1836 no warnings "experimental::lexical_subs";
1837 use feature "lexical_subs";
1838
1839=item *
1840
1841L<sleep(%u) too large|perldiag/"sleep(%u) too large">
1842
1843(W overflow) You called C<sleep> with a number that was larger than it can
1844reliably handle and C<sleep> probably slept for less time than requested.
1845
1846=item *
1847
1848L<Wide character in setenv|perldiag/"Wide character in %s">
1849
1850Attempts to put wide characters into environment variables via C<%ENV> now
1851provoke this warning.
1852
1853=item *
1854
1855"L<Invalid negative number (%s) in chr|perldiag/"Invalid negative number (%s) in chr">"
1856
1857C<chr()> now warns when passed a negative value [perl #83048].
1858
1859=item *
1860
1861"L<Integer overflow in srand|perldiag/"Integer overflow in srand">"
1862
1863C<srand()> now warns when passed a value that doesn't fit in a C<UV> (since the
1864value will be truncated rather than overflowing) [perl #40605].
1865
1866=item *
1867
1868"L<-i used with no filenames on the command line, reading from STDIN|perldiag/"-i used with no filenames on the command line, reading from STDIN">"
1869
1870Running perl with the C<-i> flag now warns if no input files are provided on
1871the command line [perl #113410].
1872
1873=back
1874
1875=head2 Changes to Existing Diagnostics
1876
1877=over 4
1878
1879=item *
1880
1881L<$* is no longer supported|perldiag/"$* is no longer supported">
1882
1883The warning that use of C<$*> and C<$#> is no longer supported is now
1884generated for every location that references them. Previously it would fail
1885to be generated if another variable using the same typeglob was seen first
1886(e.g. C<@*> before C<$*>), and would not be generated for the second and
1887subsequent uses. (It's hard to fix the failure to generate warnings at all
1888without also generating them every time, and warning every time is
1889consistent with the warnings that C<$[> used to generate.)
1890
1891=item *
1892
1893The warnings for C<\b{> and C<\B{> were added. They are a deprecation
1894warning which should be turned off by that category. One should not
1895have to turn off regular regexp warnings as well to get rid of these.
1896
1897=item *
1898
1899L<Constant(%s): Call to &{$^H{%s}} did not return a defined value|perldiag/Constant(%s): Call to &{$^H{%s}} did not return a defined value>
1900
1901Constant overloading that returns C<undef> results in this error message.
1902For numeric constants, it used to say "Constant(undef)". "undef" has been
1903replaced with the number itself.
1904
1905=item *
1906
1907The error produced when a module cannot be loaded now includes a hint that
1908the module may need to be installed: "Can't locate hopping.pm in @INC (you
1909may need to install the hopping module) (@INC contains: ...)"
1910
1911=item *
1912
1913L<vector argument not supported with alpha versions|perldiag/vector argument not supported with alpha versions>
1914
12b4b02f 1915This warning was not suppressible, even with C<no warnings>. Now it is
e9912eaa
RS
1916suppressible, and has been moved from the "internal" category to the
1917"printf" category.
1918
1919=item *
1920
1921C<< Can't do {n,m} with n > m in regex; marked by <-- HERE in m/%s/ >>
1922
1923This fatal error has been turned into a warning that reads:
1924
1925L<< Quantifier {n,m} with n > m can't match in regex | perldiag/Quantifier {n,m} with n > m can't match in regex >>
1926
1927(W regexp) Minima should be less than or equal to maxima. If you really want
1928your regexp to match something 0 times, just put {0}.
1929
1930=item *
1931
1932The "Runaway prototype" warning that occurs in bizarre cases has been
1933removed as being unhelpful and inconsistent.
1934
1935=item *
1936
1937The "Not a format reference" error has been removed, as the only case in
1938which it could be triggered was a bug.
1939
1940=item *
1941
1942The "Unable to create sub named %s" error has been removed for the same
1943reason.
1944
1945=item *
1946
1947The 'Can't use "my %s" in sort comparison' error has been downgraded to a
1948warning, '"my %s" used in sort comparison' (with 'state' instead of 'my'
1949for state variables). In addition, the heuristics for guessing whether
1950lexical $a or $b has been misused have been improved to generate fewer
1951false positives. Lexical $a and $b are no longer disallowed if they are
1952outside the sort block. Also, a named unary or list operator inside the
1953sort block no longer causes the $a or $b to be ignored [perl #86136].
1954
1955=back
1956
1957=head1 Utility Changes
1958
1959=head3 L<h2xs>
1960
1961=over 4
1962
1963=item *
1964
1965F<h2xs> no longer produces invalid code for empty defines. [perl #20636]
1966
1967=back
1968
1969=head1 Configuration and Compilation
1970
1971=over 4
1972
1973=item *
1974
1975Added C<useversionedarchname> option to Configure
1976
1977When set, it includes 'api_versionstring' in 'archname'. E.g.
1978x86_64-linux-5.13.6-thread-multi. It is unset by default.
1979
1980This feature was requested by Tim Bunce, who observed that
1981C<INSTALL_BASE> creates a library structure that does not
1982differentiate by perl version. Instead, it places architecture
1983specific files in "$install_base/lib/perl5/$archname". This makes
1984it difficult to use a common C<INSTALL_BASE> library path with
1985multiple versions of perl.
1986
1987By setting C<-Duseversionedarchname>, the $archname will be
1988distinct for architecture I<and> API version, allowing mixed use of
1989C<INSTALL_BASE>.
1990
1991=item *
1992
1993Add a C<PERL_NO_INLINE_FUNCTIONS> option
1994
1995If C<PERL_NO_INLINE_FUNCTIONS> is defined, don't include "inline.h"
1996
1997This permits test code to include the perl headers for definitions without
1998creating a link dependency on the perl library (which may not exist yet).
1999
2000=item *
2001
2002Configure will honour the external C<MAILDOMAIN> environment variable, if set.
2003
2004=item *
2005
2006C<installman> no longer ignores the silent option
2007
2008=item *
2009
2010Both C<META.yml> and C<META.json> files are now included in the distribution.
2011
2012=item *
2013
2014F<Configure> will now correctly detect C<isblank()> when compiling with a C++
2015compiler.
2016
2017=item *
2018
2019The pager detection in F<Configure> has been improved to allow responses which
2020specify options after the program name, e.g. B</usr/bin/less -R>, if the user
2021accepts the default value. This helps B<perldoc> when handling ANSI escapes
2022[perl #72156].
2023
2024=back
2025
2026=head1 Testing
2027
2028=over 4
2029
2030=item *
2031
2032The test suite now has a section for tests that require very large amounts
2033of memory. These tests won't run by default; they can be enabled by
2034setting the C<PERL_TEST_MEMORY> environment variable to the number of
2035gibibytes of memory that may be safely used.
2036
2037=back
2038
2039=head1 Platform Support
2040
2041=head2 Discontinued Platforms
2042
2043=over 4
2044
2045=item BeOS
2046
2047BeOS was an operating system for personal computers developed by Be Inc,
2048initially for their BeBox hardware. The OS Haiku was written as an open
2049source replacement for/continuation of BeOS, and its perl port is current and
2050actively maintained.
2051
2052=item UTS Global
2053
2054Support code relating to UTS global has been removed. UTS was a mainframe
2055version of System V created by Amdahl, subsequently sold to UTS Global. The
2056port has not been touched since before Perl v5.8.0, and UTS Global is now
2057defunct.
2058
2059=item VM/ESA
2060
2061Support for VM/ESA has been removed. The port was tested on 2.3.0, which
2062IBM ended service on in March 2002. 2.4.0 ended service in June 2003, and
2063was superseded by Z/VM. The current version of Z/VM is V6.2.0, and scheduled
2064for end of service on 2015/04/30.
2065
2066=item MPE/IX
2067
2068Support for MPE/IX has been removed.
2069
2070=item EPOC
2071
2072Support code relating to EPOC has been removed. EPOC was a family of
2073operating systems developed by Psion for mobile devices. It was the
2074predecessor of Symbian. The port was last updated in April 2002.
2075
2076=item Rhapsody
2077
2078Support for Rhapsody has been removed.
2079
2080=back
2081
2082=head2 Platform-Specific Notes
2083
2084=head3 AIX
2085
2086Configure now always adds C<-qlanglvl=extc99> to the CC flags on AIX when
2087using xlC. This will make it easier to compile a number of XS-based modules
2088that assume C99 [perl #113778].
2089
2090=head3 clang++
2091
2092There is now a workaround for a compiler bug that prevented compiling
2093with clang++ since Perl v5.15.7 [perl #112786].
2094
2095=head3 C++
2096
2097When compiling the Perl core as C++ (which is only semi-supported), the
2098mathom functions are now compiled as C<extern "C">, to ensure proper
2099binary compatibility. (However, binary compatibility isn't generally
2100guaranteed anyway in the situations where this would matter.)
2101
2102=head3 Darwin
2103
2104Stop hardcoding an alignment on 8 byte boundaries to fix builds using
2105-Dusemorebits.
2106
2107=head3 Haiku
2108
2109Perl should now work out of the box on Haiku R1 Alpha 4.
2110
2111=head3 MidnightBSD
2112
2113C<libc_r> was removed from recent versions of MidnightBSD and older versions
2114work better with C<pthread>. Threading is now enabled using C<pthread> which
2115corrects build errors with threading enabled on 0.4-CURRENT.
2116
2117=head3 Solaris
2118
2119In Configure, avoid running sed commands with flags not supported on Solaris.
2120
2121=head3 VMS
2122
2123=over
2124
2125=item *
2126
2127Where possible, the case of filenames and command-line arguments is now
2128preserved by enabling the CRTL features C<DECC$EFS_CASE_PRESERVE> and
2129C<DECC$ARGV_PARSE_STYLE> at start-up time. The latter only takes effect
2130when extended parse is enabled in the process from which Perl is run.
2131
2132=item *
2133
2134The character set for Extended Filename Syntax (EFS) is now enabled by default
2135on VMS. Among other things, this provides better handling of dots in directory
2136names, multiple dots in filenames, and spaces in filenames. To obtain the old
2137behavior, set the logical name C<DECC$EFS_CHARSET> to C<DISABLE>.
2138
2139=item *
2140
2141Fixed linking on builds configured with C<-Dusemymalloc=y>.
2142
2143=item *
2144
2145Experimental support for building Perl with the HP C++ compiler is available
2146by configuring with C<-Dusecxx>.
2147
2148=item *
2149
2150All C header files from the top-level directory of the distribution are now
2151installed on VMS, providing consistency with a long-standing practice on other
2152platforms. Previously only a subset were installed, which broke non-core
2153extension builds for extensions that depended on the missing include files.
2154
2155=item *
2156
2157Quotes are now removed from the command verb (but not the parameters) for
2158commands spawned via C<system>, backticks, or a piped C<open>. Previously,
2159quotes on the verb were passed through to DCL, which would fail to recognize
2160the command. Also, if the verb is actually a path to an image or command
2161procedure on an ODS-5 volume, quoting it now allows the path to contain spaces.
2162
2163=item *
2164
2165The B<a2p> build has been fixed for the HP C++ compiler on OpenVMS.
2166
2167=back
2168
2169=head3 Win32
2170
2171=over
2172
2173=item *
2174
2175Perl can now be built using Microsoft's Visual C++ 2012 compiler by specifying
2176CCTYPE=MSVC110 (or MSVC110FREE if you are using the free Express edition for
2177Windows Desktop) in F<win32/Makefile>.
2178
2179=item *
2180
2181The option to build without C<USE_SOCKETS_AS_HANDLES> has been removed.
2182
2183=item *
2184
2185Fixed a problem where perl could crash while cleaning up threads (including the
2186main thread) in threaded debugging builds on Win32 and possibly other platforms
2187[perl #114496].
2188
2189=item *
2190
2191A rare race condition that would lead to L<sleep|perlfunc/sleep> taking more
2192time than requested, and possibly even hanging, has been fixed [perl #33096].
2193
2194=item *
2195
2196C<link> on Win32 now attempts to set C<$!> to more appropriate values
2197based on the Win32 API error code. [perl #112272]
2198
2199Perl no longer mangles the environment block, e.g. when launching a new
2200sub-process, when the environment contains non-ASCII characters. Known
2201problems still remain, however, when the environment contains characters
2202outside of the current ANSI codepage (e.g. see the item about Unicode in
2203C<%ENV> in L<http://perl5.git.perl.org/perl.git/blob/HEAD:/Porting/todo.pod>).
2204[perl #113536]
2205
2206=item *
2207
2208Building perl with some Windows compilers used to fail due to a problem
2209with miniperl's C<glob> operator (which uses the C<perlglob> program)
2210deleting the PATH environment variable [perl #113798].
2211
2212=item *
2213
2214A new makefile option, C<USE_64_BIT_INT>, has been added to the Windows
2215makefiles. Set this to "define" when building a 32-bit perl if you want
2216it to use 64-bit integers.
2217
2218Machine code size reductions, already made to the DLLs of XS modules in
2219Perl v5.17.2, have now been extended to the perl DLL itself.
2220
2221Building with VC++ 6.0 was inadvertently broken in Perl v5.17.2 but has
2222now been fixed again.
2223
2224=back
2225
2226=head3 WinCE
2227
2228Building on WinCE is now possible once again, although more work is required
2229to fully restore a clean build.
2230
2231=head1 Internal Changes
2232
2233=over
2234
2235=item *
2236
2237Synonyms for the misleadingly named C<av_len()> have been created:
2238C<av_top_index()> and C<av_tindex>. All three of these return the
2239number of the highest index in the array, not the number of elements it
2240contains.
2241
2242=item *
2243
2244SvUPGRADE() is no longer an expression. Originally this macro (and its
2245underlying function, sv_upgrade()) were documented as boolean, although
2246in reality they always croaked on error and never returned false. In 2005
2247the documentation was updated to specify a void return value, but
2248SvUPGRADE() was left always returning 1 for backwards compatibility. This
2249has now been removed, and SvUPGRADE() is now a statement with no return
2250value.
2251
2252So this is now a syntax error:
2253
2254 if (!SvUPGRADE(sv)) { croak(...); }
2255
2256If you have code like that, simply replace it with
2257
2258 SvUPGRADE(sv);
2259
2260or to avoid compiler warnings with older perls, possibly
2261
2262 (void)SvUPGRADE(sv);
2263
2264=item *
2265
2266Perl has a new copy-on-write mechanism that allows any SvPOK scalar to be
2267upgraded to a copy-on-write scalar. A reference count on the string buffer
2268is stored in the string buffer itself. This feature is B<not enabled by
2269default>.
2270
2271It can be enabled in a perl build by running F<Configure> with
2272B<-Accflags=-DPERL_NEW_COPY_ON_WRITE>, and we would encourage XS authors
2273to try their code with such an enabled perl, and provide feedback.
2274Unfortunately, there is not yet a good guide to updating XS code to cope
2275with COW. Until such a document is available, consult the perl5-porters
2276mailing list.
2277
2278It breaks a few XS modules by allowing copy-on-write scalars to go
2279through code paths that never encountered them before.
2280
2281=item *
2282
2283Copy-on-write no longer uses the SvFAKE and SvREADONLY flags. Hence,
2284SvREADONLY indicates a true read-only SV.
2285
2286Use the SvIsCOW macro (as before) to identify a copy-on-write scalar.
2287
2288=item *
2289
2290C<PL_glob_index> is gone.
2291
2292=item *
2293
2294The private Perl_croak_no_modify has had its context parameter removed. It is
2295now has a void prototype. Users of the public API croak_no_modify remain
2296unaffected.
2297
2298=item *
2299
2300Copy-on-write (shared hash key) scalars are no longer marked read-only.
2301C<SvREADONLY> returns false on such an SV, but C<SvIsCOW> still returns
2302true.
2303
2304=item *
2305
2306A new op type, C<OP_PADRANGE> has been introduced. The perl peephole
2307optimiser will, where possible, substitute a single padrange op for a
2308pushmark followed by one or more pad ops, and possibly also skipping list
2309and nextstate ops. In addition, the op can carry out the tasks associated
2310with the RHS of a C<< my(...) = @_ >> assignment, so those ops may be optimised
2311away too.
2312
2313=item *
2314
2315Case-insensitive matching inside a [bracketed] character class with a
2316multi-character fold no longer excludes one of the possibilities in the
2317circumstances that it used to. [perl #89774].
2318
2319=item *
2320
2321C<PL_formfeed> has been removed.
2322
2323=item *
2324
2325The regular expression engine no longer reads one byte past the end of the
2326target string. While for all internally well-formed scalars this should
2327never have been a problem, this change facilitates clever tricks with
2328string buffers in CPAN modules. [perl #73542]
2329
2330=item *
2331
2332Inside a BEGIN block, C<PL_compcv> now points to the currently-compiling
2333subroutine, rather than the BEGIN block itself.
2334
2335=item *
2336
2337C<mg_length> has been deprecated.
2338
2339=item *
2340
2341C<sv_len> now always returns a byte count and C<sv_len_utf8> a character
2342count. Previously, C<sv_len> and C<sv_len_utf8> were both buggy and would
2343sometimes returns bytes and sometimes characters. C<sv_len_utf8> no longer
2344assumes that its argument is in UTF-8. Neither of these creates UTF-8 caches
2345for tied or overloaded values or for non-PVs any more.
2346
2347=item *
2348
2349C<sv_mortalcopy> now copies string buffers of shared hash key scalars when
2350called from XS modules [perl #79824].
2351
2352=item *
2353
2354C<RXf_SPLIT> and C<RXf_SKIPWHITE> are no longer used. They are now
2355#defined as 0.
2356
2357=item *
2358
2359The new C<RXf_MODIFIES_VARS> flag can be set by custom regular expression
2360engines to indicate that the execution of the regular expression may cause
2361variables to be modified. This lets C<s///> know to skip certain
2362optimisations. Perl's own regular expression engine sets this flag for the
2363special backtracking verbs that set $REGMARK and $REGERROR.
2364
2365=item *
2366
2367The APIs for accessing lexical pads have changed considerably.
2368
2369C<PADLIST>s are now longer C<AV>s, but their own type instead.
2370C<PADLIST>s now contain a C<PAD> and a C<PADNAMELIST> of C<PADNAME>s,
2371rather than C<AV>s for the pad and the list of pad names. C<PAD>s,
2372C<PADNAMELIST>s, and C<PADNAME>s are to be accessed as such through the
2373newly added pad API instead of the plain C<AV> and C<SV> APIs. See
2374L<perlapi> for details.
2375
2376=item *
2377
2378In the regex API, the numbered capture callbacks are passed an index
2379indicating what match variable is being accessed. There are special
2380index values for the C<$`, $&, $&> variables. Previously the same three
2381values were used to retrieve C<${^PREMATCH}, ${^MATCH}, ${^POSTMATCH}>
2382too, but these have now been assigned three separate values. See
2383L<perlreapi/Numbered capture callbacks>.
2384
2385=item *
2386
2387C<PL_sawampersand> was previously a boolean indicating that any of
2388C<$`, $&, $&> had been seen; it now contains three one-bit flags
2389indicating the presence of each of the variables individually.
2390
2391=item *
2392
2393The C<CV *> typemap entry now supports C<&{}> overloading and typeglobs,
2394just like C<&{...}> [perl #96872].
2395
2396=item *
2397
2398The C<SVf_AMAGIC> flag to indicate overloading is now on the stash, not the
2399object. It is now set automatically whenever a method or @ISA changes, so
2400its meaning has changed, too. It now means "potentially overloaded". When
2401the overload table is calculated, the flag is automatically turned off if
2402there is no overloading, so there should be no noticeable slowdown.
2403
2404The staleness of the overload tables is now checked when overload methods
2405are invoked, rather than during C<bless>.
2406
2407"A" magic is gone. The changes to the handling of the C<SVf_AMAGIC> flag
2408eliminate the need for it.
2409
2410C<PL_amagic_generation> has been removed as no longer necessary. For XS
2411modules, it is now a macro alias to C<PL_na>.
2412
2413The fallback overload setting is now stored in a stash entry separate from
2414overloadedness itself.
2415
2416=item *
2417
2418The character-processing code has been cleaned up in places. The changes
2419should be operationally invisible.
2420
2421=item *
2422
2423The C<study> function was made a no-op in v5.16. It was simply disabled via
2424a C<return> statement; the code was left in place. Now the code supporting
2425what C<study> used to do has been removed.
2426
2427=item *
2428
2429Under threaded perls, there is no longer a separate PV allocated for every
2430COP to store its package name (C<< cop->stashpv >>). Instead, there is an
2431offset (C<< cop->stashoff >>) into the new C<PL_stashpad> array, which
2432holds stash pointers.
2433
2434=item *
2435
2436In the pluggable regex API, the C<regexp_engine> struct has acquired a new
2437field C<op_comp>, which is currently just for perl's internal use, and
2438should be initialized to NULL by other regex plugin modules.
2439
2440=item *
2441
2442A new function C<alloccopstash> has been added to the API, but is considered
2443experimental. See L<perlapi>.
2444
2445=item *
2446
2447Perl used to implement get magic in a way that would sometimes hide bugs in
2448code that could call mg_get() too many times on magical values. This hiding of
2449errors no longer occurs, so long-standing bugs may become visible now. If
2450you see magic-related errors in XS code, check to make sure it, together
2451with the Perl API functions it uses, calls mg_get() only once on SvGMAGICAL()
2452values.
2453
2454=item *
2455
2456OP allocation for CVs now uses a slab allocator. This simplifies
2457memory management for OPs allocated to a CV, so cleaning up after a
2458compilation error is simpler and safer [perl #111462][perl #112312].
2459
2460=item *
2461
2462C<PERL_DEBUG_READONLY_OPS> has been rewritten to work with the new slab
2463allocator, allowing it to catch more violations than before.
2464
2465=item *
2466
2467The old slab allocator for ops, which was only enabled for C<PERL_IMPLICIT_SYS>
2468and C<PERL_DEBUG_READONLY_OPS>, has been retired.
2469
2470=back
2471
2472=head1 Selected Bug Fixes
2473
2474=over 4
2475
2476=item *
2477
2478Here document terminators no longer require a terminating newline character when
2479they occur at the end of a file. This was already the case at the end of a
2480string eval [perl #65838].
2481
2482=item *
2483
2484C<-DPERL_GLOBAL_STRUCT> builds now free the global struct B<after>
2485they've finished using it.
2486
2487=item *
2488
2489A trailing '/' on a path in @INC will no longer have an additional '/'
2490appended.
2491
2492=item *
2493
2494The C<:crlf> layer now works when unread data doesn't fit into its own
2495buffer. [perl #112244].
2496
2497=item *
2498
2499C<ungetc()> now handles UTF-8 encoded data. [perl #116322].
2500
2501=item *
2502
2503A bug in the core typemap caused any C types that map to the T_BOOL core
2504typemap entry to not be set, updated, or modified when the T_BOOL variable was
2505used in an OUTPUT: section with an exception for RETVAL. T_BOOL in an INPUT:
2506section was not affected. Using a T_BOOL return type for an XSUB (RETVAL)
2507was not affected. A side effect of fixing this bug is, if a T_BOOL is specified
2508in the OUTPUT: section (which previous did nothing to the SV), and a read only
2509SV (literal) is passed to the XSUB, croaks like "Modification of a read-only
2510value attempted" will happen. [perl #115796]
2511
2512=item *
2513
2514On many platforms, providing a directory name as the script name caused perl
2515to do nothing and report success. It should now universally report an error
2516and exit nonzero. [perl #61362]
2517
2518=item *
2519
2520C<sort {undef} ...> under fatal warnings no longer crashes. It had
2521begun crashing in Perl v5.16.
2522
2523=item *
2524
2525Stashes blessed into each other
2526(C<bless \%Foo::, 'Bar'; bless \%Bar::, 'Foo'>) no longer result in double
2527frees. This bug started happening in Perl v5.16.
2528
2529=item *
2530
2531Numerous memory leaks have been fixed, mostly involving fatal warnings and
2532syntax errors.
2533
2534=item *
2535
2536Some failed regular expression matches such as C<'f' =~ /../g> were not
2537resetting C<pos>. Also, "match-once" patterns (C<m?...?g>) failed to reset
2538it, too, when invoked a second time [perl #23180].
2539
2540=item *
2541
2542Several bugs involving C<local *ISA> and C<local *Foo::> causing stale
2543MRO caches have been fixed.
2544
2545=item *
2546
2547Defining a subroutine when its typeglob has been aliased no longer results
2548in stale method caches. This bug was introduced in Perl v5.10.
2549
2550=item *
2551
2552Localising a typeglob containing a subroutine when the typeglob's package
2553has been deleted from its parent stash no longer produces an error. This
2554bug was introduced in Perl v5.14.
2555
2556=item *
2557
2558Under some circumstances, C<local *method=...> would fail to reset method
2559caches upon scope exit.
2560
2561=item *
2562
2563C</[.foo.]/> is no longer an error, but produces a warning (as before) and
2564is treated as C</[.fo]/> [perl #115818].
2565
2566=item *
2567
2568C<goto $tied_var> now calls FETCH before deciding what type of goto
2569(subroutine or label) this is.
2570
2571=item *
2572
2573Renaming packages through glob assignment
2574(C<*Foo:: = *Bar::; *Bar:: = *Baz::>) in combination with C<m?...?> and
2575C<reset> no longer makes threaded builds crash.
2576
2577=item *
2578
2579A number of bugs related to assigning a list to hash have been fixed. Many of
2580these involve lists with repeated keys like C<(1, 1, 1, 1)>.
2581
2582=over 4
2583
2584=item *
2585
2586The expression C<scalar(%h = (1, 1, 1, 1))> now returns C<4>, not C<2>.
2587
2588=item *
2589
2590The return value of C<%h = (1, 1, 1)> in list context was wrong. Previously
2591this would return C<(1, undef, 1)>, now it returns C<(1, undef)>.
2592
2593=item *
2594
2595Perl now issues the same warning on C<($s, %h) = (1, {})> as it does for
2596C<(%h) = ({})>, "Reference found where even-sized list expected".
2597
2598=item *
2599
2600A number of additional edge cases in list assignment to hashes were
2601corrected. For more details see commit 23b7025ebc.
2602
2603=back
2604
2605=item *
2606
2607Attributes applied to lexical variables no longer leak memory.
2608[perl #114764]
2609
2610=item *
2611
2612C<dump>, C<goto>, C<last>, C<next>, C<redo> or C<require> followed by a
2613bareword (or version) and then an infix operator is no longer a syntax
2614error. It used to be for those infix operators (like C<+>) that have a
2615different meaning where a term is expected. [perl #105924]
2616
2617=item *
2618
2619C<require a::b . 1> and C<require a::b + 1> no longer produce erroneous
2620ambiguity warnings. [perl #107002]
2621
2622=item *
2623
2624Class method calls are now allowed on any string, and not just strings
2625beginning with an alphanumeric character. [perl #105922]
2626
2627=item *
2628
2629An empty pattern created with C<qr//> used in C<m///> no longer triggers
2630the "empty pattern reuses last pattern" behaviour. [perl #96230]
2631
2632=item *
2633
2634Tying a hash during iteration no longer results in a memory leak.
2635
2636=item *
2637
2638Freeing a tied hash during iteration no longer results in a memory leak.
2639
2640=item *
2641
2642List assignment to a tied array or hash that dies on STORE no longer
2643results in a memory leak.
2644
2645=item *
2646
2647If the hint hash (C<%^H>) is tied, compile-time scope entry (which copies
2648the hint hash) no longer leaks memory if FETCH dies. [perl #107000]
2649
2650=item *
2651
2652Constant folding no longer inappropriately triggers the special
2653C<split " "> behaviour. [perl #94490]
2654
2655=item *
2656
2657C<defined scalar(@array)>, C<defined do { &foo }>, and similar constructs
2658now treat the argument to C<defined> as a simple scalar. [perl #97466]
2659
2660=item *
2661
2662Running a custom debugging that defines no C<*DB::DB> glob or provides a
2663subroutine stub for C<&DB::DB> no longer results in a crash, but an error
2664instead. [perl #114990]
2665
2666=item *
2667
2668C<reset ""> now matches its documentation. C<reset> only resets C<m?...?>
2669patterns when called with no argument. An empty string for an argument now
2670does nothing. (It used to be treated as no argument.) [perl #97958]
2671
2672=item *
2673
2674C<printf> with an argument returning an empty list no longer reads past the
2675end of the stack, resulting in erratic behaviour. [perl #77094]
2676
2677=item *
2678
2679C<--subname> no longer produces erroneous ambiguity warnings.
2680[perl #77240]
2681
2682=item *
2683
2684C<v10> is now allowed as a label or package name. This was inadvertently
2685broken when v-strings were added in Perl v5.6. [perl #56880]
2686
2687=item *
2688
2689C<length>, C<pos>, C<substr> and C<sprintf> could be confused by ties,
2690overloading, references and typeglobs if the stringification of such
2691changed the internal representation to or from UTF-8. [perl #114410]
2692
2693=item *
2694
2695utf8::encode now calls FETCH and STORE on tied variables. utf8::decode now
2696calls STORE (it was already calling FETCH).
2697
2698=item *
2699
2700C<$tied =~ s/$non_utf8/$utf8/> no longer loops infinitely if the tied
2701variable returns a Latin-1 string, shared hash key scalar, or reference or
2702typeglob that stringifies as ASCII or Latin-1. This was a regression from
2703v5.12.
2704
2705=item *
2706
2707C<s///> without /e is now better at detecting when it needs to forego
2708certain optimisations, fixing some buggy cases:
2709
2710=over
2711
2712=item *
2713
2714Match variables in certain constructs (C<&&>, C<||>, C<..> and others) in
2715the replacement part; e.g., C<s/(.)/$l{$a||$1}/g>. [perl #26986]
2716
2717=item *
2718
2719Aliases to match variables in the replacement.
2720
2721=item *
2722
2723C<$REGERROR> or C<$REGMARK> in the replacement. [perl #49190]
2724
2725=item *
2726
2727An empty pattern (C<s//$foo/>) that causes the last-successful pattern to
2728be used, when that pattern contains code blocks that modify the variables
2729in the replacement.
2730
2731=back
2732
2733=item *
2734
2735The taintedness of the replacement string no longer affects the taintedness
2736of the return value of C<s///e>.
2737
2738=item *
2739
2740The C<$|> autoflush variable is created on-the-fly when needed. If this
2741happened (e.g., if it was mentioned in a module or eval) when the
2742currently-selected filehandle was a typeglob with an empty IO slot, it used
2743to crash. [perl #115206]
2744
2745=item *
2746
2747Line numbers at the end of a string eval are no longer off by one.
2748[perl #114658]
2749
2750=item *
2751
2752@INC filters (subroutines returned by subroutines in @INC) that set $_ to a
2753copy-on-write scalar no longer cause the parser to modify that string
2754buffer in place.
2755
2756=item *
2757
2758C<length($object)> no longer returns the undefined value if the object has
2759string overloading that returns undef. [perl #115260]
2760
2761=item *
2762
2763The use of C<PL_stashcache>, the stash name lookup cache for method calls, has
2764been restored,
2765
2766Commit da6b625f78f5f133 in August 2011 inadvertently broke the code that looks
2767up values in C<PL_stashcache>. As it's a only cache, quite correctly everything
2768carried on working without it.
2769
2770=item *
2771
2772The error "Can't localize through a reference" had disappeared in v5.16.0
2773when C<local %$ref> appeared on the last line of an lvalue subroutine.
2774This error disappeared for C<\local %$ref> in perl v5.8.1. It has now
2775been restored.
2776
2777=item *
2778
2779The parsing of here-docs has been improved significantly, fixing several
2780parsing bugs and crashes and one memory leak, and correcting wrong
2781subsequent line numbers under certain conditions.
2782
2783=item *
2784
2785Inside an eval, the error message for an unterminated here-doc no longer
2786has a newline in the middle of it [perl #70836].
2787
2788=item *
2789
2790A substitution inside a substitution pattern (C<s/${s|||}//>) no longer
2791confuses the parser.
2792
2793=item *
2794
2795It may be an odd place to allow comments, but C<s//"" # hello/e> has
2796always worked, I<unless> there happens to be a null character before the
2797first #. Now it works even in the presence of nulls.
2798
2799=item *
2800
2801An invalid range in C<tr///> or C<y///> no longer results in a memory leak.
2802
2803=item *
2804
2805String eval no longer treats a semicolon-delimited quote-like operator at
2806the very end (C<eval 'q;;'>) as a syntax error.
2807
2808=item *
2809
2810C<< warn {$_ => 1} + 1 >> is no longer a syntax error. The parser used to
2811get confused with certain list operators followed by an anonymous hash and
2812then an infix operator that shares its form with a unary operator.
2813
2814=item *
2815
2816C<(caller $n)[6]> (which gives the text of the eval) used to return the
2817actual parser buffer. Modifying it could result in crashes. Now it always
2818returns a copy. The string returned no longer has "\n;" tacked on to the
2819end. The returned text also includes here-doc bodies, which used to be
2820omitted.
2821
2822=item *
2823
2824The UTF-8 position cache is now reset when accessing magical variables, to
2825avoid the string buffer and the UTF-8 position cache getting out of sync
2826[perl #114410].
2827
2828=item *
2829
2830Various cases of get magic being called twice for magical UTF-8
2831strings have been fixed.
2832
2833=item *
2834
2835This code (when not in the presence of C<$&> etc)
2836
2837 $_ = 'x' x 1_000_000;
2838 1 while /(.)/;
2839
2840used to skip the buffer copy for performance reasons, but suffered from C<$1>
2841etc changing if the original string changed. That's now been fixed.
2842
2843=item *
2844
2845Perl doesn't use PerlIO anymore to report out of memory messages, as PerlIO
2846might attempt to allocate more memory.
2847
2848=item *
2849
2850In a regular expression, if something is quantified with C<{n,m}> where
2851C<S<n E<gt> m>>, it can't possibly match. Previously this was a fatal
2852error, but now is merely a warning (and that something won't match).
2853[perl #82954].
2854
2855=item *
2856
2857It used to be possible for formats defined in subroutines that have
2858subsequently been undefined and redefined to close over variables in the
2859wrong pad (the newly-defined enclosing sub), resulting in crashes or
2860"Bizarre copy" errors.
2861
2862=item *
2863
2864Redefinition of XSUBs at run time could produce warnings with the wrong
2865line number.
2866
2867=item *
2868
2869The %vd sprintf format does not support version objects for alpha versions.
2870It used to output the format itself (%vd) when passed an alpha version, and
2871also emit an "Invalid conversion in printf" warning. It no longer does,
2872but produces the empty string in the output. It also no longer leaks
2873memory in this case.
2874
2875=item *
2876
2877C<< $obj->SUPER::method >> calls in the main package could fail if the
2878SUPER package had already been accessed by other means.
2879
2880=item *
2881
2882Stash aliasing (C<< *foo:: = *bar:: >>) no longer causes SUPER calls to ignore
2883changes to methods or @ISA or use the wrong package.
2884
2885=item *
2886
2887Method calls on packages whose names end in ::SUPER are no longer treated
2888as SUPER method calls, resulting in failure to find the method.
2889Furthermore, defining subroutines in such packages no longer causes them to
2890be found by SUPER method calls on the containing package [perl #114924].
2891
2892=item *
2893
2894C<\w> now matches the code points U+200C (ZERO WIDTH NON-JOINER) and U+200D
2895(ZERO WIDTH JOINER). C<\W> no longer matches these. This change is because
2896Unicode corrected their definition of what C<\w> should match.
2897
2898=item *
2899
2900C<dump LABEL> no longer leaks its label.
2901
2902=item *
2903
2904Constant folding no longer changes the behaviour of functions like C<stat()>
2905and C<truncate()> that can take either filenames or handles.
2906C<stat 1 ? foo : bar> nows treats its argument as a file name (since it is an
2907arbitrary expression), rather than the handle "foo".
2908
2909=item *
2910
2911C<truncate FOO, $len> no longer falls back to treating "FOO" as a file name if
2912the filehandle has been deleted. This was broken in Perl v5.16.0.
2913
2914=item *
2915
2916Subroutine redefinitions after sub-to-glob and glob-to-glob assignments no
2917longer cause double frees or panic messages.
2918
2919=item *
2920
2921C<s///> now turns vstrings into plain strings when performing a substitution,
2922even if the resulting string is the same (C<s/a/a/>).
2923
2924=item *
2925
2926Prototype mismatch warnings no longer erroneously treat constant subs as having
2927no prototype when they actually have "".
2928
2929=item *
2930
2931Constant subroutines and forward declarations no longer prevent prototype
2932mismatch warnings from omitting the sub name.
2933
2934=item *
2935
2936C<undef> on a subroutine now clears call checkers.
2937
2938=item *
2939
2940The C<ref> operator started leaking memory on blessed objects in Perl v5.16.0.
2941This has been fixed [perl #114340].
2942
2943=item *
2944
2945C<use> no longer tries to parse its arguments as a statement, making
2946C<use constant { () };> a syntax error [perl #114222].
2947
2948=item *
2949
2950On debugging builds, "uninitialized" warnings inside formats no longer cause
2951assertion failures.
2952
2953=item *
2954
2955On debugging builds, subroutines nested inside formats no longer cause
2956assertion failures [perl #78550].
2957
2958=item *
2959
2960Formats and C<use> statements are now permitted inside formats.
2961
2962=item *
2963
2964C<print $x> and C<sub { print $x }-E<gt>()> now always produce the same output.
2965It was possible for the latter to refuse to close over $x if the variable was
2966not active; e.g., if it was defined outside a currently-running named
2967subroutine.
2968
2969=item *
2970
2971Similarly, C<print $x> and C<print eval '$x'> now produce the same output.
2972This also allows "my $x if 0" variables to be seen in the debugger [perl
2973#114018].
2974
2975=item *
2976
2977Formats called recursively no longer stomp on their own lexical variables, but
2978each recursive call has its own set of lexicals.
2979
2980=item *
2981
2982Attempting to free an active format or the handle associated with it no longer
2983results in a crash.
2984
2985=item *
2986
2987Format parsing no longer gets confused by braces, semicolons and low-precedence
2988operators. It used to be possible to use braces as format delimiters (instead
2989of C<=> and C<.>), but only sometimes. Semicolons and low-precedence operators
2990in format argument lines no longer confuse the parser into ignoring the line's
2991return value. In format argument lines, braces can now be used for anonymous
2992hashes, instead of being treated always as C<do> blocks.
2993
2994=item *
2995
2996Formats can now be nested inside code blocks in regular expressions and other
2997quoted constructs (C</(?{...})/> and C<qq/${...}/>) [perl #114040].
2998
2999=item *
3000
3001Formats are no longer created after compilation errors.
3002
3003=item *
3004
3005Under debugging builds, the B<-DA> command line option started crashing in Perl
3006v5.16.0. It has been fixed [perl #114368].
3007
3008=item *
3009
3010A potential deadlock scenario involving the premature termination of a pseudo-
3011forked child in a Windows build with ithreads enabled has been fixed. This
3012resolves the common problem of the F<t/op/fork.t> test hanging on Windows [perl
3013#88840].
3014
3015=item *
3016
3017The code which generates errors from C<require()> could potentially read one or
3018two bytes before the start of the filename for filenames less than three bytes
3019long and ending C</\.p?\z/>. This has now been fixed. Note that it could
3020never have happened with module names given to C<use()> or C<require()> anyway.
3021
3022=item *
3023
3024The handling of pathnames of modules given to C<require()> has been made
3025thread-safe on VMS.
3026
3027=item *
3028
3029Non-blocking sockets have been fixed on VMS.
3030
3031=item *
3032
3033Pod can now be nested in code inside a quoted construct outside of a string
3034eval. This used to work only within string evals [perl #114040].
3035
3036=item *
3037
3038C<goto ''> now looks for an empty label, producing the "goto must have
3039label" error message, instead of exiting the program [perl #111794].
3040
3041=item *
3042
3043C<goto "\0"> now dies with "Can't find label" instead of "goto must have
3044label".
3045
3046=item *
3047
3048The C function C<hv_store> used to result in crashes when used on C<%^H>
3049[perl #111000].
3050
3051=item *
3052
3053A call checker attached to a closure prototype via C<cv_set_call_checker>
3054is now copied to closures cloned from it. So C<cv_set_call_checker> now
3055works inside an attribute handler for a closure.
3056
3057=item *
3058
3059Writing to C<$^N> used to have no effect. Now it croaks with "Modification
3060of a read-only value" by default, but that can be overridden by a custom
3061regular expression engine, as with C<$1> [perl #112184].
3062
3063=item *
3064
3065C<undef> on a control character glob (C<undef *^H>) no longer emits an
3066erroneous warning about ambiguity [perl #112456].
3067
3068=item *
3069
3070For efficiency's sake, many operators and built-in functions return the
3071same scalar each time. Lvalue subroutines and subroutines in the CORE::
3072namespace were allowing this implementation detail to leak through.
3073C<print &CORE::uc("a"), &CORE::uc("b")> used to print "BB". The same thing
3074would happen with an lvalue subroutine returning the return value of C<uc>.
3075Now the value is copied in such cases.
3076
3077=item *
3078
3079C<method {}> syntax with an empty block or a block returning an empty list
3080used to crash or use some random value left on the stack as its invocant.
3081Now it produces an error.
3082
3083=item *
3084
3085C<vec> now works with extremely large offsets (E<gt>2 GB) [perl #111730].
3086
3087=item *
3088
3089Changes to overload settings now take effect immediately, as do changes to
3090inheritance that affect overloading. They used to take effect only after
3091C<bless>.
3092
3093Objects that were created before a class had any overloading used to remain
3094non-overloaded even if the class gained overloading through C<use overload>
3095or @ISA changes, and even after C<bless>. This has been fixed
3096[perl #112708].
3097
3098=item *
3099
3100Classes with overloading can now inherit fallback values.
3101
3102=item *
3103
3104Overloading was not respecting a fallback value of 0 if there were
3105overloaded objects on both sides of an assignment operator like C<+=>
3106[perl #111856].
3107
3108=item *
3109
3110C<pos> now croaks with hash and array arguments, instead of producing
3111erroneous warnings.
3112
3113=item *
3114
3115C<while(each %h)> now implies C<while(defined($_ = each %h))>, like
3116C<readline> and C<readdir>.
3117
3118=item *
3119
3120Subs in the CORE:: namespace no longer crash after C<undef *_> when called
3121with no argument list (C<&CORE::time> with no parentheses).
3122
3123=item *
3124
3125C<unpack> no longer produces the "'/' must follow a numeric type in unpack"
3126error when it is the data that are at fault [perl #60204].
3127
3128=item *
3129
3130C<join> and C<"@array"> now call FETCH only once on a tied C<$">
3131[perl #8931].
3132
3133=item *
3134
3135Some subroutine calls generated by compiling core ops affected by a
3136C<CORE::GLOBAL> override had op checking performed twice. The checking
3137is always idempotent for pure Perl code, but the double checking can
3138matter when custom call checkers are involved.
3139
3140=item *
3141
3142A race condition used to exist around fork that could cause a signal sent to
3143the parent to be handled by both parent and child. Signals are now blocked
3144briefly around fork to prevent this from happening [perl #82580].
3145
3146=item *
3147
3148The implementation of code blocks in regular expressions, such as C<(?{})>
3149and C<(??{})>, has been heavily reworked to eliminate a whole slew of bugs.
3150The main user-visible changes are:
3151
3152=over 4
3153
3154=item *
3155
3156Code blocks within patterns are now parsed in the same pass as the
3157surrounding code; in particular it is no longer necessary to have balanced
3158braces: this now works:
3159
3160 /(?{ $x='{' })/
3161
3162This means that this error message is no longer generated:
3163
3164 Sequence (?{...}) not terminated or not {}-balanced in regex
3165
3166but a new error may be seen:
3167
3168 Sequence (?{...}) not terminated with ')'
3169
3170In addition, literal code blocks within run-time patterns are only
3171compiled once, at perl compile-time:
3172
3173 for my $p (...) {
3174 # this 'FOO' block of code is compiled once,
3175 # at the same time as the surrounding 'for' loop
3176 /$p{(?{FOO;})/;
3177 }
3178
3179=item *
3180
3181Lexical variables are now sane as regards scope, recursion and closure
3182behavior. In particular, C</A(?{B})C/> behaves (from a closure viewpoint)
3183exactly like C</A/ && do { B } && /C/>, while C<qr/A(?{B})C/> is like
3184C<sub {/A/ && do { B } && /C/}>. So this code now works how you might
3185expect, creating three regexes that match 0, 1, and 2:
3186
3187 for my $i (0..2) {
3188 push @r, qr/^(??{$i})$/;
3189 }
3190 "1" =~ $r[1]; # matches
3191
3192=item *
3193
3194The C<use re 'eval'> pragma is now only required for code blocks defined
3195at runtime; in particular in the following, the text of the C<$r> pattern is
3196still interpolated into the new pattern and recompiled, but the individual
3197compiled code-blocks within C<$r> are reused rather than being recompiled,
3198and C<use re 'eval'> isn't needed any more:
3199
3200 my $r = qr/abc(?{....})def/;
3201 /xyz$r/;
3202
3203=item *
3204
3205Flow control operators no longer crash. Each code block runs in a new
3206dynamic scope, so C<next> etc. will not see
3207any enclosing loops. C<return> returns a value
3208from the code block, not from any enclosing subroutine.
3209
3210=item *
3211
3212Perl normally caches the compilation of run-time patterns, and doesn't
3213recompile if the pattern hasn't changed, but this is now disabled if
3214required for the correct behavior of closures. For example:
3215
3216 my $code = '(??{$x})';
3217 for my $x (1..3) {
3218 # recompile to see fresh value of $x each time
3219 $x =~ /$code/;
3220 }
3221
3222=item *
3223
3224The C</msix> and C<(?msix)> etc. flags are now propagated into the return
3225value from C<(??{})>; this now works:
3226
3227 "AB" =~ /a(??{'b'})/i;
3228
3229=item *
3230
3231Warnings and errors will appear to come from the surrounding code (or for
3232run-time code blocks, from an eval) rather than from an C<re_eval>:
3233
3234 use re 'eval'; $c = '(?{ warn "foo" })'; /$c/;
3235 /(?{ warn "foo" })/;
3236
3237formerly gave:
3238
3239 foo at (re_eval 1) line 1.
3240 foo at (re_eval 2) line 1.
3241
3242and now gives:
3243
3244 foo at (eval 1) line 1.
3245 foo at /some/prog line 2.
3246
3247=back
3248
3249=item *
3250
3251Perl now can be recompiled to use any Unicode version. In v5.16, it
3252worked on Unicodes 6.0 and 6.1, but there were various bugs if earlier
3253releases were used; the older the release the more problems.
3254
3255=item *
3256
3257C<vec> no longer produces "uninitialized" warnings in lvalue context
3258[perl #9423].
3259
3260=item *
3261
3262An optimization involving fixed strings in regular expressions could cause
3263a severe performance penalty in edge cases. This has been fixed
3264[perl #76546].
3265
3266=item *
3267
3268In certain cases, including empty subpatterns within a regular expression (such
3269as C<(?:)> or C<(?:|)>) could disable some optimizations. This has been fixed.
3270
3271=item *
3272
3273The "Can't find an opnumber" message that C<prototype> produces when passed
3274a string like "CORE::nonexistent_keyword" now passes UTF-8 and embedded
3275NULs through unchanged [perl #97478].
3276
3277=item *
3278
3279C<prototype> now treats magical variables like C<$1> the same way as
3280non-magical variables when checking for the CORE:: prefix, instead of
3281treating them as subroutine names.
3282
3283=item *
3284
3285Under threaded perls, a runtime code block in a regular expression could
3286corrupt the package name stored in the op tree, resulting in bad reads
3287in C<caller>, and possibly crashes [perl #113060].
3288
3289=item *
3290
3291Referencing a closure prototype (C<\&{$_[1]}> in an attribute handler for a
3292closure) no longer results in a copy of the subroutine (or assertion
3293failures on debugging builds).
3294
3295=item *
3296
3297C<eval '__PACKAGE__'> now returns the right answer on threaded builds if
3298the current package has been assigned over (as in
3299C<*ThisPackage:: = *ThatPackage::>) [perl #78742].
3300
3301=item *
3302
3303If a package is deleted by code that it calls, it is possible for C<caller>
3304to see a stack frame belonging to that deleted package. C<caller> could
3305crash if the stash's memory address was reused for a scalar and a
3306substitution was performed on the same scalar [perl #113486].
3307
3308=item *
3309
3310C<UNIVERSAL::can> no longer treats its first argument differently
3311depending on whether it is a string or number internally.
3312
3313=item *
3314
3315C<open> with C<< <& >> for the mode checks to see whether the third argument is
3316a number, in determining whether to treat it as a file descriptor or a handle
3317name. Magical variables like C<$1> were always failing the numeric check and
3318being treated as handle names.
3319
3320=item *
3321
3322C<warn>'s handling of magical variables (C<$1>, ties) has undergone several
3323fixes. C<FETCH> is only called once now on a tied argument or a tied C<$@>
3324[perl #97480]. Tied variables returning objects that stringify as "" are
3325no longer ignored. A tied C<$@> that happened to return a reference the
3326I<previous> time it was used is no longer ignored.
3327
3328=item *
3329
3330C<warn ""> now treats C<$@> with a number in it the same way, regardless of
3331whether it happened via C<$@=3> or C<$@="3">. It used to ignore the
3332former. Now it appends "\t...caught", as it has always done with
3333C<$@="3">.
3334
3335=item *
3336
3337Numeric operators on magical variables (e.g., S<C<$1 + 1>>) used to use
3338floating point operations even where integer operations were more appropriate,
3339resulting in loss of accuracy on 64-bit platforms [perl #109542].
3340
3341=item *
3342
3343Unary negation no longer treats a string as a number if the string happened
3344to be used as a number at some point. So, if C<$x> contains the string "dogs",
3345C<-$x> returns "-dogs" even if C<$y=0+$x> has happened at some point.
3346
3347=item *
3348
3349In Perl v5.14, C<-'-10'> was fixed to return "10", not "+10". But magical
3350variables (C<$1>, ties) were not fixed till now [perl #57706].
3351
3352=item *
3353
3354Unary negation now treats strings consistently, regardless of the internal
3355C<UTF8> flag.
3356
3357=item *
3358
3359A regression introduced in Perl v5.16.0 involving
3360C<tr/I<SEARCHLIST>/I<REPLACEMENTLIST>/> has been fixed. Only the first
3361instance is supposed to be meaningful if a character appears more than
3362once in C<I<SEARCHLIST>>. Under some circumstances, the final instance
3363was overriding all earlier ones. [perl #113584]
3364
3365=item *
3366
3367Regular expressions like C<qr/\87/> previously silently inserted a NUL
3368character, thus matching as if it had been written C<qr/\00087/>. Now it
3369matches as if it had been written as C<qr/87/>, with a message that the
3370sequence C<"\8"> is unrecognized.
3371
3372=item *
3373
3374C<__SUB__> now works in special blocks (C<BEGIN>, C<END>, etc.).
3375
3376=item *
3377
3378Thread creation on Windows could theoretically result in a crash if done
3379inside a C<BEGIN> block. It still does not work properly, but it no longer
3380crashes [perl #111610].
3381
3382=item *
3383
3384C<\&{''}> (with the empty string) now autovivifies a stub like any other
3385sub name, and no longer produces the "Unable to create sub" error
3386[perl #94476].
3387
3388=item *
3389
3390A regression introduced in v5.14.0 has been fixed, in which some calls
3391to the C<re> module would clobber C<$_> [perl #113750].
3392
3393=item *
3394
3395C<do FILE> now always either sets or clears C<$@>, even when the file can't be
3396read. This ensures that testing C<$@> first (as recommended by the
3397documentation) always returns the correct result.
3398
3399=item *
3400
3401The array iterator used for the C<each @array> construct is now correctly
3402reset when C<@array> is cleared [perl #75596]. This happens, for example, when
3403the array is globally assigned to, as in C<@array = (...)>, but not when its
3404B<values> are assigned to. In terms of the XS API, it means that C<av_clear()>
3405will now reset the iterator.
3406
3407This mirrors the behaviour of the hash iterator when the hash is cleared.
3408
3409=item *
3410
3411C<< $class->can >>, C<< $class->isa >>, and C<< $class->DOES >> now return
3412correct results, regardless of whether that package referred to by C<$class>
3413exists [perl #47113].
3414
3415=item *
3416
3417Arriving signals no longer clear C<$@> [perl #45173].
3418
3419=item *
3420
3421Allow C<my ()> declarations with an empty variable list [perl #113554].
3422
3423=item *
3424
3425During parsing, subs declared after errors no longer leave stubs
3426[perl #113712].
3427
3428=item *
3429
3430Closures containing no string evals no longer hang on to their containing
3431subroutines, allowing variables closed over by outer subroutines to be
3432freed when the outer sub is freed, even if the inner sub still exists
3433[perl #89544].
3434
3435=item *
3436
3437Duplication of in-memory filehandles by opening with a "<&=" or ">&=" mode
3438stopped working properly in v5.16.0. It was causing the new handle to
3439reference a different scalar variable. This has been fixed [perl #113764].
3440
3441=item *
3442
3443C<qr//> expressions no longer crash with custom regular expression engines
3444that do not set C<offs> at regular expression compilation time
3445[perl #112962].
3446
3447=item *
3448
3449C<delete local> no longer crashes with certain magical arrays and hashes
3450[perl #112966].
3451
3452=item *
3453
3454C<local> on elements of certain magical arrays and hashes used not to
3455arrange to have the element deleted on scope exit, even if the element did
3456not exist before C<local>.
3457
3458=item *
3459
3460C<scalar(write)> no longer returns multiple items [perl #73690].
3461
3462=item *
3463
3464String to floating point conversions no longer misparse certain strings under
3465C<use locale> [perl #109318].
3466
3467=item *
3468
3469C<@INC> filters that die no longer leak memory [perl #92252].
3470
3471=item *
3472
3473The implementations of overloaded operations are now called in the correct
3474context. This allows, among other things, being able to properly override
3475C<< <> >> [perl #47119].
3476
3477=item *
3478
3479Specifying only the C<fallback> key when calling C<use overload> now behaves
3480properly [perl #113010].
3481
3482=item *
3483
3484C<< sub foo { my $a = 0; while ($a) { ... } } >> and
3485C<< sub foo { while (0) { ... } } >> now return the same thing [perl #73618].
3486
3487=item *
3488
3489String negation now behaves the same under C<use integer;> as it does
3490without [perl #113012].
3491
3492=item *
3493
3494C<chr> now returns the Unicode replacement character (U+FFFD) for -1,
3495regardless of the internal representation. -1 used to wrap if the argument
3496was tied or a string internally.
3497
3498=item *
3499
3500Using a C<format> after its enclosing sub was freed could crash as of
3501perl v5.12.0, if the format referenced lexical variables from the outer sub.
3502
3503=item *
3504
3505Using a C<format> after its enclosing sub was undefined could crash as of
3506perl v5.10.0, if the format referenced lexical variables from the outer sub.
3507
3508=item *
3509
3510Using a C<format> defined inside a closure, which format references
3511lexical variables from outside, never really worked unless the C<write>
3512call was directly inside the closure. In v5.10.0 it even started crashing.
3513Now the copy of that closure nearest the top of the call stack is used to
3514find those variables.
3515
3516=item *
3517
3518Formats that close over variables in special blocks no longer crash if a
3519stub exists with the same name as the special block before the special
3520block is compiled.
3521
3522=item *
3523
3524The parser no longer gets confused, treating C<eval foo ()> as a syntax
3525error if preceded by C<print;> [perl #16249].
3526
3527=item *
3528
3529The return value of C<syscall> is no longer truncated on 64-bit platforms
3530[perl #113980].
3531
3532=item *
3533
3534Constant folding no longer causes C<print 1 ? FOO : BAR> to print to the
3535FOO handle [perl #78064].
3536
3537=item *
3538
3539C<do subname> now calls the named subroutine and uses the file name it
3540returns, instead of opening a file named "subname".
3541
3542=item *
3543
3544Subroutines looked up by rv2cv check hooks (registered by XS modules) are
3545now taken into consideration when determining whether C<foo bar> should be
3546the sub call C<foo(bar)> or the method call C<< "bar"->foo >>.
3547
3548=item *
3549
3550C<CORE::foo::bar> is no longer treated specially, allowing global overrides
3551to be called directly via C<CORE::GLOBAL::uc(...)> [perl #113016].
3552
3553=item *
3554
3555Calling an undefined sub whose typeglob has been undefined now produces the
3556customary "Undefined subroutine called" error, instead of "Not a CODE
3557reference".
3558
3559=item *
3560
3561Two bugs involving @ISA have been fixed. C<*ISA = *glob_without_array> and
3562C<undef *ISA; @{*ISA}> would prevent future modifications to @ISA from
3563updating the internal caches used to look up methods. The
3564*glob_without_array case was a regression from Perl v5.12.
3565
3566=item *
3567
3568Regular expression optimisations sometimes caused C<$> with C</m> to
3569produce failed or incorrect matches [perl #114068].
3570
3571=item *
3572
3573C<__SUB__> now works in a C<sort> block when the enclosing subroutine is
3574predeclared with C<sub foo;> syntax [perl #113710].
3575
3576=item *
3577
3578Unicode properties only apply to Unicode code points, which leads to
3579some subtleties when regular expressions are matched against
3580above-Unicode code points. There is a warning generated to draw your
3581attention to this. However, this warning was being generated
3582inappropriately in some cases, such as when a program was being parsed.
3583Non-Unicode matches such as C<\w> and C<[:word:]> should not generate the
3584warning, as their definitions don't limit them to apply to only Unicode
3585code points. Now the message is only generated when matching against
3586C<\p{}> and C<\P{}>. There remains a bug, [perl #114148], for the very
3587few properties in Unicode that match just a single code point. The
3588warning is not generated if they are matched against an above-Unicode
3589code point.
3590
3591=item *
3592
3593Uninitialized warnings mentioning hash elements would only mention the
3594element name if it was not in the first bucket of the hash, due to an
3595off-by-one error.
3596
3597=item *
3598
3599A regular expression optimizer bug could cause multiline "^" to behave
3600incorrectly in the presence of line breaks, such that
3601C<"/\n\n" =~ m#\A(?:^/$)#im> would not match [perl #115242].
3602
3603=item *
3604
3605Failed C<fork> in list context no longer corrupts the stack.
3606C<@a = (1, 2, fork, 3)> used to gobble up the 2 and assign C<(1, undef, 3)>
3607if the C<fork> call failed.
3608
3609=item *
3610
3611Numerous memory leaks have been fixed, mostly involving tied variables that
3612die, regular expression character classes and code blocks, and syntax
3613errors.
3614
3615=item *
3616
3617Assigning a regular expression (C<${qr//}>) to a variable that happens to
3618hold a floating point number no longer causes assertion failures on
3619debugging builds.
3620
3621=item *
3622
3623Assigning a regular expression to a scalar containing a number no longer
3624causes subsequent numification to produce random numbers.
3625
3626=item *
3627
3628Assigning a regular expression to a magic variable no longer wipes away the
3629magic. This was a regression from v5.10.
3630
3631=item *
3632
3633Assigning a regular expression to a blessed scalar no longer results in
3634crashes. This was also a regression from v5.10.
3635
3636=item *
3637
3638Regular expression can now be assigned to tied hash and array elements with
3639flattening into strings.
3640
3641=item *
3642
3643Numifying a regular expression no longer results in an uninitialized
3644warning.
3645
3646=item *
3647
3648Negative array indices no longer cause EXISTS methods of tied variables to
3649be ignored. This was a regression from v5.12.
3650
3651=item *
3652
3653Negative array indices no longer result in crashes on arrays tied to
3654non-objects.
3655
3656=item *
3657
3658C<$byte_overload .= $utf8> no longer results in doubly-encoded UTF-8 if the
3659left-hand scalar happened to have produced a UTF-8 string the last time
3660overloading was invoked.
3661
3662=item *
3663
3664C<goto &sub> now uses the current value of @_, instead of using the array
3665the subroutine was originally called with. This means
3666C<local @_ = (...); goto &sub> now works [perl #43077].
3667
3668=item *
3669
3670If a debugger is invoked recursively, it no longer stomps on its own
3671lexical variables. Formerly under recursion all calls would share the same
3672set of lexical variables [perl #115742].
3673
3674=item *
3675
3676C<*_{ARRAY}> returned from a subroutine no longer spontaneously
3677becomes empty.
3678
3679=back
3680
3681=head1 Known Problems
3682
3683=over 4
3684
3685=item *
3686
3687UTF8-flagged strings in C<%ENV> on HP-UX 11.00 are buggy
3688
3689The interaction of UTF8-flagged strings and C<%ENV> on HP-UX 11.00 is
3690currently dodgy in some not-yet-fully-diagnosed way. Expect test
3691failures in F<t/op/magic.t>, followed by unknown behavior when storing
3692wide characters in the environment.
3693
3694=back
3695
3696=head1 Obituary
3697
3698Hojung Yoon (AMORETTE), 24, of Seoul, South Korea, went to his long rest
3699on May 8, 2013 with llama figurine and autographed TIMTOADY card. He
3700was a brilliant young Perl 5 & 6 hacker and a devoted member of
3701Seoul.pm. He programmed Perl, talked Perl, ate Perl, and loved Perl. We
3702believe that he is still programming in Perl with his broken IBM laptop
3703somewhere. He will be missed.
3704
3705=head1 Acknowledgements
3706
3707Perl v5.18.0 represents approximately 12 months of development since
3708Perl v5.16.0 and contains approximately 400,000 lines of changes across
37092,100 files from 113 authors.
3710
3711Perl continues to flourish into its third decade thanks to a vibrant
3712community of users and developers. The following people are known to
3713have contributed the improvements that became Perl v5.18.0:
3714
3715Aaron Crane, Aaron Trevena, Abhijit Menon-Sen, Adrian M. Enache, Alan
3716Haggai Alavi, Alexandr Ciornii, Andrew Tam, Andy Dougherty, Anton Nikishaev,
3717Aristotle Pagaltzis, Augustina Blair, Bob Ernst, Brad Gilbert, Breno G. de
3718Oliveira, Brian Carlson, Brian Fraser, Charlie Gonzalez, Chip Salzenberg, Chris
3719'BinGOs' Williams, Christian Hansen, Colin Kuskie, Craig A. Berry, Dagfinn
3720Ilmari Mannsåker, Daniel Dragan, Daniel Perrett, Darin McBride, Dave Rolsky,
3721David Golden, David Leadbeater, David Mitchell, David Nicol, Dominic
3722Hargreaves, E. Choroba, Eric Brine, Evan Miller, Father Chrysostomos, Florian
3723Ragwitz, François Perrad, George Greer, Goro Fuji, H.Merijn Brand, Herbert
3724Breunung, Hugo van der Sanden, Igor Zaytsev, James E Keenan, Jan Dubois,
3725Jasmine Ahuja, Jerry D. Hedden, Jess Robinson, Jesse Luehrs, Joaquin Ferrero,
3726Joel Berger, John Goodyear, John Peacock, Karen Etheridge, Karl Williamson,
3727Karthik Rajagopalan, Kent Fredric, Leon Timmermans, Lucas Holt, Lukas Mai,
3728Marcus Holland-Moritz, Markus Jansen, Martin Hasch, Matthew Horsfall, Max
3729Maischein, Michael G Schwern, Michael Schroeder, Moritz Lenz, Nicholas Clark,
3730Niko Tyni, Oleg Nesterov, Patrik Hägglund, Paul Green, Paul Johnson, Paul
3731Marquess, Peter Martini, Rafael Garcia-Suarez, Reini Urban, Renee Baecker,
3732Rhesa Rozendaal, Ricardo Signes, Robin Barker, Ronald J. Kimball, Ruslan
3733Zakirov, Salvador Fandiño, Sawyer X, Scott Lanning, Sergey Alekseev, Shawn M
3734Moore, Shirakata Kentaro, Shlomi Fish, Sisyphus, Smylers, Steffen Müller,
3735Steve Hay, Steve Peters, Steven Schubiger, Sullivan Beck, Sven Strickroth,
3736Sébastien Aperghis-Tramoni, Thomas Sibley, Tobias Leich, Tom Wyant, Tony Cook,
3737Vadim Konovalov, Vincent Pit, Volker Schatz, Walt Mankowski, Yves Orton,
3738Zefram.
3739
3740The list above is almost certainly incomplete as it is automatically generated
3741from version control history. In particular, it does not include the names of
3742the (very much appreciated) contributors who reported issues to the Perl bug
3743tracker.
3744
3745Many of the changes included in this version originated in the CPAN modules
3746included in Perl's core. We're grateful to the entire CPAN community for
3747helping Perl to flourish.
3748
3749For a more complete list of all of Perl's historical contributors, please see
3750the F<AUTHORS> file in the Perl source distribution.
3751
3752=head1 Reporting Bugs
3753
3754If you find what you think is a bug, you might check the articles recently
3755posted to the comp.lang.perl.misc newsgroup and the perl bug database at
3756http://rt.perl.org/perlbug/ . There may also be information at
3757http://www.perl.org/ , the Perl Home Page.
3758
3759If you believe you have an unreported bug, please run the L<perlbug> program
3760included with your release. Be sure to trim your bug down to a tiny but
3761sufficient test case. Your bug report, along with the output of C<perl -V>,
3762will be sent off to perlbug@perl.org to be analysed by the Perl porting team.
3763
3764If the bug you are reporting has security implications, which make it
3765inappropriate to send to a publicly archived mailing list, then please send it
3766to perl5-security-report@perl.org. This points to a closed subscription
3767unarchived mailing list, which includes all the core committers, who will be
3768able to help assess the impact of issues, figure out a resolution, and help
3769co-ordinate the release of patches to mitigate or fix the problem across all
3770platforms on which Perl is supported. Please only use this address for
3771security issues in the Perl core, not for modules independently distributed on
3772CPAN.
3773
3774=head1 SEE ALSO
3775
3776The F<Changes> file for an explanation of how to view exhaustive details on
3777what changed.
3778
3779The F<INSTALL> file for how to build Perl.
3780
3781The F<README> file for general stuff.
3782
3783The F<Artistic> and F<Copying> files for copyright information.
3784
3785=cut