A pragma is a compiler directive.
There are language-defined pragmas that give instructions for optimization,
listing control, etc. An implementation may support additional (implementation-defined)
are only allowed at the following places in a program:
At any place where the syntax rules allow
a construct defined by a syntactic category whose name ends with “declaration
”, or “alternative
or one of the syntactic categories variant
but not in place of such a construct if the construct is required, or
is part of a list that is required to have at least one such construct.
Additional syntax rules and placement restrictions
exist for specific pragmas.
specific to a pragma
is an identifier or reserved word that is used
in a pragma argument with special meaning for that pragma.
If an implementation does not recognize the name
of a pragma
then it has no effect on the semantics of the program. Inside such a
only rules that apply are the Syntax Rules.
that appears at the place of an executable construct is executed. Unless
otherwise specified for a particular pragma, this execution consists
of the evaluation of each evaluable pragma argument in an arbitrary order.
The implementation shall give a warning message for
an unrecognized pragma name.
An implementation may provide implementation-defined
pragmas; the name of an implementation-defined pragma shall differ from
those of the language-defined pragmas.
An implementation may ignore an unrecognized pragma
even if it violates some of the Syntax Rules, if detecting the syntax
error is too complex.
Normally, implementation-defined pragmas should
have no semantic effect for error-free programs; that is, if the implementation-defined
pragmas in a working program are replaced with unrecognized pragmas,
the program should still be legal, and should still have the same semantics.
Normally, an implementation
should not define pragmas that can make an illegal program legal, except
used to complete a declaration;
used to configure the environment by adding, removing, or replacing library_item
The forms of List,
Page, and Optimize pragma
are as follows:
Other pragmas are defined throughout this International
Standard, and are summarized in Annex L
List takes one of the identifier
On or Off as the single argument. This pragma is allowed anywhere a pragma
is allowed. It specifies that listing of the compilation is to be continued
or suspended until a List pragma
with the opposite argument is given within the same compilation. The
is always listed if the compiler is producing a listing.
Page is allowed anywhere a pragma
is allowed. It specifies that the program text which follows the pragma
should start on a new page (if the compiler is currently producing a
Optimize takes one of the identifier
Time, Space, or Off as the single argument. This pragma
is allowed anywhere a pragma
is allowed, and it applies until the end of the immediately enclosing
declarative region, or for a pragma
at the place of a compilation_unit
to the end of the compilation
It gives advice to the implementation as to whether time or space is
the primary optimization criterion, or that optional optimizations should
be turned off. It is implementation defined how this advice is followed.
Examples of pragmas:
pragma List(Off); -- turn off listing generation
pragma Optimize(Off); -- turn off optional optimizations
pragma Pure(Rational_Numbers); -- set categorization for package
Message => "Nonexistent file"); -- assert file exists
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe