LETTERS

Find That Function With AWK

In the article "Find That Function!" (August 1988), Marvin Hymowech provides two C programs for building and searching a file of where-defined information about C functions and their related source files. I don't want to denigrate what Marvin has done (because he has obviously put a substantial amount of work into the programs), but this task (among many others!) is perfectly suited to awk.

I have provided two awk programs that do basically the same thing as his C programs. Note that the code is much more compact (by an order of magnitude or two). The bldfuncs routine has been implemented using a different algorithm than Marvin's. I consider only those lines of C source where the last character on the line is a closing parenthesis. This set of lines includes all function definition lines. (This is coding style dependent, but it's true for the way I and Marvin and 99 percent of others code C.) Of these lines, the ones that begin with if for, while, ||, and && are discarded. This leaves just the function definition lines (with a slight possibility of a comment line).

The functionality of the second program, getf has actually been enhanced in the awk version. One can search for function names using regular expression syntax --decidedly more powerful than wildcards. Note also that the awk version invokes Marvin's editor directly instead of relying on DOS environment variables.

I didn't benchmark the two versions of the program, but my guess would be that the awk version runs a little slower. Since awk is not compiled and linked, but rather interpreted, it will be inherently slower (but not slow). But this is actually an advantage when going through the code-test-debug iteration cycle.

Although awk is certainly not suitable for developing major applications, it is beautifully suited to developing this kind of utility program. With C, these "quick little utility functions" take on many of the aspects of major application development. With awk, they truly are quick and little. See Examples 1 and 2, below.

Example 1
#----------------------------------------------------------------------
#    Bldfuncs            Joseph L. Kidd
#    This awk program mimics the function of the same name given
#    in ``Find That Function'', by Marvin Hymowech in DDJ, Aug. 1988
#
#    Usage: awk  bldfuncs.awk srcfile1 srcfile2 ...
#         where srcfile1, ... may contain wildcard characters.
#    Output: A file named funcs.txt with the format:
#         srcfile1:
#              function_1 lineno1
#              function_2 lineno2
#              ...
#              function_n lineno3
#         srcfile2:
#              ...
#    (where lineno1,... are the line numbers where the functions are
#         defined.)
#----------------------------------------------------------------------

FNR == 1 { print FILENAME ":"      >"funcs.txt"   }
/\)$/     {
     if ($1 ~ /^if\(*/   ||   $1 ~ /^for\(*/ || $1 ~ /^while\(*/ ||
         $1 ~ /^\|\|/    ||   $1 ~ /^\&\&/*
          next
     else
          for (i=1; i<=NF; i++)
               if (x=index($i,"("))     {
                    if (x==1)
                         print " " $(i-1) " " FNR >"funcs.txt"
                    else
                         print " " substr($i,1,x-1)  " " FNR >"funcs.txt"
                    break
               }
}

Example 2

---------------------------------------------------------------------------
#    GETF                Joseph L. Kidd
#    This awk program mimics the program of the same name given
#    in the article ``Find That Function'', by Marvin Hymowech in DDj, aug. #    1988.
#    Usage: awk getf.awk req+<req_func_name> funcs.txt
#         where <req_func_name> is the requested function name.
#         Note that <req_func_name> is the requested function name.
#         which is significantly more powerful that DOS's wildcards.
#--------------------------------------------------------------------------
$1 ~ /:$/ { file = substr($1,1,length($1)-1) }
$1 ~ req  { print "Pattern=\"",req,"\". ",
                    $1, "can be found in file", file,
                    "at line", $2 "."
               req_func = $1
               req_file = file
               req_count++
}
END       {    if (req_count==0)
                    print "Could not find", req
               if (req_count>1)
                    print "Multiple functions found."
               if (req_count==1)   {
                    cmd = "b  -m\search_fwd " req_func "\" " req_file
                    system (cmd)
               }
}

Joseph L. Kidd

San Jose, Calif.

Dear DDJ,

I have found that two changes should be made to Marvin Hymowech's function finding programs.

1. In bldfuncs.c, get_names_one_file() is confused by the declaration of a pointer to a function, as in:

     int (*point1)( )=puts;

It eats through the next function body and records int as a function. To fix this, after

        if(c ==';' || c ==',')  /*functions
             type check declaration, */
   continue;               /* so bypass it */

add

    if(c == PARENS)
/* something pointing to a function */
continue;                    /* so bypass it */

Actually, it could still be fooled by a function that returned a pointer to a function, as in:

        int (*function( ))(){ ... }

or odd but perfectly legal declarations like

        (main)(argc, argv) { ... }

        (main(argc, argv)){ ... }

2. In patn_match(), change

       while( *s++)           ;

        while( *s)       s++;

Otherwise, s gets incremented past the terminating zero, and the returned value can be incorrect.

I also changed bldfuncs to write the line number of each function definition so that getf could use the line number rather than the function name in the command line for the editor. I believe I'll add Unix-style pattern matching as well. Thank you for a very handy tool!

James R. Van Zandt

Nashua, New Hampshire

Dear DDJ,

In his article "Find That Function!", Marvin Hyrnowech puts his finger on a major practical problem with C, namely the poor recognizability of function definitions. I have a solution to the problem that, though so crude and lowtech it's almost embarrassing, may be of use to your readers. Namely, whenever I write or revise a C source-code file, I put the token FUNC, #defined to be nothing either in stdio.h or at the head of the file at the beginning of every function definition and the comment /* FUNC */ after the #define in every macro definition, as in:

        #define FUNC

        FUNC char *strend(register char *s)
    {
    while (*s++)
    return s;
    }

        #define /* FUNC */ max(a,b) ((a)>(b)?(a):(b))

To find a specific definition I use one of the two greps as follows: