cproto  -  generate  C function prototypes and convert function defini-


       cproto [ option ...  ] [ file ...  ]


       Cproto generates function prototypes for functions defined in the spec-
       ified  C source files to the standard output.  The function definitions
       may be in the old style or ANSI C style.  Optionally, cproto also  out-
       puts declarations for variables defined in the files.  If no file argu-
       ment is given, cproto reads its input from the standard input.

       By giving a command line option, cproto will also convert function def-
       initions in the specified files from the old style to the ANSI C style.
       The original source files along with files specified by
       #include "file"
       directives appearing in the source code will be  overwritten  with  the
       converted  code.   If no file names are given on the command line, then
       the program reads the source code from the standard input  and  outputs
       the converted source to the standard output.

       If  any  comments  appear  in the parameter declarations for a function
       definition, such as in the example,
       main (argc, argv)
       int argc;       /* number of arguments */
       char *argv[];   /* arguments */
       then the converted function definition will have the form
       main (
           int argc,       /* number of arguments */
           char *argv[]   /* arguments */
       Otherwise, the converted function definition will look like
       main (int argc, char *argv[])

       Cproto can optionally convert function definitions from the ANSI  style
       to  the  old  style.   In this mode, the program also converts function
       declarators and prototypes that appear outside function  bodies.   This
       is  not  a  complete  ANSI C to old C conversion.  The program does not
       change anything within function bodies.

       Cproto can optionally generate source in lint-library format.  This  is
       useful  in  environments  where  the lint utility is used to supplement
       prototype checking of your program.


       -e     Output the keyword extern in front of every generated  prototype
              or declaration that has global scope.

       -f n   Set the style of generated function prototypes where n is a num-
              ber from 0 to 3.  For example, consider the function definition
              main (argc, argv)
              int argc;
              char *argv[];
              If the value is 0, then no prototypes are generated.   When  set
              to 1, the output is:
              int main(/*int argc, char *argv[]*/);
              For a value of 2, the output has the form:
              int main(int /*argc*/, char */*argv*/[]);
              The  default  value  is 3.  It produces the full function proto-
              int main(int argc, char *argv[]);

       -l     Generate text for a lint-library (overrides  the  "-f"  option).
              The output includes the comment
              /* LINTLIBRARY */
              Special  comments  LINT_EXTERN  and LINT_PREPRO (a la "VARARGS")
              respectively turn on the "-x" option and  copy  comment-text  to
              the output (for preprocessing in lint).  Use the comment
              /* LINT_EXTERN2 */
              to  include externs defined in the first level of include-files.
              Use the comment
              /* LINT_SHADOWED */
              to cause cproto to put  "#undef"  directives  before  each  lint
              library  declaration  (i.e., to avoid conflicts with macros that
              happen to have to have the same  name  as  the  functions,  thus
              causing syntax errors).

       Note that these special comments are not supported under VAX/VMS, since
       there is no equivalent for the "-C" option of cpp with VAX-C.

       -c     The parameter comments in the prototypes generated  by  the  -f1
              and  -f2  options  are  omitted  by default.  Use this option to
              enable the output of these comments.

       -m     Put a macro around the parameter list of every generated  proto-
              type.  For example:
              int main P_((int argc, char *argv[]));

       -M name
              Set  the  name of the macro used to surround prototype parameter
              lists when option -m is selected.  The default is "P_".

       -d     Omit the definition of  the  prototype  macro  used  by  the  -m

       -o file
              Specify the name of the output file (default: standard output).

       -O file
              Specify the name of the error file (default: standard error).

       -p     Disable  promotion  of  formal  parameters in old style function
              definitions.  By default, parameters of type char  or  short  in
              old  style  function definitions are promoted to type int in the
              function prototype or  converted  ANSI  C  function  definition.
              Parameters of type float get promoted to double as well.

       -q     Do  not  output  any error messages when the program cannot read
              the file specified in an #include directive.

       -s     By default, cproto only generates declarations for functions and
              variables  having  global scope.  This option will output static
              declarations as well.

       -S     Output only static declarations.

       -i     By default, cproto only generates declarations for functions and
              variables  having  global scope.  This option will output inline
              declarations as well.

       -T     Copy  type  definitions  from  each   file.    (Definitions   in
              included-files are copied, unlike the "-l" option).

       -v     Also output declarations for variables defined in the source.

       -x     This  option  causes procedures and variables which are declared
              "extern" to be included in the output.

       -X level
              This option limits the include-file level  from  which  declara-
              tions are extracted by examining the preprocessor output.

       -a     Convert  function  definitions  from the old style to the ANSI C

       -t     Convert function definitions from the ANSI C style to the tradi-
              tional style.

       -b     Rewrite  function definition heads to include both old style and
              new style declarations separated by  a  conditional  compilation
              directive.   For example, the program can generate this function
              #ifdef ANSI_FUNC

              main (int argc, char *argv[])

              main (argc, argv)
              int argc;
              char *argv[]

       -B directive
              Set the conditional  compilation  directive  to  output  at  the
              beginning  of  function  definitions generated by the -b option.
              The default is
              #ifdef ANSI_FUNC

       -P template
       -F template
       -C template
            Set the output format for generated prototypes,  function  defini-
            tions,  and  function  definitions with parameter comments respec-
            tively.  The format is specified by a template in the form
            " int f ( a, b )"
            but you may replace each space in this string with any  number  of
            whitespace characters.  For example, the option
            -F"int f(\n\ta,\n\tb\n\t)"
            will produce
            int main(
                    int argc,
                    char *argv[]

       -D name[=value]
              This option is passed through to the preprocessor and is used to
              define symbols for use with conditionals such as #ifdef.

       -U name
              This option is passed through to the preprocessor and is used to
              remove any definitions of this symbol.

       -I directory
              This option is passed through to the preprocessor and is used to
              specify a directory to search for files that are referenced with

       -E cpp Pipe  the  input files through the specified C preprocessor com-
              mand when generating prototypes.  By default, the  program  uses

       -E 0   Do not run the C preprocessor.

       -V     Print version information.


       The environment variable CPROTO is scanned for a list of options in the
       same format as the command line options.  Options given on the  command
       line override any corresponding environment option.


       If  an  un-tagged struct, union or enum declaration appears in a gener-
       ated function prototype or converted function definition,  the  content
       of the declaration between the braces is empty.

       The  program  does not pipe the source files through the C preprocessor
       when it is converting function definitions.  Instead, it tries to  han-
       dle  preprocessor  directives  and macros itself and can be confused by
       tricky macro expansions.  The conversion also discards some comments in
       the function definition head.

       The -v option does not generate declarations for variables defined with
       the extern specifier.  This doesn't strictly conform to the C  language
       standard  but  this rule was implemented because include files commonly
       declare variables this way.

       When the program encounters an error, it usually outputs the  not  very
       descriptive  message "syntax error".  (Your configuration may allow the
       extended error reporting in yyerror.c).

       Options that take string arguments only interpret the following charac-
       ter escape sequences:
       \n   newline
       \s   space
       \t   tab

       VARARGS comments don't get passed through on systems whose C preproces-
       sors don't support this (e.g., VAX/VMS, MS-DOS).


       Chin Huang

       Thomas Dickey
       modifications to support lint library, type-copying, and port to VAX/VMS.


       cc(1), cpp(1)

                                   July 2010                         CPROTO(1)