The standard default format for error messages is called "brief format." Brief format messages are written to stderr (the standard error file) and have the following form:
e.adb:3:04: Incorrect spelling of keyword "function" e.adb:4:20: ";" should be "is"
The first integer after the file name is the line number in the file,
and the second integer is the column number within the line.
glide can parse the error messages
and point to the referenced character.
The following switches provide control over the error message
|3. funcion X (Q : Integer) | >>> Incorrect spelling of keyword "function" 4. return Integer; | >>> ";" should be "is"|
The vertical bar indicates the location of the error, and the `>>>'
prefix can be used to search for error messages. When this switch is
used the only source lines output are those with errors.
lstands for list. This switch causes a full listing of the file to be generated. The output might look as follows:
|1. procedure E is 2. V : Integer; 3. funcion X (Q : Integer) | >>> Incorrect spelling of keyword "function" 4. return Integer; | >>> ";" should be "is" 5. begin 6. return Q + Q; 7. end; 8. begin 9. V := X + X; 10.end E;|
When you specify the -gnatv or -gnatl switches and
standard output is redirected, a brief summary is written to
stderr (standard error) giving the number of error messages and
warning messages generated.
bstands for brief. This switch causes GNAT to generate the brief format error messages to stderr (the standard error file) as well as the verbose format message or full listing (which as usual is written to stdout (the standard output file).
mstands for maximum. n is a decimal integer in the range of 1 to 999 and limits the number of error messages to be generated. For example, using -gnatm2 might yield
e.adb:3:04: Incorrect spelling of keyword "function" e.adb:5:35: missing ".." fatal error: maximum errors reached compilation abandoned
fstands for full. Normally, the compiler suppresses error messages that are likely to be redundant. This switch causes all error messages to be generated. In particular, in the case of references to undefined variables. If a given variable is referenced several times, the normal format of messages is
e.adb:7:07: "V" is undefined (more references follow)
where the parenthetical comment warns that there are additional
references to the variable
V. Compiling the same program with the
-gnatf switch yields
e.adb:7:07: "V" is undefined e.adb:8:07: "V" is undefined e.adb:8:12: "V" is undefined e.adb:8:16: "V" is undefined e.adb:9:07: "V" is undefined e.adb:9:12: "V" is undefined
qstands for quit (really "don't quit"). In normal operation mode, the compiler first parses the program and determines if there are any syntax errors. If there are, appropriate error messages are generated and compilation is immediately terminated. This switch tells GNAT to continue with semantic analysis even if syntax errors have been found. This may enable the detection of more errors in a single run. On the other hand, the semantic analyzer is more likely to encounter some internal fatal error when given a syntactically invalid tree.
In addition, if -gnatt is also specified, then the tree file is generated even if there are illegalities. It may be useful in this case to also specify -gnatq to ensure that full semantic processing occurs. The resulting tree file can be processed by ASIS, for the purpose of providing partial information about illegal units, but if the error causes the tree to be badly malformed, then ASIS may crash during the analysis.
In addition to error messages, which correspond to illegalities as defined in the Ada 95 Reference Manual, the compiler detects two kinds of warning situations.
First, the compiler considers some constructs suspicious and generates a warning message to alert you to a possible error. Second, if the compiler detects a situation that is sure to raise an exception at run time, it generates a warning message. The following shows an example of warning messages:
e.adb:4:24: warning: creation of object may raise Storage_Error e.adb:10:17: warning: static value out of range e.adb:10:17: warning: "Constraint_Error" will be raised at run time
GNAT considers a large number of situations as appropriate
for the generation of warning messages. As always, warnings are not
definite indications of errors. For example, if you do an out-of-range
assignment with the deliberate intention of raising a
Constraint_Error exception, then the warning that may be
issued does not indicate an error. Some of the situations for which GNAT
issues warnings (at least some of the time) are given in the following
list, which is not necessarily complete.
forloop that is known to be null or might be null
The following switches are available to control the handling of warning messages:
-gnatwa (activate all optional errors)
-gnatwA (suppress all optional errors)
-gnatwb (activate warnings on biased rounding)
-gnatwB (suppress warnings on biased rounding)
-gnatwc (activate warnings on conditionals)
-gnatwC (suppress warnings on conditionals)
-gnatwd (activate warnings on implicit dereferencing)
.allwill generate a warning. With this warning enabled, access checks occur only at points where an explicit
.allappears in the source code (assuming no warnings are generated as a result of this switch). The default is that such warnings are not generated. Note that -gnatwa does not affect the setting of this warning option.
-gnatwD (suppress warnings on implicit dereferencing)
-gnatwe (treat warnings as errors)
-gnatwf (activate warnings on unreferenced formals)
-gnatwF (suppress warnings on unreferenced formals)
-gnatwh (activate warnings on hiding)
-gnatwH (suppress warnings on hiding)
-gnatwi (activate warnings on implementation units).
withof an internal GNAT implementation unit, defined as any unit from the
Systemhierarchies that is not documented in either the Ada Reference Manual or the GNAT Programmer's Reference Manual. Such units are intended only for internal implementation purposes and should not be
with'ed by user programs. The default is that such warnings are generated This warning can also be turned on using -gnatwa.
-gnatwI (disable warnings on implementation units).
withof an internal GNAT implementation unit.
-gnatwl (activate warnings on elaboration pragmas)
-gnatwL (suppress warnings on elaboration pragmas)
-gnatwo (activate warnings on address clause overlays)
-gnatwO (suppress warnings on address clause overlays)
-gnatwp (activate warnings on ineffective pragma Inlines)
-gnatwP (suppress warnings on ineffective pragma Inlines)
-gnatwr (activate warnings on redundant constructs)
typ'Baseis the same as
Packwhen all components are placed by a record representation clause.
-gnatwR (suppress warnings on redundant constructs)
-gnatws (suppress all warnings)
gccback end. To suppress these back end warnings as well, use the switch
-win addition to -gnatws.
-gnatwu (activate warnings on unused entities)
with'ed and not referenced. In the case of packages, a warning is also generated if no entities in the package are referenced. This means that if the package is referenced but the only references are in
renamesdeclarations, a warning is still generated. A warning is also generated for a generic package that is
with'ed but never instantiated. In the case where a package or subprogram body is compiled, and there is a
withon the corresponding spec that is only referenced in the body, a warning is also generated, noting that the
withcan be moved to the body. The default is that such warnings are not generated. This switch also activates warnings on unreferenced formals (it is includes the effect of -gnatwf). This warning can also be turned on using -gnatwa.
-gnatwU (suppress warnings on unused entities)
A string of warning parameters can be used in the same parameter. For example:
Would turn on all optional warnings except for elaboration pragma warnings,
and also specify that warnings should be treated as errors.
gccbackend. It may be used in conjunction with -gnatws to ensure that all warnings are suppressed during the entire compilation process.