The best advice anyone can give you is to use a parser, not regular expressions. While it's probably possible to build a state machine with Perl 5 regular expressions which handles all of the possible tokens and states and state transitions appropriately, no one I know capable of writing such a thing has actually done it.

You might be able to get by with regular expressions and Text::Balanced -- we use that in Parrot to build PMCs out of our PMC mini-language which includes C code -- but for anything more complex, you'll have a much easier time using a parser.

Just about anything is possible with regexes if you go far enough but take one look at the back pages of Jeffrey Friedl's "Mastering Regular Expressions" to see the horrifying 2 page regex that results from parsing plain old email addresses correctly.

You might be able to do what you want the way you're trying but I would suggest instead giving Parse::RecDescent a shot. Bit of a learning curve but the resulting code will be much easier to read, tweak, and reuse.

(update: switched ISBN to 2nd ed.)

Bundled with Parse::RecDescent is csourceparser.pl.

You may find it enlightening.

It took me a while before I realized that csourceparser.pl was actually stored in demo/demo_another_Cgrammar.pl of Parse::RecDescent.

Another option is to fully parse the C code. There's a good start at this described here: Converting C to English with Perl

Update: Here's another grammar which might help: Parsing C

This isn't particularly hard if you pick the right approach. I think the easiest way it to tokenize the language you are parsing and then build a simple state machine to parse just enough of the tokens to get the information you want.

Since type declarations can contain parens (though usually don't) I settled on considering ") {" as the start of a function body. I think that can't happen elsewhere in valid C code. I didn't check my POD syntax and the code is very imcomplete, intentionally.

=for state_machine

START
  \n  -> {flush} START
  ws  -> START
 else -> DECL

DECL
   ;  -> {flush} START
   )  -> CLOSE

CLOSE
  {   -> {block=1} FUNC
 else -> DECL

FUNC
  {   -> {++block} FUNC
  }   -> { --block ? FUNC : END }

END
  ws  -> END
  \n  -> {save} START
 else -> {save} DECL

=end

    use enum qw( START DECL CLOSE FUNC END );

    my $state= START();
    my $part= '';
    while(  $code =~ m{
        \G(
          \n            # newline
        | [^\S\n]+      # horizontal whitespace
        | [a-z]\w*      # identifier
        | \d+           # digit string
        | "(?:[^\\"]+|\\[^\n])*"
        | '(?:[^\\']+|\\[^\n])*'
        | /\*.*?\*/     # C comment
        | //[^\n]*\n    # C++ comment
        | [^\w\s]       # punctuation mark
        )
      }xsg
    ) {
        my $token= $1;
        if(  START() == $state  ) {
            if(  $token eq "\n"  ) {
                $token= $part= '';
            } elsif(  $token =~ /\S/  ) {
                $state= DECL();
            }
        ...
        } elsif(  END() == $state  ) {
            if(  $token =~ /\S/  ) {
                push @func, $part;
                $part= '';
                ...
            }
        }
        $part .= $token;
    }
[download]

And it is pretty easy to extend the state machine to track nesting of parens so you can extract the identifier before the last outer open paren before the body of the function is detected, for example (which would be the name of the function).