Re: Bit manipulation

["Steve" <nospam_steved94@comcast.net>]

"Maurizio" <maurizio.ferracini@gmail.com> wrote in message 
news:211db0ae.0502070437.54add641@posting.google.com...
> hi, i need two hint:
>
> i need to acces to a 32 bit word (Interfaces.Unsigned_32).
> how i can do to take the three m.s.bit? (30,31,32)
>
What do you mean by "take the three m.s.bit?"

My guess is you either want to determine the value of the individual bits or 
you want to mask out the other bits.

The following example should do either:

  input_value : Interfaces.Unsigned_32;
  masked_value : Interfaces.Unsigned_32;
  bit30 : Boolean;
  bit31 : Boolean;
  bit32 : Boolean;
begin
  input_value := Get_Value( ... ); -- some function returning the value you 
want to mask
  masked_value = input_value and 16#E000_0000#;
  bit30 := (input_value and 16#2000_0000#) /= 0;
  bit31 := (input_value and 16#4000_0000#) /= 0;
  bit32 := (input_value and 16#8000_0000#) /= 0;

Note: You could give the values in binary:
  2#0010_0000_0000_0000_0000_0000_0000_0000#
  is the same as:
  16#20000000#


> second, i need to send the 32 bit word over a Tcp connection to a C
> program, but
> socket work with usigned 8 bit word, so i need to split the 32 bit in
> 4 8bit word,
> and when i read from the socket take 4 8bit word and combine in a 32
> word.

You should look beware of "network byte order" when you do this mapping. 
The built in functions "htonl" and "ntohl" swizzle the bytes into network 
byte order (if they are available).  Network byte order is basically big 
endian.  I have seen a lot of code that ignores the standards for byte 
ordering, but the socket API's I have seen obey.

Here's a snippet of code I use to swizzle the 32 bit floating point value 
into a 32 bit unsigned long value:

      TYPE aByte IS MOD 256;

      FOR aByte'SIZE USE 8;

      TYPE aByteArray IS ARRAY( Positive RANGE <> ) OF aByte'SIZE ;

      PRAGMA PACK( aByteArray );

      FUNCTION hftonl( value : s_float ) RETURN u_long IS
         TYPE aFourBytes IS NEW aByteArray(1..4);
         FUNCTION Conv IS NEW Unchecked_Conversion( aFourBytes, u_long );
         FUNCTION Conv IS NEW Unchecked_Conversion( s_float, aFourBytes );
         temp : aFourBytes := Conv( value );
      BEGIN
         RETURN Conv( aFourBytes'( temp(4), temp(3), temp(2), temp(1) ) );
      END hftonl;

I hope this helps,

Steve
(The Duck)

> i see that Ada.Unchecked_Conversion work (in an ada client/server test
> program)  but is correct?
>
> --com_buffer_type is an array of  128 32bit word
>
> subtype Datas is Ada.Streams.Stream_Element_Array(1..512); --128*4
>
> function To_Raw is
>   new Ada.Unchecked_Conversion
>      (
>      Source => Com_Buffer_Type,  --Interfaces.Unsigned_32
>      Target => Datas);     --Stream_Element is mod 2 **
> Standard'Storage_Unit
>
>   function From_Raw is
>   new Ada.Unchecked_Conversion
>      (
>      Source => Datas,
>      Target => Com_Buffer_Type);
>
> ----------------------
> best regards
> Maurizio