Changeset 42

Timestamp:

Sep 8, 2023, 11:20:27 PM (8 months ago)

Author:

chronos

Message:

• Modified: Improved simple virtual machine.

Location:

branches/simple

Files:

• Assembler.pas (added)
• Channel.pas (added)
• Cpu.pas (modified) (9 diffs)
• DeviceManager.pas (added)
• Devices (added)
• Devices/Console.pas (moved) (moved from branches/simple/Console.pas ) (4 diffs)
• Devices/Device.pas (moved) (moved from branches/simple/Device.pas ) (2 diffs)
• Devices/Screen.pas (moved) (moved from branches/simple/Screen.pas ) (5 diffs)
• Devices/Storage.pas (added)
• Forms/FormAssembler.lfm (added)
• Forms/FormAssembler.pas (added)
• Forms/FormConsole.pas (modified) (2 diffs)
• Forms/FormDevice.pas (added)
• Forms/FormDevices.lfm (added)
• Forms/FormDevices.pas (added)
• Forms/FormDisassembler.lfm (added)
• Forms/FormDisassembler.pas (added)
• Forms/FormMain.pas (modified) (7 diffs)
• Forms/FormMessages.lfm (added)
• Forms/FormMessages.pas (added)
• Forms/FormScreen.pas (modified) (5 diffs)
• Forms/FormStorage.lfm (added)
• Forms/FormStorage.pas (added)
• Instructions.pas (added)
• Machine.pas (modified) (7 diffs)
• Memory.pas (modified) (6 diffs)
• Message.pas (added)
• Parser.pas (added)
• Pin.pas (added)
• simple.lpi (modified) (5 diffs)
• simple.lpr (modified) (1 diff)

branches/simple/Cpu.pas

@@ -4 +4 @@
 
 uses
-  Classes, SysUtils, DataBus;
+  Classes, SysUtils, Channel;
 
 type
-  TInstruction = (inLoadImmediate8, inLoadImmediate16, inLoad8, inLoad16,
-    inStore8, inStore16, inInput8, inInput16, inOutput8, inOutput16,
-    inHalt, inJump);
+  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 }
@@ -16 +19 @@
   private
   public
-    IO: TDataBus8;
-    Memory: TDataBus8;
+    IO: TAddressableChannel8;
+    Memory: TAddressableChannel8;
     Terminated: Boolean;
     A: Byte;
@@ -25 +28 @@
     procedure Run;
     procedure Step;
+    constructor Create;
+    destructor Destroy; override;
   end;
 
@@ -32 +37 @@
   private
   public
-    IO: TDataBus16;
-    Memory: TDataBus16;
+    IO: TAddressableChannel16;
+    Memory: TAddressableChannel16;
     Terminated: Boolean;
     A: Word;
@@ -42 +47 @@
     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 }
@@ -58 +221 @@
 begin
   Result := Memory.Read16(PC);
-  Inc(PC, 2);
+  Inc(PC, SizeOf(Word));
 end;
 
@@ -79 +242 @@
   Instruction := TInstruction(ReadProg8);
   case Instruction of
+    inNop: ;
     inHalt: Terminated := True;
-    inLoadImmediate8: A := ReadProg8;
+    inLoadImmediate8: A := (A and $ff00) or ReadProg8;
     inLoadImmediate16: A := ReadProg16;
-    inLoad8: A := Memory.Read8(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);
-    inInput8: A := IO.Read8(ReadProg16);
+    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;
 
@@ -120 +302 @@
   Instruction := TInstruction(ReadProg8);
   case Instruction of
-    inLoadImmediate8: A := ReadProg8;
-    inLoad8: A := Memory.Read8(ReadProg8);
-    inStore8: Memory.Write8(ReadProg8, A);
-    inInput8: A := IO.Read8(ReadProg8);
-    inOutput8: IO.Write8(ReadProg8, A);
+    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;
@@ -130 +313 @@
 end;
 
+constructor TCpu8.Create;
+begin
+  IO := TAddressableChannel8.Create;
+  Memory := TAddressableChannel8.Create;
+end;
+
+destructor TCpu8.Destroy;
+begin
+  FreeAndNil(IO);
+  FreeAndNil(Memory);
+  inherited;
+end;
+
 end.
 

branches/simple/Devices/Console.pas

@@ -4 +4 @@
 
 uses
