File indexing completed on 2024-04-21 03:48:33

 #!/usr/bin/perl
 
 # Transform K&R C function definitions into ANSI equivalent.
 #
 # Author: Paul Marquess
 # Version: 1.0
 # Date: 3 October 2006
 
 # TODO
 #
 # Asumes no function pointer parameters. unless they are typedefed.
 # Assumes no literal strings that look like function definitions
 # Assumes functions start at the beginning of a line
 
 use strict;
 use warnings;
 
 local $/;
 $_ = <>;
 
 my $sp = qr{ \s* (?: /\* .*? \*/ )? \s* }x; # assume no nested comments
 
 my $d1    = qr{ $sp (?: [\w\*\s]+ $sp)* $sp \w+ $sp [\[\]\s]* $sp }x ;
 my $decl  = qr{ $sp (?: \w+ $sp )+ $d1 }xo ;
 my $dList = qr{ $sp $decl (?: $sp , $d1 )* $sp ; $sp }xo ;
 
 
 while (s/^
             (                  # Start $1
                 (              #   Start $2
                     .*?        #     Minimal eat content
                     ( ^ \w [\w\s\*]+ )    #     $3 -- function name
                     \s*        #     optional whitespace
                 )              # $2 - Matched up to before parameter list
 
                 \( \s*         # Literal "(" + optional whitespace
                 ( [^\)]+ )     # $4 - one or more anythings except ")"
                 \s* \)         # optional whitespace surrounding a Literal ")"
 
                 ( (?: $dList )+ ) # $5
 
                 $sp ^ {        # literal "{" at start of line
             )                  # Remember to $1
         //xsom
       )
 {
     my $all = $1 ;
     my $prefix = $2;
     my $param_list = $4 ;
     my $params = $5;
 
     StripComments($params);
     StripComments($param_list);
     $param_list =~ s/^\s+//;
     $param_list =~ s/\s+$//;
 
     my $i = 0 ;
     my %pList = map { $_ => $i++ }
                 split /\s*,\s*/, $param_list;
     my $pMatch = '(\b' . join('|', keys %pList) . '\b)\W*$' ;
 
     my @params = split /\s*;\s*/, $params;
     my @outParams = ();
     foreach my $p (@params)
     {
         if ($p =~ /,/)
         {
             my @bits = split /\s*,\s*/, $p;
             my $first = shift @bits;
             $first =~ s/^\s*//;
             push @outParams, $first;
             $first =~ /^(\w+\s*)/;
             my $type = $1 ;
             push @outParams, map { $type . $_ } @bits;
         }
         else
         {
             $p =~ s/^\s+//;
             push @outParams, $p;
         }
     }
 
 
     my %tmp = map { /$pMatch/;  $_ => $pList{$1}  }
               @outParams ;
 
     @outParams = map  { "    $_" }
                  sort { $tmp{$a} <=> $tmp{$b} }
                  @outParams ;
 
     print $prefix ;
     print "(\n" . join(",\n", @outParams) . ")\n";
     print "{" ;
 
 }
 
 # Output any trailing code.
 print ;
 exit 0;
 
 
 sub StripComments
 {
 
   no warnings;
 
   # Strip C & C++ coments
   # From the perlfaq
   $_[0] =~
 
     s{
        /\*         ##  Start of /* ... */ comment
        [^*]*\*+    ##  Non-* followed by 1-or-more *'s
        (
          [^/*][^*]*\*+
        )*          ##  0-or-more things which don't start with /
                    ##    but do end with '*'
        /           ##  End of /* ... */ comment
 
      |         ##     OR  C++ Comment
        //          ## Start of C++ comment //
        [^\n]*      ## followed by 0-or-more non end of line characters
 
      |         ##     OR  various things which aren't comments:
 
        (
          "           ##  Start of " ... " string
          (
            \\.           ##  Escaped char
          |               ##    OR
            [^"\\]        ##  Non "\
          )*
          "           ##  End of " ... " string
 
        |         ##     OR
 
          '           ##  Start of ' ... ' string
          (
            \\.           ##  Escaped char
          |               ##    OR
            [^'\\]        ##  Non '\
          )*
          '           ##  End of ' ... ' string
 
        |         ##     OR
 
          .           ##  Anything other char
          [^/"'\\]*   ##  Chars which doesn't start a comment, string or escape
        )
      }{$2}gxs;
 
 }