Download LCLint User's Guide
Transcript
36
LCLint User’s Guide
One solution is to use the comma operator to define the macro:
# define incCounts()
(ntotal++, ncurrent++)
More complicated macros can be written using a do … while construction:
# define incCounts() \
do { ntotal++; ncurrent++; } while (FALSE)
LCLint detects these pitfalls in macro definitions, and checks that a macro behaves as much like a
function as possible. A client should only be able to tell that a function was implemented by a macro
if it attempts to use the macro as a pointer to a function.
LCLint does these checks on a macro definition corresponding to a function:
• Each parameter to a macro (except those declared to be side-effect free, see Section 8.2.1) must be
used exactly once in all possible executions of the macro, so side-effecting arguments behave as
expected.21 (Controlled by macroparams.)
• A parameter to a macro may not be used as the left-hand side of an assignment expression or as
the operand of an increment or decrement operator in the macro text, since this produces nonfunctional behavior. (Controlled by macroassign.)
• Macro parameters must be enclosed in parentheses when they are used in potentially dangerous
contexts. (Controlled by macroparens.)
• A macro definition must be syntactically equivalent to a statement when it is invoked followed by
a semicolon. (Controlled by macrostmt.)
• The type of the macro body must match the return type of the corresponding function. If the macro
is declared with type void, its body may have any type but the macro value may not be used.
• All variables declared in the body of a macro definition must be in the macro variable namespace,
so they do not conflict with variables in the scope where the macro is invoked (which may be used
in the macro parameters). By default, the macro namespace is all names prefixed by m_. (See
Section 9.2 for information on controlling namespaces.)
At the call site, a macro is checked like any other function call.
8.2.1 Side-Effect Free Parameters
Suppose we really do want to implement square as a macro, but want do so in a safe way. One way
to do this is to require that it is never invoked with a parameter that has a side-effect. LCLint will
check that this constraint holds, if the parameter is annotated to be side-effect free. That is, the
expression corresponding to this parameter must not modify any state, so it does not matter how many
times it is evaluated. The sef annotation is used to denote a parameter that may not have any sideeffects:
extern int square (/*@sef@*/ int x);
# define square(x) ((x) *(x))
Now, LCLint will not report an error checking the definition of square even though x is used more
than once.
A message will be reported, however, if square is invoked with a parameter that has a side-effect.
For the code fragment,
square (i++)
21
To be completely correct, all the macro parameters should be evaluated before the macro has any
side-effects. Since checking this would require extensive analysis for occasional modest gain, it was not
considered worth implementing.