-  Classes, SysUtils, Device, DeviceMapper;
+  Classes, SysUtils, Device, DeviceManager, Channel;
 
 type
-  { TConsole }
 
-  TConsole = class(TDevice16)
+  { TConsole8 }
+
+  TConsole8 = class(TDevice8)
   private
     FOnRead: TReadEvent8;
@@ -16 +17 @@
     function Read8: Byte;
   public
-    procedure RegisterMapper8(Mapper: TDeviceMapper8); override;
-    procedure RegisterMapper16(Mapper: TDeviceMapper16); override;
+    function GetHandlerCount: Integer; override;
+    function GetHandler(Address: Integer): TChannel8; override;
+    property OnWrite: TWriteEvent8 read FOnWrite write FOnWrite;
+    property OnRead: TReadEvent8 read FOnRead write FOnRead;
+  end;
+
+  { TConsole16 }
+
+  TConsole16 = class(TDevice16)
+  private
+    FOnRead: TReadEvent8;
+    FOnWrite: TWriteEvent8;
+    procedure Write8(Data: Byte);
+    function Read8: Byte;
+  public
+    function GetHandlerCount: Integer; override;
+    function GetHandler(Address: Integer): TChannel16; override;
     property OnWrite: TWriteEvent8 read FOnWrite write FOnWrite;
     property OnRead: TReadEvent8 read FOnRead write FOnRead;
@@ -25 +41 @@
 implementation
 
-{ TConsole }
+{ TConsole8 }
 
-procedure TConsole.RegisterMapper8(Mapper: TDeviceMapper8);
-begin
-  Mapper.RegisterReadHandler(Read8);
-  Mapper.RegisterWriteHandler(Write8);
-end;
-
-procedure TConsole.RegisterMapper16(Mapper: TDeviceMapper16);
-begin
-  Mapper.RegisterReadHandler(Read8, nil);
-  Mapper.RegisterWriteHandler(Write8, nil);
-end;
-
-procedure TConsole.Write8(Data: Byte);
+procedure TConsole8.Write8(Data: Byte);
 begin
   if Assigned(FOnWrite) then FOnWrite(Data);
 end;
 
-function TConsole.Read8: Byte;
+function TConsole8.Read8: Byte;
 begin
   if Assigned(FOnRead) then Result := FOnRead
@@ -50 +54 @@
 end;
 
+function TConsole8.GetHandlerCount: Integer;
+begin
+  Result := 1;
+end;
+
+function TConsole8.GetHandler(Address: Integer): TChannel8;
+begin
+  if Address = 0 then begin
+    Result := TChannel8.Create;
+    Result.Read8 := Read8;
+    Result.Write8 := Write8;
+  end;
+end;
+
+{ TConsole16 }
+
+procedure TConsole16.Write8(Data: Byte);
+begin
+  if Assigned(FOnWrite) then FOnWrite(Data);
+end;
+
+function TConsole16.Read8: Byte;
+begin
+  if Assigned(FOnRead) then Result := FOnRead
+    else Result := 0;
+end;
+
+function TConsole16.GetHandlerCount: Integer;
+begin
+  Result := 1;
+end;
+
+function TConsole16.GetHandler(Address: Integer): TChannel16;
+begin
+  if Address = 0 then begin
+    Result := TChannel16.Create;
+    Result.Read8 := Read8;
+    Result.Write8 := Write8;
+  end;
+end;
 
 end.

branches/simple/Devices/Device.pas

@@ -4 +4 @@
 
 uses
-  Classes, SysUtils, DeviceMapper;
+  Classes, SysUtils, Channel, Generics.Collections, Forms;
 
 type
+  TDeviceClass = (dcNone, dcKeyboard, dcMouse, dcStorage, dcScreen, dcConsole,
+    dcTimer);
+  TDeviceClassSet = set of TDeviceClass;
+
   { TDevice8 }
 
   TDevice8 = class
-    procedure RegisterMapper8(Mapper: TDeviceMapper8); virtual; abstract;
+    BaseAddress: Byte;
+    procedure SetDataBus(Channel: TAddressableChannel8); virtual;
+    function GetHandlerCount: Integer; virtual;
+    function GetHandler(Address: Integer): TChannel8; virtual;
   end;
 
@@ -16 +23 @@
 
   TDevice16 = class
