Re: Endianness independance

[Stephen Leake <Stephen.A.Leake@nasa.gov>]

"Marin David Condic" <mcondic.auntie.spam@acm.org> writes:

> Well, but if hardware is not standardized, then why would you expect
> languages to be standardized? (With respect to data representations.)

The point is that Ada provides a _standard_, _single_ representation
clause that works for both kinds of hardware:

--  Abstract :
--
--  Define constants to reflect hardware bit and word endianness in
--  record representation clauses. Obviously, this file is highly
--  system-dependent.
--
with System;
package SAL.Endianness is
   pragma Pure;

   --  This is for gnat on a Mongoose processor
   System_Name : constant System.Name := System.SYSTEM_NAME_GNAT;

   type Byte_Order_Type is (Big_Endian, Little_Endian);
   Byte_Order : constant Byte_Order_Type := Big_Endian;

   --  The Mongoose documentation numbers bits with LSB = 0. However,
   --  the byte order is Big_Endian, so the Ada compiler assumes bits
   --  are numbered with MSB = 0, since that allows representation
   --  clauses with fields that cross natural boundaries.

   Bit_Order      : constant := -1; -- 1 or -1
   High_Bit_First : constant :=  1; -- 0 or  1
   Low_Bit_First  : constant :=  0; -- 1 or  0

   --  Use one of these, corresponding to the natural size of the
   --  record you are laying out.
   LSBit_8        : constant :=  7; -- 0 or  7
   LSBit_16       : constant := 15; -- 0 or 15
   LSBit_32       : constant := 31; -- 0 or 31
   LSBit_56       : constant := 55; -- 0 or 55

end SAL.Endianness;

package Foo is
   type B_Field_Control_Type is record
      --  [1] Table 4.2.8
      Spare_1 : Interfaces_More.Unsigned_29;
      Data    : Interfaces_More.Unsigned_3;
   end record;

   for B_Field_Control_Type use record
      Spare_1 at 0 range
         Low_Bit_First  * (LSBit_32 + Bit_Order *  3) + High_Bit_First * (LSBit_32 + Bit_Order * 31) ..
         High_Bit_First * (LSBit_32 + Bit_Order *  3) + Low_Bit_First  * (LSBit_32 + Bit_Order * 31);

      Data at 0 range
         Low_Bit_First  * (LSBit_32 + Bit_Order *  0) + High_Bit_First * (LSBit_32 + Bit_Order *  2) ..
         High_Bit_First * (LSBit_32 + Bit_Order *  0) + Low_Bit_First  * (LSBit_32 + Bit_Order *  2);

   end record;
   for B_Field_Control_Type'Size use 32;
end foo;

In C, you have to use the preprocessor to get this.

In Ada, it would be nice if you could say:

for B_Field_Control_Type'Bit_Order use Little_Bit_First;

But you can't, because the compiler would have to know whether the
data is "naturally" 32, 16, or 8 bit (that's what the "LSBit_32" is
for above).

-- 
-- Stephe