Bit manipulation/fr: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1		-	\
2		-	\
3		-
4	1		## Opération masquées
5	2
6	3		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).
7	4
8	5		(NdT : une solution peut résider dans l'emploi de fonctions génériques, non développées ici.)
9	6
10	7		``` pascal
11	8		procedure ClearBit(var Value: QWord; Index: Byte);
12	9		begin
13	10		Value := Value and ((QWord(1) shl Index) xor High(QWord));
14	11		end;
15	12
16	13		procedure SetBit(var Value: QWord; Index: Byte);
17	14		begin
18	15		Value:= Value or (QWord(1) shl Index);
19	16		end;
20	17
21	18		procedure PutBit(var Value: QWord; Index: Byte; State: Boolean);
22	19		begin
23	20		Value := (Value and ((QWord(1) shl Index) xor High(QWord))) or (QWord(State) shl Index);
24	21		end;
25	22
26	23		function GetBit(Value: QWord; Index: Byte): Boolean;
27	24		begin
28	25		Result := ((Value shr Index) and 1) = 1;
29	26		end;
30	27		```
31	28
32	29		## Enregistrement bit-paqueté (Bitpacked)
33	30
34	31		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.
35	32
36	33		``` pascal
37	34		TByteBits = bitpacked record
38	35		Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7: Boolean;
39	36		end;
40	37
41	38		TByteEx = packed record
42	39		case Integer of
43	40		0: (ByteAccess: Byte);
44	41		1: (BitAccess: TByteBits);
45	42		end;
46	43
47	44		TSomeBitLevelStructure = bitpacked record
48	45		OneBit: 0..1;
49	46		TwoBits: 0..3;
50	47		FourBits: 0..15;
51	48		EightBits: 0..255
52	49		end;
53	50		```
54	51
55	52		NB : on accède au bit via des identificateurs.
56	53
57	54		Le paquetage par bit peut être contrôlé en utilisant la directive [\$BITPACKING](http://www.freepascal.org/docs-html/prog/progsu6.html).
58	55
59	56		## Type ensemble
60	57
61	58		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](http://www.freepascal.org/docs-html/prog/progsu57.html#x63-620001.1.57) pour modifier la taille de l'ensemble. Il y aussi certaines limitations sur la taille maximale d'un ensemble.
62	59
63	60		``` pascal
64	61		{$packset 1}
65	62		{$packenum 1}
66	63
67	64		type
68	65		TByteBits = set of (Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7);
69	66		```
70	67
71	68		## TBits
72	69
73	70		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.
74	71
75	72		``` pascal
76	73		TBits = class(TObject)
77	74		public
78	75		constructor Create(TheSize : longint = 0); virtual;
79	76		destructor Destroy; override;
80	77		function GetFSize : longint;
81	78		procedure SetOn(Bit : longint);
82	79		procedure Clear(Bit : longint);
83	80		procedure Clearall;
84	81		procedure AndBits(BitSet : TBits);
85	82		procedure OrBits(BitSet : TBits);
86	83		procedure XorBits(BitSet : TBits);
87	84		procedure NotBits(BitSet : TBits);
88	85		function Get(Bit : longint) : boolean;
89	86		procedure Grow(NBit : longint);
90	87		function Equals(Obj : TObject): Boolean; override; overload;
91	88		function Equals(BitSet : TBits) : Boolean; overload;
92	89		procedure SetIndex(Index : longint);
93	90		function FindFirstBit(State : boolean) : longint;
94	91		function FindNextBit : longint;
95	92		function FindPrevBit : longint;
96	93
97	94		{ functions and properties to match TBits class }
98	95		function OpenBit: longint;
99	96		property Bits[Bit: longint]: Boolean read get write SetBit; default;
100	97		property Size: longint read FBSize write setSize;
101	98		end;
102	99		```
103	100
104	101		NB :
105	102
106	103		- Pas de limitation de taille comme avec les ensembles,
107	104		- les bits sont accessibles uniquement de manière ordinale.
108	105
109	106		## Propriété enregistrement et valeur index
110	107
111	108		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](http://www.freepascal.org/docs-html/ref/refsu31.html). 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.
112	109
113	110		``` pascal
114	111		{$mode delphi}
115	112
116	113		TSomeBitStructure = record
117	114		private
118	115		RawData: Word;
119	116		function GetBits(const AIndex: Integer): Integer; inline;
120	117		procedure SetBits(const AIndex: Integer; const AValue: Integer); inline;
121	118		public
122	119		// High byte of index offset, low byte of index is bit count
123	120		property OneBit: Integer index $0001 read GetBits write SetBits;
124	121		property TwoBits: Integer index $0102 read GetBits write SetBits;
125	122		property FourBits: Integer index $0304 read GetBits write SetBits;
126	123		property EightBits: Integer index $0708 read GetBits write SetBits;
127	124		end;
128	125
129	126		{$OPTIMIZATION ON}
130	127		{$OVERFLOWCHECKS OFF}
131	128		function TSomeBitStructure.GetBits(const AIndex: Integer): Integer;
132	129		var
133	130		Offset: Integer;
134	131		BitCount: Integer;
135	132		Mask: Integer;
136	133		begin
137	134		BitCount := AIndex and $FF;
138	135		Offset := AIndex shr 8;
139	136		Mask := ((1 shl BitCount) - 1);
140	137		Result := (RawData shr Offset) and Mask;
141	138		end;
142	139
143	140		procedure TSomeBitStructure.SetBits(const AIndex: Integer; const AValue: Integer);
144	141		var
145	142		Offset: Integer;
146	143		BitCount: Integer;
147	144		Mask: Integer;
148	145		begin
149	146		BitCount := AIndex and $FF;
150	147		Offset := AIndex shr 8;
151	148		Mask := ((1 shl BitCount) - 1);
152	149		Assert(aValue <= Mask);
153	150		RawData := (RawData and (not (Mask shl Offset))) or (AValue shl Offset);
154	151		end;
155	152		```
156	153
157	154		---
158	155		From the Free Pascal wiki, page "Bit manipulation/fr", as it stood on 2020-02-10 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history