source: branches/CpuSingleSize/Memory.pas

unit Memory;

interface

uses
  Classes, SysUtils, Cpu;

type

  { TMemory }

  TMemory = class
  private
    FCapacity: Integer;
    FSize: Integer;
    function GetItem(Index: Integer): TInteger;
    procedure SetCapacity(AValue: Integer);
    procedure SetItem(Index: Integer; AValue: TInteger);
    procedure SetSize(AValue: Integer);
    procedure UpdateCapacity(ASize: Integer);
  public
    Data: array of TInteger;
    Position: Integer;
    procedure Write(Value: TInteger);
    procedure WriteString(Value: string);
    procedure WriteMemory(Memory: TMemory);
    function Read: TInteger;
    procedure Assign(Source: TMemory);
    procedure SaveToFile(FileName: string);
    property Size: Integer read FSize write SetSize;
    property Capacity: Integer read FCapacity write SetCapacity;
    property Items[Index: Integer]: TInteger read GetItem write SetItem; default;
  end;


implementation

{ TMemory }

procedure TMemory.SetCapacity(AValue: Integer);
begin
  if FCapacity = AValue then Exit;
  FCapacity := AValue;
  SetLength(Data, FCapacity);
  if FSize > FCapacity then FSize := FCapacity;
end;

function TMemory.GetItem(Index: Integer): TInteger;
begin
  Result := Data[Index];
end;

procedure TMemory.SetItem(Index: Integer; AValue: TInteger);
begin
  Data[Index] := AValue;
end;

procedure TMemory.SetSize(AValue: Integer);
begin
  if FSize = AValue then Exit;
  UpdateCapacity(AValue);
  FSize := AValue;
end;

procedure TMemory.UpdateCapacity(ASize: Integer);
const
  MinStep = 1000;
begin
  if ASize > FSize then begin  // Grow
    if (ASize > Capacity) then begin
      if ((ASize - Size) < MinStep) then Capacity := Capacity + MinStep
      else Capacity := ASize;
    end;
  end else
  if ASize < FSize then begin  // Shrink
    if (Capacity - ASize) > MinStep then
      Capacity := ASize;
  end;
end;

procedure TMemory.Write(Value: TInteger);
begin
  if Position + 1 > FSize then Size := Position + 1;
  Data[Position] := Value;
  Inc(Position);
end;

procedure TMemory.WriteString(Value: string);
var
  I: Integer;
begin
  if Length(Value) > 0 then begin
    if Position + Length(Value) > FSize then Size := Position + Length(Value);
    for I := 0 to Length(Value) - 1 do
      Data[Position + I] := Ord(Value[I + 1]);
    Inc(Position, Length(Value));
  end;
end;

procedure TMemory.WriteMemory(Memory: TMemory);
begin
  if Memory.Size > 0 then begin
    if Position + Memory.Size > FSize then Size := Position + Memory.Size;
    Move(Memory.Data[0], Data[Position], Memory.Size * SizeOf(TInteger));
    Inc(Position, Memory.Size);
  end;
end;

function TMemory.Read: TInteger;
begin
  Result := Data[Position];
  Inc(Position);
end;

procedure TMemory.Assign(Source: TMemory);
begin
  Size := Source.Size;
  if Size > 0 then
    Move(Source.Data[0], Data[0], Size * SizeOf(TInteger));
  Position := Source.Position;
end;

procedure TMemory.SaveToFile(FileName: string);
var
  F: TFileStream;
begin
  if FileExists(FileName) then
    F := TFileStream.Create(FileName, fmOpenWrite)
    else F := TFileStream.Create(FileName, fmCreate);
  try
    if Size > 0 then F.Write(Data[0], Size * SizeOf(TInteger));
  finally
    F.Free;
  end;
end;

end.