How negative lookbehind works in below example?

Question

Why on applying regular expression(rx) on data(d) gives output(o) ?
Regular expression (rx):

s/(?<!\#include)[\s]*\<[\s]*([^\s\>]*)[\s]*\>/\<$1\>/g

Data (d):

#include  <a.h>  // 2 spaces after e

output (o):

#include <a.h>  // 1 space is still there

Expected output is:

#include<a.h>  // no space after include

tip: `[\s]` is pointless. `[]` is for grouping MULTIPLE characters into a single match point. `[\s]*` is functionally identical to `\s*`. — Marc B, Jul 31 '13 at 15:15

score 6 · Accepted Answer · edited May 23 '17 at 12:16

6

The condition (?<!\#include) is true as soon as you've passed the first of the two spaces, therefore the match starts there.

#include  <a.h>
         ^^^^^^- matched by your regex.

That means the space is not removed by your replace operation.

If you use a positive lookbehind assertion instead, you get the desired result:

s/(?<=#include)\s*<\s*([^\s>]*)\s*>/<$1>/g;

which can be rewritten to use the more efficient \K:

s/#include\K\s*<\s*([^\s>]*)\s*>/<$1>/g;

edited May 23 '17 at 12:16

Community

1
1

answered Jul 31 '13 at 15:16

Tim Pietzcker

313,408
56
485
544

1

Or no lookbehind at all, like `s/(#include)\s*]*)\s*>/$1/g` – Qtax Jul 31 '13 at 15:20
I wanted to know why first space after #include is not the part of regex match. – user1414235 Jul 31 '13 at 15:28
@user1414235 Yes, and Tim told you, so what's the problem? – sepp2k Jul 31 '13 at 15:31
1

@user1414235 Because you've used a *negative* lookbehind assertion, which prevented a match starting point at this position. – Tim Pietzcker Jul 31 '13 at 15:32

score 2 · Answer 2 · answered Jul 31 '13 at 15:17

2

?<!\#include)[\s] is a space that is not directly preceded by #include. The first space in #include <a.h> is directly preceded by #include, so it isn't matched. The second one isn't (it's preceded by the other space), so that's where the match starts.

answered Jul 31 '13 at 15:17

sepp2k

353,842
52
662
667

Casimir et Hippolyte · Answer 3 · 2013-07-31T17:01:57.467

As an aside comment, you can use this pattern which doesn't use the lookbehind:

s/(?:#include\K|\G)(?:\s+|(<|[^\s><]+))/$1/g

pattern details:

(?:              # open a non capturing group
    #include\K   # match "#include" and reset it from the match result
  |              # OR
    \G           # a contiguous match
)                # close the non capturing group
(?:          
    \s+          # white characters (spaces or tabs here) 
  |              # OR
    (            # capturing group
        <
      |
        [^\s><]+ # content inside brackets except spaces (and brackets)
    )
)

The search stop at the closing bracket since it is not describe in the pattern and since there is no more contiguous matches until the next #include.

How negative lookbehind works in below example?

3 Answers3