This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
simpify and speed up /.*.../ handling
authorDavid Mitchell <davem@iabyn.com>
Tue, 10 Feb 2015 12:17:51 +0000 (12:17 +0000)
committerDavid Mitchell <davem@iabyn.com>
Tue, 10 Feb 2015 12:37:10 +0000 (12:37 +0000)
commit0fa70a06a98fc8fa9840d4dbaa31fc2d3b28b99b
tree26a06d1b96e1d6e7bfc5a2df9ddf663a5672f4da
parent5904c5c0c031fad19e61f5d279d624a91a196e02
simpify and speed up /.*.../ handling

See RT ##123743.

A pattern that starts /.*/ has a fake MBOL or SBOL flag added, along
with PREGf_IMPLICIT.

The idea is that, with /.*.../s, if the NFA don't match when started at
pos 0, then it's not going to match if started at any other position
either; while /.*.../ won't match at any other start position up until
the next \n.

However, the branch in regexec() that implemented this was a bit a mess
(like much in the perl core, it had gradually accreted), and caused
intuit-enabled /.*.../ and /.*...patterns to go quadratic.

The branch looked roughly like:

    if (anchored) {
        if (regtry(s)) goto success;
        if (can_intuit) {
            while (s < end) {
                s = intuit(s+1);
                if (!s) goto fail;
                if (regtry(s)) goto success;
            }
        }
        else {
            while (s < end) {
                s = skip_to_next_newline(s);
                if (regtry(s)) goto success;
            }
        }
    }

The problem is that in the presence of a .* at the start of the pattern,
intuit() will always return either NULL on failure, or the start position,
rather than any later position. So the can_intuit branch above calls
regtry() on every character position.

This commit fixes this by changing the structure of the code to be like
this, where it only tries things on newline boundaries:

    if (anchored) {
        if (regtry(s)) goto success;
        while (1) {
            s = skip_to_next_newline(s);
            if (can_intuit) {
                s = intuit(s+1);
                if (!s) goto fail;
            }
            if (regtry(s)) goto success;
        }
    }

This makes the code a lot simpler, and mostly avoids quadratic behaviour
(you can still get it with a string consisting mainly of newlines).
regexec.c
t/re/speed.t