source: branches/virtcpu varint/UVarInt.pas

unit UVarInt;

{$mode delphi}

interface

uses
  Classes, SysUtils, Math;

const
  BitAlignment = 8;

type
  { TVarInt }

  TVarInt = record
  private
  public
    Value: Int64;
    class operator Implicit(A: TVarInt): Int64;
    class operator Implicit(A: TVarInt): QWord;
    class operator Implicit(A: TVarInt): Integer;
    class operator Implicit(A: TVarInt): Byte;
    class operator Implicit(A: TVarInt): Char;
    class operator Implicit(A: Byte): TVarInt;
    class operator Implicit(A: Integer): TVarInt;
    class operator Implicit(A: Int64): TVarInt;
    class operator Implicit(A: QWord): TVarInt;
    class operator Explicit(A: Byte): TVarInt;
    class operator Explicit(A: Integer): TVarInt;
    class operator Explicit(A: Int64): TVarInt;
    class operator Explicit(A: TVarInt): Int64;
    class operator Inc(A: TVarInt): TVarInt;
    class operator Inc(A: TVarInt; B: TVarInt): TVarInt;
    class operator Dec(A: TVarInt): TVarInt;
    class operator Dec(A: TVarInt; B: TVarInt): TVarInt;
    class operator Negative(A: TVarInt): TVarInt;
    class operator Add(A: TVarInt; B: TVarInt): TVarInt;
    class operator Multiply(A: TVarInt; B: TVarInt): TVarInt;
    class operator IntDivide(A: TVarInt; B: TVarInt): TVarInt;
    class operator Modulus(A: TVarInt; B: TVarInt): TVarInt;
    class operator Subtract(A: TVarInt; B: TVarInt): TVarInt;
    class operator Equal(A: TVarInt; B: TVarInt): Boolean;
    class operator NotEqual(A: TVarInt; B: TVarInt): Boolean;
    class operator GreaterThan(A: TVarInt; B: TVarInt): Boolean;
    class operator GreaterThanOrEqual(A: TVarInt; B: TVarInt): Boolean;
    class operator LessThan(A: TVarInt; B: TVarInt): Boolean;
    class operator LessThanOrEqual(A: TVarInt; B: TVarInt): Boolean;
    class operator LeftShift(A: TVarInt; B: TVarInt): TVarInt;
    class operator RightShift(A: TVarInt; B: TVarInt): TVarInt;
    class operator BitwiseAnd(A: TVarInt; B: TVarInt): TVarInt;
    class operator BitwiseOr(A: TVarInt; B: TVarInt): TVarInt;
    class operator BitwiseXor(A: TVarInt; B: TVarInt): TVarInt;
    function GetByteSize: Integer;
    function WriteToAddr(Ptr: Pointer): Integer;
    function ReadFromAddr(Ptr: Pointer): Integer;
  end;

  { TVarUInt }

  TVarUInt = record
  private
  public
    Value: QWord;
    class operator Implicit(A: TVarUInt): Int64;
    class operator Implicit(A: TVarUInt): QWord;
    class operator Implicit(A: TVarUInt): Integer;
    class operator Implicit(A: TVarUInt): Byte;
    class operator Implicit(A: TVarUInt): Char;
    class operator Implicit(A: TVarUInt): TVarInt;
    class operator Implicit(A: Byte): TVarUInt;
    class operator Implicit(A: Integer): TVarUInt;
    class operator Implicit(A: Int64): TVarUInt;
    class operator Implicit(A: QWord): TVarUInt;
    class operator Implicit(A: TVarInt): TVarUInt;
    class operator Explicit(A: Byte): TVarUInt;
    class operator Explicit(A: Integer): TVarUInt;
    class operator Explicit(A: Int64): TVarUInt;
    class operator Explicit(A: TVarUInt): Int64;
    class operator Inc(A: TVarUInt): TVarUInt;
    class operator Inc(A: TVarUInt; B: TVarInt): TVarUInt;
    class operator Dec(A: TVarUInt): TVarUInt;
    class operator Dec(A: TVarUInt; B: TVarUInt): TVarUInt;
    class operator Negative(A: TVarUInt): TVarUInt;
    class operator Add(A: TVarUInt; B: TVarUInt): TVarUInt;
    class operator Multiply(A: TVarUInt; B: TVarUInt): TVarUInt;
    class operator IntDivide(A: TVarUInt; B: TVarUInt): TVarUInt;
    class operator Modulus(A: TVarUInt; B: TVarUInt): TVarUInt;
    class operator Subtract(A: TVarUInt; B: TVarUInt): TVarUInt;
    class operator Equal(A: TVarUInt; B: TVarUInt): Boolean;
    class operator NotEqual(A: TVarUInt; B: TVarUInt): Boolean;
    class operator GreaterThan(A: TVarUInt; B: TVarUInt): Boolean;
    class operator GreaterThanOrEqual(A: TVarUInt; B: TVarUInt): Boolean;
    class operator LessThan(A: TVarUInt; B: TVarUInt): Boolean;
    class operator LessThanOrEqual(A: TVarUInt; B: TVarUInt): Boolean;
    class operator LeftShift(A: TVarUInt; B: TVarUInt): TVarUInt;
    class operator RightShift(A: TVarUInt; B: TVarUInt): TVarUInt;
    class operator BitwiseAnd(A: TVarUInt; B: TVarUInt): TVarUInt;
    class operator BitwiseOr(A: TVarUInt; B: TVarUInt): TVarUInt;
    class operator BitwiseXor(A: TVarUInt; B: TVarUInt): TVarUInt;
    function GetByteSize: Integer;
    function WriteToAddr(Ptr: Pointer): Integer;
    function ReadFromAddr(Ptr: Pointer): Integer;
  end;

