unit ramdrive;

interface

uses device;

type
  PRamDrive = ^TRamDrive;
  TRamDrive = object(Tdevice)
   private
    ramData:pointer;
    ramDriveSize:dword;
   public
    constructor init(ramDriveSectors:dword);
    function read(ptr:pointer; offset:int64; length:dword):integer; virtual;
    function write(ptr:pointer; offset:int64; length:dword):integer; virtual;
    destructor done; virtual;
  end; // TRamDrive

(*
function dev_ramDrive:PDevice;
function dev_ramDestroy:integer;
*)
implementation

{const RAM_DRIVE_SIZE = 1024*1024*20;}

constructor TRamDrive.init;
begin
  inherited init;
  if (ramDriveSectors = 0) then runError; // I can't imagine why you'd want a 0 byte ramdrive
  ramDriveSize := ramDriveSectors * SECTOR_SIZE;
  ramData := NIL;
  GetMem(ramData, ramDriveSize);
  if (ramData = NIL) then runError;
  major := 1;
  sectors := ramDriveSectors;
end; // TRamDrive.init

function TRamDrive.read;
var data:pointer;
begin
  data := pointer(dword(ramData) + dword(offset)*SECTOR_SIZE);
  if (offset+length > sectors) then runError;
  move(data^, ptr^, length*SECTOR_SIZE);
  result := length
end; // TRamDrive.read

function TRamDrive.write;
var data:pointer;
begin
  data := pointer(dword(ramData) + dword(offset) * 512);
  if (offset+length > sectors) then halt;
  move(ptr^, data^, length*512);
  result := length;
end; // TRamDrive.write

destructor TRamDrive.done;
begin
  inherited done;
  if (ramData <> NIL) then FreeMem(ramData, ramDriveSize);
  ramData := NIL;
end; // TRamDrive.done
(*
var ram_data:pointer;
var ram_drive_size:dword;

function ramDrive_read(dev:PDevice; ptr:pointer; offset:int64; length:dword):integer;
var data:pointer;
begin
  data := pointer(dword(ram_data) + dword(offset)*512);
  if (offset+length > dev^.sectors) then halt;
  move(data^, ptr^, length*512);
  result := length;
end; {ramDrive_read}

function ramDrive_write(dev:PDevice; ptr:pointer; offset:int64; length:dword):integer;
var data:pointer;
begin
  data := pointer(dword(ram_data) + dword(offset) * 512);
  if (offset+length > dev^.sectors) then halt;
  move(ptr^, data^, length*512);
  result := length;
end; {ramDrive_write}

function dev_ramDrive:PDevice;
var
  ramDevice : PDevice;
  ramDisk : file;
  ramDriveSize : dword;
begin
  new(ramDevice);
  assign(ramDisk, 'ram.dsk');
  reset(ramDisk, 1);
  ram_drive_size := filesize(ramDisk);

  getmem(ram_data, ram_drive_size);
  fillchar(ram_data^, ram_drive_size, 0);
  blockread(ramDisk, ram_data^, ram_drive_size);
  close(ramDisk);

  with ramDevice^ do
    begin
      major := 1;
      sectors := ram_drive_size div 512;
      read := ramDrive_read;
      write := ramDrive_write;
    end;
  result := ramDevice;
end;

function dev_ramDestroy:integer;
var
  ramDisk : file;

begin
  assign(ramDisk, 'ram.dsk');
  reset(ramDisk, 1);
  blockwrite(ramDisk, ram_data^, ram_drive_size);
  close(ramDisk);
  freemem(ram_data, ram_drive_size);
end;

begin
  ram_data := NIL;
  ram_drive_size := 0; *)
end.