source: branches/CpuSingleSize/Instructions.pas

unit Instructions;

interface

uses
  Classes, SysUtils, Generics.Collections, Cpu;

type
  TParamType = (ptNone, ptNumber, ptReg, ptRegIndirect, ptRegIndirectIndex,
    ptRegIndirectGroup);
  TParamTypeArray = array of TParamType;

  TInstructionInfo = class
    Instruction: TInstruction;
    Name: string;
    Params: TParamTypeArray;
    Description: string;
  end;

  { TInstructionSet }

  TInstructionSet = class
    Items: TObjectList<TInstructionInfo>;
    function SearchName(Name: string): TInstructionInfo;
    function SearchInstruction(Instruction: TInstruction): TInstructionInfo;
    function AddNew(Instruction: TInstruction; Name: string;
      Params: TParamTypeArray; Description: string): TInstructionInfo;
    constructor Create;
    destructor Destroy; override;
  end;


implementation


{ TInstructionSet }

function TInstructionSet.SearchName(Name: string): TInstructionInfo;
var
  I: Integer;
begin
  I := 0;
  while (I < Items.Count) and (Items[I].Name <> Name) do Inc(I);
  if I < Items.Count then Result := Items[I]
    else Result := nil;
end;

function TInstructionSet.SearchInstruction(Instruction: TInstruction
  ): TInstructionInfo;
var
  I: Integer;
begin
  I := 0;
  while (I < Items.Count) and (Items[I].Instruction <> Instruction) do Inc(I);
  if I < Items.Count then Result := Items[I]
    else Result := nil;
end;

function TInstructionSet.AddNew(Instruction: TInstruction; Name: string;
  Params: TParamTypeArray; Description: string): TInstructionInfo;
begin
  Result := TInstructionInfo.Create;
  Result.Instruction := Instruction;
  Result.Name := Name;
  Result.Params := Params;
  Result.Description := Description;
  Items.Add(Result);
end;

constructor TInstructionSet.Create;
begin
  Items := TObjectList<TInstructionInfo>.Create;
  AddNew(inNop, 'NOP', [], 'No operation - The instruction doesn''t do anything.');
  AddNew(inHalt, 'HALT', [], 'It terminates program execution and halts processor. Processor can be waked up by interrupt.');
  AddNew(inSet, 'SET', [ptReg, ptNumber], 'Sets register to immediate constant value.');
  AddNew(inCopy, 'CP', [ptReg, ptReg], 'Copies value from one register to another.');
  AddNew(inInc, 'INC', [ptReg], 'Increments value in specified register.');
  AddNew(inDec, 'DEC', [ptReg], 'Decrements value in specified register.');
  AddNew(inLoad, 'LD', [ptReg, ptRegIndirect], 'Loads value from memory to register.');
  AddNew(inStore, 'ST', [ptRegIndirect, ptReg], 'Stores value from register to memory.');
  AddNew(inAdd, 'ADD', [ptReg, ptReg], 'Adds second register to first register.');
  AddNew(inSub, 'SUB', [ptReg, ptReg], 'Subtracts second register from first register.');
  AddNew(inIn, 'IN', [ptReg, ptRegIndirectGroup], 'Reads value from input port to register.');
  AddNew(inOut, 'OUT', [ptRegIndirectGroup, ptReg], 'Writes value from register to output port.');
  AddNew(inJumpZero, 'JZ', [ptReg, ptNumber], 'Jumps to given address if value of register is zero');
  AddNew(inJumpNotZero, 'JNZ', [ptReg, ptNumber], 'Jumps to given address if value of register is not zero');
  AddNew(inPush, 'PUSH', [ptReg], 'Pushes value of register to top of the stack.');
  AddNew(inPop, 'POP', [ptReg], 'Pops value of register from top of the stack.');
  AddNew(inCall, 'CALL', [ptNumber], 'Calls subroutine at given address. Stores return address to the stack.');
  AddNew(inRet, 'RET', [], 'Return from subroutine. Reads return address from top of the stack to IP register.');
  AddNew(inAnd, 'AND', [ptReg, ptReg], 'Bitwise AND operation. Result is stored in first parameter.');
  AddNew(inOr, 'OR', [ptReg, ptReg], 'Bitwise OR operation. Result is stored in first parameter.');
  AddNew(inXor, 'XOR', [ptReg, ptReg], 'Bitwise XOR operation. Result is stored in first parameter.');
  AddNew(inXor, 'SHL', [ptReg, ptReg], 'Shifts all bits to the left in first register by n bits according value of second register.');
  AddNew(inXor, 'SHR', [ptReg, ptReg], 'Shifts all bits to the right in first register by n bits according value of second register.');
  AddNew(inMul, 'MUL', [ptReg, ptReg], 'Multiplies first register with second register value.');
  AddNew(inDiv, 'DIV', [ptReg, ptReg], 'Diviedes first register with second register value.');
  AddNew(inMod, 'MOD', [ptReg, ptReg], 'Returns modulo in first registr after division of values.');
  AddNew(inJump, 'JP', [ptNumber], 'Unconditional absolute jump to defined address.');
  AddNew(inJumpRel, 'JR', [ptNumber], 'Unconditional relative jump to defined address.');
  AddNew(inLoadIndex, 'LDI', [ptReg, ptRegIndirectIndex], 'Loads value from memory with numeric index to register.');
  AddNew(inStoreIndex, 'STI', [ptRegIndirectIndex, ptReg], 'Stores value from register to memory with numeric index.');
  AddNew(inLoadCpu, 'LDC', [], 'Loads value from system register.');
  AddNew(inStoreCpu, 'STC', [], 'Stores value to system register.');
  AddNew(inEi, 'EI', [], 'Enables interrupts.');
  AddNew(inDi, 'DI', [], 'Disables interrupts.');
end;

destructor TInstructionSet.Destroy;
begin
  FreeAndNil(Items);
  inherited;
end;

end.