BBS水木清华站∶精华区
WARNING OPTIONS
Warnings are diagnostic messages that report constructions
which are not inherently erroneous but which are risky or
suggest there may have been an error.
These options control the amount and kinds of warnings
produced by GNU CC:
-fsyntax-only
Check the code for syntax errors, but don't emit
any output.
-w Inhibit all warning messages.
-Wno-import
Inhibit warning messages about the use of #import.
-pedantic
Issue all the warnings demanded by strict ANSI
standard C; reject all programs that use forbidden
extensions.
Valid ANSI standard C programs should compile prop-
erly with or without this option (though a rare few
will require `-ansi'). However, without this op-
tion, certain GNU extensions and traditional C fea-
tures are supported as well. With this option,
they are rejected. There is no reason to use this
option; it exists only to satisfy pedants.
`-pedantic' does not cause warning messages for use
of the alternate keywords whose names begin and end
with `__'. Pedantic warnings are also disabled in
the expression that follows __extension__. Howev-
er, only system header files should use these es-
cape routes; application programs should avoid
them.
-pedantic-errors
Like `-pedantic', except that errors are produced
rather than warnings.
-W Print extra warning messages for these events:
o A nonvolatile automatic variable might be changed
by a call to longjmp. These warnings are possible
only in optimizing compilation.
The compiler sees only the calls to setjmp. It
cannot know where longjmp will be called; in fact,
a signal handler could call it at any point in the
code. As a result, you may get a warning even when
there is in fact no problem because longjmp cannot
in fact be called at the place which would cause a
problem.
o A function can return either with or without a val-
ue. (Falling off the end of the function body is
considered returning without a value.) For exam-
ple, this function would evoke such a warning:
foo (a)
{
if (a > 0)
return a;
}
Spurious warnings can occur because GNU CC does not
realize that certain functions (including abort and
longjmp) will never return.
o An expression-statement contains no side effects.
o An unsigned value is compared against zero with `>'
or `<='.
-Wimplicit
Warn whenever a function or parameter is implicitly
declared.
-Wreturn-type
Warn whenever a function is defined with a return-
type that defaults to int. Also warn about any re-
turn statement with no return-value in a function
whose return-type is not void.
-Wunused
Warn whenever a local variable is unused aside from
its declaration, whenever a function is declared
static but never defined, and whenever a statement
computes a result that is explicitly not used.
-Wswitch
Warn whenever a switch statement has an index of
enumeral type and lacks a case for one or more of
the named codes of that enumeration. (The presence
of a default label prevents this warning.) case
labels outside the enumeration range also provoke
warnings when this option is used.
-Wcomment
Warn whenever a comment-start sequence `/*' appears
in a comment.
-Wtrigraphs
Warn if any trigraphs are encountered (assuming
they are enabled).
-Wformat
Check calls to printf and scanf, etc., to make sure
that the arguments supplied have types appropriate
to the format string specified.
-Wchar-subscripts
Warn if an array subscript has type char. This is
a common cause of error, as programmers often for-
get that this type is signed on some machines.
-Wuninitialized
An automatic variable is used without first being
initialized.
These warnings are possible only in optimizing com-
pilation, because they require data flow informa-
tion that is computed only when optimizing. If you
don't specify `-O', you simply won't get these
warnings.
These warnings occur only for variables that are
candidates for register allocation. Therefore,
they do not occur for a variable that is declared
volatile, or whose address is taken, or whose size
is other than 1, 2, 4 or 8 bytes. Also, they do
not occur for structures, unions or arrays, even
when they are in registers.
Note that there may be no warning about a variable
that is used only to compute a value that itself is
never used, because such computations may be delet-
ed by data flow analysis before the warnings are
printed.
These warnings are made optional because GNU CC is
not smart enough to see all the reasons why the
code might be correct despite appearing to have an
error. Here is one example of how this can happen:
{
int x;
switch (y)
{
case 1: x = 1;
break;
case 2: x = 4;
break;
case 3: x = 5;
}
foo (x);
}
If the value of y is always 1, 2 or 3, then x is
always initialized, but GNU CC doesn't know this.
Here is another common case:
{
int save_y;
if (change_y) save_y = y, y = new_y;
...
if (change_y) y = save_y;
}
This has no bug because save_y is used only if it
is set.
Some spurious warnings can be avoided if you de-
clare as volatile all the functions you use that
never return.
-Wparentheses
Warn if parentheses are omitted in certain con-
texts.
-Wtemplate-debugging
When using templates in a C++ program, warn if de-
bugging is not yet fully available (C++ only).
-Wall All of the above `-W' options combined. These are
all the options which pertain to usage that we rec-
ommend avoiding and that we believe is easy to
avoid, even in conjunction with macros.
The remaining `-W...' options are not implied by `-Wall'
because they warn about constructions that we consider
reasonable to use, on occasion, in clean programs.
-Wtraditional
Warn about certain constructs that behave differ-
ently in traditional and ANSI C.
o Macro arguments occurring within string constants
in the macro body. These would substitute the ar-
gument in traditional C, but are part of the con-
stant in ANSI C.
o A function declared external in one block and then
used after the end of the block.
o A switch statement has an operand of type long.
-Wshadow
Warn whenever a local variable shadows another lo-
cal variable.
-Wid-clash-len
Warn whenever two distinct identifiers match in the
first len characters. This may help you prepare a
program that will compile with certain obsolete,
brain-damaged compilers.
-Wpointer-arith
Warn about anything that depends on the "size of" a
function type or of void. GNU C assigns these
types a size of 1, for convenience in calculations
with void * pointers and pointers to functions.
-Wcast-qual
Warn whenever a pointer is cast so as to remove a
type qualifier from the target type. For example,
warn if a const char * is cast to an ordinary char
*.
-Wcast-align
Warn whenever a pointer is cast such that the re-
quired alignment of the target is increased. For
example, warn if a char * is cast to an int * on
machines where integers can only be accessed at
two- or four-byte boundaries.
-Wwrite-strings
Give string constants the type const char[length]
so that copying the address of one into a non-const
char * pointer will get a warning. These warnings
will help you find at compile time code that can
try to write into a string constant, but only if
you have been very careful about using const in
declarations and prototypes. Otherwise, it will
just be a nuisance; this is why we did not make
`-Wall' request these warnings.
-Wconversion
Warn if a prototype causes a type conversion that
is different from what would happen to the same ar-
gument in the absence of a prototype. This in-
cludes conversions of fixed point to floating and
vice versa, and conversions changing the width or
signedness of a fixed point argument except when
the same as the default promotion.
-Waggregate-return
Warn if any functions that return structures or
unions are defined or called. (In languages where
you can return an array, this also elicits a warn-
ing.)
-Wstrict-prototypes
Warn if a function is declared or defined without
specifying the argument types. (An old-style func-
tion definition is permitted without a warning if
preceded by a declaration which specifies the argu-
ment types.)
-Wmissing-prototypes
Warn if a global function is defined without a pre-
vious prototype declaration. This warning is is-
sued even if the definition itself provides a pro-
totype. The aim is to detect global functions that
fail to be declared in header files.
-Wmissing-declarations
Warn if a global function is defined without a pre-
vious declaration. Do so even if the definition
itself provides a prototype. Use this option to
detect global functions that are not declared in
header files.
-Wredundant-decls
Warn if anything is declared more than once in the
same scope, even in cases where multiple declara-
tion is valid and changes nothing.
-Wnested-externs
Warn if an extern declaration is encountered within
an function.
-Wenum-clash
Warn about conversion between different enumeration
types (C++ only).
-Woverloaded-virtual
(C++ only.) In a derived class, the definitions of
virtual functions must match the type signature of
a virtual function declared in the base class. Use
this option to request warnings when a derived
class declares a function that may be an erroneous
attempt to define a virtual function: that is, warn
when a function with the same name as a virtual
function in the base class, but with a type signa-
ture that doesn't match any virtual functions from
the base class.
-Winline
Warn if a function can not be inlined, and either
it was declared as inline, or else the -fin-
line-functions option was given.
-Werror
Treat warnings as errors; abort compilation after
any warning.
BBS水木清华站∶精华区