function DecodeUnaryLength(Data: Byte): Integer;
function GetUnaryLengthMask(Length: Integer): Byte;

resourcestring
  SVarIntOverflow = 'VarInt read overflow.';


implementation

function GetUnaryLengthMask(Length: Integer): Byte;
begin
  Result := ((1 shl (BitAlignment - Length)) - 1) xor $ff;
end;

function DecodeUnaryLength(Data: Byte): Integer;
begin
  Result := 1;
  while (((Data shr (BitAlignment - Result)) and 1) = 1) and
    (Result <= BitAlignment) do Inc(Result);
end;

{ TVarUInt }

class operator TVarUInt.Implicit(A: TVarUInt): Int64;
begin
  Result := A.Value;
end;

class operator TVarUInt.Implicit(A: TVarUInt): QWord;
begin
  Result := A.Value;
end;

class operator TVarUInt.Implicit(A: TVarUInt): Integer;
begin
  Result := A.Value;
end;

class operator TVarUInt.Implicit(A: TVarUInt): Byte;
begin
  Result := A.Value;
end;

class operator TVarUInt.Implicit(A: TVarUInt): Char;
begin
  Result := Chr(A.Value);
end;

class operator TVarUInt.Implicit(A: TVarUInt): TVarInt;
begin
  Result.Value := A.Value;
end;

class operator TVarUInt.Implicit(A: Byte): TVarUInt;
begin
  Result.Value := A;
end;

class operator TVarUInt.Implicit(A: Integer): TVarUInt;
begin
  Result.Value := A;
end;

class operator TVarUInt.Implicit(A: Int64): TVarUInt;
begin
  Result.Value := A;
end;

class operator TVarUInt.Implicit(A: QWord): TVarUInt;
begin
  Result.Value := A;
end;

class operator TVarUInt.Implicit(A: TVarInt): TVarUInt;
begin
  Result.Value := A.Value;
end;

class operator TVarUInt.Explicit(A: Byte): TVarUInt;
begin
  Result.Value := A;
end;

class operator TVarUInt.Explicit(A: Integer): TVarUInt;
begin
  Result.Value := A;
end;

class operator TVarUInt.Explicit(A: Int64): TVarUInt;
begin
  Result.Value := A;
end;

class operator TVarUInt.Explicit(A: TVarUInt): Int64;
begin
  Result := A.Value;
end;

