cproto   -   generate   C  function  prototypes  and  convert  function


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


       Cproto generates function  prototypes  for  functions  defined  in  the
       specified  C  source  files  to  the  standard  output.   The  function
       definitions may be in the old  style  or  ANSI  C  style.   Optionally,
       cproto  also  outputs  declarations for variables defined in the files.
       If no file argument is given, cproto reads its input from the  standard

       By  giving  a  command  line  option, cproto will also convert function
       definitions 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
              number  from  0  to  3.   For  example,  consider  the  function

              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

              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
              prototype.  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_".

       -n     Rather  than filling in "void" for functions without parameters,
              use a comment "/*empty*/".

       -N name
              Rather than filling in "void" for functions without  parameters,
              use the given name.

       -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
              declarations 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
              traditional 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
              definitions, and function definitions  with  parameter  comments
              respectively.  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
              command  when  generating  prototypes.   By default, the program
              uses /lib/cpp.

       -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
       generated  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
       handle 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
       character escape sequences:

              \n   newline
              \s   space
              \t   tab

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


       Chin Huang

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


       cc(1), cpp(1)

Version 4.7r                      2021-01-10                         CPROTO(1)