4.21. Running Protoize
The program protoize is an optional part of GCC. You can use
it to add prototypes to a program, thus converting the program to ISO
C in one respect. The companion program unprotoize does the
reverse: it removes argument types from any prototypes that are found.
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-ISO form.
Both conversion programs print a warning for any function declaration or
definition that 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 (for DOS, the saved filename ends in .sav
without the original .c suffix). If the .save (.sav
for DOS) file already exists, then the source file is simply discarded.
protoize and unprotoize both depend on GCC itself to
scan the program and collect information about the functions it uses.
So neither of these programs will work until GCC is installed.
Here is a table of the options you can use with protoize and
unprotoize. Each option works with both programs unless
otherwise stated.
- -B directory
Look for the file SYSCALLS.c.X in 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.
- -c compilation-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.
Note that 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.
There are certain gcc arguments that you cannot use, because they
would 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 (.cc for DOS-based file
systems) 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.
- -i string
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 {. 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, the name
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.
For example:
gcc -Dfoo=bar file1.c -aux-info file1.X
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.
Section 11.10 Caveats of using protoize, for more information on how to use
protoize successfully.
