Why does this regular expression match?

Question

I have this regex:

(?<!Sub ).*\(.*\)

And I'd like it to match this:

MsgBox ("The total run time to fix AREA and TD fields is: " & =imeElapsed & " minutes.")

But not this:

Sub ChangeAreaTD()

But somehow I still match the one that starts with Sub... does anyone have any idea why? I thought I'd be excluding "Sub " by doing

(?<!Sub )

Any help is appreciated!

Thanks.

Answer 1

Do this:

^MsgBox .*\(.*\)

The problem is that a negative lookbehind does not guarantee the beginning of a string. It will match anywhere.

However, adding a ^ character at the beginning of the regex does guarantee the beginning of the string. Then, change Sub to MsgBox so it only matches strings that begin with MsgBox

Answer 2

You have a backtracking problem here. The first .* in (?<!Sub ).*\(.*\) can match ChangeAreaTD or hangeAreaTD. In the latter case, the previous 4 characters are ub C, which does not match Sub. As the lookbehind is negated, this counts as a match!

Just adding a ^ to the beginning of your regex will not help you, as look-behind is a zero-length matching phrase. ^(?<!MsgBox ) would be looking for a line that followed a line ending in MsgBox. What you need to do instead is ^(?!Sub )(.*\(.*\)). This can be interpreted as "Starting at the beginning of a string, make sure it does not start with Sub. Then, capture everything in the string if it looks like a method call".

A good explanation of how regex engines parse lookaround can be found here.

Answer 3

If your wanting to match just the functions call, not declaration, then the pre bracket match should not match any characters, but more likely any identifier characters followed by spaces. Thus

(?<!Sub )[a-zA-Z][a-zA-Z0-9_]* *\(.*\)

The identifier may need more tokens depending on the language your matching.

Answer 4

Your regex (?<!Sub ).*\(.*\), taken apart:

(?<!         # negative look-behind
  Sub        #   the string "Sub " must not occur before the current position
)            # end negative look-behind
.*           # anything       ~ matches up to the end of the string!
\(           # a literal "("  ~ causes the regex to backtrack to the last "("
  .*         # anything       ~ matches up to the end of the string again!
\)           # a literal ")"  ~ causes the regex to backtrack to the last ")"

So, with your test string:

Sub ChangeAreaTD()

• The look-behind is fulfilled immediately (right at position 0).
• The .* travels to the end of the string after that.
• Because of this .*, the look-behind never really makes a difference.

You were probably thinking of

(?<!Sub .*)\(.*\)

but it is very unlikely that variable-length look-behind is supported by your regex engine.

So what I would do is this (since variable-length look-ahead is widely supported):

^(?!.*\bSub\b)[^(]+\(([^)]+)\)

which translates as:

^           # At the start of the string,
(?!         # do a negative look-ahead:
  .*        #   anything
  \b        #   a word boundary
  Sub       #   the string "Sub"
  \b        #   another word bounday
)           # end negative look-ahead. If not found,
[^(]+       # match anything except an opening paren  ~ to prevent backtracking
\(          # match a literal "("
(           # match group 1
  [^)]+     #   match anything up to a closing paren  ~ to prevent backtracking
)           # end match group 1
\)          # match a literal ")".

and then go for the contents of match group 1.

However, regex generally is hideously ill-suited for parsing code. This is true for HTML the same way it is true for VB code. You will get wrong matches even with the improved regex. For example here, because of the nested parens:

MsgBox ("The total run time to fix all fields (AREA, TD)  is: ...")