Syntax:
pragma Ordered (enumeration_first_subtype_LOCAL_NAME);
Most enumeration types are from a conceptual point of view unordered. For example, consider:
type Color is (Red, Blue, Green, Yellow);
By Ada semantics Blue > Red and Green > Blue,
but really these relations make no sense; the enumeration type merely
specifies a set of possible colors, and the order is unimportant.
For unordered enumeration types, it is generally a good idea if clients avoid comparisons (other than equality or inequality) and explicit ranges. (A `client' is a unit where the type is referenced, other than the unit where the type is declared, its body, and its subunits.) For example, if code buried in some client says:
if Current_Color < Yellow then ... if Current_Color in Blue .. Green then ...
then the client code is relying on the order, which is undesirable.
It makes the code hard to read and creates maintenance difficulties if
entries have to be added to the enumeration type. Instead,
the code in the client should list the possibilities, or an
appropriate subtype should be declared in the unit that declares
the original enumeration type. E.g., the following subtype could
be declared along with the type Color:
subtype RBG is Color range Red .. Green;
and then the client could write:
if Current_Color in RBG then ... if Current_Color = Blue or Current_Color = Green then ...
However, some enumeration types are legitimately ordered from a conceptual point of view. For example, if you declare:
type Day is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
then the ordering imposed by the language is reasonable, and clients can depend on it, writing for example:
if D in Mon .. Fri then ... if D < Wed then ...
The pragma `Ordered' is provided to mark enumeration types that are conceptually ordered, alerting the reader that clients may depend on the ordering. GNAT provides a pragma to mark enumerations as ordered rather than one to mark them as unordered, since in our experience, the great majority of enumeration types are conceptually unordered.
The types Boolean, Character, Wide_Character,
and Wide_Wide_Character
are considered to be ordered types, so each is declared with a
pragma Ordered in package Standard.
Normally pragma Ordered serves only as documentation and a guide for
coding standards, but GNAT provides a warning switch `-gnatw.u' that
requests warnings for inappropriate uses (comparisons and explicit
subranges) for unordered types. If this switch is used, then any
enumeration type not marked with pragma Ordered will be considered
as unordered, and will generate warnings for inappropriate uses.
Note that generic types are not considered ordered or unordered (since the template can be instantiated for both cases), so we never generate warnings for the case of generic enumerated types.
For additional information please refer to the description of the `-gnatw.u' switch in the GNAT User’s Guide.