[Ada] Manipulation de "Bits"

Version imprimable

Bonsoir,

Voila j'aurais voulu savoir si en ADA la manipulation de bits était permise ?

Je m'explique mieux :

Donc, j'ai un nombre en en Base 10 : 4100, que je transforme en binaire
0001000000000100

Sur ce binaire, je fais 3 coupures :
0001 || 00 || 0000000100

Et en fait, mon objectif est de récupérer le nombre que chaque section contient. Dans cet exemple, cela serait (de droite à gauche) le : 4 , 0 et 1

Pour faire ceci, je fais :
4100 mod 1024 pour extraire le "4" (1024 car 2^10)
ensuite, je vire le 4 (pour obtenir: 0001 || 00 )
je divise donc 4100 par 1024
et ainsi de suite..

ok tout cela marche correctement, MAIS n'y a t-il pas en ADA un moyen de faire plus simple, comme par exemple en C/C++

il y a ce genre de chose
Code:

1 2 3 droite = nombre & 1023 ; milieu = (nombre & 3072) >> 10 ; gauche = (nombre & 61440) >> 12 ;
ou
Code:

1 2 3 4 5 6 struct champ_de_bits { unsigned int gauche : 4; /* Premier champ : 4 bits. */ unsigned int milieu : 2; /* Deuxième champ : 2 bits. */ unsigned int droite : 10; /* Dernier champ : 10 bits. */ };
En ADA une instruction pareille est-elle disponible ? Si oui peut-on m'expliquer comment faire ?

D'avance merci

il faut utiliser le type MOD et les opérateurs "or" "and" "xor"

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
with TEXT_IO;
use TEXT_IO;
procedure ANDOR is
   type MOD256 is mod 256;
   A : MOD256 := 6;
   B : MOD256 := 3;
begin
   PUT_LINE (MOD256'IMAGE(A or B));
   PUT_LINE (MOD256'IMAGE(A and B));
   if (A and 128) = 0 then
      PUT_LINE ("bit 7 de A = 0");
   else
      PUT_LINE ("bit 7 de A = 1");
   end if;
   B := B xor 1; -- bascule le bit 0 de B à 0
   PUT_LINE (MOD256'IMAGE(B));
 
 
end ANDOR;

Une solution utilisant unchecked_conversion, pourrait donner ça.
Oui unchecked_conversion c'est mal.

Bon, attention à la portablitité du machin quand même :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
with Unchecked_Conversion;
with Text_Io;
 
procedure Test is
  type Value_T is range 0 .. 16#FFFF#;
  for Value_T'Size use 16;
 
  Value : Value_T;
 
  type Field1_T is range 0 .. 16#F#;
  for Field1_T'Size use 4;
 
  type Field2_T is range 0 .. 16#3#;
  for Field2_T'Size use 2;
 
  type Field3_T is range 0 .. 16#3FF#;
  for Field3_T'Size use 10;
 
 
  type Record_T is
    record
      f1 : Field1_T;
      f2 : Field2_T;
      f3 : Field3_T;
    end record;
 
  for Record_T use
    record
      f1 at 0 range 12 .. 15;
      f2 at 0 range 10 .. 11;
      f3 at 0 range  0 ..  9;
    end record;
 
  Rec : Record_T;
 
  function Conv is new Unchecked_Conversion(Source => Value_T, 
                                            Targe  => Record_T);
 
begin
  Value := 2#0011010000001100#; -- f1 = 3 , f2 = 1 , f3 = 12
 
  Rec := Conv(Value);
 
  Text_Io.Put_Line("F1 = " & Field1_T'Image(Rec.f1) & 
                          "--  F2 = " & Field2_T'Image(Rec.f2) & 
                          "--  F3 = " & Field3_T'Image(Rec.f3));
 
end Test;