Bit manipulation/de: 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		# Maskierte Operationen
5	2
6	3		Dieses Beispiel ist ein einfacher Ansatz zur Bit-Manipulation. Das Beispiel bietet den Vorteil, dass Operationen, mit Bit-Gruppen, auf einmal durchgeführt werden.\
7	4
8	5		``` pascal
9	6		procedure ClearBit(var Value: QWord; Index: Byte);
10	7		begin
11	8		Value := Value and ((1 shl Index) xor High(QWord)));
12	9		end;
13	10
14	11		procedure SetBit(var Value: QWord; Index: Byte);
15	12		begin
16	13		Value := Value or (QWord(State) shl Index);
17	14		end;
18	15
19	16		procedure PutBit(var Value: QWord; Index: Byte; State: Boolean);
20	17		begin
21	18		Value := (Value and ((1 shl Index) xor High(QWord))) or (QWord(State) shl Index);
22	19		end;
23	20
24	21		function GetBit(Value: QWord; Index: Byte): Boolean;
25	22		begin
26	23		Result := ((Value shr Index) and 1) = 1;
27	24		end;
28	25		```
29	26
30		-	\
31	27		=Bitpacked record= Die Verwendung von bitpacked records, wird durch die lokale Compilerdirektive {\$BITPACKING ON} ermöglicht.\
32		-	\
	28	+
