``````{
ROB GREEN

> What if I want to just access a bit?  Say I have a Byte, to store
> Various access levels (if it does/doesn't have this, that, or the
> other).  How can I
> 1)  Access, say, bit 4?
> 2)  Give, say, bit 4, a value of 1?

Heres a Procedure i wrote to handle all that.  if you need speed, then
i suggest to manually check each bit, rather than use the Procedures.

(these Procedures are based on 1, not 0.  thus each Byte is like so:
87654321   instead of 76543210.  to change to 0 base, change the Array to

to set a bit: (b is an Integer Type, BIT is which bit to set
b:=b or BIT;   ex: b:=b or 128  (set bit 8)

to clear a bit:
b:=b and not BIT;  ex:b:=b and not 8;  (clears bit 4)

to check a bit:
if b and BIT<>0 then..  ex:if b and 64 then..  (check bit 7)
}

Const
{ Used to convert the Bit value to the actual corresponding number }
bit : Array[1..32] of LongInt =
(1, 2, 4, 8, \$10, \$20, \$40, \$80, \$100, \$200, \$400, \$800, \$1000, \$2000,
\$4000, \$8000, \$10000, \$20000, \$40000, \$80000, \$100000, \$200000,
\$400000, \$800000, \$1000000, \$2000000, \$4000000, \$8000000, \$10000000,
\$20000000, \$40000000, \$80000000);

{b is which bit to set(1-32), size is the size of temp.
Use  SIZEOF(TEMP) to get the value, and temp is the actuall Integer based
number
returns True if bit set, False if not}

Function checkbit(b : Byte; size : Byte; Var temp) : Boolean; {1-32}
Var
c : Boolean;
begin
c:=False;
Case size of
1 : c := Byte(temp) and bit[b] <> 0;     {Byte,shortint}
2 : c := Word(temp) and bit[b] <> 0;     {Word,Integer}
4 : c := LongInt(temp) and bit[b] <> 0;  {LongInt}
else
Writeln('Invalid size');
end;
checkbit := c;
end;

{b,size,and temp same as above.  if onoff =True the bit will be set,
else the bit will be cleared}

Procedure setbit(b : Byte; onoff : Boolean; size : Byte; Var temp); {1-32}
begin
if onoff then
Case size of
1 : Byte(temp) := Byte(temp) or bit[b];        {Byte}
2 : Word(temp) := Word(temp) or bit[b];        {Word}
4 : LongInt(temp) := LongInt(Temp) or bit[b];  {LongInt}
else
Writeln('Invalid size');
end
else
Case size of
1 : Byte(temp) := Byte(temp) and not bit[b];   {Byte}
2 : Word(temp) := Word(temp) and not bit[b];   {Word}
4 : LongInt(temp) := LongInt(Temp) and not bit[b];{LongInt}
else
Writeln('Invalid size');
end;
end;

{this is a sample test Program i wrote For you to see how to use the
stuff above}

Var
i : LongInt;
j : Byte;
begin
i := 0;
setbit(4,True,sizeof(i),i);  {8}
Writeln(i);
setbit(9,True,sizeof(i),i);  {256+8 = 264}
Writeln(i);
setbit(9,False,sizeof(i),i); {8}
Writeln(i);
setbit(20,True,sizeof(i),i); { \$80000+8 = \$80008}
Writeln(i);
For i := 65550 to 65575 do
begin
Write(i : 8, ' = ');
For j := 32 downto 1 do {to print right}
if checkbit(j, sizeof(i), i) then
Write('1')
else
Write('0');
Writeln;
end;
end.

``````