source: branches/simple/Cpu.pas

unit Cpu;

interface

uses
  Classes, SysUtils, Channel;

type
  TInstruction = (inLoadImmediate, inLoadImmediate8, inLoadImmediate16,
    inLoad, inLoad8, inLoad16, inLoad32, inLoad64,
    inStore, inStore8, inStore16, inStore32, inStore64,
    inInput, inInput8, inInput16, inInput32, inInput64,
    inOutput, inOutput8, inOutput16, inOutput32, inOutput64,
    inNop, inHalt, inJump);

  { TCpu8 }

  TCpu8 = class
  private
  public
    IO: TAddressableChannel8;
    Memory: TAddressableChannel8;
    Terminated: Boolean;
    A: Byte;
    PC: Byte;
    function ReadProg8: Byte;
    procedure Reset;
    procedure Run;
    procedure Step;
    constructor Create;
    destructor Destroy; override;
  end;

  { TCpu16 }

  TCpu16 = class
  private
  public
    IO: TAddressableChannel16;
    Memory: TAddressableChannel16;
    Terminated: Boolean;
    A: Word;
    PC: Word;
    function ReadProg8: Byte;
    function ReadProg16: Word;
    procedure Reset;
    procedure Run;
    procedure Step;
    constructor Create;
    destructor Destroy; override;
  end;

  TCpu = class
    BitWidth: TBitWidth;
    Cpu8: TCpu8;
    Cpu16: TCpu16;
  end;

  TRegMulti = record
    case Byte of
      0: (ValueByte: Byte);
      1: (ValueWord: Word);
  end;

  { TCpuMulti }

  TCpuMulti = class
  private
  public
    IO: TAddressableChannelMulti;
    Memory: TAddressableChannelMulti;
    Terminated: Boolean;
    A: TRegMulti;
    PC: TRegMulti;
    BitWidth: TBitWidth;
    function ReadProg8: Byte;
    function ReadProg16: Word;
    procedure Reset;
    procedure Run;
    procedure Step;
    constructor Create;
    destructor Destroy; override;
  end;


implementation

{ TCpuMulti }

function TCpuMulti.ReadProg8: Byte;
begin
  case BitWidth of
    bw8: begin
      Result := Memory.ReadA8D8(PC.ValueByte);
      Inc(PC.ValueByte);
    end;
    bw16: begin
      Result := Memory.ReadA16D8(PC.ValueWord);
      Inc(PC.ValueWord);
    end;
  end;
end;

function TCpuMulti.ReadProg16: Word;
begin
  case BitWidth of
    //bw8: begin
    //  Result := Memory.ReadA8D16(PC.ValueByte);
    //  Inc(PC.ValueByte);
    //end;
    bw16: begin
      Result := Memory.ReadA16D16(PC.ValueWord);
      Inc(PC.ValueWord);
    end;
  end;
end;

procedure TCpuMulti.Reset;
begin
  Terminated := False;
  PC.ValueWord := 0;
end;

procedure TCpuMulti.Run;
begin
  while not Terminated do
    Step;
end;

procedure TCpuMulti.Step;
var
  Instruction: TInstruction;
begin
  Instruction := TInstruction(ReadProg8);
  case Instruction of
    inNop: ;
    inHalt: Terminated := True;
    inLoadImmediate8: A.ValueByte := ReadProg8;
    inLoadImmediate16: A.ValueWord := ReadProg16;
    inLoadImmediate: case BitWidth of
      bw8: A.ValueByte := ReadProg8;
      bw16: A.ValueWord := ReadProg16;
    end;
    inLoad8: case BitWidth of
      bw8: A.ValueByte := Memory.ReadA8D8(ReadProg8);
      bw16: A.ValueByte := Memory.ReadA16D8(ReadProg16);
    end;
    inLoad16: case BitWidth of
      //bw8: A.ValueWord := Memory.ReadA8D16(ReadProg8);
      bw16: A.ValueWord := Memory.ReadA16D16(ReadProg16);
    end;
    inLoad: case BitWidth of
      bw8: A.ValueByte := Memory.ReadA8D8(ReadProg8);
      bw16: A.ValueWord := Memory.ReadA16D16(ReadProg16);
    end;
    inStore8: case BitWidth of
      bw8: Memory.WriteA8D8(ReadProg8, A.ValueByte);
      bw16: Memory.WriteA16D8(ReadProg16, A.ValueByte);
    end;
    inStore16: case BitWidth of
      //bw8: Memory.WriteA8D16(ReadProg8, A.ValueWord);
      bw16: Memory.WriteA16D16(ReadProg16, A.ValueWord);
    end;
    inStore: case BitWidth of
      bw8: Memory.WriteA8D8(ReadProg8, A.ValueByte);
      bw16: Memory.WriteA16D16(ReadProg16, A.ValueWord);
    end;
    inInput8: case BitWidth of
      bw8: A.ValueByte := IO.ReadA8D8(ReadProg8);
      bw16: A.ValueByte := IO.ReadA16D8(ReadProg16);
    end;
    inInput16: case BitWidth of
      //bw8: A.ValueWord := IO.ReadA8D16(ReadProg8);
      bw16: A.ValueWord := IO.ReadA16D16(ReadProg16);
    end;
    inInput: case BitWidth of
      bw8: A.ValueByte := IO.ReadA8D8(ReadProg8);
      bw16: A.ValueWord := IO.ReadA16D16(ReadProg16);
    end;
    inOutput8: case BitWidth of
      bw8: IO.WriteA8D8(ReadProg8, A.ValueByte);
      bw16: IO.WriteA16D8(ReadProg16, A.ValueWord);
    end;
    inOutput16: case BitWidth of
      //bw8: IO.WriteA8D16(ReadProg8, A.ValueWord);
      bw16: IO.WriteA16D16(ReadProg16, A.ValueWord);
    end;
    inOutput: case BitWidth of
      bw8: IO.WriteA8D8(ReadProg8, A.ValueByte);
      bw16: IO.WriteA16D16(ReadProg16, A.ValueWord);
    end;
    inJump: case BitWidth of
      bw8: PC.ValueByte := ReadProg8;
      bw16: PC.ValueWord := ReadProg16;
    end;
  end;
