Re: Enumeration representation

["Matthew Heaney" <matthew_heaney@acm.org>]

In article <37D8E3BC.175DB72C@newtech.it> , Alex <busato@newtech.it>  wrote:

> I've written the following example program for testing enumeration
> represetantion clause:
>
> with Ada.Text_IO; use Ada.Text_IO;
>
>
> procedure MainEnum is
>
>       type Status is (a,b,c,d,e);
>       pragma Discard_Names(Status);

Why did you use Discard_Names?

>       for Status use
>        ( a => 0,
>          b => 20,
>          c => 400,
>          d => 800,
>          e => 1600);
>
>        S : Status;
> begin
>       S := b;
>       Put(" => " & S'img);

The image of literal B is of course "B".  But I don't know what 'Img will
return if you also use pragma Discard_Names.

> end MainEnum;
>
> I've compiled it with Gnat (the latest version)
> the output of program is 1 but I was expecting another value : 20.

GNAT seems to be displaying the value of T'Pos.

You want to underlying representation.  If so, you'll have use
Unchecked_Conversion to convert the literal to an integer, and then display
that.

An alternative is to use the GNAT-specific attribute 'Enum_Rep (I think
that's what it's called).

But if you really want to display 20, then why did you use an enumeration
type at all?  Why not do this:

  type Status_Type is range 0 .. 1600;

  A : constant Status_Type := 0;
  B : constant Status_Type := 20;     -- 20 or 200?
  C : constant Status_Type := 400;
  D : constant Status_Type := 800;
  E : constant Status_Type := 1600;

This is more or less equivalent to what you had using an enumeration type.
The difference is that Status_Type'Image (B) returns " 20", which is what
you wanted.


> Does  Gnat support this clause?

The pragma Discard_Names?  Look in Annex M of the GNAT User's Guide or
Reference Manual.

Why do you need that pragma anyway?  Do you have some storage restrictions?


> Did I use this clause badly?

I think so.  Give us some more specific information about what you're trying
to do.

> Thank you very much,

You're very welcome.

Matt