What's the technical reason for "lookbehind assertion MUST be fixed length" in regex?

Question

For example,the regex below will cause failure reporting lookbehind assertion is not fixed length:

#(?<!(?:(?:src)|(?:href))=["\']?)((?:https?|ftp)://[^\s\'"<>()]+)#S

Such kind of restriction doesn't exist for lookahead.

Solution 1

Lookahead and lookbehind aren't nearly as similar as their names imply. The lookahead expression works exactly the same as it would if it were a standalone regex, except it's anchored at the current match position and it doesn't consume what it matches.

Lookbehind is a whole different story. Starting at the current match position, it steps backward through the text one character at a time, attempting to match its expression at each position. In cases where no match is possible, the lookbehind has to go all the way to the beginning of the text (one character at a time, remember) before it gives up. Compare that to the lookahead expression, which gets applied exactly once.

This is a gross oversimplification, of course, and not all flavors work that way, but you get the idea. The way lookbehinds are applied is fundamentally different from (and much, much less efficient than) the way lookaheads are applied. It only makes sense to put a limit on how far back the lookbehind has to look.

Solution 2

First of all, this isn't true for all regular expression libraries (like .NET).

For PCRE, the reason appears to be:

The implementation of lookbehind assertions is, for each alternative, to temporarily move the current position back by the fixed width and then try to match.

(at least, according to http://www.autoitscript.com/autoit3/pcrepattern.html).

Solution 3

PCRE doesn't support floating lookbehind because it can cause major performance problems. This is because of the lack of right-to-left matching capability: PCRE can start a branch only from a fixed left, but left of a variable-length lookbehind can not be fixed.

Generally, try to branch your lookbehind part to fixed length patterns if possible. For example instead of:

(?<=(src|href)=")etc.

(1) use this:

(?:(?<=src=")|(?<=href="))etc.

(2) Or with \K:

(src|href)="\Ketc.

Note that \K is not a real lookbehind, because it always starts search at the end of previous match (no potential backstep into the previous match).

(3) In some complex lookbehind-only cases you can search with an "inverted" lookahead expression in a reversed string. Not too elegant but it works:

.cte(?="=(ferh|crs))

Solution 4

I had the same issue and fixed it by using (?: subexpression)

Defines a noncapturing group. such as Write(?:Line)? "WriteLine" in "Console.WriteLine()" "Write" in "Console.Write(value)"

I had to change the Regex below which is suppose to catch before , or something in the start of string which was giving me lookbehind assertion is not fixed length.

(?<=,|^)

with this,

(?:(?<=,)|^)

View more solutions

Comments

[wamp]

Why not use the same algorithm for lookahead and lookbehind? Isn't the prototype the same?

[Rich]

wamp, then you'd have to reverse the regex in the lookbehind and step backwards. Regular expressions usually only work forwards and reversing a particular expression is likely nontrivial.

[Lysol]

So why can't you just look for the look-behind first, and then find the rest of the pattern?

[Alan Moore]

@AidanMueller: Some flavors (including PCRE) support the \K construct, which does just that: foo\Kbar has to match foo first, but pretends the match really started at bar. But that only works for positive lookbehinds.

[Lysol]

@AlanMoore That makes sense. Now one thing I'm not sure on. Does look-behind look for what is immediately preceding? Or does it just mean "somewhere before the pattern"?

[Alan Moore]

@AidanMueller: Immediately preceding. To put it another way, whatever is matched by the lookbehind has to end exactly where the next part of the regex starts matching.

[Lysol]

@AlanMoore I still don't understand why it has to be fixed-length though? Why can't positive look-behinds simply be marked as not part of the actual match?

[Alan Moore]

@AidanMueller: Well, greediness is one problem. Consider the Java regex (?<=f\w{0,4})\w*r applied to the string foobar. If it worked as you described, the result would be just r, but it matches oobar. In PCRE you can use (?<=fooba|foob|foo|fo|f)\w*r and the result will still be oobar, proving that lookbehind behavior trumps ordered alternation as well as greediness. Even in .NET, which places no restrictions at all on lookbehinds, (?<=f\w*)\w*r matches oobar.

[Dávid Horváth]

They were able to implement a fix size checker (try #(?<=fw(*SKIP)(*FAIL)|f)oo#) while right-to-left capability is sorely lacking.

[roelofs]

Thank you for your answer! Can you please provide some context or additional information, instead of just the commands? That will make the answer more useful for other people looking for information.

[M.kazem Akhgary]

so technically its possible to have variable length lookbehind expression, its only not allowed because it may cause performance problems?

[jlh]

I think that technically it would be feasible to reverse many variable-width expressions. It doesn't work for all of them, but it works for a great deal of useful expression, so that it would be a partial solution to the problem.

[user202729]

The "fundamentally different" part looks wrong. It should usually be possible to "reverse" the regex and match it against the reversed string, just that the implementation of pcre in particular doesn't do it.

[Alan Moore]

@user202729 Yes, the question was in the context of PCRE. Other flavors have slightly different restrictions, while .NET treats lookahead and lookbehind exactly the same.