end;

constructor TCpuMulti.Create;
begin
  IO := TAddressableChannelMulti.Create;
  Memory := TAddressableChannelMulti.Create;
end;

destructor TCpuMulti.Destroy;
begin
  FreeAndNil(IO);
  FreeAndNil(Memory);
  inherited;
end;

{ TCpu16 }

function TCpu16.ReadProg8: Byte;
begin
  Result := Memory.Read8(PC);
  Inc(PC);
end;

function TCpu16.ReadProg16: Word;
begin
  Result := Memory.Read16(PC);
  Inc(PC, SizeOf(Word));
end;

procedure TCpu16.Reset;
begin
  Terminated := False;
  PC := 0;
end;

procedure TCpu16.Run;
begin
  while not Terminated do
    Step;
end;

procedure TCpu16.Step;
var
  Instruction: TInstruction;
begin
  Instruction := TInstruction(ReadProg8);
  case Instruction of
    inNop: ;
    inHalt: Terminated := True;
    inLoadImmediate8: A := (A and $ff00) or ReadProg8;
    inLoadImmediate16: A := ReadProg16;
    inLoadImmediate: A := ReadProg16;
    inLoad8: A := (A and $ff00) or Memory.Read8(ReadProg16);
    inLoad16: A := Memory.Read16(ReadProg16);
    inLoad: A := Memory.Read16(ReadProg16);
    inStore8: Memory.Write8(ReadProg16, A);
    inStore16: Memory.Write16(ReadProg16, A);
    inStore: Memory.Write16(ReadProg16, A);
    inInput8: A := (A and $ff00) or IO.Read8(ReadProg16);
    inInput16: A := IO.Read16(ReadProg16);
    inInput: A := IO.Read16(ReadProg16);
    inOutput8: IO.Write8(ReadProg16, A);
    inOutput16: IO.Write16(ReadProg16, A);
    inOutput: IO.Write16(ReadProg16, A);
    inJump: PC := ReadProg16;
  end;
end;

constructor TCpu16.Create;
begin
  IO := TAddressableChannel16.Create;
  Memory := TAddressableChannel16.Create;
end;

destructor TCpu16.Destroy;
begin
  FreeAndNil(IO);
  FreeAndNil(Memory);
  inherited;
end;

{ TCpu8 }

function TCpu8.ReadProg8: Byte;
begin
  Result := Memory.Read8(PC);
  Inc(PC);
end;

procedure TCpu8.Reset;
begin
  Terminated := False;
  PC := 0;
end;

procedure TCpu8.Run;
begin
  while not Terminated do
    Step;
end;

procedure TCpu8.Step;
var
  Instruction: TInstruction;
begin
  Instruction := TInstruction(ReadProg8);
  case Instruction of
    inNop: ;
    inLoadImmediate, inLoadImmediate8: A := ReadProg8;
    inLoad, inLoad8: A := Memory.Read8(ReadProg8);
    inStore, inStore8: Memory.Write8(ReadProg8, A);
    inInput, inInput8: A := IO.Read8(ReadProg8);
    inOutput, inOutput8: IO.Write8(ReadProg8, A);
    inHalt: Terminated := True;
    inJump: PC := ReadProg8;
  end;
end;

constructor TCpu8.Create;
begin
  IO := TAddressableChannel8.Create;
  Memory := TAddressableChannel8.Create;
end;

destructor TCpu8.Destroy;
begin
  FreeAndNil(IO);
  FreeAndNil(Memory);
  inherited;
end;

end.