source: branches/Z80/UZ80Compiler.pas

unit UZ80Compiler;

{$mode Delphi}{$H+}

interface

uses
  Classes, SysUtils, UDynamicNumber;

type
  TMaskedValue = class
  private
    function GetSize: Integer;
    procedure SetSize(const AValue: Integer);
  public
    Value: TDynamicNumber;
    Mask: TDynamicNumber;
    property Size: Integer read GetSize write SetSize;
    constructor Create;
    destructor Destroy; override;
  end;

  TStringEnumeration = class
    Values: TStringList;
    constructor Create;
    destructor Destroy; override;
  end;

  TOperandType = (otEnumeration, otConstant);

  TOperand = class
    OperandType: TOperandType;
    MaskedValue: TMaskedValue;
    Enumeration: TStringEnumeration;
    constructor Create;
    destructor Destroy; override;
  end;

  TOpcode = class
    Name: string;
    Cycles: Integer;
    Operands: TList;
    MaskedValue: TMaskedValue;
    constructor Create;
    destructor Destroy; override;
  end;

  { TZ80Compiler }

  TZ80Compiler = class
  private
    OperandEnumerations: TList;
    Opcodes: TList;
    MachineCode: TMemoryStream;
    procedure InitOpcodes;
    function FindOpcodeByName(Name: string): TOpcode;
    function ParseLine(var Text: string; Separator: string = ' '): string;
  public
    procedure Load(StringList: TStringList);
    constructor Create;
    destructor Destroy; override;
  end;

implementation

{ TZ80Compiler }

procedure TZ80Compiler.InitOpcodes;
var
  SigleRegistersEnum: TStringEnumeration;
begin
  SigleRegistersEnum := TStringEnumeration.Create;
  with SigleRegistersEnum do begin
    Values.Add('B');
    Values.Add('C');
    Values.Add('D');
    Values.Add('E');
    Values.Add('H');
    Values.Add('L');
    Values.Add('(HL)');
    Values.Add('A');
  end;
  OperandEnumerations.Add(SigleRegistersEnum);

  with TOpcode(Opcodes[Opcodes.Add(TOpcode.Create)]) do begin
    Name := 'NOP';
    with MaskedValue do begin
      Value.Assign(0);
      Mask.Assign($ff);
    end;
  end;
  with TOpcode(Opcodes[Opcodes.Add(TOpcode.Create)]) do begin
    Name := 'INC';
    with MaskedValue do begin
      Value.Assign($04);
      Mask.Assign($c7);
    end;
    with TOperand(Operands[Operands.Add(TOperand.Create)]) do begin
      OperandType := otEnumeration;
      Enumeration := SigleRegistersEnum;
      with MaskedValue do begin
        Value.Assign($00);
        Mask.Assign($38);
      end;
    end;
  end;
end;

function TZ80Compiler.FindOpcodeByName(Name: string): TOpcode;
var
  I: Integer;
begin
  I := 0;
  while (I < Opcodes.Count) and (TOpcode(Opcodes[I]).Name <> Name) do Inc(I);
  if I < Opcodes.Count then Result := Opcodes[I]
    else Result := nil;
end;

function TZ80Compiler.ParseLine(var Text: string; Separator: string = ' '): string;
begin
  Text := Trim(Text);
  Result := Copy(Text, 1, Pos(Separator, Text) - 1);
  if Result <> '' then
    Delete(Text, 1, Length(Result) + Length(Separator));
end;

procedure TZ80Compiler.Load(StringList: TStringList);
var
  I: Integer;
  Line: string;
  InstructionName: string;
  Instruction: TOpcode;
  Parameter: string;
  begin
  for I := 0 to StringList.Count - 1 do begin
    Line := Trim(StringList[I]);
    Line := StringReplace(Line, #9, ' ', [rfReplaceAll]);
    if Length(Line) > 0 then begin
      if Line[1] = ';' then Continue; // Skip commented lines
      InstructionName := ParseLine(Line);
      Instruction := FindOpcodeByName(InstructionName);
      if Assigned(Instruction) then begin
        WriteLn(InstructionName);
        if Pos(',', Line) > 0 then Parameter := ParseLine(Line, ',')
          else Parameter := Line;
        WriteLn(Parameter);
      end else WriteLn('Unknown instruction name "' + InstructionName + '"');
    end;
  end;
end;

constructor TZ80Compiler.Create;
begin
  MachineCode := TMemoryStream.Create;
  Opcodes := TList.Create;
  OperandEnumerations := TList.Create;
  InitOpcodes;
end;

destructor TZ80Compiler.Destroy;
var
  I: Integer;
begin
  for I := 0 to Opcodes.Count - 1 do
    TOpcode(Opcodes[I]).Destroy;
  Opcodes.Destroy;
  for I := 0 to OperandEnumerations.Count - 1 do
    TStringEnumeration(OperandEnumerations[I]).Destroy;
  OperandEnumerations.Destroy;
  MachineCode.Destroy;
  inherited Destroy;
end;

{ TMaskedValue }

function TMaskedValue.GetSize: Integer;
begin
  Result := Value.Size;
end;

procedure TMaskedValue.SetSize(const AValue: Integer);
begin
  Value.Size := AValue;
  Mask.Size := AValue;
end;

constructor TMaskedValue.Create;
begin
  Mask := TDynamicNumber.Create;
  Value := TDynamicNumber.Create;
end;

destructor TMaskedValue.Destroy;
begin
  Mask.Destroy;
  Value.Destroy;
  inherited Destroy;
end;

{ TOpcode }

constructor TOpcode.Create;
begin
  MaskedValue := TMaskedValue.Create;
  Operands := TList.Create;
end;

destructor TOpcode.Destroy;
var
  I: Integer;
begin
  for I := 0 to Operands.Count - 1 do
    TOperand(Operands[I]).Destroy;
  Operands.Destroy;
  MaskedValue.Destroy;
  inherited Destroy;
end;

{ TOperand }

constructor TOperand.Create;
begin
  MaskedValue := TMaskedValue.Create;
  Enumeration := nil;
end;

destructor TOperand.Destroy;
begin
  MaskedValue.Destroy;
  inherited Destroy;
end;

{ TStringEnumeration }

constructor TStringEnumeration.Create;
begin
  Values := TStringList.Create;
end;

destructor TStringEnumeration.Destroy;
begin
  Values.Destroy;
  inherited Destroy;
end;

end.