source: branches/virtcpu varint/UInstructionWriter.pas

unit UInstructionWriter;

{$mode delphi}{$H+}

interface

uses
  Classes, SysUtils, UCpu;

type
  { TInstructionWriter }

  TInstructionWriter = class
  private
  public
    Memory: Pointer;
    IP: T;
    function GetRelativeAddr(BaseIP, TargetAddr: T): T;
    procedure Write(Value: T);
    procedure WriteSigned(Value: T);
    procedure WriteOpcode(Value: TOpcode);
    procedure WriteString(Text: string);
    procedure NoOperation;
    procedure Load(R1, R2: Integer);
    procedure Halt;
    procedure LoadConst(R, Value: Integer);
    procedure LoadMemory(R1, R2: Integer);
    procedure StoreMemory(R1, R2: Integer);
    procedure Neg(R: Integer);
    procedure Input(R1, R2: Integer);
    procedure Output(R1, R2: Integer);
    procedure Subtract(R1, R2: Integer);
    procedure Jump(Addr: Integer);
    procedure JumpCond(Addr: Integer);
    procedure JumpRelative(R1: Integer; Addr: Integer);
    procedure JumpRelativeCond(Addr: Integer);
    procedure TestEqual(R1, R2: Integer);
    procedure Increment(R: Integer);
    procedure Decrement(R: Integer);
    constructor Create;
    procedure Init;
  end;


implementation

{ TInstructionWriter }

function TInstructionWriter.GetRelativeAddr(BaseIP, TargetAddr: T): T;
begin
  Result := TargetAddr - (BaseIP + 1 + T.GetByteSize);
end;

procedure TInstructionWriter.WriteString(Text: string);
var
  I: Integer;
begin
  for I := 1 to Length(Text) do
    Write(Ord(Text[I]));
end;

procedure TInstructionWriter.NoOperation;
begin
  WriteOpcode(opNop);
end;

procedure TInstructionWriter.Load(R1, R2: Integer);
begin
  WriteOpcode(opLoad);
  Write(R1);
  Write(R2);
end;

procedure TInstructionWriter.Halt;
begin
  WriteOpcode(opHalt);
end;

procedure TInstructionWriter.LoadConst(R, Value: Integer);
begin
  WriteOpcode(opLoadConst);
  Write(R);
  Write(Value);
end;

procedure TInstructionWriter.LoadMemory(R1, R2: Integer);
begin
  WriteOpcode(opLoadMem);
  Write(R1);
  Write(R2);
end;

procedure TInstructionWriter.StoreMemory(R1, R2: Integer);
begin
  WriteOpcode(opStoreMem);
  Write(R1);
  Write(R2);
end;

procedure TInstructionWriter.Neg(R: Integer);
begin
  WriteOpcode(opNeg);
  Write(R);
end;

procedure TInstructionWriter.Input(R1, R2: Integer);
begin
  WriteOpcode(opInput);
  Write(R1);
  Write(R2);
end;

procedure TInstructionWriter.Output(R1, R2: Integer);
begin
  WriteOpcode(opOutput);
  Write(R1);
  Write(R2);
end;

procedure TInstructionWriter.Subtract(R1, R2: Integer);
begin
  WriteOpcode(opSub);
  Write(R1);
  Write(R2);
end;

procedure TInstructionWriter.Jump(Addr: Integer);
begin
  WriteOpcode(opJump);
  Write(Addr);
end;

procedure TInstructionWriter.JumpCond(Addr: Integer);
begin
  WriteOpcode(opJumpCond);
  Write(Addr);
end;

procedure TInstructionWriter.TestEqual(R1, R2: Integer);
begin
  WriteOpcode(opTestEqual);
  Write(R1);
  Write(R2);
end;

procedure TInstructionWriter.JumpRelative(R1: Integer; Addr: Integer);
begin
  WriteOpcode(opJumpRel);
  Write(R1);
  Write(Addr);
end;

procedure TInstructionWriter.JumpRelativeCond(Addr: Integer);
begin
  WriteOpcode(opJumpRelCond);
  Write(Addr - IP - 1);
end;

procedure TInstructionWriter.Increment(R: Integer);
begin
  WriteOpcode(opInc);
  Write(R);
end;

procedure TInstructionWriter.Decrement(R: Integer);
begin
  WriteOpcode(opDec);
  Write(R);
end;

constructor TInstructionWriter.Create;
begin
  Memory := nil;
  Init;
end;

procedure TInstructionWriter.Init;
begin
  IP := 0;
end;

procedure TInstructionWriter.Write(Value: T);
var
  C: Integer;
begin
  C := Value.WriteToAddr(Pointer(NativeUInt(Memory) + IP));
  Inc(IP, C);
end;

procedure TInstructionWriter.WriteSigned(Value: T);
var
  C: Integer;
begin
  C := Value.WriteToAddr(Pointer(NativeUInt(Memory) + IP));
  Inc(IP, C);
end;

procedure TInstructionWriter.WriteOpcode(Value: TOpcode);
begin
  Write(Integer(Value));
end;


end.