{ Unit for absolute memory manipulation ver 1995-05-10
  Modified for Z80180 16 bit I/O addresses }

UNIT memory;

INTERFACE

  FUNCTION out(port: int; data: char);
  FUNCTION in(port: int): char;
  FUNCTION call(funptr: pointer);
  FUNCTION set(address: int; data: int);
  FUNCTION copy(source,dest: pointer; size: int);
  FUNCTION fill(dest: pointer; size: int; data: char);

IMPLEMENTATION


  FUNCTION out(port: int; data: char);
  BEGIN
    inline($FD,$4E,4,$FD,$6E,6,$06,$00,$ED,$69);
  END;


  FUNCTION in(port: int): char;
  BEGIN
    inline($FD,$4E,4,$06,$00,$ED,$68);
  END;


  FUNCTION call(funptr: pointer);
   type
     fn = function();
  BEGIN
    fn(funptr)();
  END call;


  { Store data at absolute memory address }

  FUNCTION set(address: int; data: int);
   type
     ptr = ^int; 
  BEGIN
    ptr(address)^ := data;
    {inline($FD,$E1,$DD,$E1,$D1,$E1,$73,$23,$72,$DD,$E9);}
  END set;


  {FUNCTION set(address: word; data: byte);
  BEGIN
    inline($DD,$E1,$D1,$E1,$73,$DD,$E9);
  END set;}


  { Copy memory contents from source address to destination of specified length
    in bytes. Handles overlapping areas. This one is FAST }

  FUNCTION copy(source,dest: pointer; size: int);
  BEGIN
    if size > 0 then
       if int(source) > int(dest) then
          inline($FD,$6E,4,$FD,$66,5);
          inline($FD,$5E,6,$FD,$56,7);
          inline($FD,$4E,8,$FD,$46,9);
          inline($ED,$B0);
       else
          source := pointer(int(source) + size - 1);
          dest := pointer(int(dest) + size - 1);
          inline($FD,$6E,4,$FD,$66,5);
          inline($FD,$5E,6,$FD,$56,7);
          inline($FD,$4E,8,$FD,$46,9);
          inline($ED,$B8);
       end if;
    end if;
  END copy;


  { Fill with 'data' byte from 'dest' address and 'size' bytes forward. }

  FUNCTION fill(dest: pointer; size: int; data: char);
  BEGIN
    if size > 0 then
       inline($FD,$6E,4,$FD,$66,5);
       inline($FD,$5E,6,$FD,$56,7);
       inline($FD,$4E,8,$FD,$46,9);
       inline($71,$23,$1B,$7B,$B2,$20,$F9);
    end if;
  END fill;


BEGIN
END memory;