NAME

DESCRIPTION

If you are upgrading from an earlier release such as v5.14.0, first read perl5160delta, which describes differences between v5.14.0 and v5.16.0.

Core Enhancements

    no warnings "experimental::feature_name";
    use feature "feature_name";  # would warn without the prev line

    no warnings "experimental::feature_name";

    no if $] >= 5.018, warnings => "experimental::feature_name";

    $ PERL_HASH_SEED_DEBUG=1 ./perl -e1
    HASH_FUNCTION = MURMUR3 HASH_SEED = 0x1476bb9f

    use 5.018;
    no warnings "experimental::lexical_subs";
    use feature "lexical_subs";

Security

Incompatible Changes

 my $undraftable = "\N{4F}";    # Syntax error!

  $dec = " \cK \t 123";
  $hex = " \cK \t 0xF";

  say 0 + $dec;   # was 0 with warning, now 123
  say int $dec;   # was 0, now 123
  say oct $hex;   # was 0, now  15

    %_=(_,"Just another ");
    $_="Perl hacker,\n";
    s//_}->{_/e;print

  no if $] >= 5.018, warnings => "experimental::smartmatch";

 m/a/and 1

 m/a/ and 1

    $*; # deprecation warning
    use warnings "void";
    $#; # void warning; no deprecation warning

Deprecations

    U+0085 NEXT LINE
    U+200E LEFT-TO-RIGHT MARK
    U+200F RIGHT-TO-LEFT MARK
    U+2028 LINE SEPARATOR
    U+2029 PARAGRAPH SEPARATOR

  m{foo}
  s(foo)(bar)

  m{foo\{1,3\}}

Future Deprecations

•

Platforms without support infrastructure

Both Windows CE and z/OS have been historically under-maintained, and are currently neither successfully building nor regularly being smoke tested. Efforts are underway to change this situation, but it should not be taken for granted that the platforms are safe and supported. If they do not become buildable and regularly smoked, support for them may be actively removed in future releases. If you have an interest in these platforms and you can lend your time, expertise, or hardware to help support these platforms, please let the perl development effort know by emailing "perl5-porters@perl.org".

Some platforms that appear otherwise entirely dead are also on the short list for removal between now and v5.20.0:

• Swapping of $< and $>

  Perl has supported the idiom of swapping $< and $> (and likewise $( and $)) to temporarily drop permissions since 5.0, like this:

      ($<, $>) = ($>, $<);
      

  However, this idiom modifies the real user/group id, which can have undesirable side-effects, is no longer useful on any platform perl supports and complicates the implementation of these variables and list assignment in general.

  As an alternative, assignment only to $> is recommended:

      local $> = $<;
      

  See also: Setuid Demystified <http://www.cs.berkeley.edu/~daw/papers/setuid-usenix02.pdf>.

• "microperl", long broken and of unclear present purpose, will be removed.
• Revamping "\Q" semantics in double-quotish strings when combined with other escapes.

  There are several bugs and inconsistencies involving combinations of "\Q" and escapes like "\x", "\L", etc., within a "\Q...\E" pair. These need to be fixed, and doing so will necessarily change current behavior. The changes have not yet been settled.

• Use of $x, where "x" stands for any actual (non-printing) C0 control character will be disallowed in a future Perl version. Use "${x}" instead (where again "x" stands for a control character), or better, $^A , where "^" is a caret (CIRCUMFLEX ACCENT), and "A" stands for any of the characters listed at the end of "OPERATOR DIFFERENCES" in perlebcdic.

Performance Enhancements

• Lists of lexical variable declarations ("my($x, $y)") are now optimised down to a single op and are hence faster than before.
• A new C preprocessor define "NO_TAINT_SUPPORT" was added that, if set, disables Perl's taint support altogether. Using the -T or -t command line flags will cause a fatal error. Beware that both core tests as well as many a CPAN distribution's tests will fail with this change. On the upside, it provides a small performance benefit due to reduced branching.

  Do not enable this unless you know exactly what you are getting yourself into.

