13.4 Enumeration Representation Clauses
1
[An enumeration_representation_clause
specifies the internal codes for enumeration literals.]
Syntax
2
enumeration_representation_clause ::=
for first_subtype_local_name use enumeration_aggregate;
3
enumeration_aggregate ::= array_aggregate
Name Resolution Rules
4
{expected type (enumeration_representation_clause
expressions) [partial]} The
enumeration_aggregate
shall be written as a one-dimensional
array_aggregate,
for which the index subtype is the unconstrained subtype of the enumeration
type, and each component expression is expected to be of any integer
type.
4.a
Ramification: The “full coverage
rules” for aggregates applies. An others
is not allowed — there is no applicable index constraint in this
context.
Legality Rules
5
The first_subtype_local_name
of an enumeration_representation_clause shall
denote an enumeration subtype.
5.a
Ramification: As for all type-related
representation items, the local_name is required
to denote a first subtype.
6/2
{
AI95-00287-01}
Each component of the array_aggregate
shall be given by an expression rather than
a <>. The
expressions expressions
given in the
array_aggregate shall be static,
and shall specify distinct integer codes for each value of the enumeration
type; the associated integer codes shall satisfy the predefined ordering
relation of the type.
6.a
Reason: Each value of the enumeration
type has to be given an internal code, even if the first subtype of the
enumeration type is constrained to only a subrange (this is only possible
if the enumeration type is a derived type). This “full coverage”
requirement is important because one may refer to Enum'Base'First and
Enum'Base'Last, which need to have defined representations.
Static Semantics
7
{aspect of representation
(coding) [partial]} {coding
(aspect of representation)} An
enumeration_representation_clause
specifies the
coding aspect of representation.
{internal
code} The coding consists of the
internal
code for each enumeration literal, that is, the integral value used
internally to represent each literal.
Implementation Requirements
8
For nonboolean enumeration types, if the coding is
not specified for the type, then for each value of the type, the internal
code shall be equal to its position number.
8.a
Reason: This default representation is
already used by all known Ada compilers for nonboolean enumeration types.
Therefore, we make it a requirement so users can depend on it, rather
than feeling obliged to supply for every enumeration type an enumeration
representation clause that is equivalent to this default rule.
8.b
Discussion: For boolean types, it is
relatively common to use all ones for True, and all zeros for False,
since some hardware supports that directly. Of course, for a one-bit
Boolean object (like in a packed array), False is presumably zero and
True is presumably one (choosing the reverse would be extremely unfriendly!).
Implementation Advice
9
{recommended
level of support (enumeration_representation_clause) [partial]}
The recommended level of support for
enumeration_representation_clauses
is:
10
- An implementation should support at
least the internal codes in the range System.Min_Int..System.Max_Int.
An implementation need not support enumeration_representation_clauses
for boolean types.
10.a
Ramification: The implementation may
support numbers outside the above range, such as numbers greater than
System.Max_Int. See AI83-00564.
10.b
Reason: The benefits of specifying the
internal coding of a boolean type do not outweigh the implementation
costs. Consider, for example, the implementation of the logical operators
on a packed array of booleans with strange internal codes. It's implementable,
but not worth it.
10.c/2
Implementation Advice:
The recommended level of support for
enumeration_representation_clauses should
be followed.
11/1
11 {
8652/0009}
{
AI95-00137-01}
Unchecked_Conversion may be used to query the internal codes used for
an enumeration type. The attributes of the type, such as Succ, Pred,
and Pos, are unaffected by the
enumeration_representation_clause representation_clause.
For example, Pos always returns the position number,
not the internal
integer code that might have been specified in
an
enumeration_representation_clause a
representation_clause.
11.a
Discussion:
Suppose the enumeration type in question is derived:
11.b
type T1 is (Red, Green, Blue);
subtype S1 is T1 range Red .. Green;
type S2 is new S1;
for S2 use (Red => 10, Green => 20, Blue => 30);
11.c/1
{
8652/0009}
{
AI95-00137-01}
The
enumeration_representation_clause representation_clause
has to specify values for all enumerals, even ones that are not in S2
(such as Blue). The Base attribute can be used to get at these values.
For example:
11.d
for I in S2'Base loop
... -- When I equals Blue, the internal code is 30.
end loop;
11.e
We considered allowing or requiring “for
S2'Base use ...” in cases like this, but it didn't seem
worth the trouble.
Examples
12
Example of an enumeration
representation clause:
13
type Mix_Code is (ADD, SUB, MUL, LDA, STA, STZ);
14
for Mix_Code use
(ADD => 1, SUB => 2, MUL => 3, LDA => 8, STA => 24, STZ =>33);
Extensions to Ada 83
14.a
{
extensions to Ada 83}
As
in other similar contexts, Ada 95 allows expressions of any integer type,
not just expressions of type
universal_integer, for the component
expressions in the
enumeration_aggregate.
The preference rules for the predefined operators of
root_integer
eliminate any ambiguity.
14.b
For portability, we now require that the default
coding for an enumeration type be the “obvious” coding using
position numbers. This is satisfied by all known implementations.
Wording Changes from Ada 95
14.c/2
{
8652/0009}
{
AI95-00137-01}
Corrigendum: Updated to reflect that we
no longer have something called representation_clause.14.d/2
{
AI95-00287-01}
Added wording to prevent the use of <> in
a enumeration_representation_clause. (<>
is newly added to array_aggregates.)
Sponsored by Ada-Europe