Annotated Ada Reference ManualLegal Information
Contents   Index   References   Search   Previous   Next 

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
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.
NOTES
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.)

Contents   Index   References   Search   Previous   Next 
Ada-Europe Sponsored by Ada-Europe