Intel XENIX 286 Programmers Guide (86) - Tenox.tc

XENIX Programming lint: C Program Checker
Checking Expression Evaluation Order
In complicated expressions, the best order in which to evaluate subexpressions may be
highly machine-dependent. For example, on machines in which the stack runs backward,
function arguments will probably be best evaluated from right to left; on machines with
a stack running forward, left to right is probably best. Function calls embedded as
arguments of other functions may or may not be treated in the same way as ordinary
arguments. Sim ilar issues arise with other operators that have side effects, such as the
assignment operators and the increment and decrement operators.
So that the efficiency of C on a particular machine is not unduly compromised, the C
language leaves the order of evaluation of complicated expressions up to the compiler,
and various C compilers have considerable differences in the order in which they will
evaluate complicated expressions. In particular, if any variable is changed by a side
effect, and also used elsewhere in the same expression, the result is explicitly
undefined.
lint checks for the important special case where a simple scalar variable is affected.
For example, the statement
a[i] = b[i + +] ;
will draw the comment
warning: i evaluation order undefined
Embedding Directives
There are occasions when the program mer is smarter than lint. There may be valid
reasons for illegal type casts, functions with a variable number of arguments, and other
constructions that lint finds objectionable. Moreover, as specified in the above sections,
the flow of control information produced by lint often has blind spots, causing
occasional spurious messages about perfectly reasonable programs. Some way of
communicating with lint, typically to turn off its output, is desirable. Therefore, a
number of words are recognized by lint when they are embedded in com ments in a C
source file. These words are called directives. lint directives are invisible to the
compiler.
The first directive discussed concerns flow of control information. If a particular place
in the program cannot be reached, this can be asserted at the appropriate spot in the
program with the directive
I* NOTREACHED *I
Similarly, if you desire to turn off strict type checking for the next expression, use the
directive
I* NOSTRICT *I
3-11