Man Linux: Main Page and Category List


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

       -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 Dickey
       modifications to support lint library, type-copying, and port to VAX/VMS.


       cc(1), cpp(1)

                                  March 2004