Bit manipulation/fr

│ Deutsch (de) │ English (en) │ français (fr) │

Opération masquées

Ceci est une approche bas niveau basique pour manier les manipulation de bit. Le principale avantage est que les opérations peuvent être réalisées sur un groupes de bits en une seule fois. Mais l'utilisateur doit faire face à ces opérations par lui-même. Un autre problème est l'intervalle maximal des valeurs utilisées dans les paramètres de fonction. Il faut donc séparer les implémentations de chaque type ordinal pour de meilleures performances (contrairement à ce qui peut être fait en C en utilisant le préprocesseur).

(NdT : une solution peut résider dans l'emploi de fonctions génériques, non développées ici.)

procedure ClearBit(var Value: QWord; Index: Byte);
begin
  Value := Value and ((QWord(1) shl Index) xor High(QWord));
end;

procedure SetBit(var Value: QWord; Index: Byte);
begin
  Value:=  Value or (QWord(1) shl Index);
end;

procedure PutBit(var Value: QWord; Index: Byte; State: Boolean); 
begin
  Value := (Value and ((QWord(1) shl Index) xor High(QWord))) or (QWord(State) shl Index);
end;

function GetBit(Value: QWord; Index: Byte): Boolean;
begin
  Result := ((Value shr Index) and 1) = 1;
end;

Enregistrement bit-paqueté (Bitpacked)

FPC a une extension utile qui permet non seulement le paquetage des enregistrements par octet mais aussi le paquetage par bit. Ceci permet de définir non seulement des structures de bits en utilisant le type booléen ou des intervalles 0..1 mais aussi des champs à n états ou n-bits dans des enregistrements p.ex. le type intervalle 0..3 pour 2 bits. L'utilisation conjointe d'une telle structure de bits et d'un enregistrement avec variante permet d'accéder à la mémoire soit par octet soit par bit individuel.

TByteBits = bitpacked record
  Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7: Boolean;
end;

TByteEx = packed record
  case Integer of
    0: (ByteAccess: Byte);  
    1: (BitAccess: TByteBits);
end;

TSomeBitLevelStructure = bitpacked record
  OneBit: 0..1;
  TwoBits: 0..3;
  FourBits: 0..15;
  EightBits: 0..255
end;

NB : on accède au bit via des identificateurs.

Le paquetage par bit peut être contrôlé en utilisant la directive $BITPACKING.

Type ensemble

Parce que les ensembles sont basiquement des tableaux de tous les états qui sont des types booléens, il est donc possible de les utiliser comme tableaux de bits. Mais cela nécessite l'emploi de la directive de compilation $PACKENUM pour modifier la taille de l'ensemble. Il y aussi certaines limitations sur la taille maximale d'un ensemble.

{$packset 1}
{$packenum 1}

type
  TByteBits = set of (Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7);

TBits

Cette classe fait partie de la bibliothèque RTL de FPC, contenue dans l'unité Classes et s'emploie de manière similaire à celle de Delphi. Elle fournit seulement quelques méthodes pour les manipulations de bits.

   TBits = class(TObject)
   public
      constructor Create(TheSize : longint = 0); virtual;
      destructor Destroy; override;
      function  GetFSize : longint;
      procedure SetOn(Bit : longint);
      procedure Clear(Bit : longint);
      procedure Clearall;
      procedure AndBits(BitSet : TBits);
      procedure OrBits(BitSet : TBits);
      procedure XorBits(BitSet : TBits);
      procedure NotBits(BitSet : TBits);
      function  Get(Bit : longint) : boolean;
      procedure Grow(NBit : longint);
      function  Equals(Obj : TObject): Boolean; override; overload;
      function  Equals(BitSet : TBits) : Boolean; overload;
      procedure SetIndex(Index : longint);
      function  FindFirstBit(State : boolean) : longint;
      function  FindNextBit : longint;
      function  FindPrevBit : longint;

      { functions and properties to match TBits class }
      function OpenBit: longint;
      property Bits[Bit: longint]: Boolean read get write SetBit; default;
      property Size: longint read FBSize write setSize;
   end;

NB :

• Pas de limitation de taille comme avec les ensembles,
• les bits sont accessibles uniquement de manière ordinale.

Propriété enregistrement et valeur index

Une autre implémentation intéressante des structures alignées sur les bits peur être utilisée avec la capacité des enregistrements avancés (FPC 2.6.0+). Pour toutes les propriétés, vous devez utiliser un accesseur en écriture et un en lecture qui peuvent gérer les manipulations générales des bits et définir l'index qui est transmis à ces méthodes. Pour plus d'informations, reportez-vous aux propriétés indexées. Parce que l'index de propriété est unique, il a été divisé en deux paramètres pour décrire, la position et la taille de la valeur de bit. Dans le cas de l'exemple suivant, le décalage peut être de 0..255 et la taille de la valeur 0..255 bits. Un autre problème est que vous devez vous assurer que les composants définis dans la structure ne se chevaucheront pas.

{$mode delphi}

  TSomeBitStructure = record
  private
    RawData: Word;
    function GetBits(const AIndex: Integer): Integer; inline;
    procedure SetBits(const AIndex: Integer; const AValue: Integer); inline;
  public
    // High byte of index offset, low byte of index is bit count
    property OneBit: Integer index $0001 read GetBits write SetBits;
    property TwoBits: Integer index $0102 read GetBits write SetBits;
    property FourBits: Integer index $0304 read GetBits write SetBits;
    property EightBits: Integer index $0708 read GetBits write SetBits;
  end;

{$OPTIMIZATION ON}
{$OVERFLOWCHECKS OFF}
function TSomeBitStructure.GetBits(const AIndex: Integer): Integer;
var
  Offset: Integer;
  BitCount: Integer;
  Mask: Integer;
begin
  BitCount := AIndex and $FF;
  Offset := AIndex shr 8;
  Mask := ((1 shl BitCount) - 1);
  Result := (RawData shr Offset) and Mask;
end;

procedure TSomeBitStructure.SetBits(const AIndex: Integer; const AValue: Integer);
var
  Offset: Integer;
  BitCount: Integer;
  Mask: Integer;
begin
  BitCount := AIndex and $FF;
  Offset := AIndex shr 8;
  Mask := ((1 shl BitCount) - 1);
  Assert(aValue <= Mask);
  RawData := (RawData and (not (Mask shl Offset))) or (AValue shl Offset);
end;