Re: Flags in Ada?

[ncohen@watson.ibm.com (Norman H. Cohen)]

In article <38mle1$e3m@gnat.cs.nyu.edu>, dewar@cs.nyu.edu (Robert Dewar)
writes: 
|> well to me Dave's approach seems overkill
|>
|> I really don't see the objection to a packed record.

The original question asked how to provide for logical operations among
corresponding flags in different flag sets.  Packed arrays of Booleans
provide this and packed records of Booleans do not, except with tedious
explicit programming: 

   generic
      with Op (Left, Right: Boolean) return Boolean;
   function Packed_Record_Op;

   function Packed_Record_Op
      (Left, Right: Packed_Record_Type) return Packed_Record_Type is
   begin
      return
         ( Op(Left.Component_1, Right.Component_1),
             ...,
           Op(Left.Component_N, Right.Component_N) );
   end Packed_Record_Op;

   function "and" is new Packed_Record_Op("and");
   function "or"  is new Packed_Record_Op("or");
   function "xor" is new Packed_Record_Op("xor");

   function "not" (Right: Packed_Record_Op) return Packed_Record_Op is
   begin
      return (not Right.Component_1, ..., not Right.Component_N);
   end "not";

Still, if you require explicit control over the mapping of Booleans in
such an array to specific bits in a word (for the sake of a low-level
external interface), only record representation clauses can provide them.

It is unfortunate that there is no portable way to indicate whether,as
index values increase, the positions of components in a packed array of
Booleans go from LSB to MSB or MSB to LSB.

--
Norman H. Cohen    ncohen@watson.ibm.com