(gcc.info.gz) Running Protoize

Info Catalog

(gcc.info.gz) Precompiled Headers

(gcc.info.gz) Invoking GCC

 
 3.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.
 
   Protoize Caveats, for more information on how to use
 `protoize' successfully.
 

Info Catalog

(gcc.info.gz) Precompiled Headers

(gcc.info.gz) Invoking GCC