[Back to NUMBERS SWAG index] [Back to Main SWAG index] [Original]

    {
    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
    [0..31] instead of [1..32].)

    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.

[Back to NUMBERS SWAG index] [Back to Main SWAG index] [Original]