33	29		Der Free Pascal Compiler bietet die Möglichkeit einzelne Bits im Speicher anzusprechen. Mit dem Beispiel kann sowohl das ganze Byte als auch das einzelne Bit in diesem Byte angeprochen werden.\
34	30		Dies kann man mit einem Record oder einem Array lösen.\
35		-	\
36	31
37	32		``` pascal
38	33		...
39	34
40	35		// Compilerdirektive
41	36		{$BITPACKING ON}
42	37
43	38		...
44	39
45	40		type
46	41		TByteBits = bitpacked record
47	42		Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7: Boolean;
48	43		end;
49	44
50	45		TByteEx = packed record
51	46		case Integer of
52	47		0: (ByteAccess: Byte);
53	48		1: (BitAccess: TByteBits);
54	49		3: (BitArray: bitpacked array[0..7] of Boolean);
55	50		end;
56	51
57	52		...
58	53
59	54		```
60	55
61		-	\
62	56		Beispiel für die Verwendung von TByteBits und TByteEx:
63	57
64	58		``` pascal
65	59		// Wertzuweisung als Byte
66	60		ByteEx.ByteAccess := 4;
67	61
68	62		// Ändert den Wert von Bit7 und damit den Wert
69	63		// der über ByteEx.ByteAccess wieder ausgelesen wird
70	64		// in diesem Beispiel beträgt der Wert in
71	65		// ByteEx.ByteAccess 132
72	66		ByteEx.BitAccess.Bit7 := True;
73	67
74	68		// Über die Array
75	69		ByteEx.BitArray[7] := True;
76	70		```
77	71
78		-	\
79		-
80	72		# Set
81	73
82		-	\
83	74		In Sets kann man die Bits eintragen, die für die Bitmanipulation in frage kommen.\
84	75
85	76		``` pascal
86	77
87	78		...
88	79
89	80		// Compilerdirektiven
90	81		{$packset 1}
91	82		{$packenum 1}
92	83
93	84		...
94	85
95	86		type
96	87		TSetByteBits = set of (Bit0, Bit1, Bit2, Bit3, Bit4, Bit5, Bit6, Bit7);
97	88
98	89		...
99	90
100	91		var
101	92		SetByteBits: TSetByteBits;
102	93		...
103	94
104	95		begin
105	96
106	97		...
107	98
108	99		// legt fest, welche Elemente im Set gespeichert werden
109	100		SetByteBits := [Bit0 .. Bit7];
110	101
111	102		// Startet eine Bitmanipulation, wenn Bit3 im Set gefunden wird
112	103		if Bit3 in SetByteBits then
113	104		begin
114	105		...
115	106		end;
116	107
117	108		...
118	109
119	110		end;
120	111
121	112		...
122	113
123	114		```
124	115
125		-	\
126		-
127	116		# TBits
128	117
129		-	\
130	118		Diese Klasse ist Teil der Klasse Unit aus der Free Pascal RTL Bibliothek. Die Klasse bietet einige Methoden zur Bit-Manipulation.
131	119
132	120		``` pascal
133	121		TBits = class(TObject)
134	122		public
135	123		constructor Create(TheSize : longint = 0); virtual;
136	124		destructor Destroy; override;
137	125		function GetFSize : longint;
138	126		procedure SetOn(Bit : longint);
139	127		procedure Clear(Bit : longint);
140	128		procedure Clearall;
141	129		procedure AndBits(BitSet : TBits);
142	130		procedure OrBits(BitSet : TBits);
143	131		procedure XorBits(BitSet : TBits);
144	132		procedure NotBits(BitSet : TBits);
145	133		function Get(Bit : longint) : boolean;
146	134		procedure Grow(NBit : longint);
147	135		function Equals(Obj : TObject): Boolean; override; overload;
148	136		function Equals(BitSet : TBits) : Boolean; overload;
149	137		procedure SetIndex(Index : longint);
150	138		function FindFirstBit(State : boolean) : longint;
151	139		function FindNextBit : longint;
152	140		function FindPrevBit : longint;
153	141
154	142		// Funktionen und Eigenschaften zu entsprechen TBits class
155	143		function OpenBit: longint;
156	144		property Bits[Bit: longint]: Boolean read get write SetBit; default;
157	145		property Size: longint read FBSize write setSize;
158	146		end;
159	147		```
160	148
161		-	\
162	149		Beispiel für eine Verwendung:
163	150
164	151		``` pascal
165	152		...
166	153
167	154		var
168	155		Bits: TBits;
169	156		bytI: Byte;
170	157
171	158		begin
172	159
173	160		...
174	161
175	162		// Erstellt das Objekt
176	163		Bits := TBits.Create;
177	164
178	165		// Legt die Grösse fest
179	166		Bits.Size := 5;
180	167
181	168		// legt für einige Bits den Wert fest
182	169		Bits[0] := true;
183	170		Bits[1] := true;
184	171		Bits[4] := true;
185	172
186	173		// Ausagbe der Werte
187	174		for bytI := 0 to Bits.Size-1 do
188	175		if Bits[bytI] = true
189	176		then ShowMessage(inttostr(bytI) + ' ' + BoolToStr(Bits[bytI]))
190	177		else ShowMessage(inttostr(bytI) + ' ' + BoolToStr(Bits[bytI]));
191	178
192	179		// gibt den Speicher des Objektes wieder frei
193	180		Bits.Free;
194	181
195	182		...
196	183
197	184		end;
198	185
199	186		...
200	187		```
201	188
202		-	\
203	189		=Record Eigenschaften und Wertindex=\
204	190		Another interesting implementation of bit aligned structure can be used with capabilities of advanced records (FPC 2.6.0+). For all properties you have to use setter and getter which can handle general bit manipulations and set index which is passed to these methods. For more information refer to [Indexed properties](http://www.freepascal.org/docs-html/ref/refsu31.html). Because index is only one, it has to be divided to two parameters to describe location and size on bit value. In case of the following example, the offset can be 0..255 and size of value 0..255 bits. Another problem is that you have to ensure that defined structure components will not overlay.
205	191
206	192		``` pascal
207	193		{$mode delphi}
208	194
209	195		TSomeBitStructure = record
210	196		private
211	197		RawData: Word;
212	198		function GetBits(const AIndex: Integer): Integer; inline;
213	199		procedure SetBits(const AIndex: Integer; const AValue: Integer); inline;
214	200		public
215	201		// High byte of index offset, low byte of index is bit count
216	202		property OneBit: Integer index $0001 read GetBits write SetBits;
217	203		property TwoBits: Integer index $0102 read GetBits write SetBits;
218	204		property FourBits: Integer index $0304 read GetBits write SetBits;
219	205		property EightBits: Integer index $0708 read GetBits write SetBits;
220	206		end;
221	207
222	208		{$OPTIMIZATION ON}
223	209		{$OVERFLOWCHECKS OFF}
224	210		function TSomeBitStructure.GetBits(const AIndex: Integer): Integer;
225	211		var
226	212		Offset: Integer;
227	213		BitCount: Integer;
228	214		Mask: Integer;
229	215		begin
230	216		BitCount := AIndex and $FF;
231	217		Offset := AIndex shr 8;
232	218		Mask := ((1 shl BitCount) - 1);
233	219		Result := (RawData shr Offset) and Mask;
234	220		end;
235	221
236	222		procedure TSomeBitStructure.SetBits(const AIndex: Integer; const AValue: Integer);
237	223		var
238	224		Offset: Integer;
239	225		BitCount: Integer;
240	226		Mask: Integer;
241	227		begin
242	228		BitCount := AIndex and $FF;
243	229		Offset := AIndex shr 8;
244	230		Mask := ((1 shl BitCount) - 1);
245	231		Assert(aValue <= Mask);
246	232		RawData := (RawData and (not (Mask shl Offset))) or (AValue shl Offset);
247	233		end;
248	234		```
249	235
250	236		---
251	237		From the Free Pascal wiki, page "Bit manipulation/de", 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