Next: Pragma Weak_External, Previous: Pragma Warning_As_Error, Up: Implementation Defined Pragmas [Contents][Index]
Syntax:
pragma Warnings ([TOOL_NAME,] DETAILS [, REASON]); DETAILS ::= On | Off DETAILS ::= On | Off, local_NAME DETAILS ::= static_string_EXPRESSION DETAILS ::= On | Off, static_string_EXPRESSION TOOL_NAME ::= GNAT | GNATProve REASON ::= Reason => STRING_LITERAL {& STRING_LITERAL}
Note: in Ada 83 mode, a string literal may be used in place of a static string expression (which does not exist in Ada 83).
Note if the second argument of DETAILS
is a local_NAME
then the
second form is always understood. If the intention is to use
the fourth form, then you can write NAME & ""
to force the
intepretation as a `static_string_EXPRESSION'.
Note: if the first argument is a valid TOOL_NAME
, it will be interpreted
that way. The use of the TOOL_NAME
argument is relevant only to users
of SPARK and GNATprove, see last part of this section for details.
Normally warnings are enabled, with the output being controlled by
the command line switch. Warnings (Off
) turns off generation of
warnings until a Warnings (On
) is encountered or the end of the
current unit. If generation of warnings is turned off using this
pragma, then some or all of the warning messages are suppressed,
regardless of the setting of the command line switches.
The Reason
parameter may optionally appear as the last argument
in any of the forms of this pragma. It is intended purely for the
purposes of documenting the reason for the Warnings
pragma.
The compiler will check that the argument is a static string but
otherwise ignore this argument. Other tools may provide specialized
processing for this string.
The form with a single argument (or two arguments if Reason present),
where the first argument is ON
or OFF
may be used as a configuration pragma.
If the LOCAL_NAME
parameter is present, warnings are suppressed for
the specified entity. This suppression is effective from the point where
it occurs till the end of the extended scope of the variable (similar to
the scope of Suppress
). This form cannot be used as a configuration
pragma.
In the case where the first argument is other than ON
or
OFF
,
the third form with a single static_string_EXPRESSION argument (and possible
reason) provides more precise
control over which warnings are active. The string is a list of letters
specifying which warnings are to be activated and which deactivated. The
code for these letters is the same as the string used in the command
line switch controlling warnings. For a brief summary, use the gnatmake
command with no arguments, which will generate usage information containing
the list of warnings switches supported. For
full details see the section on Warning Message Control
in the
GNAT User’s Guide.
This form can also be used as a configuration pragma.
The warnings controlled by the -gnatw
switch are generated by the
front end of the compiler. The GCC back end can provide additional warnings
and they are controlled by the -W
switch. Such warnings can be
identified by the appearance of a string of the form [-W{xxx}]
in the
message which designates the -W`xxx'
switch that controls the message.
The form with a single `static_string_EXPRESSION' argument also works for these
warnings, but the string must be a single full -W`xxx'
switch in this
case. The above reference lists a few examples of these additional warnings.
The specified warnings will be in effect until the end of the program
or another pragma Warnings
is encountered. The effect of the pragma is
cumulative. Initially the set of warnings is the standard default set
as possibly modified by compiler switches. Then each pragma Warning
modifies this set of warnings as specified. This form of the pragma may
also be used as a configuration pragma.
The fourth form, with an On|Off
parameter and a string, is used to
control individual messages, based on their text. The string argument
is a pattern that is used to match against the text of individual
warning messages (not including the initial "warning: " tag).
The pattern may contain asterisks, which match zero or more characters in
the message. For example, you can use
pragma Warnings (Off, "bits of*unused")
to suppress the warning
message warning: 960 bits of "a" unused
. No other regular
expression notations are permitted. All characters other than asterisk in
these three specific cases are treated as literal characters in the match.
The match is case insensitive, for example XYZ matches xyz.
Note that the pattern matches if it occurs anywhere within the warning message string (it is not necessary to put an asterisk at the start and the end of the message, since this is implied).
The above use of patterns to match the message applies only to warning
messages generated by the front end. This form of the pragma with a string
argument can also be used to control warnings provided by the back end and
mentioned above. By using a single full -W`xxx'
switch in the pragma,
such warnings can be turned on and off.
There are two ways to use the pragma in this form. The OFF form can be used as a configuration pragma. The effect is to suppress all warnings (if any) that match the pattern string throughout the compilation (or match the -W switch in the back end case).
The second usage is to suppress a warning locally, and in this case, two pragmas must appear in sequence:
pragma Warnings (Off, Pattern); ... code where given warning is to be suppressed pragma Warnings (On, Pattern);
In this usage, the pattern string must match in the Off and On pragmas, and (if `-gnatw.w' is given) at least one matching warning must be suppressed.
Note: if the ON form is not found, then the effect of the OFF form extends until the end of the file (pragma Warnings is purely textual, so its effect does not stop at the end of the enclosing scope).
Note: to write a string that will match any warning, use the string
"***"
. It will not work to use a single asterisk or two
asterisks since this looks like an operator name. This form with three
asterisks is similar in effect to specifying pragma Warnings (Off)
except (if -gnatw.w
is given) that a matching
pragma Warnings (On, "***")
will be required. This can be
helpful in avoiding forgetting to turn warnings back on.
Note: the debug flag -gnatd.i
can be
used to cause the compiler to entirely ignore all WARNINGS pragmas. This can
be useful in checking whether obsolete pragmas in existing programs are hiding
real problems.
Note: pragma Warnings does not affect the processing of style messages. See separate entry for pragma Style_Checks for control of style messages.
Users of the formal verification tool GNATprove for the SPARK subset of Ada may
use the version of the pragma with a TOOL_NAME
parameter.
If present, TOOL_NAME
is the name of a tool, currently either GNAT
for the
compiler or GNATprove
for the formal verification tool. A given tool only
takes into account pragma Warnings that do not specify a tool name, or that
specify the matching tool name. This makes it possible to disable warnings
selectively for each tool, and as a consequence to detect useless pragma
Warnings with switch -gnatw.w
.
Next: Pragma Weak_External, Previous: Pragma Warning_As_Error, Up: Implementation Defined Pragmas [Contents][Index]