CPROTO(1)

💖 CPROTO — bestie edition 💖

okay so real talk, this is cproto from the User commands crew, and it's genuinely one of those tools that looks boring and is secretly doing the most. it generates C function prototypes and converts function definitions. that's the whole personality. periodt.

---

✨ SYNOPSIS ✨

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

---

🌸 DESCRIPTION 🌸

🍓 Extracting

so cproto looks at the C source files you hand it and generates function prototypes for all the functions defined in there, dumping them to standard output. the function definitions can be old style or ANSI C style, it does not care, it's flexible like that. optionally you can also get it to output declarations for variables defined in the files. and if you give it no file argument at all? it just reads from standard input. lowkey chill.

🦋 Converting ANSI C

cproto can convert function definitions in simple source files from the old style to the ANSI C style (peep BUGS for the limitations, bestie, don't say i didn't warn you). the original source files — plus any files pulled in by

#include "file"

directives sitting in the source code — will get overwritten with the converted code. yes, overwritten. no, there is no undo. 🙈

if you don't give it any file names on the command line, it reads the source from standard input and writes the converted source to standard output. safe.

if there are any comments in the parameter declarations for a function definition, like in this example here:

main (argc, argv)
int argc;       /* number of arguments */
char *argv[];   /* arguments */
{
}

then the converted function definition comes out looking like:

int
main (
    int argc,       /* number of arguments */
    char *argv[]   /* arguments */
)
{
}

but if there are no comments? then the converted function definition is just:

int
main (int argc, char *argv[])
{
}

clean. simple. iconic.

💅 Converting K&R C

cproto can also go the other way: convert function definitions from the ANSI style to the old K&R style. in this mode it also converts function declarators and prototypes that appear outside function bodies. heads up though — this is not a complete ANSI C to old C conversion. the program does not change anything within function bodies. hands off the body, that's the rule.

⭐ Lint-libraries

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

---

👑 OPTIONS 👑

• -a — convert function definitions from the old style to the ANSI C style.
• -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

• -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
{
}

• -C template — set the output format for function definitions with parameter comments. the -F and -P options let you set the format for prototypes and function definitions.

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[]
        )

• -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. (they were just being shy fr.)
• -D name[=value] — this option is passed through to the preprocessor and is used to define symbols for use with conditionals such as #ifdef.
• -d — omit the definition of the prototype macro used by the -m option.
• -E cpp — pipe the input files through the specified C preprocessor command when generating prototypes. by default, the program uses “gcc -E” via a pipe.
• -E 0 — do not run the C preprocessor.
• -e — output the keyword extern in front of every generated prototype or declaration that has global scope.
• -F template — set the output format for function definitions as in the “-C” option.
• -f n — set the style of generated function prototypes where n is a number 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 prototype:

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

• -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.
• -i — by default, cproto only generates declarations for functions and variables having global scope. this option will output inline declarations as well.
• -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 the C preprocessor with VAX-C. 💀

• -M name — set the name of the macro used to surround prototype parameter lists when option -m is selected. the default is “P_”.
• -m — put a macro around the parameter list of every generated prototype. for example:

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

• -N name — rather than filling in “void” for functions without parameters, use the given name.
• -n — rather than filling in “void” for functions without parameters, use a comment “/*empty*/”.
• -O file — specify the name of the error file (default: standard error).
• -o file — specify the name of the output file (default: standard output).
• -P template — set the output format for generated prototypes as in the “-C” option.
• -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. glow-up denied, sorry.
• -q — do not output any error messages when the program cannot read the file specified in an #include directive.
• -S — output only static declarations.
• -s — by default, cproto only generates declarations for functions and variables having global scope. this option will output static declarations as well.
• -T — copy type definitions from each file. (definitions in included-files are copied, unlike the “-l” option).
• -t — convert function definitions from the ANSI C style to the traditional style.
• -U name — this option is passed through to the preprocessor and is used to remove any definitions of this symbol.
• -V — print version information.
• -v — also output declarations for variables defined in the source.
• -X level — this option limits the include-file level from which declarations are extracted by examining the preprocessor output.
• -x — this option causes procedures and variables which are declared “extern” to be included in the output.

---

🌈 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 corresponding environment option. command line stays winning, as it should. 💅

---

💀 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. yeah. just vibes in there. nothing else.

the program does not pipe the source files through the C preprocessor when it is converting function definitions (i.e., options -a, -b, -t). that is because cproto does the conversion by replacing strings, rather than by converting to/from lexical tokens. instead of using the C preprocessor, cproto tries to handle preprocessor directives and macros itself, to find type definitions. there are several limitations as a result:

• the search-path for included files contains only “/usr/include” and the directories listed by “-I” options.
• conditional directives (e.g., “#if”) are ignored.
• only macros without parameters are handled.
• some comments in the function definition head are discarded.

the -v option does not generate declarations for variables defined with the extern specifier. this does not 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). not me getting a one-word error message and having to figure out my whole life 😭

options that take string arguments only interpret the following character escape sequences:

\n   newline
\s   space
\t   tab

VARARGS comments are not passed through on systems whose C preprocessors do not support this (e.g., VAX/VMS, MS-DOS).

---

🫶 AUTHORS 🫶

• Chin Huang — cthuang@vex.net, cthuang@interlog.com
• Thomas E. Dickey — dickey@invisible-island.net — modifications to support lint library, type-copying, and port to VAX/VMS.

---

🎀 SEE ALSO 🎀

cc(1), cpp(1)

---

and that's a wrap, bestie 🦋 this was Version 4.8a, dated 2026-07-26 — go forth and prototype responsibly ✨💖