Re: Enumeration representation

[Keith Thompson <kst@cts.com>]

Robert Dewar <robert_dewar@my-deja.com> writes:
> > Even an attribute that gives an integer type guaranteed to be
> > Unchecked_Conversion-compatible with a given enumeration type would
> > have helped, in a ugly sort of way. (I'm assuming such a type has to
> > be of the same size and signedness as the (internal representation
> > of the) enumeration type.
> 
> It's easy enough to define the type you need ...
> 
> > Unless the semantics of Unchecked_Conversion between discrete types
> > of different sizes are well-defined -- I've never been quite clear
> > on that point.)
> 
> No, the sizes should be the same, but this is easy enough to
> arrange. In GNAT everything is fine if sizes are different,
> you just get the equivalent of a type conversion without
> any checks, but not all compilers (and certainly not the RM)
> guarantee this.

Hmm.  Ok, suppose you have an enumeration type Foo.  It may or may not
have an enumeration representation clause; if it does, it may or may
not assign negative values to some of the literals.  How do you
declare an integer type that's guaranteed to be the same size and
signedness?

You could do something like this:

    type Equivalent_Type is range -2**Foo'Size .. 2**Foo'Size - 1;
    for Equivalent_Type'Size use Foo'Size;

but I'm not sure that's enough.  (I'm assuming 2's-complement; there
are ugly but portable ways to avoid that assumption.)  For example, it
doesn't distinguish between the following two cases:

    type Unsigned_Byte is (B0, B1, ..., B255);
    for Unsigned_Byte use (0, 1, ..., 255); -- a confirming rep clause
    for Unsigned_Byte'Size use 8;

and

    type Signed_Byte is (BM128, BM127, ..., BM1, B0, B1, ..., B127);
    for Signed_Byte use (-128, -127, ..., -1, 0, 1, ..., 127);
    for Signed_Byte'Size use 8;

If you could get at the internal representation, you could use

    type Equivalent_Type is range Foo'Enum_Rep(Foo'First) ..
                                  Foo'Enum_Rep(Foo'Last);
    for Equivalent_Type'Size use Foo'Size;

but of course the language doesn't provide that.

In real life, the programmer can usually make use of detailed
knowledge about any enumeration representation clause, but it would be
nice not to have to.

-- 
Keith Thompson (The_Other_Keith) kst@cts.com  <http://www.ghoti.net/~kst>
San Diego Supercomputer Center           <*>  <http://www.sdsc.edu/~kst>
"Oh my gosh!  You are SO ahead of your time!" -- anon.