Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
CPROTO(1)		    General Commands Manual		     CPROTO(1)

       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  li-
	      brary  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 en-
	      able 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  op-

       -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.  Pa-
	      rameters 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  in-
	      cluded-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  be-
	      ginning 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)


Want to link to this manual page? Use this URL:

home | help