-    procedure RegisterMapper8(Mapper: TDeviceMapper8); virtual; abstract;
-    procedure RegisterMapper16(Mapper: TDeviceMapper16); virtual; abstract;
+    BaseAddress: Word;
+    procedure SetDataBus(Channel: TAddressableChannel16); virtual;
+    function GetHandlerCount: Integer; virtual;
+    function GetHandler(Address: Integer): TChannel16; virtual;
   end;
+
+  { TDevice32 }
+
+  TDevice32 = class
+    BaseAddress: DWord;
+    procedure SetDataBus(Channel: TAddressableChannel32); virtual;
+    function GetHandlerCount: Integer; virtual;
+    function GetHandler(Address: Integer): TChannel32; virtual;
+  end;
+
+  { TDevice64 }
+
+  TDevice64 = class
+    BaseAddress: QWord;
+    procedure SetDataBus(Channel: TAddressableChannel64); virtual;
+    function GetHandlerCount: Integer; virtual;
+    function GetHandler(Address: Integer): TChannel64; virtual;
+  end;
+
+  TDevice = class;
+
+  { TFormDevice }
+
+  TFormDevice = class(TForm)
+  protected
+    function GetDevice: TDevice; virtual;
+    procedure SetDevice(AValue: TDevice); virtual;
+  public
+    property Device: TDevice read GetDevice write SetDevice;
+  end;
+
+  TFormDeviceClass = class of TFormDevice;
+
+  { TDevice }
+
+  TDevice = class
+    Name: string;
+    DeviceClass: TDeviceClass;
+    Form: TFormDevice;
+  end;
+
+  { TDevices }
+
+  TDevices = class(TObjectList<TDevice>)
+    function GetDevicesCountByClass(DeviceClass: TDeviceClass): Integer;
+    function GetDevicesByClass(DeviceClass: TDeviceClass): TDevices;
+    function GetClasses: TDeviceClassSet;
+  end;
+
+const
+  DeviceClassText: array[TDeviceClass] of string = ('None', 'Keyboard', 'Mouse', 'Storage', 'Screen', 'Console', 'Timer');
 
 
 implementation
 
+{ TFormDevice }
+
+function TFormDevice.GetDevice: TDevice;
+begin
+  Result := nil;
+end;
+
+procedure TFormDevice.SetDevice(AValue: TDevice);
+begin
+end;
+
+{ TDevices }
+
+function TDevices.GetDevicesCountByClass(DeviceClass: TDeviceClass): Integer;
+var
+  I: Integer;
+begin
+  Result := 0;
+  for I := 0 to Count - 1 do
+    if Items[I].DeviceClass = DeviceClass then Inc(Result);
+end;
+
+function TDevices.GetDevicesByClass(DeviceClass: TDeviceClass): TDevices;
+var
+  I: Integer;
+begin
+  Result := TDevices.Create(False);
+  for I := 0 to Count - 1 do
+    if Items[I].DeviceClass = DeviceClass then Result.Add(Items[I])
+end;
+
+function TDevices.GetClasses: TDeviceClassSet;
+var
+  I: Integer;
+begin
+  Result := [];
+  for I := 0 to Count - 1 do
+    if not (Items[I].DeviceClass in Result) then
+      Result := Result + [Items[I].DeviceClass];
+end;
+
+{ TDevice32 }
+
+procedure TDevice32.SetDataBus(Channel: TAddressableChannel32);
+begin
+end;
+
+function TDevice32.GetHandlerCount: Integer;
+begin
+  Result := 0;
+end;
+
+function TDevice32.GetHandler(Address: Integer): TChannel32;
+begin
+end;
+
+{ TDevice64 }
+
+procedure TDevice64.SetDataBus(Channel: TAddressableChannel64);
+begin
+end;
+
+function TDevice64.GetHandlerCount: Integer;
+begin
+  Result := 0;
+end;
+
+function TDevice64.GetHandler(Address: Integer): TChannel64;
+begin
+end;
+
+{ TDevice8 }
+
+procedure TDevice8.SetDataBus(Channel: TAddressableChannel8);
+begin
+end;
+
+function TDevice8.GetHandlerCount: Integer;
+begin
+  Result := 0;
+end;
+
+function TDevice8.GetHandler(Address: Integer): TChannel8;
+begin
+end;
+
+{ TDevice16 }
+
+procedure TDevice16.SetDataBus(Channel: TAddressableChannel16);
+begin
+end;
+
+function TDevice16.GetHandlerCount: Integer;
+begin
+  Result := 0;
+end;
+
+function TDevice16.GetHandler(Address: Integer): TChannel16;
+begin
+end;
+
 end.
 

