foreach (@FILE_ARRAY){
  next unless /^(?:([0-9_a-zA-Z*]+) +)?(?:([0-9_a-zA-Z*]+) +)?(?:([0-9
+_a-zA-Z*]+) +)?([0-9_a-zA-Z*]+)\((.+?)\)/;
  my ($args, @definition) = map { defined($_)?$_:'' } $5, $1, $2, $3, 
+$3;
  print join(" ", @definition) . " ARGS: $args\n";
}
[download]

sub foo {
  my $self = shift;
  my $p = {@_};
  my $name = $p->{name} or die;
  my $value = $p->{value} || 123;
}
[download]

Forgot to mention that for the Perl part I may not care about the arguments the same way... unless using this PPI is smart and I can get some interesting data from it which I can use with the ND. :)

But if there are portions of code that have been commented out by bracketing a region between "/*" and "*/", and the region happens to contain (strings resembling) function declarations, then adding your extra comment lines is likely to bolix things. (I haven't checked on this in a while, but I recall not being able to rely on whether embedded "/* ... */" comments would be handled correctly by every C compiler.)

To take this sort of task seriously, regex matching won't really do it -- you have to parse the text character by character, so that at any given point, you know what sort of content you're dealing with (quoted string, comment string, function body, "#define" directive, etc), and you know how to interpret each character as you get to it (e.g. whether it was preceded by "\").

Still, if I could assume that some C source code really has a well-behaved format, and "false-alarm" matches of function declarations won't happen, then a regex like this might do:

my $csrc;
{
    local $/;    # slurp the source code
    $csrc = <>;  # from stdin or $ARGV[0]
}
while ( $csrc =~ /\n((?:\w+\*?\s+)+) (\w+\s*) \( (.*?) \) \s* \{ /gsx 
+)
{
    my ( $functype, $funcname, $funcarg ) = ( $1, $2, $3 );
    my @funcargs = split /,\s*/, $funcarg;
    print "found function def:\n type=$functype\n name=$funcname\n arg
+s=\n   ";
    print join( "\n   ", @funcargs ), "\n";

    # do other stuff with these strings...
}
[download]

Slurping the file like that makes it easier to handle the multi-line function declarations, but then makes it just a little harder to insert the extra comment strings correctly (not impossible, certainly).

Maybe what you really want is to enhance whatever editor you normally use for writing C code, by adding a macro or function of some sort that will take a highlighted region, copy/paste it, and reformat the upper copy as a comment block. (I'm sure folks have done this numerous times with emacs/elisp.)

What you are doing is going to require manual editing anyway -- someone is supposed to type in explanations for the paramaters, etc, or else the whole exercise is pointless, right? -- so the right tool for this job is a macro in a text editor, not Perl (unless your editor lets you declare macros with embedded perl scripting).

Later Im gonna add for parsing Perl scripts aswell, but that is alot easier.

Heheh, yeah right... NOT (unless your perl source code holds to even more stringent style constraints that your C code). But good luck with that anyway.

For vim we made:

map <F8> 0f)%b"2yef)b"3yeO/* Function: <esc>"2po/<esc>O<esc>a Paramete
+rs: <esc>"3p<esc>
[download]

Not entirely perfect I think... :)

/ Ace

#!/usr/bin/perl 

# Script to add comments for Natural Doc. http://www.naturaldoc.org

use strict;
use warnings;

use Tie::File;

use Data::Dumper;

if (@ARGV < 1) {
    print "Usage: app file";
    exit(0);
}

my $file;
open $file, $ARGV[0] or die $!;
my $data = join("", <$file>);
close $file;

my $data_with_comment = "";
my @matches;

while ( $data =~ /\n((?:\w+\*?\*?\s+)+) (\*?\w+\s*) \s* \((.*?) \) (\s
+*\{)/gsx ) {
    push(@matches, { 'fullmatch' => $&, 'functype' => $1, 'funcname' =
+> $2, 'funcargs' => $3 });
}

foreach (@matches) {

    my $fullmatch = $_->{'fullmatch'};
    my $functype  = $_->{'functype'};
    my $funcname  = $_->{'funcname'};
    my $funcargs  = $_->{'funcargs'};

    my $comment = "";
    my @funcargs = split /,\s*/, $funcargs;

    my $args  =  join( ", ", @funcargs );
    my $args2 =  join( "\n *  ", @funcargs );
    $comment .= qq {
/* Function: $funcname($args)
 *
 * 
 *
 * Arguments:
 *  $args2
 *
 * Returns:
 *  $functype
 *
 */ };
    $data =~ s/\Q$fullmatch\E/$comment$fullmatch/;
}

print $data;
[download]

How can this be exteneded for parsing the CPP functions : static gboolean g::ber_read(wtap *wth, int *err, gchar **err_info, gint64 *data_offset)

Change the regex to accept the namespace prefix of the function name.

...roboticus

When your only tool is a hammer, all problems look like your thumb.

#!/usr/bin/perl 

# Script to add comments for Natural Doc. http://www.naturaldoc.org

use strict;
use warnings;

use Tie::File;

use Data::Dumper;


my $file;
open $file, "searchfs.c" or die $!;
my $data = join("", <$file>);
close $file;

my $data_with_comment = "";
my $rest = "";
while ( $data =~ /(.*?)\n((?:\w+\*?\*?\s+)+)(\*?\w+\s*)\s*\((.*?)\)(\s
+*\{)/gsx ) {

    $rest = $data;
    #print $rest;
    #sleep 4;
    my $code_before = $1;
    my $code_after = $5;
    $data_with_comment .= $code_before;

    my ( $functype, $funcname, $funcarg ) = ( $2, $3, $4 );
    my @funcargs = split /,\s*/, $funcarg;
    #print "found function def:\n type=$functype\n name=$funcname\n ar
+gs=";
    #print join( "\n   ", @funcargs ), "\n";

    my $args  =  join( ", ", @funcargs );
    my $args2 =  join( "\n *  ", @funcargs );
    #$data_with_comment .= "\n";
    $data_with_comment .= qq{
/* Function: $funcname($args)
 *
 * 
 *
 * Arguments:
 *  $args2
 *
 * Returns:
 *  $functype
 *
 */
};
    #print join( "\n   ", @funcargs ), "\n";

    $data_with_comment .= $2 . $3 . "(" . $4 . ")";

    $data_with_comment .= $code_after;
}

print $data_with_comment;
[download]