source: branches/ByteArray/Instructions.pas

unit Instructions;

interface

uses
  Classes, SysUtils, Generics.Collections, Cpu;

type
  TParamType = (ptNone, ptRegIndirectIndex, ptRegIndirect, ptReg,
    ptDataWidth, ptAddressWidth, ptData, ptAddress);
  TParamTypeArray = array of TParamType;

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

  { TInstructionInfos }

  TInstructionInfos = class(TObjectList<TInstructionInfo>)
    function SearchByName(Name: string): TInstructionInfo;
    function SearchByNameMultiple(Name: string): TInstructionInfos;
    function SearchInstruction(Instruction: TInstruction): TInstructionInfo;
    function AddNew(Instruction: TInstruction; Name: string;
      Params: TParamTypeArray; Description: string): TInstructionInfo;
    procedure Init;
  end;

const
  ParamTypeString: array[TParamType] of string = ('None', 'Data', 'Address',
    'Register', 'Indirect register', 'Indirect indexed register',
    'Data width', 'Address width');


implementation

{ TInstructionInfos }

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

function TInstructionInfos.SearchByNameMultiple(Name: string
  ): TInstructionInfos;
var
  I: Integer;
begin
  Result := TInstructionInfos.Create(False);
  for I := 0 to Count - 1 do
    if Items[I].Name = Name then Result.Add(Items[I]);
end;

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

function TInstructionInfos.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;
  Add(Result);
end;

procedure TInstructionInfos.Init;
begin
  Clear;
  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(inLoadConst, 'LD', [ptReg, ptData], 'Sets register to immediate constant value.');
  AddNew(inLoadConstSize, 'LD', [ptDataWidth, ptReg, ptData], 'Sets register to immediate constant value.');
  AddNew(inLoad, 'LD', [ptReg, ptReg], 'Copies value from one register to another.');
  AddNew(inLoadSize, 'LD', [ptDataWidth, ptReg, ptReg], 'Copies value from one register to another.');
  AddNew(inLoadMem, 'LD', [ptReg, ptRegIndirect], 'Loads value from memory to register.');
  AddNew(inLoadMemSize, 'LD', [ptDataWidth, ptReg, ptRegIndirect], 'Loads value from memory to register.');
  AddNew(inStoreMem, 'LD', [ptRegIndirect, ptReg], 'Stores value from register to memory.');
  AddNew(inStoreMemSize, 'LD', [ptDataWidth, ptRegIndirect, ptReg], 'Stores value from register to memory.');
  AddNew(inLoadMemIndex, 'LD', [ptReg, ptRegIndirectIndex], 'Loads value from memory with numeric index to register.');
  AddNew(inLoadMemIndexSize, 'LD', [ptDataWidth, ptReg, ptRegIndirectIndex], 'Loads value from memory with numeric index to register.');
  AddNew(inStoreMemIndex, 'LD', [ptRegIndirectIndex, ptReg], 'Stores value from register to memory with numeric index.');
  AddNew(inStoreMemIndexSize, 'LD', [ptDataWidth, ptRegIndirectIndex, ptReg], 'Stores value from register to memory with numeric index.');
  AddNew(inInc, 'INC', [ptReg], 'Increments value in specified register.');
  AddNew(inIncSize, 'INC', [ptDataWidth, ptReg], 'Increments value in specified register.');
  AddNew(inDec, 'DEC', [ptReg], 'Decrements value in specified register.');
  AddNew(inDecSize, 'DEC', [ptDataWidth, ptReg], 'Decrements value in specified register.');
  AddNew(inAdd, 'ADD', [ptReg, ptReg], 'Adds second register to first register.');
  AddNew(inAddSize, 'ADD', [ptDataWidth, ptReg, ptReg], 'Adds second register to first register.');
  AddNew(inSub, 'SUB', [ptReg, ptReg], 'Subtracts second register from first register.');
  AddNew(inSubSize, 'SUB', [ptDataWidth, ptReg, ptReg], 'Subtracts second register from first register.');
  AddNew(inInput, 'IN', [ptReg, ptRegIndirect], 'Reads value from input port to register.');
  AddNew(inOutput, 'OUT', [ptRegIndirect, ptReg], 'Writes value from register to output port.');
  AddNew(inJumpZero, 'JZ', [ptReg, ptAddress], 'Jumps to given address if value of register is zero');
  AddNew(inJumpNotZero, 'JNZ', [ptReg, ptAddress], '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(inPushSize, 'PUSH', [ptDataWidth, ptReg], 'Pushes value of register to top of the stack.');
  AddNew(inPop, 'POP', [ptReg], 'Pops value of register from top of the stack.');
  AddNew(inPopSize, 'POP', [ptDataWidth, ptReg], 'Pops value of register from top of the stack.');
  AddNew(inCall, 'CALL', [ptAddress], 'Calls subroutine at given address. Stores return address to the stack.');
  AddNew(inCallSize, 'CALL', [ptAddressWidth, ptAddress], '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(inRetSize, 'RET', [ptAddressWidth], '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(inAndSize, 'AND', [ptDataWidth, 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(inOrSize, 'OR', [ptDataWidth, 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(inXorSize, 'XOR', [ptDataWidth, ptReg, ptReg], 'Bitwise XOR operation. Result is stored in first parameter.');
  AddNew(inShl, 'SHL', [ptReg, ptReg], 'Shifts all bits to the left in first register by n bits according value of second register.');
  AddNew(inShlSize, 'SHL', [ptDataWidth, ptReg, ptReg], 'Shifts all bits to the left in first register by n bits according value of second register.');
  AddNew(inShr, 'SHR', [ptReg, ptReg], 'Shifts all bits to the right in first register by n bits according value of second register.');
  AddNew(inShrSize, 'SHR', [ptDataWidth, 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(inMulSize, 'MUL', [ptDataWidth, ptReg, ptReg], 'Multiplies first register with second register value.');
  AddNew(inDiv, 'DIV', [ptReg, ptReg], 'Diviedes first register with second register value.');
  AddNew(inDivSize, 'DIV', [ptDataWidth, 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', [ptAddress], 'Unconditional absolute jump to defined address.');
  AddNew(inJumpSize, 'JP', [ptAddressWidth, ptAddress], 'Unconditional absolute jump to defined address.');
  AddNew(inJumpRel, 'JR', [ptAddress], 'Unconditional relative jump to defined address.');
  AddNew(inJumpRelSize, 'JR', [ptAddressWidth, ptAddress], 'Unconditional relative jump to defined address.');
  //AddNew(inLoadCpu, 'LDC', [], 'Loads value from system register.');
  //AddNew(inStoreCpu, 'STC', [], 'Stores value to system register.');
  AddNew(inEnableInterrupts, 'EI', [], 'Enables interrupts.');
  AddNew(inDisableInterrupts, 'DI', [], 'Disables interrupts.');
end;

end.