branches/simple/Devices/Screen.pas

@@ -4 +4 @@
 
 uses
-  Classes, SysUtils, Device, DeviceMapper, Memory;
+  Classes, SysUtils, Device, DeviceManager, Memory, Channel;
 
 type
@@ -31 +31 @@
     constructor Create;
     destructor Destroy; override;
-    procedure RegisterMapper8(Mapper: TDeviceMapper8); override;
+    function GetHandlerCount: Integer; override;
+    function GetHandler(Address: Integer): TChannel8; override;
     property OnChange: TNotifyEvent read FOnChange write FOnChange;
   end;
@@ -59 +60 @@
     constructor Create;
     destructor Destroy; override;
-    procedure RegisterMapper8(Mapper: TDeviceMapper8); override;
-    procedure RegisterMapper16(Mapper: TDeviceMapper16); override;
+    function GetHandlerCount: Integer; override;
+    function GetHandler(Address: Integer): TChannel16; override;
     property OnChange: TNotifyEvent read FOnChange write FOnChange;
   end;
 
+  TScreen = class(TDevice)
+    BitWidth: TBitWidth;
+    Screen8: TScreen8;
+    Screen16: TScreen16;
+    constructor Create(BitWidth: TBitWidth; Screen8: TScreen8; Screen16: TScreen16);
+  end;
+
 
 implementation
+
+{ TScreen }
+
+constructor TScreen.Create(BitWidth: TBitWidth; Screen8: TScreen8;
+  Screen16: TScreen16);
+begin
+  Self.BitWidth := BitWidth;
+  Self.Screen8 := Screen8;
+  Self.Screen16 := Screen16;
+end;
 
 { TScreen16 }
@@ -149 +167 @@
 end;
 
-procedure TScreen16.RegisterMapper8(Mapper: TDeviceMapper8);
-begin
-end;
-
-procedure TScreen16.RegisterMapper16(Mapper: TDeviceMapper16);
-begin
-  Mapper.RegisterReadHandler(ReadData8, ReadData16);
-  Mapper.RegisterWriteHandler(WriteData8, WriteData16);
-  Mapper.RegisterReadHandler(nil, ReadAddr16);
-  Mapper.RegisterWriteHandler(nil, WriteAddr16);
-  Mapper.RegisterReadHandler(nil, ReadWidth16);
-  Mapper.RegisterWriteHandler(nil, WriteWidth16);
-  Mapper.RegisterReadHandler(nil, ReadHeight16);
-  Mapper.RegisterWriteHandler(nil, WriteHeight16);
+function TScreen16.GetHandlerCount: Integer;
+begin
+  Result := 4;
+end;
+
+function TScreen16.GetHandler(Address: Integer): TChannel16;
+begin
+  if Address = 0 then begin
+    Result := TChannel16.Create;
+    Result.Read16 := ReadData16;
+    Result.Write16 := WriteData16;
+  end else
+  if Address = 1 then begin
+    Result := TChannel16.Create;
+    Result.Read16 := ReadAddr16;
+    Result.Write16 := WriteAddr16;
+  end else
+  if Address = 2 then begin
+    Result := TChannel16.Create;
+    Result.Read16 := ReadWidth16;
+    Result.Write16 := WriteWidth16;
+  end else
+  if Address = 3 then begin
+    Result := TChannel16.Create;
+    Result.Read16 := ReadHeight16;
+    Result.Write16 := WriteHeight16;
+  end;
 end;
 
@@ -236 +267 @@
 end;
 
