{
CHRIS QUARTETTI

>Is there an easy way to create a 1-bit or 2-bit data structure.  For
>example, a 2-bit Type that can hold 4 possible values.  For that matter,
>is there a hard way? <g>  Thanks very much -Greg

   I suppose this would qualify For the hard way-- not too flexible, but it
works. It would be a bit easier to do this if you wanted a bunch of the same
size Variables (ie 4 4 bit Variables, or an Array of 4*x 4 bit Variables).
FWIW I used BP7 here, but TP6 and up will work. Also, it need not be Object
oriented.
}

Type
  bitf = Object                                                                                  { split 'bits' into bitfields }
    bits : Word;                         { 16 bits total }

    Function  get : Word;

    Procedure set1(value : Word);        { this will be 2 bits }
    Function  get1 : Word;

    Procedure set2(value : Word);        { this will be 13 bits }
    Function  get2 : Word;

    Procedure set3(value : Word);        { this will be 1 bit }
    Function  get3 : Word;
  end;

Function bitf.get : Word;
begin
  get := bits;
end;

Procedure bitf.set1(value : Word);
{ Set the value of the first bitfield }
Const
  valmask  : Word = $C000;  { 11000000 00000000 }
  bitsmask : Word = $3FFF;  { 00111111 11111111 }
begin
  value := value shl 14 and valmask;
  bits  := value + (bits and bitsmask);
end;

Function bitf.get1 : Word;
{ Get the value of the first bitfield }
begin
  get1 := bits shr 14;
end;

Procedure bitf.set2(value : Word);
{ Set the value of the second bitfield }
Const
  valmask  : Word = $3FFE;  { 00111111 11111110 }
  bitsmask : Word = $C001;  { 11000000 00000001 }
begin
  value := (value shl 1) and valmask;
  bits  := value + (bits and bitsmask);
end;

Function bitf.get2 : Word;
{ Get the value of the second bitfield }
Const
  valmask : Word = $3FFE;   { 00111111 11111110 }
begin
  get2 := (bits and valmask) shr 1;
end;

Procedure bitf.set3(value : Word);
{ Set the value of the third bitfield }
Const
  valmask  : Word = $0001;  { 00000000 00000001 }
  bitsmask : Word = $FFFE;  { 11111111 11111110 }
begin
  value := value and valmask;
  bits  := value + (bits and bitsmask);
end;

Function bitf.get3 : Word;
{ Get the value of the third bitfield }
Const
  valmask : Word = $0001;  { 00000000 00000001 }
begin
  get3 := bits and valmask;
end;

Var
  x : bitf;

begin
  x.set1(3);        { set all to maximum values }
  x.set2(8191);
  x.set3(1);
  Writeln(x.get1, ', ', x.get2, ', ', x.get3, ', ', x.get);
end.