• "pack" with constant arguments is now constant folded in most cases [perl #113470].
• Speed up in regular expression matching against Unicode properties. The largest gain is for "\X", the Unicode "extended grapheme cluster." The gain for it is about 35% - 40%. Bracketed character classes, e.g., "[0-9\x{100}]" containing code points above 255 are also now faster.
• On platforms supporting it, several former macros are now implemented as static inline functions. This should speed things up slightly on non-GCC platforms.
• The optimisation of hashes in boolean context has been extended to affect "scalar(%hash)", "%hash ? ... : ...", and "sub { %hash || ... }".
• Filetest operators manage the stack in a fractionally more efficient manner.
• Globs used in a numeric context are now numified directly in most cases, rather than being numified via stringification.
• The "x" repetition operator is now folded to a single constant at compile time if called in scalar context with constant operands and no parentheses around the left operand.

Modules and Pragmata

  $ corelist --diff 5.16.0 5.18.0

Documentation

Utility Changes

•

h2xs no longer produces invalid code for empty defines. [perl #20636]

Configuration and Compilation

• Added "useversionedarchname" option to Configure

  When set, it includes 'api_versionstring' in 'archname'. E.g. x86_64-linux-5.13.6-thread-multi. It is unset by default.

  This feature was requested by Tim Bunce, who observed that "INSTALL_BASE" creates a library structure that does not differentiate by perl version. Instead, it places architecture specific files in "$install_base/lib/perl5/$archname". This makes it difficult to use a common "INSTALL_BASE" library path with multiple versions of perl.

  By setting "-Duseversionedarchname", the $archname will be distinct for architecture and API version, allowing mixed use of "INSTALL_BASE".

• Add a "PERL_NO_INLINE_FUNCTIONS" option

  If "PERL_NO_INLINE_FUNCTIONS" is defined, don't include "inline.h"

  This permits test code to include the perl headers for definitions without creating a link dependency on the perl library (which may not exist yet).

• Configure will honour the external "MAILDOMAIN" environment variable, if set.
• "installman" no longer ignores the silent option
• Both "META.yml" and "META.json" files are now included in the distribution.
• Configure will now correctly detect "isblank()" when compiling with a C++ compiler.
• The pager detection in Configure has been improved to allow responses which specify options after the program name, e.g. /usr/bin/less -R, if the user accepts the default value. This helps perldoc when handling ANSI escapes [perl #72156].

Testing

•

The test suite now has a section for tests that require very large amounts of memory. These tests won't run by default; they can be enabled by setting the "PERL_TEST_MEMORY" environment variable to the number of gibibytes of memory that may be safely used.

Platform Support

Internal Changes

• Synonyms for the misleadingly named "av_len()" have been created: "av_top_index()" and "av_tindex". All three of these return the number of the highest index in the array, not the number of elements it contains.
• SvUPGRADE() is no longer an expression. Originally this macro (and its underlying function, sv_upgrade()) were documented as boolean, although in reality they always croaked on error and never returned false. In 2005 the documentation was updated to specify a void return value, but SvUPGRADE() was left always returning 1 for backwards compatibility. This has now been removed, and SvUPGRADE() is now a statement with no return value.

  So this is now a syntax error:

      if (!SvUPGRADE(sv)) { croak(...); }
      

  If you have code like that, simply replace it with

      SvUPGRADE(sv);
      

  or to avoid compiler warnings with older perls, possibly

      (void)SvUPGRADE(sv);
      

• Perl has a new copy-on-write mechanism that allows any SvPOK scalar to be upgraded to a copy-on-write scalar. A reference count on the string buffer is stored in the string buffer itself. This feature is not enabled by default.

  It can be enabled in a perl build by running Configure with -Accflags=-DPERL_NEW_COPY_ON_WRITE, and we would encourage XS authors to try their code with such an enabled perl, and provide feedback. Unfortunately, there is not yet a good guide to updating XS code to cope with COW. Until such a document is available, consult the perl5-porters mailing list.

  It breaks a few XS modules by allowing copy-on-write scalars to go through code paths that never encountered them before.

• Copy-on-write no longer uses the SvFAKE and SvREADONLY flags. Hence, SvREADONLY indicates a true read-only SV.

  Use the SvIsCOW macro (as before) to identify a copy-on-write scalar.

• "PL_glob_index" is gone.
• The private Perl_croak_no_modify has had its context parameter removed. It is now has a void prototype. Users of the public API croak_no_modify remain unaffected.
• Copy-on-write (shared hash key) scalars are no longer marked read-only. "SvREADONLY" returns false on such an SV, but "SvIsCOW" still returns true.
• A new op type, "OP_PADRANGE" has been introduced. The perl peephole optimiser will, where possible, substitute a single padrange op for a pushmark followed by one or more pad ops, and possibly also skipping list and nextstate ops. In addition, the op can carry out the tasks associated with the RHS of a "my(...) = @_" assignment, so those ops may be optimised away too.
• Case-insensitive matching inside a [bracketed] character class with a multi-character fold no longer excludes one of the possibilities in the circumstances that it used to. [perl #89774].
• "PL_formfeed" has been removed.
• The regular expression engine no longer reads one byte past the end of the target string. While for all internally well-formed scalars this should never have been a problem, this change facilitates clever tricks with string buffers in CPAN modules. [perl #73542]
• Inside a BEGIN block, "PL_compcv" now points to the currently-compiling subroutine, rather than the BEGIN block itself.
• "mg_length" has been deprecated.
• "sv_len" now always returns a byte count and "sv_len_utf8" a character count. Previously, "sv_len" and "sv_len_utf8" were both buggy and would sometimes returns bytes and sometimes characters. "sv_len_utf8" no longer assumes that its argument is in UTF-8. Neither of these creates UTF-8 caches for tied or overloaded values or for non-PVs any more.
• "sv_mortalcopy" now copies string buffers of shared hash key scalars when called from XS modules [perl #79824].
• The new "RXf_MODIFIES_VARS" flag can be set by custom regular expression engines to indicate that the execution of the regular expression may cause variables to be modified. This lets "s///" know to skip certain optimisations. Perl's own regular expression engine sets this flag for the special backtracking verbs that set $REGMARK and $REGERROR.
• The APIs for accessing lexical pads have changed considerably.

  "PADLIST"s are now longer "AV"s, but their own type instead. "PADLIST"s now contain a "PAD" and a "PADNAMELIST" of "PADNAME"s, rather than "AV"s for the pad and the list of pad names. "PAD"s, "PADNAMELIST"s, and "PADNAME"s are to be accessed as such through the newly added pad API instead of the plain "AV" and "SV" APIs. See perlapi for details.

• In the regex API, the numbered capture callbacks are passed an index indicating what match variable is being accessed. There are special index values for the "$`, $&, $&" variables. Previously the same three values were used to retrieve "${^PREMATCH}, ${^MATCH}, ${^POSTMATCH}" too, but these have now been assigned three separate values. See "Numbered capture callbacks" in perlreapi.
• "PL_sawampersand" was previously a boolean indicating that any of "$`, $&, $&" had been seen; it now contains three one-bit flags indicating the presence of each of the variables individually.
• The "CV *" typemap entry now supports "&{}" overloading and typeglobs, just like "&{...}" [perl #96872].
• The "SVf_AMAGIC" flag to indicate overloading is now on the stash, not the object. It is now set automatically whenever a method or @ISA changes, so its meaning has changed, too. It now means "potentially overloaded". When the overload table is calculated, the flag is automatically turned off if there is no overloading, so there should be no noticeable slowdown.

  The staleness of the overload tables is now checked when overload methods are invoked, rather than during "bless".

  "A" magic is gone. The changes to the handling of the "SVf_AMAGIC" flag eliminate the need for it.

  "PL_amagic_generation" has been removed as no longer necessary. For XS modules, it is now a macro alias to "PL_na".

  The fallback overload setting is now stored in a stash entry separate from overloadedness itself.

• The character-processing code has been cleaned up in places. The changes should be operationally invisible.
• The "study" function was made a no-op in v5.16. It was simply disabled via a "return" statement; the code was left in place. Now the code supporting what "study" used to do has been removed.
• Under threaded perls, there is no longer a separate PV allocated for every COP to store its package name ("cop->stashpv"). Instead, there is an offset ("cop->stashoff") into the new "PL_stashpad" array, which holds stash pointers.
• In the pluggable regex API, the "regexp_engine" struct has acquired a new field "op_comp", which is currently just for perl's internal use, and should be initialized to NULL by other regex plugin modules.
• A new function "alloccopstash" has been added to the API, but is considered experimental. See perlapi.
• Perl used to implement get magic in a way that would sometimes hide bugs in code that could call mg_get() too many times on magical values. This hiding of errors no longer occurs, so long-standing bugs may become visible now. If you see magic-related errors in XS code, check to make sure it, together with the Perl API functions it uses, calls mg_get() only once on SvGMAGICAL() values.
• OP allocation for CVs now uses a slab allocator. This simplifies memory management for OPs allocated to a CV, so cleaning up after a compilation error is simpler and safer [perl #111462][perl #112312].
• "PERL_DEBUG_READONLY_OPS" has been rewritten to work with the new slab allocator, allowing it to catch more violations than before.
• The old slab allocator for ops, which was only enabled for "PERL_IMPLICIT_SYS" and "PERL_DEBUG_READONLY_OPS", has been retired.

Selected Bug Fixes

• Here document terminators no longer require a terminating newline character when they occur at the end of a file. This was already the case at the end of a string eval [perl #65838].
• "-DPERL_GLOBAL_STRUCT" builds now free the global struct after they've finished using it.
• A trailing '/' on a path in @INC will no longer have an additional '/' appended.
• The ":crlf" layer now works when unread data doesn't fit into its own buffer. [perl #112244].
• "ungetc()" now handles UTF-8 encoded data. [perl #116322].
• A bug in the core typemap caused any C types that map to the T_BOOL core typemap entry to not be set, updated, or modified when the T_BOOL variable was used in an OUTPUT: section with an exception for RETVAL. T_BOOL in an INPUT: section was not affected. Using a T_BOOL return type for an XSUB (RETVAL) was not affected. A side effect of fixing this bug is, if a T_BOOL is specified in the OUTPUT: section (which previous did nothing to the SV), and a read only SV (literal) is passed to the XSUB, croaks like "Modification of a read-only value attempted" will happen. [perl #115796]
• On many platforms, providing a directory name as the script name caused perl to do nothing and report success. It should now universally report an error and exit nonzero. [perl #61362]
• "sort {undef} ..." under fatal warnings no longer crashes. It had begun crashing in Perl v5.16.
• Stashes blessed into each other ("bless \%Foo::, 'Bar'; bless \%Bar::, 'Foo'") no longer result in double frees. This bug started happening in Perl v5.16.
• Numerous memory leaks have been fixed, mostly involving fatal warnings and syntax errors.
• Some failed regular expression matches such as "'f' =~ /../g" were not resetting "pos". Also, "match-once" patterns ("m?...?g") failed to reset it, too, when invoked a second time [perl #23180].
• Several bugs involving "local *ISA" and "local *Foo::" causing stale MRO caches have been fixed.
• Defining a subroutine when its typeglob has been aliased no longer results in stale method caches. This bug was introduced in Perl v5.10.
• Localising a typeglob containing a subroutine when the typeglob's package has been deleted from its parent stash no longer produces an error. This bug was introduced in Perl v5.14.
• Under some circumstances, "local *method=..." would fail to reset method caches upon scope exit.
• "/[.foo.]/" is no longer an error, but produces a warning (as before) and is treated as "/[.fo]/" [perl #115818].
• "goto $tied_var" now calls FETCH before deciding what type of goto (subroutine or label) this is.
• Renaming packages through glob assignment ("*Foo:: = *Bar::; *Bar:: = *Baz::") in combination with "m?...?" and "reset" no longer makes threaded builds crash.
• A number of bugs related to assigning a list to hash have been fixed. Many of these involve lists with repeated keys like "(1, 1, 1, 1)".

• Attributes applied to lexical variables no longer leak memory. [perl #114764]
• "dump", "goto", "last", "next", "redo" or "require" followed by a bareword (or version) and then an infix operator is no longer a syntax error. It used to be for those infix operators (like "+") that have a different meaning where a term is expected. [perl #105924]
• "require a::b . 1" and "require a::b + 1" no longer produce erroneous ambiguity warnings. [perl #107002]
• Class method calls are now allowed on any string, and not just strings beginning with an alphanumeric character. [perl #105922]
• An empty pattern created with "qr//" used in "m///" no longer triggers the "empty pattern reuses last pattern" behaviour. [perl #96230]
• Tying a hash during iteration no longer results in a memory leak.
• Freeing a tied hash during iteration no longer results in a memory leak.
• List assignment to a tied array or hash that dies on STORE no longer results in a memory leak.
• If the hint hash ("%^H") is tied, compile-time scope entry (which copies the hint hash) no longer leaks memory if FETCH dies. [perl #107000]
• Constant folding no longer inappropriately triggers the special "split " "" behaviour. [perl #94490]
• "defined scalar(@array)", "defined do { &foo }", and similar constructs now treat the argument to "defined" as a simple scalar. [perl #97466]
• Running a custom debugging that defines no *DB::DB glob or provides a subroutine stub for &DB::DB no longer results in a crash, but an error instead. [perl #114990]
• "reset """ now matches its documentation. "reset" only resets "m?...?" patterns when called with no argument. An empty string for an argument now does nothing. (It used to be treated as no argument.) [perl #97958]
• "printf" with an argument returning an empty list no longer reads past the end of the stack, resulting in erratic behaviour. [perl #77094]
• "--subname" no longer produces erroneous ambiguity warnings. [perl #77240]
• "v10" is now allowed as a label or package name. This was inadvertently broken when v-strings were added in Perl v5.6. [perl #56880]
• "length", "pos", "substr" and "sprintf" could be confused by ties, overloading, references and typeglobs if the stringification of such changed the internal representation to or from UTF-8. [perl #114410]
• utf8::encode now calls FETCH and STORE on tied variables. utf8::decode now calls STORE (it was already calling FETCH).
• "$tied =~ s/$non_utf8/$utf8/" no longer loops infinitely if the tied variable returns a Latin-1 string, shared hash key scalar, or reference or typeglob that stringifies as ASCII or Latin-1. This was a regression from v5.12.
• "s///" without /e is now better at detecting when it needs to forego certain optimisations, fixing some buggy cases:

• The taintedness of the replacement string no longer affects the taintedness of the return value of "s///e".
• The $| autoflush variable is created on-the-fly when needed. If this happened (e.g., if it was mentioned in a module or eval) when the currently-selected filehandle was a typeglob with an empty IO slot, it used to crash. [perl #115206]
• Line numbers at the end of a string eval are no longer off by one. [perl #114658]
• @INC filters (subroutines returned by subroutines in @INC) that set $_ to a copy-on-write scalar no longer cause the parser to modify that string buffer in place.
• "length($object)" no longer returns the undefined value if the object has string overloading that returns undef. [perl #115260]
• The use of "PL_stashcache", the stash name lookup cache for method calls, has been restored,

  Commit da6b625f78f5f133 in August 2011 inadvertently broke the code that looks up values in "PL_stashcache". As it's only a cache, quite correctly everything carried on working without it.

• The error "Can't localize through a reference" had disappeared in v5.16.0 when "local %$ref" appeared on the last line of an lvalue subroutine. This error disappeared for "\local %$ref" in perl v5.8.1. It has now been restored.
• The parsing of here-docs has been improved significantly, fixing several parsing bugs and crashes and one memory leak, and correcting wrong subsequent line numbers under certain conditions.
• Inside an eval, the error message for an unterminated here-doc no longer has a newline in the middle of it [perl #70836].
• A substitution inside a substitution pattern ("s/${s|||}//") no longer confuses the parser.
• It may be an odd place to allow comments, but "s//"" # hello/e" has always worked, unless there happens to be a null character before the first #. Now it works even in the presence of nulls.
• An invalid range in "tr///" or "y///" no longer results in a memory leak.
• String eval no longer treats a semicolon-delimited quote-like operator at the very end ("eval 'q;;'") as a syntax error.
• "warn {$_ => 1} + 1" is no longer a syntax error. The parser used to get confused with certain list operators followed by an anonymous hash and then an infix operator that shares its form with a unary operator.
• "(caller $n)[6]" (which gives the text of the eval) used to return the actual parser buffer. Modifying it could result in crashes. Now it always returns a copy. The string returned no longer has "\n;" tacked on to the end. The returned text also includes here-doc bodies, which used to be omitted.
• The UTF-8 position cache is now reset when accessing magical variables, to avoid the string buffer and the UTF-8 position cache getting out of sync [perl #114410].
• Various cases of get magic being called twice for magical UTF-8 strings have been fixed.
• This code (when not in the presence of $& etc)

      $_ = 'x' x 1_000_000;
      1 while /(.)/;
      

  used to skip the buffer copy for performance reasons, but suffered from $1 etc changing if the original string changed. That's now been fixed.

• Perl doesn't use PerlIO anymore to report out of memory messages, as PerlIO might attempt to allocate more memory.
• In a regular expression, if something is quantified with "{n,m}" where "n > m", it can't possibly match. Previously this was a fatal error, but now is merely a warning (and that something won't match). [perl #82954].
• It used to be possible for formats defined in subroutines that have subsequently been undefined and redefined to close over variables in the wrong pad (the newly-defined enclosing sub), resulting in crashes or "Bizarre copy" errors.
• Redefinition of XSUBs at run time could produce warnings with the wrong line number.
• The %vd sprintf format does not support version objects for alpha versions. It used to output the format itself (%vd) when passed an alpha version, and also emit an "Invalid conversion in printf" warning. It no longer does, but produces the empty string in the output. It also no longer leaks memory in this case.
• "$obj->SUPER::method" calls in the main package could fail if the SUPER package had already been accessed by other means.
• Stash aliasing ("*foo:: = *bar::") no longer causes SUPER calls to ignore changes to methods or @ISA or use the wrong package.
• Method calls on packages whose names end in ::SUPER are no longer treated as SUPER method calls, resulting in failure to find the method. Furthermore, defining subroutines in such packages no longer causes them to be found by SUPER method calls on the containing package [perl #114924].
• "\w" now matches the code points U+200C (ZERO WIDTH NON-JOINER) and U+200D (ZERO WIDTH JOINER). "\W" no longer matches these. This change is because Unicode corrected their definition of what "\w" should match.
• "dump LABEL" no longer leaks its label.
• Constant folding no longer changes the behaviour of functions like "stat()" and "truncate()" that can take either filenames or handles. "stat 1 ? foo : bar" nows treats its argument as a file name (since it is an arbitrary expression), rather than the handle "foo".
• "truncate FOO, $len" no longer falls back to treating "FOO" as a file name if the filehandle has been deleted. This was broken in Perl v5.16.0.
• Subroutine redefinitions after sub-to-glob and glob-to-glob assignments no longer cause double frees or panic messages.
• "s///" now turns vstrings into plain strings when performing a substitution, even if the resulting string is the same ("s/a/a/").
• Prototype mismatch warnings no longer erroneously treat constant subs as having no prototype when they actually have "".
• Constant subroutines and forward declarations no longer prevent prototype mismatch warnings from omitting the sub name.
• "undef" on a subroutine now clears call checkers.
• The "ref" operator started leaking memory on blessed objects in Perl v5.16.0. This has been fixed [perl #114340].
• "use" no longer tries to parse its arguments as a statement, making "use constant { () };" a syntax error [perl #114222].
• On debugging builds, "uninitialized" warnings inside formats no longer cause assertion failures.
• On debugging builds, subroutines nested inside formats no longer cause assertion failures [perl #78550].
• Formats and "use" statements are now permitted inside formats.
• "print $x" and "sub { print $x }->()" now always produce the same output. It was possible for the latter to refuse to close over $x if the variable was not active; e.g., if it was defined outside a currently-running named subroutine.
• Similarly, "print $x" and "print eval '$x'" now produce the same output. This also allows "my $x if 0" variables to be seen in the debugger [perl #114018].
• Formats called recursively no longer stomp on their own lexical variables, but each recursive call has its own set of lexicals.
• Attempting to free an active format or the handle associated with it no longer results in a crash.
• Format parsing no longer gets confused by braces, semicolons and low-precedence operators. It used to be possible to use braces as format delimiters (instead of "=" and "."), but only sometimes. Semicolons and low-precedence operators in format argument lines no longer confuse the parser into ignoring the line's return value. In format argument lines, braces can now be used for anonymous hashes, instead of being treated always as "do" blocks.
• Formats can now be nested inside code blocks in regular expressions and other quoted constructs ("/(?{...})/" and "qq/${...}/") [perl #114040].
• Formats are no longer created after compilation errors.
• Under debugging builds, the -DA command line option started crashing in Perl v5.16.0. It has been fixed [perl #114368].
• A potential deadlock scenario involving the premature termination of a pseudo- forked child in a Windows build with ithreads enabled has been fixed. This resolves the common problem of the t/op/fork.t test hanging on Windows [perl #88840].
• The code which generates errors from "require()" could potentially read one or two bytes before the start of the filename for filenames less than three bytes long and ending "/\.p?\z/". This has now been fixed. Note that it could never have happened with module names given to "use()" or "require()" anyway.
• The handling of pathnames of modules given to "require()" has been made thread-safe on VMS.
• Non-blocking sockets have been fixed on VMS.
• Pod can now be nested in code inside a quoted construct outside of a string eval. This used to work only within string evals [perl #114040].
• "goto ''" now looks for an empty label, producing the "goto must have label" error message, instead of exiting the program [perl #111794].
• "goto "\0"" now dies with "Can't find label" instead of "goto must have label".
• The C function "hv_store" used to result in crashes when used on "%^H" [perl #111000].
• A call checker attached to a closure prototype via "cv_set_call_checker" is now copied to closures cloned from it. So "cv_set_call_checker" now works inside an attribute handler for a closure.
• Writing to $^N used to have no effect. Now it croaks with "Modification of a read-only value" by default, but that can be overridden by a custom regular expression engine, as with $1 [perl #112184].
• "undef" on a control character glob ("undef *^H") no longer emits an erroneous warning about ambiguity [perl #112456].
• For efficiency's sake, many operators and built-in functions return the same scalar each time. Lvalue subroutines and subroutines in the CORE:: namespace were allowing this implementation detail to leak through. "print &CORE::uc("a"), &CORE::uc("b")" used to print "BB". The same thing would happen with an lvalue subroutine returning the return value of "uc". Now the value is copied in such cases.
• "method {}" syntax with an empty block or a block returning an empty list used to crash or use some random value left on the stack as its invocant. Now it produces an error.
• "vec" now works with extremely large offsets (>2 GB) [perl #111730].
• Changes to overload settings now take effect immediately, as do changes to inheritance that affect overloading. They used to take effect only after "bless".

  Objects that were created before a class had any overloading used to remain non-overloaded even if the class gained overloading through "use overload" or @ISA changes, and even after "bless". This has been fixed [perl #112708].

• Classes with overloading can now inherit fallback values.
• Overloading was not respecting a fallback value of 0 if there were overloaded objects on both sides of an assignment operator like "+=" [perl #111856].
• "pos" now croaks with hash and array arguments, instead of producing erroneous warnings.
• "while(each %h)" now implies "while(defined($_ = each %h))", like "readline" and "readdir".
• Subs in the CORE:: namespace no longer crash after "undef *_" when called with no argument list (&CORE::time with no parentheses).
• "unpack" no longer produces the "'/' must follow a numeric type in unpack" error when it is the data that are at fault [perl #60204].
• "join" and "@array" now call FETCH only once on a tied $" [perl #8931].
• Some subroutine calls generated by compiling core ops affected by a "CORE::GLOBAL" override had op checking performed twice. The checking is always idempotent for pure Perl code, but the double checking can matter when custom call checkers are involved.
• A race condition used to exist around fork that could cause a signal sent to the parent to be handled by both parent and child. Signals are now blocked briefly around fork to prevent this from happening [perl #82580].
• The implementation of code blocks in regular expressions, such as "(?{})" and "(??{})", has been heavily reworked to eliminate a whole slew of bugs. The main user-visible changes are:

• Perl now can be recompiled to use any Unicode version. In v5.16, it worked on Unicodes 6.0 and 6.1, but there were various bugs if earlier releases were used; the older the release the more problems.
• "vec" no longer produces "uninitialized" warnings in lvalue context [perl #9423].
• An optimization involving fixed strings in regular expressions could cause a severe performance penalty in edge cases. This has been fixed [perl #76546].
• In certain cases, including empty subpatterns within a regular expression (such as "(?:)" or "(?:|)") could disable some optimizations. This has been fixed.
• The "Can't find an opnumber" message that "prototype" produces when passed a string like "CORE::nonexistent_keyword" now passes UTF-8 and embedded NULs through unchanged [perl #97478].
• "prototype" now treats magical variables like $1 the same way as non-magical variables when checking for the CORE:: prefix, instead of treating them as subroutine names.
• Under threaded perls, a runtime code block in a regular expression could corrupt the package name stored in the op tree, resulting in bad reads in "caller", and possibly crashes [perl #113060].
• Referencing a closure prototype ("\&{$_[1]}" in an attribute handler for a closure) no longer results in a copy of the subroutine (or assertion failures on debugging builds).
• "eval '__PACKAGE__'" now returns the right answer on threaded builds if the current package has been assigned over (as in "*ThisPackage:: = *ThatPackage::") [perl #78742].
• If a package is deleted by code that it calls, it is possible for "caller" to see a stack frame belonging to that deleted package. "caller" could crash if the stash's memory address was reused for a scalar and a substitution was performed on the same scalar [perl #113486].
• "UNIVERSAL::can" no longer treats its first argument differently depending on whether it is a string or number internally.
• "open" with "<&" for the mode checks to see whether the third argument is a number, in determining whether to treat it as a file descriptor or a handle name. Magical variables like $1 were always failing the numeric check and being treated as handle names.
• "warn"'s handling of magical variables ($1, ties) has undergone several fixes. "FETCH" is only called once now on a tied argument or a tied $@ [perl #97480]. Tied variables returning objects that stringify as "" are no longer ignored. A tied $@ that happened to return a reference the previous time it was used is no longer ignored.
• "warn """ now treats $@ with a number in it the same way, regardless of whether it happened via "$@=3" or "$@="3"". It used to ignore the former. Now it appends "\t...caught", as it has always done with "$@="3"".
• Numeric operators on magical variables (e.g., "$1 + 1") used to use floating point operations even where integer operations were more appropriate, resulting in loss of accuracy on 64-bit platforms [perl #109542].
• Unary negation no longer treats a string as a number if the string happened to be used as a number at some point. So, if $x contains the string "dogs", "-$x" returns "-dogs" even if "$y=0+$x" has happened at some point.
• In Perl v5.14, "-'-10'" was fixed to return "10", not "+10". But magical variables ($1, ties) were not fixed till now [perl #57706].
• Unary negation now treats strings consistently, regardless of the internal "UTF8" flag.
• A regression introduced in Perl v5.16.0 involving "tr/SEARCHLIST/REPLACEMENTLIST/" has been fixed. Only the first instance is supposed to be meaningful if a character appears more than once in "SEARCHLIST". Under some circumstances, the final instance was overriding all earlier ones. [perl #113584]
• Regular expressions like "qr/\87/" previously silently inserted a NUL character, thus matching as if it had been written "qr/\00087/". Now it matches as if it had been written as "qr/87/", with a message that the sequence "\8" is unrecognized.
• "__SUB__" now works in special blocks ("BEGIN", "END", etc.).
• Thread creation on Windows could theoretically result in a crash if done inside a "BEGIN" block. It still does not work properly, but it no longer crashes [perl #111610].
• "\&{''}" (with the empty string) now autovivifies a stub like any other sub name, and no longer produces the "Unable to create sub" error [perl #94476].
• A regression introduced in v5.14.0 has been fixed, in which some calls to the "re" module would clobber $_ [perl #113750].
• "do FILE" now always either sets or clears $@, even when the file can't be read. This ensures that testing $@ first (as recommended by the documentation) always returns the correct result.
• The array iterator used for the "each @array" construct is now correctly reset when @array is cleared [perl #75596]. This happens, for example, when the array is globally assigned to, as in "@array = (...)", but not when its values are assigned to. In terms of the XS API, it means that "av_clear()" will now reset the iterator.

  This mirrors the behaviour of the hash iterator when the hash is cleared.

• "$class->can", "$class->isa", and "$class->DOES" now return correct results, regardless of whether that package referred to by $class exists [perl #47113].
• Arriving signals no longer clear $@ [perl #45173].
• Allow "my ()" declarations with an empty variable list [perl #113554].
• During parsing, subs declared after errors no longer leave stubs [perl #113712].
• Closures containing no string evals no longer hang on to their containing subroutines, allowing variables closed over by outer subroutines to be freed when the outer sub is freed, even if the inner sub still exists [perl #89544].
• Duplication of in-memory filehandles by opening with a "<&=" or ">&=" mode stopped working properly in v5.16.0. It was causing the new handle to reference a different scalar variable. This has been fixed [perl #113764].
• "qr//" expressions no longer crash with custom regular expression engines that do not set "offs" at regular expression compilation time [perl #112962].
• "delete local" no longer crashes with certain magical arrays and hashes [perl #112966].
• "local" on elements of certain magical arrays and hashes used not to arrange to have the element deleted on scope exit, even if the element did not exist before "local".
• "scalar(write)" no longer returns multiple items [perl #73690].
• String to floating point conversions no longer misparse certain strings under "use locale" [perl #109318].
• @INC filters that die no longer leak memory [perl #92252].
• The implementations of overloaded operations are now called in the correct context. This allows, among other things, being able to properly override "<>" [perl #47119].
• Specifying only the "fallback" key when calling "use overload" now behaves properly [perl #113010].
• "sub foo { my $a = 0; while ($a) { ... } }" and "sub foo { while (0) { ... } }" now return the same thing [perl #73618].
• String negation now behaves the same under "use integer;" as it does without [perl #113012].
• "chr" now returns the Unicode replacement character (U+FFFD) for -1, regardless of the internal representation. -1 used to wrap if the argument was tied or a string internally.
• Using a "format" after its enclosing sub was freed could crash as of perl v5.12.0, if the format referenced lexical variables from the outer sub.
• Using a "format" after its enclosing sub was undefined could crash as of perl v5.10.0, if the format referenced lexical variables from the outer sub.
• Using a "format" defined inside a closure, which format references lexical variables from outside, never really worked unless the "write" call was directly inside the closure. In v5.10.0 it even started crashing. Now the copy of that closure nearest the top of the call stack is used to find those variables.
• Formats that close over variables in special blocks no longer crash if a stub exists with the same name as the special block before the special block is compiled.
• The parser no longer gets confused, treating "eval foo ()" as a syntax error if preceded by "print;" [perl #16249].
• The return value of "syscall" is no longer truncated on 64-bit platforms [perl #113980].
• Constant folding no longer causes "print 1 ? FOO : BAR" to print to the FOO handle [perl #78064].
• "do subname" now calls the named subroutine and uses the file name it returns, instead of opening a file named "subname".
• Subroutines looked up by rv2cv check hooks (registered by XS modules) are now taken into consideration when determining whether "foo bar" should be the sub call "foo(bar)" or the method call ""bar"->foo".
• "CORE::foo::bar" is no longer treated specially, allowing global overrides to be called directly via "CORE::GLOBAL::uc(...)" [perl #113016].
• Calling an undefined sub whose typeglob has been undefined now produces the customary "Undefined subroutine called" error, instead of "Not a CODE reference".
• Two bugs involving @ISA have been fixed. "*ISA = *glob_without_array" and "undef *ISA; @{*ISA}" would prevent future modifications to @ISA from updating the internal caches used to look up methods. The *glob_without_array case was a regression from Perl v5.12.
• Regular expression optimisations sometimes caused "$" with "/m" to produce failed or incorrect matches [perl #114068].
• "__SUB__" now works in a "sort" block when the enclosing subroutine is predeclared with "sub foo;" syntax [perl #113710].
• Unicode properties only apply to Unicode code points, which leads to some subtleties when regular expressions are matched against above-Unicode code points. There is a warning generated to draw your attention to this. However, this warning was being generated inappropriately in some cases, such as when a program was being parsed. Non-Unicode matches such as "\w" and "[:word:]" should not generate the warning, as their definitions don't limit them to apply to only Unicode code points. Now the message is only generated when matching against "\p{}" and "\P{}". There remains a bug, [perl #114148], for the very few properties in Unicode that match just a single code point. The warning is not generated if they are matched against an above-Unicode code point.
• Uninitialized warnings mentioning hash elements would only mention the element name if it was not in the first bucket of the hash, due to an off-by-one error.
• A regular expression optimizer bug could cause multiline "^" to behave incorrectly in the presence of line breaks, such that ""/\n\n" =~ m#\A(?:^/$)#im" would not match [perl #115242].
• Failed "fork" in list context no longer corrupts the stack. "@a = (1, 2, fork, 3)" used to gobble up the 2 and assign "(1, undef, 3)" if the "fork" call failed.
• Numerous memory leaks have been fixed, mostly involving tied variables that die, regular expression character classes and code blocks, and syntax errors.
• Assigning a regular expression ("${qr//}") to a variable that happens to hold a floating point number no longer causes assertion failures on debugging builds.
• Assigning a regular expression to a scalar containing a number no longer causes subsequent numification to produce random numbers.
• Assigning a regular expression to a magic variable no longer wipes away the magic. This was a regression from v5.10.
• Assigning a regular expression to a blessed scalar no longer results in crashes. This was also a regression from v5.10.
• Regular expression can now be assigned to tied hash and array elements with flattening into strings.
• Numifying a regular expression no longer results in an uninitialized warning.
• Negative array indices no longer cause EXISTS methods of tied variables to be ignored. This was a regression from v5.12.
• Negative array indices no longer result in crashes on arrays tied to non-objects.
• "$byte_overload .= $utf8" no longer results in doubly-encoded UTF-8 if the left-hand scalar happened to have produced a UTF-8 string the last time overloading was invoked.
• "goto &sub" now uses the current value of @_, instead of using the array the subroutine was originally called with. This means "local @_ = (...); goto &sub" now works [perl #43077].
• If a debugger is invoked recursively, it no longer stomps on its own lexical variables. Formerly under recursion all calls would share the same set of lexical variables [perl #115742].
• *_{ARRAY} returned from a subroutine no longer spontaneously becomes empty.
• When using "say" to print to a tied filehandle, the value of "$\" is correctly localized, even if it was previously undef. [perl #119927]

Known Problems

•

UTF8-flagged strings in %ENV on HP-UX 11.00 are buggy

The interaction of UTF8-flagged strings and %ENV on HP-UX 11.00 is currently dodgy in some not-yet-fully-diagnosed way. Expect test failures in t/op/magic.t, followed by unknown behavior when storing wide characters in the environment.

Obituary

Acknowledgements

Perl continues to flourish into its third decade thanks to a vibrant community of users and developers. The following people are known to have contributed the improvements that became Perl v5.18.0:

Aaron Crane, Aaron Trevena, Abhijit Menon-Sen, Adrian M. Enache, Alan Haggai Alavi, Alexandr Ciornii, Andrew Tam, Andy Dougherty, Anton Nikishaev, Aristotle Pagaltzis, Augustina Blair, Bob Ernst, Brad Gilbert, Breno G. de Oliveira, Brian Carlson, Brian Fraser, Charlie Gonzalez, Chip Salzenberg, Chris 'BinGOs' Williams, Christian Hansen, Colin Kuskie, Craig A. Berry, Dagfinn Ilmari Mannsaaker, Daniel Dragan, Daniel Perrett, Darin McBride, Dave Rolsky, David Golden, David Leadbeater, David Mitchell, David Nicol, Dominic Hargreaves, E. Choroba, Eric Brine, Evan Miller, Father Chrysostomos, Florian Ragwitz, Francois Perrad, George Greer, Goro Fuji, H.Merijn Brand, Herbert Breunung, Hugo van der Sanden, Igor Zaytsev, James E Keenan, Jan Dubois, Jasmine Ahuja, Jerry D. Hedden, Jess Robinson, Jesse Luehrs, Joaquin Ferrero, Joel Berger, John Goodyear, John Peacock, Karen Etheridge, Karl Williamson, Karthik Rajagopalan, Kent Fredric, Leon Timmermans, Lucas Holt, Lukas Mai, Marcus Holland-Moritz, Markus Jansen, Martin Hasch, Matthew Horsfall, Max Maischein, Michael G Schwern, Michael Schroeder, Moritz Lenz, Nicholas Clark, Niko Tyni, Oleg Nesterov, Patrik Haegglund, Paul Green, Paul Johnson, Paul Marquess, Peter Martini, Rafael Garcia-Suarez, Reini Urban, Renee Baecker, Rhesa Rozendaal, Ricardo Signes, Robin Barker, Ronald J. Kimball, Ruslan Zakirov, Salvador Fandin~o, Sawyer X, Scott Lanning, Sergey Alekseev, Shawn M Moore, Shirakata Kentaro, Shlomi Fish, Sisyphus, Smylers, Steffen Mueller, Steve Hay, Steve Peters, Steven Schubiger, Sullivan Beck, Sven Strickroth, Sebastien Aperghis-Tramoni, Thomas Sibley, Tobias Leich, Tom Wyant, Tony Cook, Vadim Konovalov, Vincent Pit, Volker Schatz, Walt Mankowski, Yves Orton, Zefram.

The list above is almost certainly incomplete as it is automatically generated from version control history. In particular, it does not include the names of the (very much appreciated) contributors who reported issues to the Perl bug tracker.

Many of the changes included in this version originated in the CPAN modules included in Perl's core. We're grateful to the entire CPAN community for helping Perl to flourish.

For a more complete list of all of Perl's historical contributors, please see the AUTHORS file in the Perl source distribution.

Reporting Bugs

If you believe you have an unreported bug, please run the perlbug program included with your release. Be sure to trim your bug down to a tiny but sufficient test case. Your bug report, along with the output of "perl -V", will be sent off to perlbug@perl.org to be analysed by the Perl porting team.

If the bug you are reporting has security implications, which make it inappropriate to send to a publicly archived mailing list, then please send it to perl5-security-report@perl.org. This points to a closed subscription unarchived mailing list, which includes all the core committers, who will be able to help assess the impact of issues, figure out a resolution, and help co-ordinate the release of patches to mitigate or fix the problem across all platforms on which Perl is supported. Please only use this address for security issues in the Perl core, not for modules independently distributed on CPAN.

SEE ALSO

The INSTALL file for how to build Perl.

The README file for general stuff.

The Artistic and Copying files for copyright information.