Duplicated checksum code

[delphidabbler]

bdiff/Src/BDiff/UPatchWriters.pas

Line 114 in 464fe21

function TBinaryPatchWriter.CheckSum(Data: PCChar; Length: Cardinal): Longint;

and

bdiff/Src/BPatch/UPatcher.pas

Line 19 in 464fe21

class function CheckSum(Data: PAnsiChar; DataSize: Cardinal;

have similar, but not identical code:

class function TPatcher.CheckSum(Data: PAnsiChar; DataSize: Cardinal;
  const BFCheckSum: Integer): Longint;
begin
  Result := BFCheckSum;
  while DataSize <> 0 do
  begin
    Dec(DataSize);
    Result := ((Result shr 30) and 3) or (Result shl 2);
    Result := Result xor PShortInt(Data)^;
    Inc(Data);
  end;
end;

function TBinaryPatchWriter.CheckSum(Data: PCChar; Length: Cardinal): Longint;
begin
  Result := 0;
  while Length <> 0 do
  begin
    Dec(Length);
    Result := ((Result shr 30) and 3) or (Result shl 2);
    Result := Result xor Ord(Data^);
    Inc(Data);
  end;
end;

For the avoidance of error could the calculation part of the loops be extracted into a utility function? Such a function would need to be passed a brought forward checksum and the two types of Data parameters would need to be cast to ShortInt (= Int8).

Could be something like:

function UpdateChecksum(BF: Longint; Value: Int8): Longint;
begin
  Result := ((Result shr 30) and 3) or (Result shl 2);
  Result := Result xor Value;
end;

or

procedure UpdateChecksum(var CheckSum: Longint; Value: Int8);
begin
  CheckSum := (CheckSum shr 30) and 3) or (CheckSum shl 2);
  CheckSum := CheckSum xor Value;
end;

[delphidabbler]

How about a class, TCheckSum, that calculates a checksum for all the bytes that are added to it. The class could be passed a starting checksum in its constructor.

Something like:

type
  TCheckSum = class
  private
    fCheckSum: Longint;
  public
    constructor Create(Seed: Longint);
    procedure Add(Value: Int8);
    property CheckSum: Longint read fCheckSum;
  end;

Implemented as:

procedure TCheckSum.Add(Value: Int8);
begin
  fCheckSum := (fCheckSum shr 30) and 3) or (fCheckSum shl 2);
  fCheckSum := fCheckSum xor Value;
end;

constructor TCheckSum.Create(Seed: Longint);
begin
  inherited Create;
  fCheckSum := Seed;
end;

Our two pieces of code that calculate checksums then become:

class function TPatcher.CheckSum(Data: PAnsiChar; DataSize: Cardinal;
  const BFCheckSum: Integer): Longint;
begin
  var CS := TCheckSum.Create(BFCheckSum);
  try
    while DataSize <> 0 do
    begin
      Dec(DataSize);
      CS.Add(PShortInt(Data)^);
      Inc(Data);
    end;
    Result := CS.CheckSum;
  finally
    CS.Free;
  end;
end;

function TBinaryPatchWriter.CheckSum(Data: PCChar; Length: Cardinal): Longint;
begin
  var CS := TCheckSum.Create(0);
  try
    while Length <> 0 do
    begin
      Dec(Length);
      CS.Add(Ord(Data^));
      Inc(Data);
    end;
    Result := CS.CheckSum;
  finally
    CS.Free;
  end;
end;

It may be possible to run the loop from within TCheckSum if either the calling methods create an array of Int8 (or a buffer) to pass into TCheckSum, or the length of data is passed to TCheckSum and there's a callback function for each data item.

[delphidabbler]

It may be possible to run the loop from within TCheckSum if either the calling methods create an array of Int8 (or a buffer) to pass into TCheckSum, or the length of data is passed to TCheckSum and there's a callback function for each data item.

Extending TCheckSum from #13 (comment), we could have:

type
  TCheckSum = class
  // ...
  public
    // ...
    procedure AddBuffer(Data: PInt8; Length: Cardinal);
    // ...
  end;

// ...

procedure TCheckSum.AddBuffer(Data: PInt8; Length: Cardinal);
begin
  while Length > 0 do
  begin
    Dec(Length);
    Add(Data^);
    Inc(Data);
  end;
end;

Now the calling code reduces to:

class function TPatcher.CheckSum(Data: PAnsiChar; DataSize: Cardinal;
  const BFCheckSum: Integer): Longint;
begin
  var CS := TCheckSum.Create(BFCheckSum);
  try
    CS.AddBuffer(PInt8(Data), DataSize);
    Result := CS.CheckSum;
  finally
    CS.Free;
  end;
end;

function TBinaryPatchWriter.CheckSum(Data: PCChar; Length: Cardinal): Longint;
begin
  var CS := TCheckSum.Create(0);
  try
    CS.AddBuffer(PInt8(Data), Length);
    Result := CS.CheckSum;
  finally
    CS.Free;
  end;
end;

[delphidabbler]

var CS := TCheckSum.Create(BFCheckSum);

If this code is implemented before conversion to Delphi 11 (issue #12), then occurrences of inline variable declarations will need to be changed to use to separate the var declaration & initialisation.