Computer Science
CPROTO(1) CPROTO(1)
NAME
cproto - generate C function prototypes and convert func-
tion definitions
SYNOPSIS
cproto [ option ... ] [ file ... ]
DESCRIPTION
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 input.
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 overwrit-
ten 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
int
main (
int argc, /* number of arguments */
char *argv[] /* arguments */
)
{
}
Otherwise, the converted function definition will look
like
int
main (int argc, char *argv[])
{
}
Cproto can optionally convert function definitions from
the ANSI style to the old style. In this mode, the pro-
gram also converts function declarators and prototypes
that appear outside function bodies. This is not a com-
plete ANSI C to old C conversion. The program does not
change anything within function bodies.
Cproto can optionally generate source in lint-library for-
mat. This is useful in environments where the lint util-
ity is used to supplement prototype checking of your pro-
gram.
OPTIONS
-e Output the keyword extern in front of every gener-
ated 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, con-
sider the function definition
main (argc, argv)
int argc;
char *argv[];
{
}
If the value is 0, then no prototypes are gener-
ated. 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 func-
tion prototype:
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 con-
flicts 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 com-
ments.
-m Put a macro around the parameter list of every gen-
erated prototype. For example:
int main P_((int argc, char *argv[]));
-M name
Set the name of the macro used to surround proto-
type parameter lists when option -m is selected.
The default is "P_".
-d Omit the definition of the prototype macro used by
the -m option.
-o file
Specify the name of the output file (default: stan-
dard output).
-O file
Specify the name of the error file (default: stan-
dard error).
-p Disable promotion of formal parameters in old style
function definitions. By default, parameters of
type char or short in old style function defini-
tions are promoted to type int in the function pro-
totype 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.
-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.
-a Convert function definitions from the old style to
the ANSI C style.
-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 definition:
#ifdef ANSI_FUNC
int
main (int argc, char *argv[])
#else
int
main (argc, argv)
int argc;
char *argv[]
#endif
{
}
-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, func-
tion definitions, and function definitions with
parameter comments respectively. The format is spec-
ified 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 condi-
tionals such as #ifdef.
-U name
This option is passed through to the preprocessor
and is used to remove any definitions of this sym-
bol.
-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 #include.
-E cpp Pipe the input files through the specified C pre-
processor command when generating prototypes. By
default, the program uses /lib/cpp.
-E 0 Do not run the C preprocessor.
-V Print version information.
ENVIRONMENT
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 correspond-
ing environment option.
BUGS
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 expan-
sions. 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 vari-
ables 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 fol-
lowing 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).
AUTHOR
Chin Huang
cthuang@vex.net
cthuang@interlog.com
Thomas Dickey
dickey@clark.net
modifications to support lint library, type-copying, and port to VAX/VMS.
SEE ALSO
cc(1), cpp(1)
January 1998 1
Back to the index
