perl5440delta - Man Page

This document describes differences between the 5.42.0 release and the 5.44.0 release.

• Deprecated since 5.12, using goto to jump into the body of a loop or other block construct from outside is no longer permitted. [GH #23618 <https://github.com/Perl/perl5/issues/23618>]

• m/...[...].../xx has new restrictions

  Using an unescaped # or literal vertical space is now deprecated in a regular expression bracketed character class that is compiled with the /xx modifier.  These still work, but deprecation warnings will be generated unless turned off or the constructs are cured as follows.

  • Escape a # by preceding it with a backslash, like in

     m/ [ % \# ( ) ] /xx

  • Use constructs like \n instead of literal vertical space.

• Simple (non-overflowing) addition (+), subtraction (-) and multiplication (*) of integers are slightly sped up, as long as sufficient underlying C compiler support is available.
• Populating a hash from a list of key/value pairs when the keys are constant string operands known at compile time is commonly now faster. [GH #24228 <https://github.com/Perl/perl5/issues/24228>]
• Processing of signatures at the start of a subroutine under the signatures feature is now more efficient at runtime.

The following additions or changes have been made to diagnostic output, including warnings and fatal error messages. For the complete list of diagnostic messages, see perldiag.

• C23 <stdckdint.h> and associated macros are now used if available.
• It is now possible to pass to Configure the values dealing with POSIX locale categories, overriding its automatic calculation of these.  This enables cross-compilation to work.  The easiest way to do this is to extract the C program that does the calculation from Configure and then run it on the target machine, and then pass the values it outputs to Configure on the other machine.  Porting/Glossary has examples. [GH #22992 <https://github.com/Perl/perl5/issues/22992>]
• The PERL_CREATE_GVSV configuration macro has been removed. It was almost undocumented and it has been disabled by default since Perl 5.10.0. Its purpose was to force all GVs to initialize their SV slot on creation. [GH #24177 <https://github.com/Perl/perl5/issues/24177>]

Tests were added and changed to reflect the other additions and changes in this release. Furthermore, these changes were made:

• Karl Williamson gave a talk at TPRC 2025 asking people to contribute tests to find old issues that are no longer a problem, and todo tests to reflect reproduction cases for known outstanding bugs. (video link <https://www.youtube.com/watch?v=CwX4Xsf5y5E>) It gained renewed interest this year, leading to an uptick in test submissions from new authors, for which we are extremely grateful.
• When testing embedding, add a sanity check to ensure the libperl we link against matches the perl we are building.  [GH #22125 <https://github.com/Perl/perl5/issues/22125>]

• The XS parser, ExtUtils::ParseXS, has been further extensively restructured internally.  Most of these changes shouldn't be visible externally, but might affect XS code which was using invalid or unsupported syntax.  Several minor bug-fixes were included.
• Removed the deprecated (since 5.32) functions sv_locking() and sv_unlocking.

• Perl_expected_size has been added as an experimental stub macro. The intention is to build on this such that it can be passed a size in bytes, then returns the interpreter's best informed guess of what actual usable allocation size would be returned by the malloc implementation in use.

  This would help with sizing allocations such that SvLEN is more accurate and not trying to shrink string buffers to save size when the intended saving is unrealistic.

• SvPV_shrink_to_cur has been revised to include a byte for copy-on-write (COW), so that the resulting string could be COWed in the future.

  It also now uses Perl_expected_size, compared against the current buffer size, and does not try to do a reallocation if the requested memory saving is unrealistic.

• sv_vcatpvfn_flags() now substitutes the Unicode REPLACEMENT CHARACTER for malformed input.  Previously it used the NUL character.
• For core Perl maintainers, the syntax of embed.fnc has been extended. Every function, foo(), named in that file has generated for it a macro named PERL_ARGS_ASSERT_FOO.  The macro expands to assert() calls that do basic sanity checking for each argument to foo() that we currently deem as being appropriate to have such checking.  (That means that many arguments are not checked, and that the generated macro may currently expand to nothing.)  With this release, you can add assert() statements yourself to embed.fnc that will be incorporated into the generated macro, beyond the system-generated ones. Comments and examples in embed.fnc give details.
• A new function valid_utf8_to_uv has been added.  This is synonymous with valid_utf8_to_uvchr; its reason for existence is to have consistent spelling with the names of the other functions that translate from UTF-8, so you don't have to remember a different spelling.

• "newSVsv_flags_NN" in perlapi is a new function for creating a new SV and assigning the value(s) of an existing SV to it.

  Historically, Perl_newSVsv_flags and Perl_sv_mortalcopy_flags would pass a new SV head and the original SV to Perl_sv_setsv_flags. However, the latter contains many branches of no relevance to a fresh SV, so they now make use of the new function to streamline the process.

  Perl_newSVsv_flags is now essentially a NULL pointer check and wrapper around the new function, so has been moved into sv_inline.h.

• "STATIC_ASSERT_DECL" in perlapi and STATIC_ASSERT_STMT are like assert(), but are evaluated at compile time.  That means their argument must be a constant expression that can be verified by the compiler, and so they effectively have no cost, not appearing in the code that gets executed.  These were added in v5.28, but not until now have we opened their use up to XS writers.  At the same time, a new variant has been added, STATIC_ASSERT_EXPR which is suitable for use in an expression, such as a comma expression in a C macro.

• Perl_sv_backoff, which undoes the OOK string offset mechanism now only moves the string buffer contents to the start of the buffer if SvOK(sv) is true. Historically, the buffer contents were always moved, but if the buffer contents are defunct and no longer required, doing that incurs an unnecessary cost proportional to the size of the shifted contents.

  (The assumption in this change is that SvOK(sv) is a valid indicator of whether the string buffer contents are "live" or not.)

  See [GH #23967 <https://github.com/Perl/perl5/issues/23967>] for an example of where such a copy was noticeable.

• Fixed a bug in the "sv_numeq" in perlapi API where values with numeric ("0+") overloading but not equality or numeric comparison overloading would always be compared as floating point values.  This could lead to large integers being reported as equal when they weren't.
• Fixed a bug in "sv_numeq" in perlapi where the SV_SKIP_OVERLOAD flag would skip operator overloading, but would still honor numeric ("0+") overloading.

• Added "sv_numne" in perlapi, sv_numle, sv_numlt, sv_numge, sv_numgt and "sv_numcmp" in perlapi APIs that perform numeric comparison in the same way perl does, including overloading.  Separate APIs for each comparison are needed to invoke their corresponding overload when needed.  Inspired by [GH #23918 <https://github.com/Perl/perl5/issues/23918>]

  This also extends the sv_numeq API to support SV_FORCE_OVERLOAD.

• Added the AMGf_force_scalar flag to the "amagic_call" in perlapi API to force scalar context for overload calls.
• Added the AMGf_force_overload flag to the "amagic_call" in perlapi API to allow forcing overloading to be honored even in the context of no overloading;.

• The SvFLAGS bits used by SvPCS_IMPORTED() and SvOOK() have now been merged into the same position, thus freeing up a flags bit for possible future purposes. This merge is distinguished by the fact that the PCS_IMPORTED behaviour is only used on references (when SvROK is true), whereas the OOK only applies to string buffers (when SvROK is false).

  This change shouldn't affect any XS module code that is using the test macros correctly, though might cause confusion to code that attempts to analyse SvFLAGS bits directly outside of the helper macros.

• An upper limit has been applied to the multiplier operand of the repetition operator. Constant folding will not be attempted if the operand is a numerical constant above PERL_FOLD_REPEAT_LIMIT. See [GH #20586 <https://github.com/Perl/perl5/issues/20586>] and [GH #23561 <https://github.com/Perl/perl5/issues/23561>] for background.
• Dedicated check functions Perl_ck_anonhash and Perl_ck_aassign have been added and are used to hekify some OP_CONST hash keys at compile time. [GH #24228 <https://github.com/Perl/perl5/issues/24228>]
• The macro "fromCTRL" in perlapi has been added to be the inverse of the existing "toCTRL" in perlapi.  toCTRL('A') yields 1 (the control character SOH on all platforms Perl works on); fromCTRL(1) yields 'A'.
• Perl_check_hash_fields_and_hekify, partly called as a compile-time optimization, no longer preemptively converts an NV to a HEK if the compile time and run time locales could differ. [GH #24252 <https://github.com/Perl/perl5/issues/24252>]

• When a UTF-8 constant string was used as the hash key in an insert operation, such as $hash{'über maus'} = 1;, and the string could be converted into a single byte representation, the flag noting the original encoding (HVhek_WASUTF8) was not always retained.

  When this occurred, the relevant scalars returned by keys %hash would not be in the original, expected UTF-8 encoding.

  The original encoding is now captured and propagated. [GH #24266 <https://github.com/Perl/perl5/issues/24266>] [GH #24290 <https://github.com/Perl/perl5/pull/24290>]

• When a constant IV or NV was used as a hash key, such as in my %hash = ( 42 => 0 );, and was preemptively stringified into a hash key, the fact that the numerical value came first was lost. This unintentionally modified deparse output for such keys.

  The numerical values are now carried across, and flags on the key variable reflect the original data type.

  Note: This now preserves the form of constant keys supplied to tied hashes in list assignments. [GH #24302 <https://github.com/Perl/perl5/issues/24302>]

• A new function, "defer_error" in perlapi, has been added to report errors in compiling a perl program.  "qerror" in perlapi is a deprecated alias for it.  Previously, qerror existed but was undocumented.

  [GH #23676 <https://github.com/Perl/perl5/issues/23676>]

• "op_clear" in perlapi is now part of the API.

  [GH #23676 <https://github.com/Perl/perl5/issues/23676>]

• Reported argument counts in method signatures now account for $self

  In previous versions of Perl, the exception message thrown by a method subroutine with a signature when it does not receive an appropriate number of arguments to match its declared parameters failed to account for the implied $self parameter, causing the numbers in the message to be 1 fewer than intended.

  This has now been fixed, so messages report the correct number of arguments including the object invocant.

• When both operands of arithmetic operators (+, -, etc.) are overloaded objects which have no method for that operator but have a 0+ method and the fallback option set to TRUE, perl will normally call the 0+ method for the left operand first and then call one for the right operand, i.e. in the same order as operand evaluation. But if use integer; is in effect, the 0+ methods used to be called in wrong (reverse) order.

• Certain constructs involving a two-variable for loop would crash the perl compiler in v5.42.0:

      # Two-variable for loop over a list returned from a method call:
      for my ($x, $y) (Some::Class->foo()) { ... }
      for my ($x, $y) ($object->foo()) { ... }

  and

      # Two-variable for loop over a list returned from a call to a
      # lexical(ly imported) subroutine, all inside a lexically scoped
      # or anonymous subroutine:
      my sub foo { ... }
      my $fn = sub {
          for my ($x, $y) (foo()) { ... }
      };
  
      use builtin qw(indexed);  # lexical import!
      my sub bar {
          for my ($x, $y) (indexed(...)) { ... }
      }

  These have been fixed.  [GH #23405 <https://github.com/Perl/perl5/issues/23405>]

• Several error conditions in the pack and unpack operations were not detected and now are.

• INTERFACE keyword in XS

  INTERFACE is now compatible with ISO/IEC 9899:2024 ("C23"), which is the default language version used by GCC 15. Previously, it generated code that failed to compile as C23.

  Secondly, INTERFACE now supports Perl package names as C types (i.e. Foo::Bar gets auto-converted to Foo__Bar).

  [GH #23192 <https://github.com/Perl/perl5/issues/23192>]

• &CORE::__CLASS__ no longer returns invalid results

  CORE::__CLASS__ would work as expected when used as a bareword or aliased:

      use feature qw(class);
      class Foo {
          BEGIN { *cls = \&CORE::__CLASS__; }
          method bar() {
              my $class1 = CORE::__CLASS__;  # ok
              my $class2 = cls;              # ok
          }
      }

  But when called with an ampersand (&CORE::__CLASS__()) or through a reference (my $ref = \&CORE::__CLASS__; $ref->()), it would return unrelated strings. These runtime calls have been fixed to throw an error of the form &CORE::__CLASS__ cannot be called directly instead of silently returning incorrect results.

  [GH #23737 <https://github.com/Perl/perl5/issues/23737>]

• parse_subsignature() can now handle empty subroutine signatures

  Previously, calling the parse_subsignature() API function with an empty signature would cause a "Syntax error" failure, requiring code which calls it to detect the special case and take appropriate steps.  This is now fixed, returning the same optree that the parser would yield for a regular empty signature during normal parse time.

  [GH #17689 <https://github.com/Perl/perl5/issues/17689>]

• The -CA flag (or equivalently, the PERL_UNICODE=A environment setting) tells perl to treat command-line arguments as UTF-8 strings. (See perlrun for details.) However, this did not extend to the global variables implicitly created by the -s option:

   $ perl -CA -s -e 'printf "%vx\n", $_ for $foo, $ARGV[0]' -- -foo=é é
   c3.a9
   e9

  Here $foo would end up containing the two-byte UTF-8 representation of "LATIN SMALL LETTER E WITH ACUTE", but $ARGV[0] would contain a single codepoint corresponding to U+00E9.

  This has been fixed: If -CA is in effect, options parsed by -s are treated as UTF-8, too. In the example above, $foo and $ARGV[0] now both contain chr(0xE9). [GH #23377 <https://github.com/Perl/perl5/issues/23377>]

• We have long claimed to support identifiers up to about 255 characters long.  However this was actually true only for identifiers that consisted of only ASCII characters.  The real upper limit was as few as 64 characters for identifiers written in languages using non-ASCII characters, for example, Chinese or Osage.  Now an identifier in any language may contain at least 255 characters.
• Fixed parsing of array names starting with a digit in double-quotish context under use utf8;.
• use 5.42 now turns on use source::encoding "ascii" for the remainder of the line (besides subsequent lines). [GH #23881 <https://github.com/Perl/perl5/issues/23881>]

• Since 5.32.0, the second branch of a ternary condition operator wasn't getting the correct autovivification context applied. For example in something like

      @{ $cond ? $h{foo} : $h{bar} } = ...;

  the first branch would correctly autovivify $h{foo} to an array ref, but the second branch might incorrectly autovivify $h{bar} to a hash ref. [GH #18669 <https://github.com/Perl/perl5/issues/18669>].

• Don't warn about jumping into a construct if we're DIE-ing [GH #23922 <https://github.com/Perl/perl5/pull/23922>].
• Regexes which include both a sub-pattern (e.g. (??{...}) or (?&FOO)) and a cut (i.e. (?>...)) could sometimes cause a premature scope exit in other code during a match.  For example, in something like (?{ local $x = ... }), the local might have been unwound before the pattern has finished matching. [GH #16197 <https://github.com/Perl/perl5/issues/16197>]
• DB::sub is not meant to be called for sub calls from the DB package, but calls to overloaded subs for overloaded values used in the DB package would result in calls to DB::sub.  Fixed the check for the current package in amagic_call().  [GH #24001 <https://github.com/Perl/perl5/issues/24001>].
• Fix parsing of hexadecimal floating-point numbers whose significand (aka "mantissa") values are too large to fit in UV range. Such literals (for example, 0x1234567890.1p+0 for 32-bit IV/UV platform, or 0x1234567890_1234567890.1p+0 for 64-bit IV/UV) used to be parsed incorrectly.
• Perl 5.42.0 did not handle the transition to/from daylight savings time properly, fixed in 5.42.1.  The time and/or timezone could be off by an hour in the intervals surrounding such transitions.  This was a regression from earlier releases.  This bug was evident from perl space in the "strftime" in POSIX function, and in XS code with any of "my_strftime" in perlapi, "sv_strftime_ints" in perlapi, or "sv_strftime_tm" in perlapi.
• sort() optimizes common comparisons from calling the OP tree for a comparison block into a call to a C function.  The C function used for overloaded numeric comparisons did not handle the case where there was no comparison overload but there was a numeric ("0+") overload correctly, losing precision for large overloaded integer arguments that are not exactly representable as a Perl floating point value (NV). [GH #23956 <https://github.com/Perl/perl5/issues/23956>]
• When a scalar variable used as the target of a filehandle is undef'ed while being output, garbage bytes would be left in that scalar. [GH #24008 <https://github.com/Perl/perl5/issues/24008>]
• When a scalar variable was used as the target of a filehandle and also was output onto itself, garbage could result, or even trigger a segmentation fault (as in open $fh, '>', \$str; print $fh $str;). [GH #24199 <https://github.com/Perl/perl5/issues/24199>]
• close(STDOUT) when STDOUT has been opened as a pipe will now properly wait for the child to exit on Windows.  [GH #4106 <https://github.com/Perl/perl5/issues/4106>]

• Calling an XSUB via goto in scalar context, where the XSUB didn't return exactly one value, could result in the return of the wrong number of items, leading to potential stack corruption. For example:

      sub wrap { goto \&an_xsub_which_returns_no_values }
      $ret = wrap();

  [GH #24212 <https://github.com/Perl/perl5/issues/24212>]

• On debugging perls, instantiating a class with an array field with an empty initializer list would abort with an error:

      class Foo {
          field @bar = ();
      }
      Foo->new();

  Error message: perl: inline.h:194: Perl_av_new_alloc: Assertion `size > 0' failed.

  This has been fixed. [GH #24246 <https://github.com/Perl/perl5/issues/24246>]

• Refassigning to a class field in a method could result in the SV for that field being released when the method exited.  The next access to that field could result in a crash or an assertion, or if the freed SV had been re-used, random data.  Discussed in [GH #24187 <https://github.com/Perl/perl5/issues/24187>]

None

"WELL VOLUNTEERED!" echoed across conference rooms and IRC channels. Matt S. Trout's battle cry that transformed reluctant volunteers into community leaders.

With profound sadness, we announce Matt's passing. Since the early 2000s, Matt shaped Perl through sheer force of will: IRC operator, PAUSE administrator, Shadowcat Systems co-founder, architect of DBIx::Class. His opinions came wrapped in profanity and delivered at maximum volume. He suffered no fools and grew to sometimes realize he should apologize. Yet this same abrasive exterior protected fierce dedication to mentoring, developers he harangued into volunteering now lead the community themselves. Matt's deliberately mind-bending code pushed Perl forward. Every modern Perl developer touches his legacy daily.

Well volunteered, Matt. Rest in peace.

Perl 5.44.0 represents approximately 12 months of development since Perl 5.42.0 and contains approximately 270,000 lines of changes across 1,300 files from 71 authors.

Excluding auto-generated files, documentation and release tools, there were approximately 110,000 lines of changes to 860 .pm, .t, .c and .h files.

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

Alexander Karelas, Aristotle Pagaltzis, Arne Johannessen, Bartosz Jarzyna, Branislav Zahradník, brian d foy, Chad Granum, Chris 'BinGOs' Williams, Chris Prather, Christian Hansen, Craig A. Berry, Dagfinn Ilmari Mannsåker, Dan Book, Dan Church, Daniel Dragan, Daniel Laügt, Daniel Tang, Dan Kogai, Dave Cross, David Mitchell, Dmitrii Kuvaiskii, E. Choroba, Ed J, Elvin Aslanov, Eric Herman, Eugen Konkov, Graham Knop, Harald Jörg, H.Merijn Brand, Igor Todorovski, James Cook, James E Keenan, James Raspass, Jörg Thomas, Karen Etheridge, Karl Williamson, Leon Timmermans, Lukas Mai, Marc Reisner, Masahiro Iuchi, Matthew Horsfall, Maxim Vuets, Max Maischein, Nicolas R, Olaf Alders, Paul Evans, Paul Marquess, Peter John Acklam, Philippe Bruhat (BooK), Ricardo Signes, Richard Leach, Robert Rothenberg, Ryan Carsten Schmidt, Samuel Smith, Samuel Young, Scott Baker, Sevan Janiyan, Shirakata Kentaro, Sisyphus, Stan Ulbrych, Stefan Adams, Štěpán Němec, Steve Hay, TAKAI Kousuke, Thibault Duponchelle, Toby Inkster, Tomasz Konojacki, Tom Wyant, Tony Cook, Unicode Consortium, Yitzchak Scott-Thoennes.

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.

If you find what you think is a bug, you might check the perl bug database at <https://github.com/Perl/perl5/issues>. There may also be information at <https://www.perl.org/>, the Perl Home Page.

If you believe you have an unreported bug, please open an issue at <https://github.com/Perl/perl5/issues>. Be sure to trim your bug down to a tiny but sufficient test case.

If the bug you are reporting has security implications which make it inappropriate to send to a public issue tracker, then see "Security VULNERABILITY CONTACT INFORMATION" in perlsec for details of how to report the issue.

If you wish to thank the Perl 5 Porters for the work we had done in Perl 5, you can do so by running the perlthanks program:

    perlthanks

This will send an email to the Perl 5 Porters list with your show of thanks.

The Changes file for an explanation of how to view exhaustive details on what changed.

The INSTALL file for how to build Perl.

The README file for general stuff.

The Artistic and Copying files for copyright information.