--- Begin Message ---
- To: submit@bugs.debian.org
- Subject: buster-pu: package perl/5.28.2
- From: Dominic Hargreaves <dom@earth.li>
- Date: Sun, 24 May 2020 16:58:31 +0100
- Message-id: <20200524155831.ik5g5lbdvg7t5beo@urchin.earth.li>
Package: release.debian.org
User: release.debian.org@packages.debian.org
Usertags: pu
Tags: buster
X-Debbugs-Cc: ntyni@debian.org, debian-perl@lists.debian.org
Hi release team,
The perl interpreter team would like to move to a model where we
attempt to keep Debian stable releases more or less in sync with
upstream maint branches - which are conservatively maintained along the
lines of the policies here, which match pretty well with Debian's:
https://perldoc.perl.org/5.30.0/perlpolicy.html#MAINTENANCE-BRANCHES
In the past we have done a more or less complete import of new
upstream releases (excluding patches which do not affect Debian) whilst
keeping the previous version number intact[1]. This was done out of
an abundance of caution (not knowing the risks of the upstream version
number changing in stable) but, after a few more years of relatively
pain free transitions in unstable, we think that the cost/risk of the
manual cherry-picking procedure, together with the lack of transparency
to users about which version they are running, outweighs the potential
benefits of keeping the upstream version unchanged.
Therefore, we propose to apply the 5.28.2 release to buster at the next
opportunity (is the next stable update scheduled?)
A tentative branch is at [2], and an abbreviated patch (excluding
churn caused by version numbers and developer documentation) and
separately, the upstream changelog, is attached.
One complicating factor would be the need to binnmu four packages
that are sensitive to the upstream version number as part of the
stable update, as we routinely do for updates in unstable. Beyond that,
we don't anticipate any major issues. We would do a complete test
rebuild of perl-related packages in advance to catch any other
issues (an learning point from the update in [1]).
Thanks for your consideration.
[1] <https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=822336>
[2] <https://salsa.debian.org/perl-team/interpreter/perl/-/tree/dom/buster-5.28.2>
=encoding utf8
=head1 NAME
perldelta - what is new for perl v5.28.2
=head1 DESCRIPTION
This document describes differences between the 5.28.1 release and the 5.28.2
release.
If you are upgrading from an earlier release such as 5.28.0, first read
L<perl5281delta>, which describes differences between 5.28.0 and 5.28.1.
=head1 Incompatible Changes
=head2 Any set of digits in the Common script are legal in a script run of
another script
There are several sets of digits in the Common script. C<[0-9]> is the most
familiar. But there are also C<[\x{FF10}-\x{FF19}]> (FULLWIDTH DIGIT ZERO -
FULLWIDTH DIGIT NINE), and several sets for use in mathematical notation, such
as the MATHEMATICAL DOUBLE-STRUCK DIGITs. Any of these sets should be able to
appear in script runs of, say, Greek. But the previous design overlooked all
but the ASCII digits C<[0-9]>, so the design was flawed. This has been fixed,
so is both a bug fix and an incompatibility.
All digits in a run still have to come from the same set of ten digits.
L<[perl #133547]|https://rt.perl.org/Ticket/Display.html?id=133547>
=head1 Modules and Pragmata
=head2 Updated Modules and Pragmata
=over 4
=item *
L<Module::CoreList> has been upgraded from version 5.20181129_28 to 5.20190419.
=item *
L<PerlIO::scalar> has been upgraded from version 0.29 to 0.30.
=item *
L<Storable> has been upgraded from version 3.08 to 3.08_01.
=back
=head1 Platform Support
=head2 Platform-Specific Notes
=over 4
=item Windows
The Windows Server 2003 SP1 Platform SDK build, with its early x64 compiler and
tools, was accidentally broken in Perl 5.27.9. This has now been fixed.
=item Mac OS X
Perl's build and testing process on Mac OS X for C<-Duseshrplib> builds is now
compatible with Mac OS X System Integrity Protection (SIP).
SIP prevents binaries in F</bin> (and a few other places) being passed the
C<DYLD_LIBRARY_PATH> environment variable. For our purposes this prevents
C<DYLD_LIBRARY_PATH> from being passed to the shell, which prevents that
variable being passed to the testing or build process, so running C<perl>
couldn't find F<libperl.dylib>.
To work around that, the initial build of the F<perl> executable expects to
find F<libperl.dylib> in the build directory, and the library path is then
adjusted during installation to point to the installed library.
L<[perl #126706]|https://rt.perl.org/Ticket/Display.html?id=126706>
=back
=head1 Selected Bug Fixes
=over 4
=item *
If an in-place edit is still in progress during global destruction and the
process exit code (as stored in C<$?>) is zero, perl will now treat the
in-place edit as successful, replacing the input file with any output produced.
This allows code like:
perl -i -ne 'print "Foo"; last'
to replace the input file, while code like:
perl -i -ne 'print "Foo"; die'
will not. Partly resolves [perl #133659].
L<[perl #133659]|https://rt.perl.org/Ticket/Display.html?id=133659>
=item *
A regression in Perl 5.28 caused the following code to fail
close(STDIN); open(CHILD, "|wc -l")'
because the child's stdin would be closed on exec. This has now been fixed.
=item *
C<pack "u", "invalid uuencoding"> now properly NUL terminates the zero-length
SV produced.
L<[perl #132655]|https://rt.perl.org/Ticket/Display.html?id=132655>
=item *
Failing to compile a format now aborts compilation. Like other errors in
sub-parses this could leave the parser in a strange state, possibly crashing
perl if compilation continued.
L<[perl #132158]|https://rt.perl.org/Ticket/Display.html?id=132158>
=item *
See L</Any set of digits in the Common script are legal in a script run of
another script>.
=back
=head1 Acknowledgements
Perl 5.28.2 represents approximately 4 months of development since Perl 5.28.1
and contains approximately 2,500 lines of changes across 75 files from 13
authors.
Excluding auto-generated files, documentation and release tools, there were
approximately 1,200 lines of changes to 29 .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.28.2:
Aaron Crane, Abigail, Andy Dougherty, David Mitchell, Karen Etheridge, Karl
Williamson, Leon Timmermans, Nicolas R., Sawyer X, Steve Hay, Tina Müller,
Tony Cook, Zak B. Elep.
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 F<AUTHORS> file in the Perl source distribution.
=head1 Reporting Bugs
If you find what you think is a bug, you might check the perl bug database
at L<https://rt.perl.org/> . There may also be information at
L<http://www.perl.org/> , the Perl Home Page.
If you believe you have an unreported bug, please run the L<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 C<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 see
L<perlsec/SECURITY VULNERABILITY CONTACT INFORMATION>
for details of how to report the issue.
=head1 Give Thanks
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 C<perlthanks> program:
perlthanks
This will send an email to the Perl 5 Porters list with your show of thanks.
=head1 SEE ALSO
The F<Changes> file for an explanation of how to view exhaustive details on
what changed.
The F<INSTALL> file for how to build Perl.
The F<README> file for general stuff.
The F<Artistic> and F<Copying> files for copyright information.
=cut
diff --git a/Configure b/Configure
index 437b8afc5..77b92b01a 100755
--- a/Configure
+++ b/Configure
@@ -10736,6 +10736,7 @@ hasproto='varname=$1; func=$2; shift; shift;
while $test $# -ge 2; do
case "$1" in
$define) echo "#include <$2>";;
+ literal) echo "$2" ;;
esac ;
shift 2;
done > try.c;
@@ -16173,12 +16174,46 @@ set mbtowc d_mbtowc
eval $inlibc
: see if memmem exists
-set memmem d_memmem
-eval $inlibc
+: We need both a prototype in string.h and the symbol in libc.
+echo " "
+d_memmem_proto=''
+xx1="#$d_gnulibc HAS_GNULIBC"
+xx2='#if defined(HAS_GNULIBC) && !defined(_GNU_SOURCE)'
+xx3='# define _GNU_SOURCE'
+xx4='#endif'
+set d_memmem_proto memmem literal "$xx1" literal "$xx2" literal "$xx3" literal "$xx4" define string.h
+eval $hasproto
+case "$d_memmem_proto" in
+ define) # see if memmem exists
+ set memmem d_memmem
+ eval $inlibc
+ ;;
+ *) val=$undef
+ set d_memmem
+ eval $setvar
+ ;;
+esac
: see if memrchr exists
-set memrchr d_memrchr
-eval $inlibc
+: We need both a prototype in string.h and the symbol in libc.
+echo " "
+d_memrchr_proto=''
+xx1="#$d_gnulibc HAS_GNULIBC"
+xx2='#if defined(HAS_GNULIBC) && !defined(_GNU_SOURCE)'
+xx3='# define _GNU_SOURCE'
+xx4='#endif'
+set d_memrchr_proto memrchr literal "$xx1" literal "$xx2" literal "$xx3" literal "$xx4" define string.h
+eval $hasproto
+case "$d_memrchr_proto" in
+ define) # see if memrchr exists
+ set memrchr d_memrchr
+ eval $inlibc
+ ;;
+ *) val=$undef
+ set d_memrchr
+ eval $setvar
+ ;;
+esac
: see if mkdir exists
set mkdir d_mkdir
@@ -18787,12 +18822,46 @@ set strftime d_strftime
eval $inlibc
: see if strlcat exists
-set strlcat d_strlcat
-eval $inlibc
+: We need both a prototype in string.h and the symbol in libc.
+echo " "
+d_strlcat_proto=''
+xx1="#$d_gnulibc HAS_GNULIBC"
+xx2='#if defined(HAS_GNULIBC) && !defined(_GNU_SOURCE)'
+xx3='# define _GNU_SOURCE'
+xx4='#endif'
+set d_strlcat_proto strlcat literal "$xx1" literal "$xx2" literal "$xx3" literal "$xx4" define string.h
+eval $hasproto
+case "$d_strlcat_proto" in
+ define) # see if strlcat exists
+ set strlcat d_strlcat
+ eval $inlibc
+ ;;
+ *) val=$undef
+ set d_strlcat
+ eval $setvar
+ ;;
+esac
: see if strlcpy exists
-set strlcpy d_strlcpy
-eval $inlibc
+: We need both a prototype in string.h and the symbol in libc.
+echo " "
+d_strlcpy_proto=''
+xx1="#$d_gnulibc HAS_GNULIBC"
+xx2='#if defined(HAS_GNULIBC) && !defined(_GNU_SOURCE)'
+xx3='# define _GNU_SOURCE'
+xx4='#endif'
+set d_strlcpy_proto strlcpy literal "$xx1" literal "$xx2" literal "$xx3" literal "$xx4" define string.h
+eval $hasproto
+case "$d_strlcpy_proto" in
+ define) # see if strlcpy exists
+ set strlcpy d_strlcpy
+ eval $inlibc
+ ;;
+ *) val=$undef
+ set d_strlcpy
+ eval $setvar
+ ;;
+esac
: see if strnlen exists
set strnlen d_strnlen
diff --git a/Makefile.SH b/Makefile.SH
index 084924dab..77a40b342 100755
--- a/Makefile.SH
+++ b/Makefile.SH
@@ -64,8 +64,16 @@ true)
-compatibility_version \
${api_revision}.${api_version}.${api_subversion} \
-current_version \
- ${revision}.${patchlevel}.${subversion} \
- -install_name \$(shrpdir)/\$@"
+ ${revision}.${patchlevel}.${subversion}"
+ case "$osvers" in
+ 1[5-9]*|[2-9]*)
+ shrpldflags="$shrpldflags -install_name `pwd`/\$@ -Xlinker -headerpad_max_install_names"
+ exeldflags="-Xlinker -headerpad_max_install_names"
+ ;;
+ *)
+ shrpldflags="$shrpldflags -install_name \$(shrpdir)/\$@"
+ ;;
+ esac
;;
cygwin*)
shrpldflags="$shrpldflags -Wl,--out-implib=libperl.dll.a -Wl,--image-base,0x52000000"
@@ -331,6 +339,14 @@ MANIFEST_SRT = MANIFEST.srt
!GROK!THIS!
+case "$useshrplib$osname" in
+truedarwin)
+ $spitshell >>$Makefile <<!GROK!THIS!
+PERL_EXE_LDFLAGS=$exeldflags
+!GROK!THIS!
+ ;;
+esac
+
case "$usecrosscompile$perl" in
define?*)
$spitshell >>$Makefile <<!GROK!THIS!
@@ -1042,6 +1058,20 @@ $(PERL_EXE): $& $(perlmain_dep) $(LIBPERL) $(static_ext) ext.libs $(PERLEXPORT)
$(SHRPENV) $(CC) -o perl $(CLDFLAGS) $(CCDLFLAGS) $(perlmain_objs) $(LLIBPERL) $(static_ext) `cat ext.libs` $(libs)
!NO!SUBS!
;;
+
+ darwin)
+ case "$useshrplib$osvers" in
+ true1[5-9]*|true[2-9]*) $spitshell >>$Makefile <<'!NO!SUBS!'
+ $(SHRPENV) $(CC) -o perl $(PERL_EXE_LDFLAGS) $(CLDFLAGS) $(CCDLFLAGS) $(perlmain_objs) $(static_ext) $(LLIBPERL) `cat ext.libs` $(libs)
+!NO!SUBS!
+ ;;
+ *) $spitshell >>$Makefile <<'!NO!SUBS!'
+ $(SHRPENV) $(CC) -o perl $(CLDFLAGS) $(CCDLFLAGS) $(perlmain_objs) $(static_ext) $(LLIBPERL) `cat ext.libs` $(libs)
+!NO!SUBS!
+ ;;
+ esac
+ ;;
+
*) $spitshell >>$Makefile <<'!NO!SUBS!'
$(SHRPENV) $(CC) -o perl $(CLDFLAGS) $(CCDLFLAGS) $(perlmain_objs) $(static_ext) $(LLIBPERL) `cat ext.libs` $(libs)
!NO!SUBS!
diff --git a/dist/Module-CoreList/Changes b/dist/Module-CoreList/Changes
index fd08103d6..dcfcd74a9 100644
--- a/dist/Module-CoreList/Changes
+++ b/dist/Module-CoreList/Changes
@@ -1,6 +1,27 @@
+5.20190419
+ - Updated for v5.28.2
+
+5.20190320
+ - Updated for v5.29.9
+
+5.20190220
+ - Updated for v5.29.8
+
+5.20190120
+ - Updated for v5.29.7
+
+5.20181218
+ - Updated for v5.29.6
+
5.20181129_28
- Updated for v5.28.1
+5.20181129_26
+ - Updated for v5.26.3
+
+5.20181120
+ - Updated for v5.29.5
+
5.20181020
- Updated for v5.29.4
diff --git a/dist/Module-CoreList/lib/Module/CoreList.pm b/dist/Module-CoreList/lib/Module/CoreList.pm
index a254a1c97..e98180b5c 100644
--- a/dist/Module-CoreList/lib/Module/CoreList.pm
+++ b/dist/Module-CoreList/lib/Module/CoreList.pm
@@ -4,7 +4,7 @@ use strict;
our ( %released, %version, %families, %upstream, %bug_tracker, %deprecated, %delta );
use version;
-our $VERSION = '5.20181129_28';
+our $VERSION = '5.20190419';
sub PKG_PATTERN () { q#\A[a-zA-Z_][0-9a-zA-Z_]*(?:(::|')[0-9a-zA-Z_]+)*\z# }
sub _looks_like_invocant ($) { local $@; !!eval { $_[0]->isa(__PACKAGE__) } }
@@ -339,7 +339,14 @@ sub changes_between {
5.029002 => '2018-08-20',
5.029003 => '2018-09-20',
5.029004 => '2018-10-20',
+ 5.029005 => '2018-11-20',
+ 5.026003 => '2018-11-29',
5.028001 => '2018-11-29',
+ 5.029006 => '2018-12-18',
+ 5.029007 => '2019-01-20',
+ 5.029008 => '2019-02-20',
+ 5.029009 => '2019-03-20',
+ 5.028002 => '2019-04-19',
);
for my $version ( sort { $a <=> $b } keys %released ) {
@@ -15814,6 +15821,48 @@ for my $version ( sort { $a <=> $b } keys %released ) {
'arybase' => 1,
}
},
+ 5.029005 => {
+ delta_from => 5.029004,
+ changed => {
+ 'B::Op_private' => '5.029005',
+ 'Config' => '5.029005',
+ 'Cwd' => '3.76',
+ 'Data::Dumper' => '2.173',
+ 'Errno' => '1.30',
+ 'File::Spec' => '3.76',
+ 'File::Spec::AmigaOS' => '3.76',
+ 'File::Spec::Cygwin' => '3.76',
+ 'File::Spec::Epoc' => '3.76',
+ 'File::Spec::Functions' => '3.76',
+ 'File::Spec::Mac' => '3.76',
+ 'File::Spec::OS2' => '3.76',
+ 'File::Spec::Unix' => '3.76',
+ 'File::Spec::VMS' => '3.76',
+ 'File::Spec::Win32' => '3.76',
+ 'GDBM_File' => '1.18',
+ 'Module::CoreList' => '5.20181120',
+ 'Module::CoreList::Utils'=> '5.20181120',
+ 'NDBM_File' => '1.15',
+ 'ODBM_File' => '1.16',
+ 'SDBM_File' => '1.15',
+ 're' => '0.37',
+ },
+ removed => {
+ }
+ },
+ 5.026003 => {
+ delta_from => 5.026002,
+ changed => {
+ 'Archive::Tar' => '2.24_01',
+ 'B::Op_private' => '5.026003',
+ 'Config' => '5.026003',
+ 'Module::CoreList' => '5.20181129_26',
+ 'Module::CoreList::TieHashDelta'=> '5.20181129_26',
+ 'Module::CoreList::Utils'=> '5.20181129_26',
+ },
+ removed => {
+ }
+ },
5.028001 => {
delta_from => 5.028,
changed => {
@@ -15825,6 +15874,363 @@ for my $version ( sort { $a <=> $b } keys %released ) {
removed => {
}
},
+ 5.029006 => {
+ delta_from => 5.029005,
+ changed => {
+ 'B::Op_private' => '5.029006',
+ 'Config' => '5.029006',
+ 'Config::Perl::V' => '0.32',
+ 'ExtUtils::ParseXS' => '3.40',
+ 'ExtUtils::ParseXS::Constants'=> '3.40',
+ 'ExtUtils::ParseXS::CountLines'=> '3.40',
+ 'ExtUtils::ParseXS::Eval'=> '3.40',
+ 'ExtUtils::ParseXS::Utilities'=> '3.40',
+ 'File::Find' => '1.35',
+ 'Module::CoreList' => '5.20181218',
+ 'Module::CoreList::Utils'=> '5.20181218',
+ 'POSIX' => '1.86',
+ 'Storable' => '3.14',
+ 'Test2' => '1.302141',
+ 'Test2::API' => '1.302141',
+ 'Test2::API::Breakage' => '1.302141',
+ 'Test2::API::Context' => '1.302141',
+ 'Test2::API::Instance' => '1.302141',
+ 'Test2::API::Stack' => '1.302141',
+ 'Test2::Event' => '1.302141',
+ 'Test2::Event::Bail' => '1.302141',
+ 'Test2::Event::Diag' => '1.302141',
+ 'Test2::Event::Encoding'=> '1.302141',
+ 'Test2::Event::Exception'=> '1.302141',
+ 'Test2::Event::Fail' => '1.302141',
+ 'Test2::Event::Generic' => '1.302141',
+ 'Test2::Event::Note' => '1.302141',
+ 'Test2::Event::Ok' => '1.302141',
+ 'Test2::Event::Pass' => '1.302141',
+ 'Test2::Event::Plan' => '1.302141',
+ 'Test2::Event::Skip' => '1.302141',
+ 'Test2::Event::Subtest' => '1.302141',
+ 'Test2::Event::TAP::Version'=> '1.302141',
+ 'Test2::Event::V2' => '1.302141',
+ 'Test2::Event::Waiting' => '1.302141',
+ 'Test2::EventFacet' => '1.302141',
+ 'Test2::EventFacet::About'=> '1.302141',
+ 'Test2::EventFacet::Amnesty'=> '1.302141',
+ 'Test2::EventFacet::Assert'=> '1.302141',
+ 'Test2::EventFacet::Control'=> '1.302141',
+ 'Test2::EventFacet::Error'=> '1.302141',
+ 'Test2::EventFacet::Hub'=> '1.302141',
+ 'Test2::EventFacet::Info'=> '1.302141',
+ 'Test2::EventFacet::Meta'=> '1.302141',
+ 'Test2::EventFacet::Parent'=> '1.302141',
+ 'Test2::EventFacet::Plan'=> '1.302141',
+ 'Test2::EventFacet::Render'=> '1.302141',
+ 'Test2::EventFacet::Trace'=> '1.302141',
+ 'Test2::Formatter' => '1.302141',
+ 'Test2::Formatter::TAP' => '1.302141',
+ 'Test2::Hub' => '1.302141',
+ 'Test2::Hub::Interceptor'=> '1.302141',
+ 'Test2::Hub::Interceptor::Terminator'=> '1.302141',
+ 'Test2::Hub::Subtest' => '1.302141',
+ 'Test2::IPC' => '1.302141',
+ 'Test2::IPC::Driver' => '1.302141',
+ 'Test2::IPC::Driver::Files'=> '1.302141',
+ 'Test2::Tools::Tiny' => '1.302141',
+ 'Test2::Util' => '1.302141',
+ 'Test2::Util::ExternalMeta'=> '1.302141',
+ 'Test2::Util::Facets2Legacy'=> '1.302141',
+ 'Test2::Util::HashBase' => '1.302141',
+ 'Test2::Util::Trace' => '1.302141',
+ 'Test::Builder' => '1.302141',
+ 'Test::Builder::Formatter'=> '1.302141',
+ 'Test::Builder::Module' => '1.302141',
+ 'Test::Builder::Tester' => '1.302141',
+ 'Test::Builder::Tester::Color'=> '1.302141',
+ 'Test::Builder::TodoDiag'=> '1.302141',
+ 'Test::More' => '1.302141',
+ 'Test::Simple' => '1.302141',
+ 'Test::Tester' => '1.302141',
+ 'Test::Tester::Capture' => '1.302141',
+ 'Test::Tester::CaptureRunner'=> '1.302141',
+ 'Test::Tester::Delegate'=> '1.302141',
+ 'Test::use::ok' => '1.302141',
+ 'ok' => '1.302141',
+ 'threads::shared' => '1.59',
+ },
+ removed => {
+ 'Storable::Limit' => 1,
+ }
+ },
+ 5.029007 => {
+ delta_from => 5.029006,
+ changed => {
+ 'App::Cpan' => '1.672',
+ 'B::Op_private' => '5.029007',
+ 'CPAN' => '2.22',
+ 'CPAN::Distribution' => '2.22',
+ 'CPAN::Plugin::Specfile'=> '0.02',
+ 'Compress::Raw::Bzip2' => '2.084',
+ 'Compress::Raw::Zlib' => '2.084',
+ 'Compress::Zlib' => '2.084',
+ 'Config' => '5.029007',
+ 'Cwd' => '3.77',
+ 'DB_File' => '1.843',
+ 'File::Find' => '1.36',
+ 'File::Spec' => '3.77',
+ 'File::Spec::AmigaOS' => '3.77',
+ 'File::Spec::Cygwin' => '3.77',
+ 'File::Spec::Epoc' => '3.77',
+ 'File::Spec::Functions' => '3.77',
+ 'File::Spec::Mac' => '3.77',
+ 'File::Spec::OS2' => '3.77',
+ 'File::Spec::Unix' => '3.77',
+ 'File::Spec::VMS' => '3.77',
+ 'File::Spec::Win32' => '3.77',
+ 'File::Temp' => '0.2309',
+ 'IO::Compress::Adapter::Bzip2'=> '2.084',
+ 'IO::Compress::Adapter::Deflate'=> '2.084',
+ 'IO::Compress::Adapter::Identity'=> '2.084',
+ 'IO::Compress::Base' => '2.084',
+ 'IO::Compress::Base::Common'=> '2.084',
+ 'IO::Compress::Bzip2' => '2.084',
+ 'IO::Compress::Deflate' => '2.084',
+ 'IO::Compress::Gzip' => '2.084',
+ 'IO::Compress::Gzip::Constants'=> '2.084',
+ 'IO::Compress::RawDeflate'=> '2.084',
+ 'IO::Compress::Zip' => '2.084',
+ 'IO::Compress::Zip::Constants'=> '2.084',
+ 'IO::Compress::Zlib::Constants'=> '2.084',
+ 'IO::Compress::Zlib::Extra'=> '2.084',
+ 'IO::Uncompress::Adapter::Bunzip2'=> '2.084',
+ 'IO::Uncompress::Adapter::Identity'=> '2.084',
+ 'IO::Uncompress::Adapter::Inflate'=> '2.084',
+ 'IO::Uncompress::AnyInflate'=> '2.084',
+ 'IO::Uncompress::AnyUncompress'=> '2.084',
+ 'IO::Uncompress::Base' => '2.084',
+ 'IO::Uncompress::Bunzip2'=> '2.084',
+ 'IO::Uncompress::Gunzip'=> '2.084',
+ 'IO::Uncompress::Inflate'=> '2.084',
+ 'IO::Uncompress::RawInflate'=> '2.084',
+ 'IO::Uncompress::Unzip' => '2.084',
+ 'Math::BigFloat' => '1.999816',
+ 'Math::BigInt' => '1.999816',
+ 'Math::BigInt::Calc' => '1.999816',
+ 'Math::BigInt::FastCalc'=> '0.5008',
+ 'Math::BigInt::Lib' => '1.999816',
+ 'Module::CoreList' => '5.20190120',
+ 'Module::CoreList::Utils'=> '5.20190120',
+ 'Test2' => '1.302160',
+ 'Test2::API' => '1.302160',
+ 'Test2::API::Breakage' => '1.302160',
+ 'Test2::API::Context' => '1.302160',
+ 'Test2::API::Instance' => '1.302160',
+ 'Test2::API::Stack' => '1.302160',
+ 'Test2::Event' => '1.302160',
+ 'Test2::Event::Bail' => '1.302160',
+ 'Test2::Event::Diag' => '1.302160',
+ 'Test2::Event::Encoding'=> '1.302160',
+ 'Test2::Event::Exception'=> '1.302160',
+ 'Test2::Event::Fail' => '1.302160',
+ 'Test2::Event::Generic' => '1.302160',
+ 'Test2::Event::Note' => '1.302160',
+ 'Test2::Event::Ok' => '1.302160',
+ 'Test2::Event::Pass' => '1.302160',
+ 'Test2::Event::Plan' => '1.302160',
+ 'Test2::Event::Skip' => '1.302160',
+ 'Test2::Event::Subtest' => '1.302160',
+ 'Test2::Event::TAP::Version'=> '1.302160',
+ 'Test2::Event::V2' => '1.302160',
+ 'Test2::Event::Waiting' => '1.302160',
+ 'Test2::EventFacet' => '1.302160',
+ 'Test2::EventFacet::About'=> '1.302160',
+ 'Test2::EventFacet::Amnesty'=> '1.302160',
+ 'Test2::EventFacet::Assert'=> '1.302160',
+ 'Test2::EventFacet::Control'=> '1.302160',
+ 'Test2::EventFacet::Error'=> '1.302160',
+ 'Test2::EventFacet::Hub'=> '1.302160',
+ 'Test2::EventFacet::Info'=> '1.302160',
+ 'Test2::EventFacet::Info::Table'=> undef,
+ 'Test2::EventFacet::Meta'=> '1.302160',
+ 'Test2::EventFacet::Parent'=> '1.302160',
+ 'Test2::EventFacet::Plan'=> '1.302160',
+ 'Test2::EventFacet::Render'=> '1.302160',
+ 'Test2::EventFacet::Trace'=> '1.302160',
+ 'Test2::Formatter' => '1.302160',
+ 'Test2::Formatter::TAP' => '1.302160',
+ 'Test2::Hub' => '1.302160',
+ 'Test2::Hub::Interceptor'=> '1.302160',
+ 'Test2::Hub::Interceptor::Terminator'=> '1.302160',
+ 'Test2::Hub::Subtest' => '1.302160',
+ 'Test2::IPC' => '1.302160',
+ 'Test2::IPC::Driver' => '1.302160',
+ 'Test2::IPC::Driver::Files'=> '1.302160',
+ 'Test2::Tools::Tiny' => '1.302160',
+ 'Test2::Util' => '1.302160',
+ 'Test2::Util::ExternalMeta'=> '1.302160',
+ 'Test2::Util::Facets2Legacy'=> '1.302160',
+ 'Test2::Util::HashBase' => '1.302160',
+ 'Test2::Util::Trace' => '1.302160',
+ 'Test::Builder' => '1.302160',
+ 'Test::Builder::Formatter'=> '1.302160',
+ 'Test::Builder::Module' => '1.302160',
+ 'Test::Builder::Tester' => '1.302160',
+ 'Test::Builder::Tester::Color'=> '1.302160',
+ 'Test::Builder::TodoDiag'=> '1.302160',
+ 'Test::More' => '1.302160',
+ 'Test::Simple' => '1.302160',
+ 'Test::Tester' => '1.302160',
+ 'Test::Tester::Capture' => '1.302160',
+ 'Test::Tester::CaptureRunner'=> '1.302160',
+ 'Test::Tester::Delegate'=> '1.302160',
+ 'Test::use::ok' => '1.302160',
+ 'Unicode::Collate' => '1.27',
+ 'Unicode::Collate::CJK::Big5'=> '1.27',
+ 'Unicode::Collate::CJK::GB2312'=> '1.27',
+ 'Unicode::Collate::CJK::JISX0208'=> '1.27',
+ 'Unicode::Collate::CJK::Korean'=> '1.27',
+ 'Unicode::Collate::CJK::Pinyin'=> '1.27',
+ 'Unicode::Collate::CJK::Stroke'=> '1.27',
+ 'Unicode::Collate::CJK::Zhuyin'=> '1.27',
+ 'Unicode::Collate::Locale'=> '1.27',
+ 'lib' => '0.65',
+ 'ok' => '1.302160',
+ },
+ removed => {
+ 'Math::BigInt::CalcEmu' => 1,
+ }
+ },
+ 5.029008 => {
+ delta_from => 5.029007,
+ changed => {
+ 'B' => '1.76',
+ 'B::Op_private' => '5.029008',
+ 'Config' => '5.029008',
+ 'Devel::PPPort' => '3.44',
+ 'Encode' => '3.00',
+ 'Encode::Unicode' => '2.18',
+ 'ExtUtils::Miniperl' => '1.09',
+ 'IO' => '1.40',
+ 'IO::Dir' => '1.40',
+ 'IO::File' => '1.40',
+ 'IO::Handle' => '1.40',
+ 'IO::Pipe' => '1.40',
+ 'IO::Poll' => '1.40',
+ 'IO::Seekable' => '1.40',
+ 'IO::Select' => '1.40',
+ 'IO::Socket' => '1.40',
+ 'IO::Socket::INET' => '1.40',
+ 'IO::Socket::UNIX' => '1.40',
+ 'JSON::PP' => '4.00',
+ 'JSON::PP::Boolean' => '4.00',
+ 'Module::CoreList' => '5.20190220',
+ 'Module::CoreList::Utils'=> '5.20190220',
+ 'Module::Load' => '0.34',
+ 'Net::Ping' => '2.71',
+ 'POSIX' => '1.87',
+ 'Test2' => '1.302162',
+ 'Test2::API' => '1.302162',
+ 'Test2::API::Breakage' => '1.302162',
+ 'Test2::API::Context' => '1.302162',
+ 'Test2::API::Instance' => '1.302162',
+ 'Test2::API::Stack' => '1.302162',
+ 'Test2::Event' => '1.302162',
+ 'Test2::Event::Bail' => '1.302162',
+ 'Test2::Event::Diag' => '1.302162',
+ 'Test2::Event::Encoding'=> '1.302162',
+ 'Test2::Event::Exception'=> '1.302162',
+ 'Test2::Event::Fail' => '1.302162',
+ 'Test2::Event::Generic' => '1.302162',
+ 'Test2::Event::Note' => '1.302162',
+ 'Test2::Event::Ok' => '1.302162',
+ 'Test2::Event::Pass' => '1.302162',
+ 'Test2::Event::Plan' => '1.302162',
+ 'Test2::Event::Skip' => '1.302162',
+ 'Test2::Event::Subtest' => '1.302162',
+ 'Test2::Event::TAP::Version'=> '1.302162',
+ 'Test2::Event::V2' => '1.302162',
+ 'Test2::Event::Waiting' => '1.302162',
+ 'Test2::EventFacet' => '1.302162',
+ 'Test2::EventFacet::About'=> '1.302162',
+ 'Test2::EventFacet::Amnesty'=> '1.302162',
+ 'Test2::EventFacet::Assert'=> '1.302162',
+ 'Test2::EventFacet::Control'=> '1.302162',
+ 'Test2::EventFacet::Error'=> '1.302162',
+ 'Test2::EventFacet::Hub'=> '1.302162',
+ 'Test2::EventFacet::Info'=> '1.302162',
+ 'Test2::EventFacet::Meta'=> '1.302162',
+ 'Test2::EventFacet::Parent'=> '1.302162',
+ 'Test2::EventFacet::Plan'=> '1.302162',
+ 'Test2::EventFacet::Render'=> '1.302162',
+ 'Test2::EventFacet::Trace'=> '1.302162',
+ 'Test2::Formatter' => '1.302162',
+ 'Test2::Formatter::TAP' => '1.302162',
+ 'Test2::Hub' => '1.302162',
+ 'Test2::Hub::Interceptor'=> '1.302162',
+ 'Test2::Hub::Interceptor::Terminator'=> '1.302162',
+ 'Test2::Hub::Subtest' => '1.302162',
+ 'Test2::IPC' => '1.302162',
+ 'Test2::IPC::Driver' => '1.302162',
+ 'Test2::IPC::Driver::Files'=> '1.302162',
+ 'Test2::Tools::Tiny' => '1.302162',
+ 'Test2::Util' => '1.302162',
+ 'Test2::Util::ExternalMeta'=> '1.302162',
+ 'Test2::Util::Facets2Legacy'=> '1.302162',
+ 'Test2::Util::HashBase' => '1.302162',
+ 'Test2::Util::Trace' => '1.302162',
+ 'Test::Builder' => '1.302162',
+ 'Test::Builder::Formatter'=> '1.302162',
+ 'Test::Builder::Module' => '1.302162',
+ 'Test::Builder::Tester' => '1.302162',
+ 'Test::Builder::Tester::Color'=> '1.302162',
+ 'Test::Builder::TodoDiag'=> '1.302162',
+ 'Test::More' => '1.302162',
+ 'Test::Simple' => '1.302162',
+ 'Test::Tester' => '1.302162',
+ 'Test::Tester::Capture' => '1.302162',
+ 'Test::Tester::CaptureRunner'=> '1.302162',
+ 'Test::Tester::Delegate'=> '1.302162',
+ 'Test::use::ok' => '1.302162',
+ 'XS::APItest' => '1.00',
+ 'deprecate' => '0.04',
+ 'ok' => '1.302162',
+ 'perlfaq' => '5.20190126',
+ },
+ removed => {
+ }
+ },
+ 5.029009 => {
+ delta_from => 5.029008,
+ changed => {
+ 'B::Op_private' => '5.029009',
+ 'Config' => '5.029009',
+ 'Devel::PPPort' => '3.45',
+ 'Encode' => '3.01',
+ 'ExtUtils::Manifest' => '1.72',
+ 'JSON::PP' => '4.02',
+ 'JSON::PP::Boolean' => '4.02',
+ 'Module::CoreList' => '5.20190320',
+ 'Module::CoreList::Utils'=> '5.20190320',
+ 'PerlIO::encoding' => '0.27',
+ 'Unicode' => '12.0.0',
+ 'threads::shared' => '1.60',
+ 'utf8' => '1.22',
+ 'warnings' => '1.44',
+ },
+ removed => {
+ }
+ },
+ 5.028002 => {
+ delta_from => 5.028001,
+ changed => {
+ 'B::Op_private' => '5.028002',
+ 'Config' => '5.028002',
+ 'Module::CoreList' => '5.20190419',
+ 'Module::CoreList::Utils'=> '5.20190419',
+ 'PerlIO::scalar' => '0.30',
+ 'Storable' => '3.08_01',
+ },
+ removed => {
+ }
+ },
);
sub is_core
@@ -16757,6 +17163,20 @@ sub is_core
arybase => '1',
}
},
+ 5.029005 => {
+ delta_from => 5.027002,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.026003 => {
+ delta_from => 5.026002,
+ changed => {
+ },
+ removed => {
+ }
+ },
5.028001 => {
delta_from => 5.028000,
changed => {
@@ -16764,6 +17184,41 @@ sub is_core
removed => {
}
},
+ 5.029006 => {
+ delta_from => 5.029005,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.029007 => {
+ delta_from => 5.029006,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.029008 => {
+ delta_from => 5.029007,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.029009 => {
+ delta_from => 5.029008,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.028002 => {
+ delta_from => 5.028001,
+ changed => {
+ },
+ removed => {
+ }
+ },
);
%deprecated = _undelta(\%deprecated);
@@ -17280,11 +17735,11 @@ sub is_core
'CPAN::Tarzip' => undef,
'CPAN::URL' => undef,
'CPAN::Version' => undef,
- 'Compress::Raw::Bzip2' => undef,
- 'Compress::Raw::Zlib' => undef,
- 'Compress::Zlib' => undef,
+ 'Compress::Raw::Bzip2' => 'https://github.com/pmqs/Compress-Raw-Bzip2/issues',
+ 'Compress::Raw::Zlib' => 'https://github.com/pmqs/Compress-Raw-Zlib/issues',
+ 'Compress::Zlib' => 'https://github.com/pmqs/IO-Compress/issues',
'Config::Perl::V' => undef,
- 'DB_File' => undef,
+ 'DB_File' => 'https://github.com/pmqs/DB_File/issues',
'Digest' => undef,
'Digest::MD5' => undef,
'Digest::SHA' => undef,
@@ -17355,46 +17810,46 @@ sub is_core
'ExtUtils::testlib' => 'http://rt.cpan.org/NoAuth/Bugs.html?Dist=ExtUtils-MakeMaker',
'Fatal' => 'http://rt.cpan.org/NoAuth/Bugs.html?Dist=autodie',
'File::Fetch' => undef,
- 'File::GlobMapper' => undef,
+ 'File::GlobMapper' => 'https://github.com/pmqs/IO-Compress/issues',
'File::Path' => undef,
'File::Temp' => 'https://rt.cpan.org/Public/Dist/Display.html?Name=File-Temp',
'Filter::Util::Call' => undef,
'Getopt::Long' => undef,
'HTTP::Tiny' => 'https://github.com/chansen/p5-http-tiny/issues',
- 'IO::Compress::Adapter::Bzip2'=> undef,
- 'IO::Compress::Adapter::Deflate'=> undef,
- 'IO::Compress::Adapter::Identity'=> undef,
- 'IO::Compress::Base' => undef,
- 'IO::Compress::Base::Common'=> undef,
- 'IO::Compress::Bzip2' => undef,
- 'IO::Compress::Deflate' => undef,
- 'IO::Compress::Gzip' => undef,
- 'IO::Compress::Gzip::Constants'=> undef,
- 'IO::Compress::RawDeflate'=> undef,
- 'IO::Compress::Zip' => undef,
- 'IO::Compress::Zip::Constants'=> undef,
- 'IO::Compress::Zlib::Constants'=> undef,
- 'IO::Compress::Zlib::Extra'=> undef,
+ 'IO::Compress::Adapter::Bzip2'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Adapter::Deflate'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Adapter::Identity'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Base' => 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Base::Common'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Bzip2' => 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Deflate' => 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Gzip' => 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Gzip::Constants'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::RawDeflate'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Zip' => 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Zip::Constants'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Zlib::Constants'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Compress::Zlib::Extra'=> 'https://github.com/pmqs/IO-Compress/issues',
'IO::Socket::IP' => undef,
- 'IO::Uncompress::Adapter::Bunzip2'=> undef,
- 'IO::Uncompress::Adapter::Identity'=> undef,
- 'IO::Uncompress::Adapter::Inflate'=> undef,
- 'IO::Uncompress::AnyInflate'=> undef,
- 'IO::Uncompress::AnyUncompress'=> undef,
- 'IO::Uncompress::Base' => undef,
- 'IO::Uncompress::Bunzip2'=> undef,
- 'IO::Uncompress::Gunzip'=> undef,
- 'IO::Uncompress::Inflate'=> undef,
- 'IO::Uncompress::RawInflate'=> undef,
- 'IO::Uncompress::Unzip' => undef,
+ 'IO::Uncompress::Adapter::Bunzip2'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Uncompress::Adapter::Identity'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Uncompress::Adapter::Inflate'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Uncompress::AnyInflate'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Uncompress::AnyUncompress'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Uncompress::Base' => 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Uncompress::Bunzip2'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Uncompress::Gunzip'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Uncompress::Inflate'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Uncompress::RawInflate'=> 'https://github.com/pmqs/IO-Compress/issues',
+ 'IO::Uncompress::Unzip' => 'https://github.com/pmqs/IO-Compress/issues',
'IO::Zlib' => undef,
'IPC::Cmd' => undef,
'IPC::Msg' => undef,
'IPC::Semaphore' => undef,
'IPC::SharedMem' => undef,
'IPC::SysV' => undef,
- 'JSON::PP' => undef,
- 'JSON::PP::Boolean' => undef,
+ 'JSON::PP' => 'https://github.com/makamaka/JSON-PP/issues',
+ 'JSON::PP::Boolean' => 'https://github.com/makamaka/JSON-PP/issues',
'List::Util' => 'https://rt.cpan.org/Public/Dist/Display.html?Name=Scalar-List-Utils',
'List::Util::XS' => 'https://rt.cpan.org/Public/Dist/Display.html?Name=Scalar-List-Utils',
'Locale::Codes' => undef,
diff --git a/dist/Module-CoreList/lib/Module/CoreList/Utils.pm b/dist/Module-CoreList/lib/Module/CoreList/Utils.pm
index d2d8a4e95..91f7ad31c 100644
--- a/dist/Module-CoreList/lib/Module/CoreList/Utils.pm
+++ b/dist/Module-CoreList/lib/Module/CoreList/Utils.pm
@@ -4,7 +4,7 @@ use strict;
use warnings;
use Module::CoreList;
-our $VERSION = '5.20181129_28';
+our $VERSION = '5.20190419';
our %utilities;
sub utilities {
@@ -1431,6 +1431,20 @@ my %delta = (
removed => {
}
},
+ 5.029005 => {
+ delta_from => 5.029004,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.026003 => {
+ delta_from => 5.026002,
+ changed => {
+ },
+ removed => {
+ }
+ },
5.028001 => {
delta_from => 5.028000,
changed => {
@@ -1438,6 +1452,41 @@ my %delta = (
removed => {
}
},
+ 5.029006 => {
+ delta_from => 5.029005,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.029007 => {
+ delta_from => 5.029006,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.029008 => {
+ delta_from => 5.029007,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.029009 => {
+ delta_from => 5.029008,
+ changed => {
+ },
+ removed => {
+ }
+ },
+ 5.028002 => {
+ delta_from => 5.028001,
+ changed => {
+ },
+ removed => {
+ }
+ },
);
%utilities = Module::CoreList::_undelta(\%delta);
diff --git a/dist/Storable/__Storable__.pm b/dist/Storable/__Storable__.pm
index e5a655ecd..8bb911718 100644
--- a/dist/Storable/__Storable__.pm
+++ b/dist/Storable/__Storable__.pm
@@ -27,7 +27,7 @@ our @EXPORT_OK = qw(
our ($canonical, $forgive_me);
-our $VERSION = '3.08';
+our $VERSION = '3.08_01';
our $recursion_limit;
our $recursion_limit_hash;
diff --git a/ext/PerlIO-scalar/scalar.pm b/ext/PerlIO-scalar/scalar.pm
index 61b62ea3a..6f4fa176b 100644
--- a/ext/PerlIO-scalar/scalar.pm
+++ b/ext/PerlIO-scalar/scalar.pm
@@ -1,5 +1,5 @@
package PerlIO::scalar;
-our $VERSION = '0.29';
+our $VERSION = '0.30';
require XSLoader;
XSLoader::load();
1;
diff --git a/ext/PerlIO-scalar/scalar.xs b/ext/PerlIO-scalar/scalar.xs
index 10a418589..e717736fa 100644
--- a/ext/PerlIO-scalar/scalar.xs
+++ b/ext/PerlIO-scalar/scalar.xs
@@ -185,11 +185,20 @@ PerlIOScalar_read(pTHX_ PerlIO *f, void *vbuf, Size_t count)
/* I assume that Off_t is at least as large as len (which
* seems safe) and that the size of the buffer in our SV is
* always less than half the size of the address space
+ *
+ * Which turns out not to be the case on 64-bit Windows, since
+ * a build with USE_LARGE_FILES=undef defines Off_t as long,
+ * which is 32-bits on 64-bit Windows. This doesn't appear to
+ * be the case on other 64-bit platforms.
*/
- STATIC_ASSERT_STMT(sizeof(Off_t) >= sizeof(len));
+#if Off_t_size >= Size_t_size
assert(len < ((~(STRLEN)0) >> 1));
if ((Off_t)len <= s->posn)
return 0;
+#else
+ if (len <= (STRLEN)s->posn)
+ return 0;
+#endif
got = len - (STRLEN)(s->posn);
if ((STRLEN)got > (STRLEN)count)
got = (STRLEN)count;
diff --git a/ext/XS-APItest/t/svcatpvf.t b/ext/XS-APItest/t/svcatpvf.t
index 15348891b..865020da3 100644
--- a/ext/XS-APItest/t/svcatpvf.t
+++ b/ext/XS-APItest/t/svcatpvf.t
@@ -16,6 +16,6 @@ for my $case (@cases) {
my ($what, $format) = @$case;
my $got = eval { test_sv_catpvf($format); 1 };
my $exn = $got ? undef : $@;
- like($exn, qr/\b\QCannot yet reorder sv_catpvfn() arguments from va_list\E\b/,
+ like($exn, qr/\b\QCannot yet reorder sv_vcatpvfn() arguments from va_list\E\b/,
"explicit $what index forbidden in va_list arguments");
}
diff --git a/hints/linux.sh b/hints/linux.sh
index 3f38ea07f..a985a8ee1 100644
--- a/hints/linux.sh
+++ b/hints/linux.sh
@@ -178,6 +178,16 @@ case "$plibpth" in
;;
esac
+# For the musl libc, perl should #define _GNU_SOURCE. Otherwise, some
+# available functions, like memem, won't be used. See the discussion in
+# [perl #133760]. musl doesn't offer an easy way to identify it, but,
+# at least on alpine linux, the ldd --version output contains the
+# string 'musl.'
+case `ldd --version 2>&1` in
+ musl*) ccflags="$ccflags -D_GNU_SOURCE" ;;
+ *) ;;
+esac
+
# libquadmath is sometimes installed as gcc internal library,
# so contrary to our usual policy of *not* looking at gcc internal
# directories we now *do* look at them, in case they contain
diff --git a/installperl b/installperl
index 3bf79d2d6..6cd65a092 100755
--- a/installperl
+++ b/installperl
@@ -304,6 +304,7 @@ elsif ($^O ne 'dos') {
safe_unlink("$installbin/$perl_verbase$ver$exe_ext");
copy("perl$exe_ext", "$installbin/$perl_verbase$ver$exe_ext");
strip("$installbin/$perl_verbase$ver$exe_ext");
+ fix_dep_names("$installbin/$perl_verbase$ver$exe_ext");
chmod(0755, "$installbin/$perl_verbase$ver$exe_ext");
}
else {
@@ -388,6 +389,7 @@ foreach my $file (@corefiles) {
if (copy_if_diff($file,"$installarchlib/CORE/$file")) {
if ($file =~ /\.(\Q$so\E|\Q$dlext\E)$/) {
strip("-S", "$installarchlib/CORE/$file") if $^O eq 'darwin';
+ fix_dep_names("$installarchlib/CORE/$file");
chmod($SO_MODE, "$installarchlib/CORE/$file");
} else {
chmod($NON_SO_MODE, "$installarchlib/CORE/$file");
@@ -791,4 +793,27 @@ sub strip
}
}
+sub fix_dep_names {
+ my $file = shift;
+
+ $^O eq "darwin" && $Config{osvers} =~ /^(1[5-9]|[2-9])/
+ && $Config{useshrplib}
+ or return;
+
+ my @opts;
+ my $so = $Config{so};
+ my $libperl = "$Config{archlibexp}/CORE/libperl.$Config{so}";
+ if ($file =~ /\blibperl.\Q$Config{so}\E$/a) {
+ push @opts, -id => $libperl;
+ }
+ else {
+ push @opts, -change => getcwd . "/libperl.$so", $libperl;
+ }
+ push @opts, $file;
+
+ $opts{verbose} and print " install_name_tool @opts\n";
+ system "install_name_tool", @opts
+ and die "Cannot update $file dependency paths\n";
+}
+
# ex: set ts=8 sts=4 sw=4 et:
diff --git a/lib/B/Op_private.pm b/lib/B/Op_private.pm
index 58953e1ee..39d97fa77 100644
--- a/lib/B/Op_private.pm
+++ b/lib/B/Op_private.pm
@@ -118,7 +118,7 @@ package B::Op_private;
our %bits;
-our $VERSION = "5.028001";
+our $VERSION = "5.028002";
$bits{$_}{3} = 'OPpENTERSUB_AMPER' for qw(entersub rv2cv);
$bits{$_}{6} = 'OPpENTERSUB_DB' for qw(entersub rv2cv);
diff --git a/numeric.c b/numeric.c
index 8754a9f64..7f30e93c9 100644
--- a/numeric.c
+++ b/numeric.c
@@ -565,9 +565,9 @@ Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send)
Helper for C<grok_number()>, accepts various ways of spelling "infinity"
or "not a number", and returns one of the following flag combinations:
- IS_NUMBER_INFINITE
+ IS_NUMBER_INFINITY
IS_NUMBER_NAN
- IS_NUMBER_INFINITE | IS_NUMBER_NEG
+ IS_NUMBER_INFINITY | IS_NUMBER_NEG
IS_NUMBER_NAN | IS_NUMBER_NEG
0
diff --git a/patchlevel.h b/patchlevel.h
index d126b0df1..6b4db75ab 100644
--- a/patchlevel.h
+++ b/patchlevel.h
@@ -15,7 +15,7 @@
#define PERL_REVISION 5 /* age */
#define PERL_VERSION 28 /* epoch */
-#define PERL_SUBVERSION 1 /* generation */
+#define PERL_SUBVERSION 2 /* generation */
/* The following numbers describe the earliest compatible version of
Perl ("compatibility" here being defined as sufficient binary/API
diff --git a/perl.c b/perl.c
index c7828e69c..f6f7be644 100644
--- a/perl.c
+++ b/perl.c
@@ -3,7 +3,7 @@
*
* Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
* 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
- * 2013, 2014, 2015, 2016, 2017, 2018 by Larry Wall and others
+ * 2013, 2014, 2015, 2016, 2017, 2018, 2019 by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
@@ -3760,7 +3760,7 @@ S_minus_v(pTHX)
#endif
PerlIO_printf(PIO_stdout,
- "\n\nCopyright 1987-2018, Larry Wall\n");
+ "\n\nCopyright 1987-2019, Larry Wall\n");
#ifdef MSDOS
PerlIO_printf(PIO_stdout,
"\nMS-DOS port Copyright (c) 1989, 1990, Diomidis Spinellis\n");
diff --git a/pod/perlre.pod b/pod/perlre.pod
index 70c53f153..c587437c7 100644
--- a/pod/perlre.pod
+++ b/pod/perlre.pod
@@ -2529,15 +2529,12 @@ characters from their native scripts and base Chinese. Perl follows
Unicode's UTS 39 (L<http://unicode.org/reports/tr39/>) Unicode Security
Mechanisms in allowing such mixtures.
-The rules used for matching decimal digits are somewhat different. Many
+The rules used for matching decimal digits are slightly stricter. Many
scripts have their own sets of digits equivalent to the Western C<0>
through C<9> ones. A few, such as Arabic, have more than one set. For
a string to be considered a script run, all digits in it must come from
-the same set, as determined by the first digit encountered. The ASCII
-C<[0-9]> are accepted as being in any script, even those that have their
-own set. This is because these are often used in commerce even in such
-scripts. But any mixing of the ASCII and other digits will cause the
-sequence to not be a script run, failing the match. As an example,
+the same set of ten, as determined by the first digit encountered.
+As an example,
qr/(*script_run: \d+ \b )/x
@@ -2558,11 +2555,11 @@ accent of some type. These are considered to be in the script of the
master character, and so never cause a script run to not match.
The other one is "Common". This consists of mostly punctuation, emoji,
-and characters used in mathematics and music, and the ASCII digits C<0>
-through C<9>. These characters can appear intermixed in text in many of
-the world's scripts. These also don't cause a script run to not match,
-except any ASCII digits encountered have to obey the decimal digit rules
-described above.
+and characters used in mathematics and music, the ASCII digits C<0>
+through C<9>, and full-width forms of these digits. These characters
+can appear intermixed in text in many of the world's scripts. These
+also don't cause a script run to not match. But like other scripts, all
+digits in a run must come from the same set of 10.
This construct is non-capturing. You can add parentheses to I<pattern>
to capture, if desired. You will have to do this if you plan to use
diff --git a/pp.c b/pp.c
index 33eac6040..def195085 100644
--- a/pp.c
+++ b/pp.c
@@ -1693,7 +1693,8 @@ PP(pp_repeat)
else {
dTOPss;
ASSUME(MARK + 1 == SP);
- XPUSHs(sv);
+ MEXTEND(SP, 1);
+ PUSHs(sv);
MARK[1] = &PL_sv_undef;
}
SP = MARK + 2;
diff --git a/pp_hot.c b/pp_hot.c
index f4e1ae726..cfd03d5a6 100644
--- a/pp_hot.c
+++ b/pp_hot.c
@@ -3932,7 +3932,7 @@ PP(pp_iter)
case CXt_LOOP_LIST: /* for (1,2,3) */
assert(OPpITER_REVERSED == 2); /* so inc becomes -1 or 1 */
- inc = 1 - (PL_op->op_private & OPpITER_REVERSED);
+ inc = (IV)1 - (IV)(PL_op->op_private & OPpITER_REVERSED);
ix = (cx->blk_loop.state_u.stack.ix += inc);
if (UNLIKELY(inc > 0
? ix > cx->blk_oldsp
@@ -3947,7 +3947,7 @@ PP(pp_iter)
case CXt_LOOP_ARY: /* for (@ary) */
av = cx->blk_loop.state_u.ary.ary;
- inc = 1 - (PL_op->op_private & OPpITER_REVERSED);
+ inc = (IV)1 - (IV)(PL_op->op_private & OPpITER_REVERSED);
ix = (cx->blk_loop.state_u.ary.ix += inc);
if (UNLIKELY(inc > 0
? ix > AvFILL(av)
diff --git a/pp_pack.c b/pp_pack.c
index 5e9cc6430..f8be9d48a 100644
--- a/pp_pack.c
+++ b/pp_pack.c
@@ -1727,7 +1727,10 @@ S_unpack_rec(pTHX_ tempsym_t* symptr, const char *s, const char *strbeg, const c
if (!checksum) {
const STRLEN l = (STRLEN) (strend - s) * 3 / 4;
sv = sv_2mortal(newSV(l));
- if (l) SvPOK_on(sv);
+ if (l) {
+ SvPOK_on(sv);
+ *SvEND(sv) = '\0';
+ }
}
/* Note that all legal uuencoded strings are ASCII printables, so
diff --git a/regexec.c b/regexec.c
index 7c83cbe4a..d0eac7253 100644
--- a/regexec.c
+++ b/regexec.c
@@ -10214,11 +10214,13 @@ Additionally all decimal digits must come from the same consecutive sequence of
For example, if all the characters in the sequence are Greek, or Common, or
Inherited, this function will return TRUE, provided any decimal digits in it
-are the ASCII digits "0".."9". For scripts (unlike Greek) that have their own
-digits defined this will accept either digits from that set or from 0..9, but
-not a combination of the two. Some scripts, such as Arabic, have more than one
-set of digits. All digits must come from the same set for this function to
-return TRUE.
+are from the same block of digits in Common. (These are the ASCII digits
+"0".."9" and additionally a block for full width forms of these, and several
+others used in mathematical notation.) For scripts (unlike Greek) that have
+their own digits defined this will accept either digits from that set or from
+one of the Common digit sets, but not a combination of the two. Some scripts,
+such as Arabic, have more than one set of digits. All digits must come from
+the same set for this function to return TRUE.
C<*ret_script>, if C<ret_script> is not NULL, will on return of TRUE
contain the script found, using the C<SCX_enum> typedef. Its value will be
@@ -10259,17 +10261,6 @@ Perl_isSCRIPT_RUN(pTHX_ const U8 * s, const U8 * send, const bool utf8_target)
* These are all defined in charclass_invlists.h */
/* XXX Here are the additional things UTS 39 says could be done:
- * Mark Chinese strings as “mixed script” if they contain both simplified
- * (S) and traditional (T) Chinese characters, using the Unihan data in the
- * Unicode Character Database [UCD]. The criterion can only be applied if
- * the language of the string is known to be Chinese. So, for example, the
- * string “写真だけの結婚式 ” is Japanese, and should not be marked as
- * mixed script because of a mixture of S and T characters. Testing for
- * whether a character is S or T needs to be based not on whether the
- * character has a S or T variant , but whether the character is an S or T
- * variant. khw notes that the sample contains a Hiragana character, and it
- * is unclear if absence of any foreign script marks the script as
- * "Chinese"
*
* Forbid sequences of the same nonspacing mark
*
@@ -10277,13 +10268,16 @@ Perl_isSCRIPT_RUN(pTHX_ const U8 * s, const U8 * send, const bool utf8_target)
* characters for at least one language in the Unicode Common Locale Data
* Repository [CLDR]. */
+ dVAR;
/* Things that match /\d/u */
SV * decimals_invlist = PL_XPosix_ptrs[_CC_DIGIT];
UV * decimals_array = invlist_array(decimals_invlist);
- /* What code point is the digit '0' of the script run? */
+ /* What code point is the digit '0' of the script run? (0 meaning FALSE if
+ * not currently known) */
UV zero_of_run = 0;
+
SCX_enum script_of_run = SCX_INVALID; /* Illegal value */
SCX_enum script_of_char = SCX_INVALID;
@@ -10293,8 +10287,6 @@ Perl_isSCRIPT_RUN(pTHX_ const U8 * s, const U8 * send, const bool utf8_target)
PERL_UINT_FAST8_T intersection_len = 0;
bool retval = TRUE;
-
- /* This is supposed to be a return parameter, but currently unused */
SCX_enum * ret_script = NULL;
assert(send >= s);
@@ -10302,7 +10294,8 @@ Perl_isSCRIPT_RUN(pTHX_ const U8 * s, const U8 * send, const bool utf8_target)
PERL_ARGS_ASSERT_ISSCRIPT_RUN;
/* All code points in 0..255 are either Common or Latin, so must be a
- * script run. We can special case it */
+ * script run. We can return immediately unless we need to know which
+ * script it is. */
if (! utf8_target && LIKELY(send > s)) {
if (ret_script == NULL) {
return TRUE;
@@ -10316,26 +10309,29 @@ Perl_isSCRIPT_RUN(pTHX_ const U8 * s, const U8 * send, const bool utf8_target)
}
}
- /* If all are Common ... */
+ /* Here, all are Common */
*ret_script = SCX_Common;
return TRUE;
}
/* Look at each character in the sequence */
while (s < send) {
+ /* If the current character being examined is a digit, this is the code
+ * point of the zero for its sequence of 10 */
+ UV zero_of_char;
+
UV cp;
/* The code allows all scripts to use the ASCII digits. This is
- * because they are used in commerce even in scripts that have their
- * own set. Hence any ASCII ones found are ok, unless a digit from
- * another set has already been encountered. (The other digit ranges
- * in Common are not similarly blessed) */
+ * because they are in the Common script. Hence any ASCII ones found
+ * are ok, unless and until a digit from another set has already been
+ * encountered. digit ranges in Common are not similarly blessed) */
if (UNLIKELY(isDIGIT(*s))) {
if (UNLIKELY(script_of_run == SCX_Unknown)) {
retval = FALSE;
break;
}
- if (zero_of_run > 0) {
+ if (zero_of_run) {
if (zero_of_run != '0') {
retval = FALSE;
break;
@@ -10361,7 +10357,7 @@ Perl_isSCRIPT_RUN(pTHX_ const U8 * s, const U8 * send, const bool utf8_target)
/* If is within the range [+0 .. +9] of the script's zero, it also is a
* digit in that script. We can skip the rest of this code for this
* character. */
- if (UNLIKELY( zero_of_run > 0
+ if (UNLIKELY( zero_of_run
&& cp >= zero_of_run
&& cp - zero_of_run <= 9))
{
@@ -10423,35 +10419,16 @@ Perl_isSCRIPT_RUN(pTHX_ const U8 * s, const U8 * send, const bool utf8_target)
/* If the run so far is Common, and the new character isn't, change the
* run's script to that of this character */
if (script_of_run == SCX_Common && script_of_char != SCX_Common) {
-
- /* But Common contains several sets of digits. Only the '0' set
- * can be part of another script. */
- if (zero_of_run > 0 && zero_of_run != '0') {
- retval = FALSE;
- break;
- }
-
script_of_run = script_of_char;
}
- /* All decimal digits must be from the same sequence of 10. Above, we
- * handled any ASCII digits without descending to here. We also
- * handled the case where we already knew what digit sequence is the
- * one to use, and the character is in that sequence. Now that we know
- * the script, we can use script_zeros[] to directly find which
- * sequence the script uses, except in a few cases it returns 0 */
- if (UNLIKELY(zero_of_run == 0) && script_of_char >= 0) {
- zero_of_run = script_zeros[script_of_char];
- }
-
- /* Now we can see if the script of the character is the same as that of
- * the run */
+ /* Now we can see if the script of the new character is the same as
+ * that of the run */
if (LIKELY(script_of_char == script_of_run)) {
/* By far the most common case */
goto scripts_match;
}
-
/* Here, the script of the run isn't Common. But characters in Common
* match any script */
if (script_of_char == SCX_Common) {
@@ -10601,54 +10578,53 @@ Perl_isSCRIPT_RUN(pTHX_ const U8 * s, const U8 * send, const bool utf8_target)
/* Here, the script of the character is compatible with that of the
* run. That means that in most cases, it continues the script run.
* Either it and the run match exactly, or one or both can be in any of
- * several scripts, and the intersection is not empty. But if the
- * character is a decimal digit, we need further handling. If we
- * haven't seen a digit before, it would establish what set of 10 all
- * must come from; and if we have established a set, we need to check
- * that this is in it.
- *
- * But there are cases we can rule out without having to look up if
- * this is a digit:
- * a. All instances of [0-9] have been dealt with earlier.
- * b. The next digit encoded by Unicode is 1600 code points further
- * on, so if the code point in this loop iteration is less than
- * that, it isn't a digit.
- * c. Most scripts that have digits have a single set of 10. If
- * we've encountered a digit in such a script, 'zero_of_run' is
- * set to the code point (call it z) whose numeric value is 0.
- * If the code point in this loop iteration is in the range
- * z..z+9, it is in the script's set of 10, and we've actually
- * handled it earlier in this function and won't reach this
- * point. But, code points in that script that aren't in that
- * range can't be digits, so we don't have to look any such up.
- * We can tell if this script is such a one by looking at
- * 'script_zeros[]' for it. It is non-zero iff it has a single
- * set of digits. This rule doesn't apply if we haven't narrowed
- * down the possible scripts to a single one yet. Nor if the
- * zero of the run is '0', as that also hasn't narrowed things
- * down completely */
- if ( cp >= FIRST_NON_ASCII_DECIMAL_DIGIT
- && ( intersection
- || script_of_char < 0 /* Also implies an intersection */
- || zero_of_run == '0'
- || script_zeros[script_of_char] == 0))
+ * several scripts, and the intersection is not empty. However, if the
+ * character is a decimal digit, it could still mean failure if it is
+ * from the wrong sequence of 10. So, we need to look at if it's a
+ * digit. We've already handled the 10 decimal digits, and the next
+ * lowest one is this one: */
+ if (cp < FIRST_NON_ASCII_DECIMAL_DIGIT) {
+ continue; /* Not a digit; this character is part of the run */
+ }
+
+ /* If we have a definitive '0' for the script of this character, we
+ * know that for this to be a digit, it must be in the range of +0..+9
+ * of that zero. */
+ if ( script_of_char >= 0
+ && (zero_of_char = script_zeros[script_of_char]))
{
- SSize_t range_zero_index;
- range_zero_index = _invlist_search(decimals_invlist, cp);
- if ( LIKELY(range_zero_index >= 0)
- && ELEMENT_RANGE_MATCHES_INVLIST(range_zero_index))
+ if ( cp < zero_of_char
+ || cp > zero_of_char + 9)
{
- UV range_zero = decimals_array[range_zero_index];
- if (zero_of_run) {
- if (zero_of_run != range_zero) {
- retval = FALSE;
- break;
- }
- }
- else {
- zero_of_run = range_zero;
- }
+ continue; /* Not a digit; this character is part of the run
+ */
+ }
+
+ }
+ else { /* Need to look up if this character is a digit or not */
+ SSize_t index_of_zero_of_char;
+ index_of_zero_of_char = _invlist_search(decimals_invlist, cp);
+ if ( UNLIKELY(index_of_zero_of_char < 0)
+ || ! ELEMENT_RANGE_MATCHES_INVLIST(index_of_zero_of_char))
+ {
+ continue; /* Not a digit; this character is part of the run.
+ */
}
+
+ zero_of_char = decimals_array[index_of_zero_of_char];
+ }
+
+ /* Here, the character is a decimal digit, and the zero of its sequence
+ * of 10 is in 'zero_of_char'. If we already have a zero for this run,
+ * they better be the same. */
+ if (zero_of_run) {
+ if (zero_of_run != zero_of_char) {
+ retval = FALSE;
+ break;
+ }
+ }
+ else { /* Otherwise we now have a zero for this run */
+ zero_of_run = zero_of_char;
}
} /* end of looping through CLOSESR text */
diff --git a/sv.c b/sv.c
index 07865bb2c..94cb2a74a 100644
--- a/sv.c
+++ b/sv.c
@@ -10810,8 +10810,8 @@ Perl_sv_catpvf_mg_nocontext(SV *const sv, const char *const pat, ...)
/*
=for apidoc sv_catpvf
-Processes its arguments like C<sv_catpvfn>, and appends the formatted
-output to an SV. As with C<sv_catpvfn> called with a non-null C-style
+Processes its arguments like C<sprintf>, and appends the formatted
+output to an SV. As with C<sv_vcatpvfn> called with a non-null C-style
variable argument list, argument reordering is not supported.
If the appended data contains "wide" characters
(including, but not limited to, SVs with a UTF-8 PV formatted with C<%s>,
@@ -10837,7 +10837,7 @@ Perl_sv_catpvf(pTHX_ SV *const sv, const char *const pat, ...)
/*
=for apidoc sv_vcatpvf
-Processes its arguments like C<sv_catpvfn> called with a non-null C-style
+Processes its arguments like C<sv_vcatpvfn> called with a non-null C-style
variable argument list, and appends the formatted output
to an SV. Does not handle 'set' magic. See C<L</sv_vcatpvf_mg>>.
@@ -11985,7 +11985,7 @@ Perl_sv_vcatpvfn_flags(pTHX_ SV *const sv, const char *const pat, const STRLEN p
if (*q == '$') {
if (args)
Perl_croak_nocontext(
- "Cannot yet reorder sv_catpvfn() arguments from va_list");
+ "Cannot yet reorder sv_vcatpvfn() arguments from va_list");
++q;
efix = (Size_t)width;
width = 0;
@@ -12053,7 +12053,7 @@ Perl_sv_vcatpvfn_flags(pTHX_ SV *const sv, const char *const pat, const STRLEN p
if (*q++ == '$') {
if (args)
Perl_croak_nocontext(
- "Cannot yet reorder sv_catpvfn() arguments from va_list");
+ "Cannot yet reorder sv_vcatpvfn() arguments from va_list");
no_redundant_warning = TRUE;
} else
goto unknown;
@@ -12138,7 +12138,7 @@ Perl_sv_vcatpvfn_flags(pTHX_ SV *const sv, const char *const pat, const STRLEN p
if (*q++ == '$') {
if (args)
Perl_croak_nocontext(
- "Cannot yet reorder sv_catpvfn() arguments from va_list");
+ "Cannot yet reorder sv_vcatpvfn() arguments from va_list");
no_redundant_warning = TRUE;
} else
goto unknown;
diff --git a/t/lib/croak/toke b/t/lib/croak/toke
index 1d45a3fdf..a3852900e 100644
--- a/t/lib/croak/toke
+++ b/t/lib/croak/toke
@@ -480,3 +480,12 @@ Bareword found where operator expected at - line 2, near "2p0"
(Missing operator before p0?)
syntax error at - line 2, near "2p0"
Execution of - aborted due to compilation errors.
+########
+# NAME [perl #132158] format with syntax errors
+format=
+@
+=h
+=cut
+EXPECT
+syntax error at - line 4, next token ???
+Execution of - aborted due to compilation errors.
diff --git a/t/op/for.t b/t/op/for.t
index a114180f0..f34fbd8b5 100644
--- a/t/op/for.t
+++ b/t/op/for.t
@@ -5,7 +5,7 @@ BEGIN {
require "./test.pl";
}
-plan(124);
+plan(126);
# A lot of tests to check that reversed for works.
@@ -664,3 +664,17 @@ is(fscope(), 1, 'return via loop in sub');
}
is($foo, "outside", "RT #123994 array outside");
}
+
+# RT #133558 'reverse' under AIX was causing loop to terminate
+# immediately, probably due to compiler bug
+
+{
+ my @a = qw(foo);
+ my @b;
+ push @b, $_ for (reverse @a);
+ is "@b", "foo", " RT #133558 reverse array";
+
+ @b = ();
+ push @b, $_ for (reverse 'bar');
+ is "@b", "bar", " RT #133558 reverse list";
+}
diff --git a/t/op/pack.t b/t/op/pack.t
index cf0e28650..bb9f86509 100644
--- a/t/op/pack.t
+++ b/t/op/pack.t
@@ -12,7 +12,7 @@ my $no_endianness = $] > 5.009 ? '' :
my $no_signedness = $] > 5.009 ? '' :
"Signed/unsigned pack modifiers not available on this perl";
-plan tests => 14717;
+plan tests => 14718;
use strict;
use warnings qw(FATAL all);
@@ -2081,3 +2081,10 @@ SKIP:
fresh_perl_like('pack "c10f1073741824"', qr/Out of memory during pack/, { stderr => 1 },
"integer overflow calculating allocation (multiply)");
}
+
+{
+ # [perl #132655] heap-buffer-overflow READ of size 11
+ # only expect failure under ASAN (and maybe valgrind)
+ fresh_perl_is('0.0 + unpack("u", "ab")', "", { stderr => 1 },
+ "ensure unpack u of invalid data nul terminates result");
+}
diff --git a/t/op/repeat.t b/t/op/repeat.t
index 978916689..fa7ce0690 100644
--- a/t/op/repeat.t
+++ b/t/op/repeat.t
@@ -6,7 +6,7 @@ BEGIN {
set_up_inc( '../lib' );
}
-plan(tests => 49);
+plan(tests => 50);
# compile time
@@ -192,3 +192,85 @@ fresh_perl_like(
eval q{() = (() or ((0) x 0)); 1};
is($@, "", "RT #130247");
+
+# yes, the newlines matter
+fresh_perl_is(<<'PERL', "", { stderr => 1 }, "(perl #133778) MARK mishandling");
+map{s[][];eval;0}<DATA>__END__
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+()x0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+0
+PERL
diff --git a/t/re/script_run.t b/t/re/script_run.t
index 10c71034c..4b098c512 100644
--- a/t/re/script_run.t
+++ b/t/re/script_run.t
@@ -51,8 +51,8 @@ foreach my $type ('script_run', 'sr', 'atomic_script_run', 'asr') {
unlike("\N{HEBREW LETTER ALEF}\N{HEBREW LETTER TAV}\N{MODIFIER LETTER SMALL Y}", $script_run, "Hebrew then Latin isn't a script run");
like("9876543210\N{DESERET SMALL LETTER WU}", $script_run, "0-9 are the digits for Deseret");
like("\N{DESERET SMALL LETTER WU}9876543210", $script_run, "Also when they aren't in the initial position");
- unlike("\N{DESERET SMALL LETTER WU}\N{FULLWIDTH DIGIT FIVE}", $script_run, "Fullwidth digits aren't the digits for Deseret");
- unlike("\N{FULLWIDTH DIGIT SIX}\N{DESERET SMALL LETTER LONG I}", $script_run, "... likewise if the digits come first");
+ like("\N{DESERET SMALL LETTER WU}\N{FULLWIDTH DIGIT FIVE}", $script_run, "Fullwidth digits may be digits for Deseret");
+ like("\N{FULLWIDTH DIGIT SIX}\N{DESERET SMALL LETTER LONG I}", $script_run, "... likewise if the digits come first");
like("1234567890\N{ARABIC LETTER ALEF}", $script_run, "[0-9] work for Arabic");
unlike("1234567890\N{ARABIC LETTER ALEF}\N{ARABIC-INDIC DIGIT FOUR}\N{ARABIC-INDIC DIGIT FIVE}", $script_run, "... but not in combination with real ARABIC digits");
@@ -97,4 +97,19 @@ foreach my $type ('script_run', 'sr', 'atomic_script_run', 'asr') {
like("abc", qr/(*asr:a[bc]*c)/, "Outer asr works on a run");
unlike("abc", qr/(*asr:a(*asr:[bc]*)c)/, "Nested asr works to exclude some things");
+ like("A\x{ff10}\x{ff19}B", qr/^(*sr:.{4})/,
+ "Non-ASCII Common digits work with Latin"); # perl #133547
+ like("A\x{ff10}BC", qr/^(*sr:.{4})/,
+ "Non-ASCII Common digits work with Latin"); # perl #133547
+ like("A\x{1d7ce}\x{1d7cf}B", qr/^(*sr:.{4})/,
+ "Non-ASCII Common digits work with Latin"); # perl #133547
+ like("A\x{1d7ce}BC", qr/^(*sr:.{4})/,
+ "Non-ASCII Common digits work with Latin"); # perl #133547
+ like("\x{1d7ce}\x{1d7cf}AB", qr/^(*sr:.{4})/,
+ "Non-ASCII Common digits work with Latin"); # perl #133547
+ like("α\x{1d7ce}βγ", qr/^(*sr:.{4})/,
+ "Non-ASCII Common digits work with Greek"); # perl #133547
+ like("\x{1d7ce}αβγ", qr/^(*sr:.{4})/,
+ "Non-ASCII Common digits work with Greek"); # perl #133547
+
done_testing();
diff --git a/t/re/subst.t b/t/re/subst.t
index dd62e95ee..d0fb04867 100644
--- a/t/re/subst.t
+++ b/t/re/subst.t
@@ -11,7 +11,7 @@ BEGIN {
require './loc_tools.pl';
}
-plan(tests => 276);
+plan(tests => 277);
$_ = 'david';
$a = s/david/rules/r;
@@ -1174,5 +1174,6 @@ __EOF__
is $lines, 4, "RT #131930";
}
-
-
+{
+ fresh_perl_is("s//00000000000format \0 '0000000\\x{800}/;eval", "", {}, "RT #133882");
+}
diff --git a/toke.c b/toke.c
index fc87252bb..622873dca 100644
--- a/toke.c
+++ b/toke.c
@@ -1829,14 +1829,14 @@ S_incline(pTHX_ const char *s, const char *end)
}
else if (GvAV(cfgv)) {
AV * const av = GvAV(cfgv);
- const I32 start = CopLINE(PL_curcop)+1;
- I32 items = AvFILLp(av) - start;
+ const line_t start = CopLINE(PL_curcop)+1;
+ SSize_t items = AvFILLp(av) - start;
if (items > 0) {
AV * const av2 = GvAVn(gv2);
SV **svp = AvARRAY(av) + start;
- I32 l = (I32)line_num+1;
- while (items--)
- av_store(av2, l++, SvREFCNT_inc(*svp++));
+ Size_t l = line_num+1;
+ while (items-- && l < SSize_t_MAX && l == (line_t)l)
+ av_store(av2, (SSize_t)l++, SvREFCNT_inc(*svp++));
}
}
}
@@ -2068,6 +2068,7 @@ S_newSV_maybe_utf8(pTHX_ const char *const start, STRLEN len)
SV * const sv = newSVpvn_utf8(start, len,
! IN_BYTES
&& UTF
+ && len != 0
&& is_utf8_non_invariant_string((const U8*)start, len));
return sv;
}
@@ -5099,6 +5100,14 @@ Perl_yylex(pTHX)
return yylex();
case LEX_FORMLINE:
+ if (PL_parser->sub_error_count != PL_error_count) {
+ /* There was an error parsing a formline, which tends to
+ mess up the parser.
+ Unlike interpolated sub-parsing, we can't treat any of
+ these as recoverable, so no need to check sub_no_recover.
+ */
+ yyquit();
+ }
assert(PL_lex_formbrack);
s = scan_formline(PL_bufptr);
if (!PL_lex_formbrack)
@@ -6518,6 +6527,7 @@ Perl_yylex(pTHX)
SAVEI32(PL_lex_formbrack);
PL_parser->form_lex_state = PL_lex_state;
PL_lex_formbrack = PL_lex_brackets + 1;
+ PL_parser->sub_error_count = PL_error_count;
goto leftbracket;
}
}
--- End Message ---