When you run these programs, you must specify a set of source files as command line arguments. The conversion programs start out by compiling these files to see what functions they define. The information gathered about a file, foo, is saved in a file named foo.X.

After scanning comes actual conversion. The specified files are all eligible to be converted; any files they include (whether sources or just headers) are eligible as well.

But not all the eligible files are converted. By default, protoize and unprotoize convert only source and header files in the current directory. You can specify additional directories whose files should be converted with the ‘-d’ directory option. You can also specify particular files to exclude with the ‘-x’ file option. A file is converted if it is eligible, its directory name matches one of the specified directory names, and its name within the directory has not been excluded.

Basic conversion with protoize consists of rewriting most function definitions and function declarations to specify the types of the arguments. The only ones not rewritten are those for varargs functions.

protoize optionally inserts prototype declarations at the beginning of the source file, to make them available for any calls that precede the function’s definition. Or it can insert prototype declarations with block scope in the blocks where undeclared functions are called.

Basic conversion with unprotoize consists of rewriting most function declarations to remove any argument types, and rewriting function definitions to the old-style pre-ANSI form.

Both conversion programs print a warning for any function declaration or definition they can’t convert. You can suppress these warnings with ‘-q’.

The output from protoize or unprotoize replaces the original source file. The original file is renamed to a name ending with .save.  If the .save file already exists, then the source file is simply discarded.

protoize and unprotoize both depend on GNU CC itself to scan the program and collect information about the functions it uses. So neither of these programs will work until GNU CC is installed.

You can use the following options with protoize and unprotoize.  Each option works with both programs unless otherwise stated.

 -Bdirectory
Look for the file SYSCALLS.c.X in the specified directory, instead of the usual directory (normally /usr/local/lib). This file contains prototype information about standard system functions. This option applies only to protoize.
-ccompilation-options
Use compilation-options as the options when running gcc to produce the .X files. The special option, -aux-info, is always passed in addition, to tell gcc to write a .X file.

Warning:

The compilation options must be given as a single argument to protoize or unprotoize.
If you want to specify several gcc options, you must quote the entire set of compilation options to make them a single word in the shell.
You cannot use certain gcc arguments because they produce the wrong kind of output. These include ‘-g’, ‘-O’, ‘–c’, ‘-S’, and ‘-o’. If you include these in the ‘compilation-options’, they are ignored.
-C
Rename files to end in ‘.C’ instead of ‘.c’. This is convenient if you are converting a C program to C++. This option applies only to protoize.
-g
Add explicit global declarations. This means inserting explicit declarations at the beginning of each source file for each function that is called in the file and was not declared. These declarations precede the first function definition that contains a call to an undeclared function. This option applies only to protoize.
-istring
Indent old-style parameter declarations with the string string. This option applies only to protoize.
unprotoize converts prototyped function definitions to old-style function definitions, where the arguments are declared between the argument list and the initial brace, ‘{’. By default, unprotoize uses five spaces as the indentation. If you want to indent with just one space instead, use ‘-i “  ” ’.
-k
Keep the .X files. Normally, they are deleted after conversion is finished.
-l
Add explicit local declarations. protoize with ‘-l’ inserts a prototype declaration for each function in each block which calls the function without any declaration. This option applies only to protoize.
-n
Make no real changes. This mode just prints information about the conversions that would have been done without ‘-n’.
-N
Make no .save files. The original files are simply deleted. Use this option with caution.
-p program
Use the program, program, as the compiler. Normally, gcc, is used.
-q
Work quietly. Most warnings are suppressed.
-v
Print the version number, just like ‘-v’ for gcc.
If you need special compiler options to compile one of your program’s source files, then you should generate that file’s ‘.X’ file specially, by running gcc on that source file with the appropriate options and the option -aux-info. Then run protoize on the entire set of files. protoize will use the existing ‘.X’ file because it is newer than the source file. Use the following example for protoize.

gcc -Dfoo=bar file1.c -aux-info 
protoize *.c

You need to include the special files along with the rest in the protoize command, even though their ‘.X’ files already exist, because otherwise they won’t get converted.
See Caveats of using protoize for more information on how to use protoize successfully.