Search a string excluding the lines starting with another string

Question

In a fortran code for example, there are lines like

c   write(6,*) "some text"

    write(6,*) "some other text"

How would I search for lines having a write but exclude all lines starting with c or C.

Answer 1

You can use the regular expression:

^\([^cC].*\)\?write

Or, using "very magic" to simplify a little:

\v^([^cC].*)?write

1. \v: turns on "very magic" so we don't have to use as many escape characters,
2. ^: matches a start of the line,
3. ([^cC].*)?: matches either nothing, or any character that is not a c/C followed by zero or more characters:
   • [^cC]: matches any character that is not a c/C — this is the part that ignores lines that start with c/C,
   • .*: matches a string of any characters of any length (including zero-length) — this part matches the rest of the line preceding the "write",
   • (...)? : makes the entire expression inside the parentheses optional — this part means that lines that start with "write" will still be matched,
4. write: matches "write"!

UPDATE: As @KarlYngveLervåg points out in the comments, the instances of write that you want to search for will be (almost) always be the first thing on the line, so you could probably get away with using a much simpler regular expression:

^\s*write

1. ^: matches the start of the line,
2. \s*: if any whitespace follows, this matches it,
3. write: matches "write".

UPDATE 2: If you're actually carrying out a :substitute operation, you can use another method, which is to use :vglobal to only perform the :substitute command on lines which don't match a pattern:

:v/^c/s/write/changed

1. :v/^c/ On all lines that don't match the regular expression ^c i.e. all lines that don't begin with a "c",
2. s/write/changed Replace "write" with "changed".

The same technique also works with :global, to perform replacements only on lines that do match a regular expression.

Answer 2

If you're going to use this pattern for substitution, you could also use zero-width lookarounds, in particular \@<!:

                                                        /\@<!
\@<!    Matches with zero width if the preceding atom does NOT match just
        before what follows.  Thus this matches if there is no position in the
        current or previous line where the atom matches such that it ends just
        before what follows.  /zero-width {not in Vi}
        Like "(?<!pattern)" in Perl, but Vim allows non-fixed-width patterns.
        The match with the preceding atom is made to end just before the match
        with what follows, thus an atom that ends in ".*" will work.
        Warning: This can be slow (because many positions need to be checked
        for a match).  Use a limit if you can, see below.
        Example                 matches 
        \(foo\)\@<!bar          any "bar" that's not in "foobar"
        \(\/\/.*\)\@<!in        "in" which is not after "//"

For example:

\(^[cC].*\)\@<!write