Re: Flags in Ada?

[stt@dsd.camb.inmet.com (Tucker Taft)]

In article <38ob12$7po@gnat.cs.nyu.edu>, Robert Dewar <dewar@cs.nyu.edu> wrote:
> ...
>Note that in Ada 9X, yet a third possibility is to use unsigned (modular)
>numbers, which also have logical operations defined, with constant values
>for the bits. This of course is even more low-level (and C-like, although
>in C, bit specs are being more widely used these days), but may be
>appropriate for algorithms where arithmetic and logical operations are
>intermixed in wierd ways.

One advantage of the modular types in Ada 9X is that they are "strong" 
types, just like all Ada numeric types.  This means that you can define
a "mask" for a particular modular type and be sure it is only
used to "and" with values of that type.  For example:

    type Control_Byte is mod 2**8;
    Start_Read_Bit  : constant Control_Byte := 2#1000_0000#;
    Start_Write_Bit : constant Control_Byte := 2#0100_0000#;
    Reset_All       : constant Control_Byte := 2#0000_0001#;

    type Status_Byte is mod 2**8;
    Char_Ready_Bit  : constant Status_Byte := 2#1000_0000#;
    Char_Mask       : constant Status_Byte := 2#0111_1111#;

    type Device_Type is record
        Status : Status_Byte;
        Control : Control_Byte;
    end record;
    pragma Convention(Assembler, Device_Type);

    Console : Device_Type;
    pragma Import(Assembler, Console);
    for Console'Address use 16#FFFF_F200#;
    pragma Volatile(Console);

 begin
   -- Reset console, then initiate read.
    Console.Control := Reset_All;
    Console.Control := Start_Read_Bit;

   -- busy wait until character ready, and then get character
    while (Console.Status and Char_Ready_Bit) = 0 loop
      -- busy wait (could keep a count to avoid an infinite loop)
        null;
    end loop;
    Next_Char := Console.Status and Char_Mask;

   ... -- etc.

Although record rep clauses would work just as well, the above
approach illustrates how modular types can be used, while still
getting a measure of safety.  The compiler will complain if you
use a Status_Byte mask on the Control register, or vice-versa.
Also, Ada's binary notation comes in quite handy for this kind
of bit twiddling.  In some ways using masks defined in binary
notation is more "graphic" than record rep clauses, making them
a little "bit" easier to read. ;-)

-Tucker Taft  stt@inmet.com
Intermetrics, Inc.