from: https://rt.cpan.org/Public/Bug/Display.html?id=127416 --- a/t/syntax_main.t- 2019-04-24 11:47:08.365496801 +0100 +++ b/t/syntax_main.t 2019-04-24 12:01:50.459442769 +0100 @@ -35,16 +35,34 @@ # This code checks whether the regexp iteration limit bug (#60034) is # present. The regexp match expression checks for getting the wrong -# result with a long input, and suffices to diagnose the bug. However, -# running that test on a pre-5.10 perl causes the stack to grow large, +# result with a long input, and suffices to diagnose the bug. +# for a pattern like /X*/, where X is sub-pattern that can match variable +# length string, e.g. (ab?), it is currently known that: +# +# on < 5.10.0, the old recursive engine will crash on too long a match; +# on < 5.29.4, /X*/ is misinterpreted as /X{0,32767}/ +# on 5.29.4+, /X*/ is misinterpreted as /X{0,65535}/ +# +# Running that test on a pre-5.10 perl causes the stack to grow large, # and if there's a limited stack size then this may overflow it and # cause perl to crash. All pre-5.10 perls have the iteration limit # bug, so there's no need to run the proper test on those verions. # 5.10 fixed the stack issue, so it's safe to run the proper test there. -my $have_iterlimit_bug = "$]" < 5.010 || do { - local $SIG{__WARN__} = sub { }; - ("a"x40000) !~ /\A(?:X?[a-z])*\z/; -}; + +my $iterlimit; # if defined, sets an upper limit for iterations + +if ($] < 5.010) { + $iterlimit = 0; +} +else { + local $SIG{__WARN__} = sub { }; + for my $i (32767, 65535) { + if (("a"x($i+1)) !~ /\A(?:X?[a-z])*\z/) { + $iterlimit = $i; + last; + } + } +} my $data_in = IO::File->new("t/read.data", "r") or die; my $line = $data_in->getline; @@ -75,7 +93,7 @@ } SKIP: { skip "perl bug affects long inputs", 2 - if $have_iterlimit_bug && length($input) >= 32766; + if defined $iterlimit && length($input) >= $iterlimit; is upgraded($input) =~ $recogniser{$prod}, !$syntax_error; is downgraded($input) =~ $recogniser{$prod}, !$syntax_error; }