Re: Ada 83 - avoiding unchecked conversions.

[mheaney@ni.net (Matthew Heaney)]

>Ensco Vendor wrote:
>> 
>> we have two 16 bit integers which we need to assemble into a single 32
>> bit integer (one is high order, the other low order).  We wish to avoid
>> unchecked conversion if we can.  Is there a standard accepted way of
>> doing this?

Unchecked conversion is the accepted way of doing this:

function To_Integer_32 (Low, High : Integer_16)
   return Integer_32 is

   type Integer_32_Record is
      record
         High_Order : Integer_16;
         Low_Order : Integer_16;
      end record;

   for Integer_32_Record use
      record
         High_Order at 0 range 16 .. 32;
         Low_Order at 0 range 0 .. 15;
      end record;

   for Integer_32_Record'Size use 32;

   function To_Integer_32 is 
      new Unchecked_Conversion (
         Integer_32_Record, 
         Integer_32);

   The_Record : constant Integer_32_Record := (
      High_Order => High, 
      Low_Order => Low);
begin
   return To_Integer_32 (The_Record);
end;

Because the source and target types have the same size, this should be
completely portable.

Some shops have the rule "Thou shalt not use Unchecked_Conversion."  But
this is silly; use it when it makes sense.

The proper place to use Unchecked_Conversion is at the interface boundary
of the sytem.  That seems to be the case for you, because you're
manipulating types whose size is known explicitly (16 and 32 bit integers).

--------------------------------------------------------------------
Matthew Heaney
Software Development Consultant
mheaney@ni.net
(818) 985-1271