How to read a file from /begin/ to /end/, if both may be on the same line

Question

I want to read the prototype of a C function through the source code of a big project.

I know the function name, and its return type, and that its prototype will be defined in a *.h file.

I'd use grep(1), but I want to be able to read multi-line prototypes, so it's discarded.

So what I usually do is:

• project: glibc
• return type: int
• function name: cacheflush

syscall='cacheflush';
find glibc/ -name '*.h' \
|xargs sed -n "/^[a-z ]*int ${syscall}[ ]*(/,/^$/p";

But that prints some unwanted lines after the ones I want:

$ find glibc/ -name '*.h' \
  |xargs sed -n "/^[a-z ]*int ${syscall}[ ]*(/,/^$/p";
extern int cacheflush (void *__addr, int __nbytes, int __op) __THROW;
#endif

extern int cacheflush (void *__addr, const int __nbytes,
               const int __op) __THROW;
#endif

extern int cacheflush (void *__addr, const int __nbytes, const int __op) __THROW;
#endif
extern int _flush_cache (char *__addr, const int __nbytes, const int __op) __THROW;

extern int cacheflush (void *__addr, const int __nbytes, const int __op) __THROW;
#endif
extern int _flush_cache (char *__addr, const int __nbytes, const int __op) __THROW;

I'd like to be able to replace the end pattern /^$/-> /;/, but then it'll only work when the function prototype spans across multiple lines. Is it possible to tell sed(1) that the end pattern might be on the same line as the begin pattern, so that the output would be the following?:

$ find glibc/ -name '*.h' | xargs sed magic;
extern int cacheflush (void *__addr, int __nbytes, int __op) __THROW;

extern int cacheflush (void *__addr, const int __nbytes,
               const int __op) __THROW;

extern int cacheflush (void *__addr, const int __nbytes, const int __op) __THROW;

extern int cacheflush (void *__addr, const int __nbytes, const int __op) __THROW;

Answer 1

You could use pcregrep's multi-line mode:

$ pcregrep --include='\.h$' -rM '(?s)^\s*(\w+\s+)*int cacheflush\s*\(.*?;' glibc
glibc/sysdeps/unix/sysv/linux/mips/sys/cachectl.h:extern int cacheflush (void *__addr, const int __nbytes, const int __op) __THROW;
glibc/sysdeps/unix/sysv/linux/csky/sys/cachectl.h:extern int cacheflush (void *__addr, const int __nbytes,
                       const int __op) __THROW;
glibc/sysdeps/unix/sysv/linux/nios2/sys/cachectl.h:extern int cacheflush (void *__addr, const int __nbytes, const int __op) __THROW;

And with PCRE, you get access to most of perl's advanced regexp operators. Here, we use:

• \w, and \s for word and whitespace characters.
• (?s): enables the s flag for . to also match on newline characters.
• *?: the non-greedy version of *. So it matches up to the first occurrence of ; and not the last like the greedy version would.

See the pcrepattern(3) man page for details.

Answer 2

There is no need to invoke sed twice, you just check before entering the range, whether the begin/end happen to be on the same line.

$ find glibc/ -name '*.h' \
|xargs sed \
    -e "/${pattern}.*;\$/b"  \
    -e "/${pattern}/,/;\$/p" \
    -e 'd' ;

Note that it will be good if you constrain the find utility to locate regular files only, otherwise you might see warnings when sed operates upon a directory whose name ends in a .h

Answer 3

I've come up with a (ugly) solution:

1. Read from /begin/ to /^$/ (blank line), repeating the first line of the pattern, so that sed(1) can act on it on a subsequent step.

2. Use sed(1) to find from /begin/ to /end/. Keep blank lines at this step to be able to use uniq(1) to correctly remove on the next step the lines we repeated on step 1.

3. Use uniq(1) to remove the repeated lines.

$ syscall=cacheflush;
$ return=int;
$ pattern="^[a-z ]*${return} ${syscall}[ ]*(";
$ find glibc/ -name '*.h' \
  |xargs sed -n -e "/${pattern}/p" -e "/${pattern}/,/^$/p" \
  |sed -n -e "/${pattern}/,/;/p" -e '/^$/p' \
  |uniq;
extern int cacheflush (void *__addr, int __nbytes, int __op) __THROW;

extern int cacheflush (void *__addr, const int __nbytes,
               const int __op) __THROW;

extern int cacheflush (void *__addr, const int __nbytes, const int __op) __THROW;

extern int cacheflush (void *__addr, const int __nbytes, const int __op) __THROW;

Please, come with a simpler solution :)