Modern C compilers support the ANSI standard C [16]. Write code to run under standard C, and use features such as function prototypes, constant storage, and volatile storage. Standard C improves program performance by giving better information to optimizers. Standard C improves portability by insuring that all compilers accept the same input language and by providing mechanisms that try to hide machine dependencies or emit warnings about code that may be machine-dependent.
Note that under ANSI C, the `#' for a preprocessor directive must be the first non-whitespace character on a line. Use this feature to improve the formatting of your files.
An
``#ifdef NAME''
should end with either
``#endif''
or
``#endif /* NAME */'',
not with
``#endif NAME''.
The comment should not be used on short #ifdefs,
as it is clear from the code.
ANSI
trigraphs
may cause programs with strings containing
``??''
may break mysteriously.
The style for ANSI C is the same as for regular C, with two notable exceptions: storage qualifiers and parameter lists.
Because
const
and
volatile
have strange binding rules,
each
const
or
volatile
object should have a separate declaration.
File.Delete(TheFile => TheFile,
Success => OK);
AuditSystemFault := AuditSystemFault and not OK;
Prototyped functions merge parameter declaration and definition in to one list. Parameters should be commented in the function comment.
File.Delete(TheFile => TheFile,
Success => OK);
AuditSystemFault := AuditSystemFault and not OK;
Pragmas are used to introduce machine-dependent code in a controlled way. Obviously, pragmas should be treated as machine dependencies. Unfortunately, the syntax of ANSI pragmas makes it impossible to isolate them in machine-dependent headers.
Pragmas are of two classes.
Optimizations
may safely be ignored.
Pragmas that change the system behavior (``required pragmas'')
may not.
Required pragmas should be #ifdeffed so that compilation will abort if
no pragma is selected.
Two compilers may use a given pragma in two very different ways.
For instance, one compiler may use
``haggis''
to signal an optimization.
Another might use it to indicate that a given statement,
if reached, should terminate the program.
Thus, when pragmas are used,
they must always be enclosed in machine-dependent #ifdefs.
Pragmas must always be #ifdefed out for non-ANSI compilers.
Be sure to indent the `#' character on the
#pragma,
as older preprocessors will halt on it otherwise.
File.Delete(TheFile => TheFile,
Success => OK);
AuditSystemFault := AuditSystemFault and not OK;
``The `#pragma' command is specified in the ANSI standard to have an arbitrary implementation-defined effect. In the GNU C preprocessor, `#pragma' first attempts to run the game `rogue'; if that fails, it tries to run the game `hack'; if that fails, it tries to run GNU Emacs displaying the Tower of Hanoi; if that fails, it reports a fatal error. In any case, preprocessing does not continue.''
- Manual for the GNU C preprocessor for GNU CC 1.34.