Re: Bit operations in Ada

[Ludovic Brenta <ludovic@ludovic-brenta.org>]

Dennis Hoppe <dennis.hoppe@hoppinet.de> writes:
> Hello,
>
> I'm new to Ada and bitwise operations is a new challenge in this
> realm. My objective is to manipulate some bit strings in Ada,
> especially:
>
> a) addition/subtraction mod 2**n,
> b) change bits directly (e.g, via array access)
> c) shift operations
> d) rotate operations
> e) and, xor, not, or
>
> I started with an array of booleans of size 2**n, that provides neat
> access to individual bits by means of an index. Unfortunately,
> addition/subtraction mod 2**n is not supported, but essential for me.
>
> Next, I tried modular types (mod 2**n), but ended up with not having
> direct access to individual bits. My last attempt was to use
> Interfaces.Unsinged_n. It is a solid package that simplifies the usage
> of bitwise operations for me by adding shift and rotate
> operations. Addition modulo n works well, but I have to dispense with
> direct bit access, too.
>
> So, what is coming next? Should I go with Interfaces.Unsinged_n and
> provide a suitable function that converts the used type into an array
> of boolean? Maybe, I'm ought to use directly an array of boolean and
> try to convert the array into an Unsigned_n; if required to add two
> bit-strings.

IIUC, modular types such as Interfaces.Unsigned_n provide all
operations you need except for direct bit access.

Solution 1:

You can access bits using "and", "or", "not", "**" and "=" like so:

declare
  A : Interfaces.Unsigned_32 := 2#00000000000000000000000000000000#;
  use type Interfaces.Unsigned_32;
  Is_Bit_8_Set : Boolean;
begin
  A := A or 2 ** 5;  -- Set bit 5 to 1
  Is_Bit_8_Set := A and 2 ** 8 /= 0; -- read bit 8
end;

Solution 2:

If this is too difficult or error-prone, you could wrap that into
inlined subprograms like so:

type Bit_Number is range 0 .. 31;

procedure Set (Bit      : in Bit_Number;
               In_Value : in out Interfaces.Unsigned_32;
               To       : in     Boolean) is
   use type Interfaces.Unsigned_32;
begin
   if To = True then
      In_Value := In_Value or 2 ** Bit;
   else
      In_Value := In_Value and not 2 ** Bit;
   end if;
end Set;

function Is_Set (Bit      : in Bit_Number;
                 In_Value : in Interfaces.Unsigned_32) return Boolean is
   use type Interfaces.Unsigned_32;
begin
   return In_Value and 2 ** Bit /= 0;
end Is_Set;

Solution 3:

Another alternative is Unchecked_Conversion:

type Bit_Number is range 0 .. 31;
type Bit_Field is array (Bit_Number) of Boolean;
pragma Pack (Bit_Field);
function To_Bit_Field is
  new Ada.Unchecked_Conversion (Source => Interfaces.Unsigned_32,
                                Target => Bit_Field);
function To_Unsigned_32 is
  new Ada.Unchecked_Conversion (Source => Bit_Field,
                                Target => Interfaces.Unsigned_32);

procedure Set (Bit      : in Bit_Number;
               In_Value : in out Interfaces.Unsigned_32;
               To       : in     Boolean) is
   Field : Bit_Field := To_Bit_Field (In_Value);
begin
   Field (Bit) := To;
   In_Value := To_Unsigned_32 (Field);
end Set;

HTH

-- 
Ludovic Brenta.