-procedure TScreen8.RegisterMapper8(Mapper: TDeviceMapper8);
-begin
-  Mapper.RegisterReadHandler(ReadData8);
-  Mapper.RegisterWriteHandler(WriteData8);
-  Mapper.RegisterReadHandler(ReadAddr8);
-  Mapper.RegisterWriteHandler(WriteAddr8);
-  Mapper.RegisterReadHandler(ReadWidth8);
-  Mapper.RegisterWriteHandler(WriteWidth8);
-  Mapper.RegisterReadHandler(ReadHeight8);
-  Mapper.RegisterWriteHandler(WriteHeight8);
+function TScreen8.GetHandlerCount: Integer;
+begin
+  Result := 4;
+end;
+
+function TScreen8.GetHandler(Address: Integer): TChannel8;
+begin
+  if Address = 0 then begin
+    Result := TChannel8.Create;
+    Result.Read8 := ReadData8;
+    Result.Write8 := WriteData8;
+  end else
+  if Address = 1 then begin
+    Result := TChannel8.Create;
+    Result.Read8 := ReadAddr8;
+    Result.Write8 := WriteAddr8;
+  end else
+  if Address = 2 then begin
+    Result := TChannel8.Create;
+    Result.Read8 := ReadWidth8;
+    Result.Write8 := WriteWidth8;
+  end else
+  if Address = 3 then begin
+    Result := TChannel8.Create;
+    Result.Read8 := ReadHeight8;
+    Result.Write8 := WriteHeight8;
+  end;
 end;
 

branches/simple/Forms/FormConsole.pas

@@ -4 +4 @@
 
 uses
-  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls;
+  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls, Device;
 
 type
@@ -10 +10 @@
   { TFormConsole }
 
-  TFormConsole = class(TForm)
+  TFormConsole = class(TFormDevice)
     Memo1: TMemo;
   public

branches/simple/Forms/FormMain.pas

@@ -43 +43 @@
 {$R *.lfm}
 
+uses
+  Screen, Channel;
+
 { TFormMain }
 
@@ -49 +52 @@
   FormScreen := TFormScreen.Create(nil);
   FormConsole := TFormConsole.Create(nil);
-  InitMachine16;
+  InitMachine8;
 end;
 
@@ -66 +69 @@
   FreeAndNil(FormScreen);
   FreeAndNil(FormConsole);
-  FreeAndNil(Machine8);
+  if Assigned(Machine8) then FreeAndNil(Machine8);
+  if Assigned(Machine16) then FreeAndNil(Machine16);
 end;
 
@@ -80 +84 @@
     Console.OnWrite := FormConsole.ConsoleWrite;
     Screen.OnChange := FormScreen.ScreenChange;
-    FormScreen.Machine := Machine8;
+    FormScreen.Screen := TScreen.Create(bw8, Machine8.Screen, nil);
     with Memory do begin
       // LD A8, 'A'
@@ -90 +94 @@
       // LD A8, 'A'
       WritePos8(Byte(inLoadImmediate8));
-      WritePos8(Ord('H'));
-      // OUT (0), A8
-      WritePos8(Byte(inOutput8));
-      WritePos8(1);
+      WritePos8(Ord('B'));
       // OUT (0), A8
       WritePos8(Byte(inOutput8));
@@ -110 +111 @@
     Console.OnWrite := FormConsole.ConsoleWrite;
     Screen.OnChange := FormScreen.ScreenChange;
-    FormScreen.Machine := Machine16;
+    FormScreen.Screen := TScreen.Create(bw16, nil, Machine16.Screen);
     with Memory do begin
       // LD A8, 'A'
@@ -122 +123 @@
       WritePos16(Ord('H'));
       // OUT8 (0), A8
-      WritePos8(Byte(inOutput8));
+      WritePos8(Byte(inOutput16));
       WritePos16(1);
       // HALT

branches/simple/Forms/FormScreen.pas

@@ -4 +4 @@
 
 uses
-  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, ExtCtrls, Machine;
+  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, ExtCtrls, Screen,
+  Channel, Device;
 
 type
@@ -10 +11 @@
   { TFormScreen }
 
-  TFormScreen = class(TForm)
+  TFormScreen = class(TFormDevice)
     Image1: TImage;
     TimerDraw: TTimer;
@@ -17 +18 @@
     DrawPending: Boolean;
   public
-    Machine: TMachine;
+    Screen: TScreen;
     procedure ScreenChange(Sender: TObject);
   end;
@@ -36 +37 @@
   if DrawPending then begin
     DrawPending := False;
-    if Machine is TMachine16 then
-    with TMachine16(Machine).Screen do begin
+    if Screen.BitWidth = bw8 then
+    with Screen.Screen8 do begin
       Image1.Picture.Bitmap.SetSize(Width * CharSize, Height * CharSize);
       Image1.Picture.Bitmap.Canvas.FillRect(0, 0, Image1.Picture.Bitmap.Width,
@@ -46 +47 @@
             Chr(Memory.Read8(Y * Width + X)));
     end else
