Miscellany

program Mad_Adder;  {$APPTYPE Console}


// en.wikipedia.org/wiki/Adder_%28electronics%29#Full_adder


//------------------------------------------------------------------------------


type    Bit             =       0..1;


var     NullBit         :       Bit
                        =       0;


//------------------------------------------------------------------------------


type    TAdder          =       class
        A               :       ^Bit;
        B               :       ^Bit;
        CIn             :       ^Bit;
        Cout            :       Bit;
        S               :       Bit;
        procedure       Compute ;
        end;


procedure TAdder.Compute;
var     tmp             :       Bit;
begin
tmp  := (A^  XOR B^  );
S    := (tmp XOR CIn^);
COut := (tmp AND CIn^) AND (A^ AND B^);
end;


//------------------------------------------------------------------------------


type    TByteAdder      =       class
        A               :       array[0..7] of Bit;
        B               :       array[0..7] of Bit;
        Adder           :       array[0..7] of TAdder;
        procedure       Compute (const A, B : Byte;  var Result : Byte;  var Carry : Bit);
        constructor     Create  ;
        destructor      Destroy ;  override;
        end;


procedure TByteAdder.Compute(const A, B : Byte;  var Result : Byte;  var Carry : Bit);
var     i               :       Integer;
begin
for i := 0 to 7 do begin
        Self.A[i] := A SHR i;
        Self.B[i] := B SHR i;
end;
for i := 0 to 7 do  Adder[i].Compute;
Result := (Byte(Adder[7].S) SHL 7) OR
          (Byte(Adder[6].S) SHL 6) OR
          (Byte(Adder[5].S) SHL 5) OR
          (Byte(Adder[4].S) SHL 4) OR
          (Byte(Adder[3].S) SHL 3) OR
          (Byte(Adder[2].S) SHL 2) OR
          (Byte(Adder[1].S) SHL 1) OR
          (Byte(Adder[0].S) SHL 0);
Carry := Adder[7].COut;
end;


constructor TByteAdder.Create;
var     i               :       Integer;
begin
inherited Create;
for i := 0 to 7 do begin
        Adder[i] := TAdder.Create;
        with Adder[i] do begin
                A := @Self.A[i];
                B := @Self.B[i];
                if (i <> 0) then CIn := @Adder[i - 1].Cout;
        end;
end;
Adder[0].CIn := @NullBit;
end;


destructor TByteAdder.Destroy;
var     i               :       Integer;
begin
for i := 0 to 7 do  Adder[i].Free;
inherited Destroy;
end;


//------------------------------------------------------------------------------


const   A               =       1;
        B               =       1;


var     ByteAdder       :       TByteAdder;
        Carry           :       Byte;
        Result          :       Byte;


begin
ByteAdder := TByteAdder.Create;
try
        ByteAdder.Compute(A, B, Result, Carry);
        Write(A, ' + ', B, ' = ', Result);
        if (Carry <> 0) then Write(' with carry');
        WriteLn;
finally
        ByteAdder.Free;
end;
end.