Re: A question re meaning/use of the "for ... use ..."

["Randy Brukardt" <randy@rrsoftware.com>]

"Keith Thompson" <kst-u@mib.org> wrote in message
news:ln1xdygaf2.fsf@nuthaus.mib.org...
> Here's an example where it doesn't work:
...

If you want an unsigned type, then use a modular type:
    type Enum_Rep is mod 2**Enum'Size;
    for Enum_Rep'Size use Enum'Size;

I know that you're now going to say that that doesn't work for a signed
representation, but that's a red herring. You have the know whether the
representation is signed or unsigned, even for your hypothetical From_Rep
attribute, because you have to decide on what sort of type to put it into.
Otherwise, you're at risk of raising Constraint_Error. (On a typical
implementation, there are modular values that don't fit into any signed
type, and of course negative values don't fit into any modular type.) Even a
non-static universal expression isn't safe: it can raise Constraint_Error
for modular values that aren't in any signed type. One example:

    generic
         type Something is (<>);
    package P is
         ...
    end P;
    package body P
         ...
         if Something'Pos(Something'Last) > 10 then -- (!)
         ...
    end P;

The expression marked (!) can (and will on many implementations) raise
Constraint_Error, because Something'Pos(Something'Last) is outside of the
range of Root_Integer.

So you really have to know which you are dealing with. For enumeration
representations, assuming modular is probably the best option, as you are
usually dealing with bit patterns.

But this whole issue comes from people trying to use enumeration
representations for purposes for which they are not intended. They're only
intended to be used for *external* representations, which means that the
program itself has no reason to be concerned with them. The program should
use the internal representation.

If you really need a discontiguous counting type, that's something that Ada
doesn't provide and you should program it yourself. That's a very rare need;
you really need to think carefully if you really need such a type.

The issue is very similar to Bit_Order, which only has to do with the way
bits are numbered in the program; it has nothing to do with the bit or byte
order in the external world. But people keep hoping that it would be,
because that would make someone else solve their hard problems.

                     Randy.