class operator TVarUInt.Inc(A: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value + 1;
end;

class operator TVarUInt.Inc(A: TVarUInt; B: TVarInt): TVarUInt;
begin
  Result.Value := A.Value + B.Value;
end;

class operator TVarUInt.Dec(A: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value - 1;
end;

class operator TVarUInt.Dec(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value - B.Value;
end;

class operator TVarUInt.Negative(A: TVarUInt): TVarUInt;
begin
  Result.Value := -A.Value;
end;

class operator TVarUInt.Add(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value + B.Value;
end;

class operator TVarUInt.Multiply(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value * B.Value;
end;

class operator TVarUInt.IntDivide(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value div B.Value;
end;

class operator TVarUInt.Modulus(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value mod B.Value;
end;

class operator TVarUInt.Subtract(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value - B.Value;
end;

class operator TVarUInt.Equal(A: TVarUInt; B: TVarUInt): Boolean;
begin
  Result := A.Value = B.Value;
end;

class operator TVarUInt.NotEqual(A: TVarUInt; B: TVarUInt): Boolean;
begin
  Result := A.Value <> B.Value;
end;

class operator TVarUInt.GreaterThan(A: TVarUInt; B: TVarUInt): Boolean;
begin
  Result := A.Value > B.Value;
end;

class operator TVarUInt.GreaterThanOrEqual(A: TVarUInt; B: TVarUInt): Boolean;
begin
  Result := A.Value >= B.Value;
end;

class operator TVarUInt.LessThan(A: TVarUInt; B: TVarUInt): Boolean;
begin
  Result := A.Value < B.Value;
end;

class operator TVarUInt.LessThanOrEqual(A: TVarUInt; B: TVarUInt): Boolean;
begin
  Result := A.Value <= B.Value;
end;

class operator TVarUInt.LeftShift(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value shl B.Value;
end;

class operator TVarUInt.RightShift(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value shr B.Value;
end;

class operator TVarUInt.BitwiseAnd(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value and B.Value;
end;

class operator TVarUInt.BitwiseOr(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value or B.Value;
end;

class operator TVarUInt.BitwiseXor(A: TVarUInt; B: TVarUInt): TVarUInt;
begin
  Result.Value := A.Value xor B.Value;
end;

function TVarUInt.GetByteSize: Integer;
var
  Length: Integer;
begin
  // Get bit length
  Length := SizeOf(Value) * BitAlignment - 1;
  while (((Value shr Length) and 1) = 0) and (Length > 0) do
    Dec(Length);
  Inc(Length);
  Result := Ceil(Length / (BitAlignment - 1));
end;

function TVarUInt.WriteToAddr(Ptr: Pointer): Integer;
var
  Length: Byte;
  Data: Byte;
  I: Integer;
  LengthMask: Byte;
begin
  Result := 0;

  Length := GetByteSize;
  LengthMask := GetUnaryLengthMask(Length);

  // Copy data
  for I := Length downto 1 do begin
    Data := (Value shr (BitAlignment * (I - 1))) and $ff;
    if I = Length then Data := (Data and
      (LengthMask xor $ff)) or ((LengthMask shl 1) and $ff);
    PByte(Ptr)^ := Data;
    Inc(Ptr);
    Inc(Result);
  end;
end;

function TVarUInt.ReadFromAddr(Ptr: Pointer): Integer;
var
  Data: Byte;
  Length: Integer;
  I: Integer;
  LengthMask: Byte;
begin
  Value := 0;
  Result := 0;
  Length := 1;
  I := 0;
  while I < Length do begin
    Data := PByte(Ptr)^;
    if I = 0 then begin
      if Data = $ff then begin
        Length := PByte(Ptr)^;
        Inc(Ptr);
        if Length > BitAlignment then
          raise Exception.Create(SVarIntOverflow);
        if Length > 0 then begin
          Data := PByte(Ptr)^;
          Inc(Ptr);
        end else Data := 0;
      end else begin
        Length := DecodeUnaryLength(Data);
        LengthMask := GetUnaryLengthMask(Length);
        Data := Data and (LengthMask xor $ff);
      end;
    end;
    Value := Value or (QWord(Data) shl ((Length - I - 1) * BitAlignment));
    Inc(I);
    Inc(Ptr);
  end;
  Result := Length;
end;

{ TVarInt }

class operator TVarInt.Implicit(A: TVarInt): Int64;
begin
  Result := A.Value;
end;

class operator TVarInt.Implicit(A: TVarInt): QWord;
begin
  Result := A.Value;
end;

class operator TVarInt.Implicit(A: TVarInt): Integer;
begin
  Result := A.Value;
end;

class operator TVarInt.Implicit(A: TVarInt): Byte;
begin
  Result := A.Value;
end;

class operator TVarInt.Implicit(A: TVarInt): Char;
begin
  Result := Char(A.Value);
end;

class operator TVarInt.Implicit(A: Byte): TVarInt;
begin
  Result.Value := A;
end;

class operator TVarInt.Implicit(A: Integer): TVarInt;
begin
  Result.Value := A;
end;

class operator TVarInt.Implicit(A: Int64): TVarInt;
begin
  Result.Value := A;
end;

class operator TVarInt.Implicit(A: QWord): TVarInt;
begin
  Result.Value := A;
end;

class operator TVarInt.Explicit(A: Byte): TVarInt;
begin
  Result.Value := A;
end;

class operator TVarInt.Explicit(A: Integer): TVarInt;
begin
  Result.Value := A;
end;

class operator TVarInt.Explicit(A: Int64): TVarInt;
begin
  Result.Value := A;
end;

class operator TVarInt.Explicit(A: TVarInt): Int64;
begin
  Result := A.Value;
end;

class operator TVarInt.Inc(A: TVarInt): TVarInt;
begin
  Result.Value := A.Value + 1;
end;

class operator TVarInt.Inc(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result := A.Value + B.Value;
end;

class operator TVarInt.Dec(A: TVarInt): TVarInt;
begin
  Result.Value := A.Value - 1;
end;

class operator TVarInt.Dec(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value - B.Value;
end;

class operator TVarInt.Negative(A: TVarInt): TVarInt;
begin
  Result.Value := -A.Value;
end;

class operator TVarInt.Add(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value + B.Value;
end;

class operator TVarInt.Multiply(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value * B.Value;
end;

class operator TVarInt.IntDivide(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value div B.Value;
end;

class operator TVarInt.Modulus(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value mod B.Value;
end;

class operator TVarInt.Subtract(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value - B.Value;
end;

class operator TVarInt.Equal(A: TVarInt; B: TVarInt): Boolean;
begin
  Result := A.Value = B.Value;
end;

class operator TVarInt.NotEqual(A: TVarInt; B: TVarInt): Boolean;
begin
  Result := A.Value <> B.Value;
end;

class operator TVarInt.GreaterThan(A: TVarInt; B: TVarInt): Boolean;
begin
  Result := A.Value > B.Value;
end;

class operator TVarInt.GreaterThanOrEqual(A: TVarInt; B: TVarInt): Boolean;
begin
  Result := A.Value >= B.Value;
end;

class operator TVarInt.LessThan(A: TVarInt; B: TVarInt): Boolean;
begin
  Result := A.Value < B.Value;
end;

class operator TVarInt.LessThanOrEqual(A: TVarInt; B: TVarInt): Boolean;
begin
  Result := A.Value <= B.Value;
end;

class operator TVarInt.LeftShift(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value shl B.Value;
end;

class operator TVarInt.RightShift(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value shr B.Value;
end;

class operator TVarInt.BitwiseAnd(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value and B.Value;
end;

class operator TVarInt.BitwiseOr(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value or B.Value;
end;

class operator TVarInt.BitwiseXor(A: TVarInt; B: TVarInt): TVarInt;
begin
  Result.Value := A.Value xor B.Value;
end;

function TVarInt.GetByteSize: Integer;
var
  UInt: TVarUInt;
begin
  UInt := Value;
  Result := UInt.GetByteSize;
end;

function TVarInt.WriteToAddr(Ptr: Pointer): Integer;
var
  UInt: TVarUInt;
begin
  UInt := Value;
  Result := UInt.WriteToAddr(Ptr);
end;

function TVarInt.ReadFromAddr(Ptr: Pointer): Integer;
var
  UInt: TVarUInt;
begin
  Result := UInt.ReadFromAddr(Ptr);
  Value := UInt;
end;


end.