The program protoize
is an optional part of GNU C. You can use
it to add prototypes to a program, thus converting the program to ANSI
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-ANSI 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
'. 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.
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
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
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
.C
' instead of `.c
'.
This is convenient if you are converting a C program to C++.
This option applies only to protoize
.
-g
protoize
.
-i string
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
.X
' files. Normally, they are deleted after conversion
is finished.
-l
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
-n
'.
-N
.save
' files. The original files are simply deleted.
Use this option with caution.
-p program
gcc
' is used.
-q
-v
-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 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 Protoize Caveats, for more information on how to use
protoize
successfully.