-    if Machine is TMachine8 then
-    with TMachine8(Machine).Screen do begin
+    if Screen.BitWidth = bw16 then
+    with Screen.Screen16 do begin
       Image1.Picture.Bitmap.SetSize(Width * CharSize, Height * CharSize);
       Image1.Picture.Bitmap.Canvas.FillRect(0, 0, Image1.Picture.Bitmap.Width,

branches/simple/Machine.pas

@@ -4 +4 @@
 
 uses
-  Classes, SysUtils, Cpu, Memory, DeviceMapper, Console, Screen;
+  Classes, SysUtils, Cpu, Memory, DeviceManager, Console, Screen;
 
 type
@@ -25 +25 @@
     procedure SetPoweredOn(AValue: Boolean); override;
   public
-    DeviceMapper: TDeviceMapper8;
+    DeviceManager: TDeviceManager8;
     Memory: TMemory8;
-    Console: TConsole;
+    Console: TConsole8;
     Cpu: TCpu8;
     Screen: TScreen8;
@@ -41 +41 @@
     procedure SetPoweredOn(AValue: Boolean); override;
   public
-    DeviceMapper: TDeviceMapper16;
+    DeviceManager: TDeviceManager16;
     Memory: TMemory16;
-    Console: TConsole;
+    Console: TConsole16;
     Cpu: TCpu16;
     Screen: TScreen16;
@@ -72 +72 @@
 constructor TMachine16.Create;
 begin
-  DeviceMapper := TDeviceMapper16.Create;
-  Console := TConsole.Create;
-  Console.RegisterMapper16(DeviceMapper);
+  Cpu := TCpu16.Create;
+  Console := TConsole16.Create;
   Screen := TScreen16.Create;
-  Screen.RegisterMapper16(DeviceMapper);
+  DeviceManager := TDeviceManager16.Create;
+  DeviceManager.RegisterDevice(Console);
+  DeviceManager.RegisterDevice(Screen);
+  DeviceManager.SetDataBus(Cpu.IO);
   Memory := TMemory16.Create;
   Memory.Size := 65535;
-  Cpu := TCpu16.Create;
-  Cpu.IO := DeviceMapper;
-  Cpu.Memory := Memory;
+  Memory.SetDataBus(Cpu.Memory);
 end;
 
@@ -87 +87 @@
 begin
   FreeAndNil(Cpu);
-  FreeAndNil(DeviceMapper);
+  FreeAndNil(DeviceManager);
   FreeAndNil(Console);
   FreeAndNil(Memory);
@@ -105 +105 @@
 constructor TMachine8.Create;
 begin
-  DeviceMapper := TDeviceMapper8.Create;
-  Console := TConsole.Create;
-  Console.RegisterMapper8(DeviceMapper);
+  Cpu := TCpu8.Create;
+  Console := TConsole8.Create;
   Screen := TScreen8.Create;
-  Screen.RegisterMapper8(DeviceMapper);
+  DeviceManager := TDeviceManager8.Create;
+  DeviceManager.RegisterDevice(Console);
+  DeviceManager.RegisterDevice(Screen);
+  DeviceManager.SetDataBus(Cpu.IO);
   Memory := TMemory8.Create;
   Memory.Size := 255;
-  Cpu := TCpu8.Create;
-  Cpu.IO := DeviceMapper;
-  Cpu.Memory := Memory;
+  Memory.SetDataBus(Cpu.Memory);
 end;
 
@@ -120 +120 @@
 begin
   FreeAndNil(Cpu);
-  FreeAndNil(DeviceMapper);
+  FreeAndNil(DeviceManager);
   FreeAndNil(Console);
   FreeAndNil(Memory);

branches/simple/Memory.pas

@@ -4 +4 @@
 
 uses
-  Classes, SysUtils, DataBus;
+  Classes, SysUtils, Channel, Device;
 
 type
+
+  { TMemoryMulti }
+
+  TMemoryMulti = class
+  private
+    Memory: array of Byte;
+    procedure SetSize(Value: QWord);
+    function GetSize: QWord;
+  public
+    Position: QWord;
+    property Size: QWord read GetSize write SetSize;
+  end;
+
   { TMemory8 }
 
-  TMemory8 = class(TDataBus8)
+  TMemory8 = class(TDevice8)
   private
     Memory: array of Byte;
@@ -18 +31 @@
     procedure WritePos8(Data: Byte);
     function ReadPos8: Byte;
-    procedure Write8(Address: Byte; Data: Byte); override;
-    function Read8(Address: Byte): Byte; override;
+    procedure Write8(Address: Byte; Data: Byte);
+    function Read8(Address: Byte): Byte;
+    procedure SetDataBus(Channel: TAddressableChannel8); override;
     property Size: Byte read GetSize write SetSize;
   end;
@@ -25 +39 @@
   { TMemory16 }
 
-  TMemory16 = class(TDataBus16)
+  TMemory16 = class(TDevice16)
   private
     Memory: array of Byte;
@@ -36 +50 @@
     procedure WritePos8(Data: Byte);
     procedure WritePos16(Data: Word);
-    function Read8(Address: Word): Byte; override;
-    function Read16(Address: Word): Word; override;
-    procedure Write8(Address: Word; Data: Byte); override;
-    procedure Write16(Address: Word; Data: Word); override;
+    function Read8(Address: Word): Byte;
+    function Read16(Address: Word): Word;
+    procedure Write8(Address: Word; Data: Byte);
+    procedure Write16(Address: Word; Data: Word);
+    procedure SetDataBus(Channel: TAddressableChannel16); override;
     property Size: Word read GetSize write SetSize;
   end;
 
+  { TMemory64 }
+
+  TMemory64 = class(TDevice64)
+  private
+    Memory: array of Byte;
+    procedure SetSize(Value: QWord);
+    function GetSize: QWord;
+  public
+    Position: QWord;
+    function ReadPos8: Byte;
+    function ReadPos16: Word;
+    function ReadPos32: DWord;
+    function ReadPos64: QWord;
+    procedure WritePos8(Data: Byte);
+    procedure WritePos16(Data: Word);
+    procedure WritePos32(Data: Word);
+    procedure WritePos64(Data: Word);
+    function Read8(Address: QWord): Byte;
+    function Read16(Address: QWord): Word;
+    function Read32(Address: QWord): DWord;
+    function Read64(Address: QWord): QWord;
+    procedure Write8(Address: QWord; Data: Byte);
+    procedure Write16(Address: QWord; Data: Word);
+    procedure Write32(Address: QWord; Data: DWord);
+    procedure Write64(Address: QWord; Data: QWord);
+    procedure SetDataBus(Channel: TAddressableChannel64); override;
+    property Size: QWord read GetSize write SetSize;
+  end;
+
+  { TMemory }
+
+  TMemory = class(TDevice)
+    BitWidth: TBitWidth;
+    Memory8: TMemory8;
+    Memory16: TMemory16;
+  end;
+
 
 implementation
+
+{ TMemory64 }
+
+procedure TMemory64.SetSize(Value: QWord);
+begin
+
+end;
+
+function TMemory64.GetSize: QWord;
+begin
+
+end;
+
+function TMemory64.ReadPos8: Byte;
+begin
+
+end;
+
+function TMemory64.ReadPos16: Word;
+begin
+
+end;
+
+function TMemory64.ReadPos32: DWord;
+begin
+
+end;
+
+function TMemory64.ReadPos64: QWord;
+begin
+
+end;
+
+procedure TMemory64.WritePos8(Data: Byte);
+begin
+
+end;
+
+procedure TMemory64.WritePos16(Data: Word);
+begin
+
+end;
+
+procedure TMemory64.WritePos32(Data: Word);
+begin
+
+end;
+
+procedure TMemory64.WritePos64(Data: Word);
+begin
+
+end;
+
+function TMemory64.Read8(Address: QWord): Byte;
+begin
+
+end;
+
+function TMemory64.Read16(Address: QWord): Word;
+begin
+
+end;
+
+function TMemory64.Read32(Address: QWord): DWord;
+begin
+
+end;
+
+function TMemory64.Read64(Address: QWord): QWord;
+begin
+
+end;
+
+procedure TMemory64.Write8(Address: QWord; Data: Byte);
+begin
+
+end;
+
+procedure TMemory64.Write16(Address: QWord; Data: Word);
+begin
+
+end;
+
+procedure TMemory64.Write32(Address: QWord; Data: DWord);
+begin
+
+end;
+
+procedure TMemory64.Write64(Address: QWord; Data: QWord);
+begin
+
+end;
+
+procedure TMemory64.SetDataBus(Channel: TAddressableChannel64);
+begin
+  inherited SetDataBus(Channel);
+end;
+
+{ TMemoryMulti }
+
+procedure TMemoryMulti.SetSize(Value: QWord);
+begin
+  SetLength(Memory, Size);
+end;
+
+function TMemoryMulti.GetSize: QWord;
+begin
+  Result := Length(Memory);
+end;
 
 { TMemory16 }
@@ -103 +264 @@
 end;
 
+procedure TMemory16.SetDataBus(Channel: TAddressableChannel16);
+begin
+  Channel.Read8 := Read8;
+  Channel.Read16 := Read16;
+  Channel.Write8 := Write8;
+  Channel.Write16 := Write16;
+end;
+
 { TMemory8 }
 
@@ -137 +306 @@
 end;
 
+procedure TMemory8.SetDataBus(Channel: TAddressableChannel8);
+begin
+  Channel.Write8 := Write8;
+  Channel.Read8 := Read8;
+end;
 
 end.

branches/simple/simple.lpi

@@ -26 +26 @@
     <RequiredPackages>
       <Item>
+        <PackageName Value="SynEdit"/>
+      </Item>
+      <Item>
         <PackageName Value="LCL"/>
       </Item>
@@ -50 +53 @@
       </Unit>
       <Unit>
-        <Filename Value="DataBus.pas"/>
+        <Filename Value="Channel.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit>
@@ -58 +61 @@
       </Unit>
       <Unit>
-        <Filename Value="DeviceMapper.pas"/>
+        <Filename Value="DeviceManager.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit>
       <Unit>
-        <Filename Value="Device.pas"/>
+        <Filename Value="Devices/Device.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit>
       <Unit>
-        <Filename Value="Console.pas"/>
+        <Filename Value="Devices/Console.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit>
       <Unit>
-        <Filename Value="Screen.pas"/>
+        <Filename Value="Devices/Screen.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit>
@@ -87 +90 @@
         <ResourceBaseClass Value="Form"/>
       </Unit>
+      <Unit>
+        <Filename Value="Assembler.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Parser.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Instructions.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Message.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Forms/FormAssembler.pas"/>
+        <IsPartOfProject Value="True"/>
+        <ComponentName Value="FormAssembler"/>
+        <HasResources Value="True"/>
+        <ResourceBaseClass Value="Form"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Forms/FormDevices.pas"/>
+        <IsPartOfProject Value="True"/>
+        <ComponentName Value="FormDevices"/>
+        <HasResources Value="True"/>
+        <ResourceBaseClass Value="Form"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Forms/FormDisassembler.pas"/>
+        <IsPartOfProject Value="True"/>
+        <ComponentName Value="FormDisassembler"/>
+        <ResourceBaseClass Value="Form"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Forms/FormMessages.pas"/>
+        <IsPartOfProject Value="True"/>
+        <ComponentName Value="FormMessages"/>
+        <ResourceBaseClass Value="Form"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Forms/FormStorage.pas"/>
+        <IsPartOfProject Value="True"/>
+        <ComponentName Value="FormStorage"/>
+        <HasResources Value="True"/>
+        <ResourceBaseClass Value="Form"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Pin.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Forms/FormDevice.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
+      <Unit>
+        <Filename Value="Devices/Storage.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit>
     </Units>
   </ProjectOptions>
@@ -96 +160 @@
     <SearchPaths>
       <IncludeFiles Value="$(ProjOutDir)"/>
-      <OtherUnitFiles Value="Forms"/>
+      <OtherUnitFiles Value="Forms;Devices"/>
       <UnitOutputDirectory Value="lib/$(TargetCPU)-$(TargetOS)"/>
     </SearchPaths>

branches/simple/simple.lpr

@@ -11 +11 @@
   {$ENDIF}
   Interfaces, // this includes the LCL widgetset
-  Forms, FormMain, Cpu, Machine, DataBus, Memory, DeviceMapper, Device, Console,
-  Screen, FormScreen, FormConsole;
+  Forms, FormMain, Cpu, Machine, Channel, Memory,
+DeviceManager, Device, Console,
+  Screen, Assembler, Parser, Instructions, Message, FormScreen, FormConsole,
+  FormAssembler, FormDevices, FormDisassembler, FormMessages, FormStorage,
+  Pin, FormDevice, Storage;
 
 {$R *.res}