Changeset 10

Timestamp:

Apr 20, 2026, 9:52:45 PM (6 days ago)

Author:

chronos

Message:

• Added: Decoding area of instructions with two prefixes.
• Modified: Improved parameter handling in disassembler.
• Modified: Improving handling of flags.

Location:

trunk

Files:

• Disassembler.pas (modified) (2 diffs)
• Z80/InstructionSetGen.pas (modified) (1 diff)
• Z80/Z80.pas (modified) (20 diffs)
• Z80/Z80InstructionInfo.pas (modified) (12 diffs)
• Z80/Z80Instructions.pas (modified) (1 diff)

trunk/Disassembler.pas

@@ -103 +103 @@
     Value := Memory.ReadByte;
     DecodedInstruction.AddOpcode(Value);
-    if Value = $cb then begin
+    if Value = $CB then begin
       Value := Memory.ReadByte;
       DecodedInstruction.AddOpcode(Value);
       Value := $100 or Value;
     end else
-    if Value = $dd then begin
-      Value := Memory.ReadByte;
-      DecodedInstruction.AddOpcode(Value);
-      Value := $200 or Value;
+    if Value = $DD then begin
+      Value := Memory.ReadByte;
+      DecodedInstruction.AddOpcode(Value);
+      if Value = $CB then begin
+        Value := Memory.ReadByte;
+        DecodedInstruction.AddOpcode(Value);
+        Value := $500 or Value;
+      end else Value := $200 or Value;
     end else
-    if Value = $ed then begin
+    if Value = $ED then begin
       Value := Memory.ReadByte;
       DecodedInstruction.AddOpcode(Value);
       Value := $300 or Value;
     end else
-    if Value = $fd then begin
-      Value := Memory.ReadByte;
-      DecodedInstruction.AddOpcode(Value);
-      Value := $400 or Value;
+    if Value = $FD then begin
+      Value := Memory.ReadByte;
+      DecodedInstruction.AddOpcode(Value);
+      if Value = $CB then begin
+        Value := Memory.ReadByte;
+        DecodedInstruction.AddOpcode(Value);
+        Value := $600 or Value;
+      end else Value := $400 or Value;
     end;
     if (Value >= 0) and (Value <= Integer(High(TInstruction))) then begin
@@ -153 +161 @@
             DecodedInstruction.Parameters := DecodedInstruction.Parameters + '(' + IntToHex(Value, 4) + ')';
           end else
+          if InstructionInfo.Params[J] = ptDisplacement then begin
+            Value := Memory.ReadByte;
+            DecodedInstruction.AddOpcode(Value);
+            DecodedInstruction.Parameters := DecodedInstruction.Parameters + IntToStr(ShortInt(Value));
+          end else
           if InstructionInfo.Params[J] in [ptRegA, ptRegB, ptRegC, ptRegD,
-            ptRegE, ptRegH, ptRegL, ptRegBC, ptRegDE, ptRegHL, ptRegSP, ptRegIX,
-            ptRegIY,
-            ptFlagZ, ptFlagNZ, ptFlagC, ptFlagNC, ptFlagP, ptFlagPO,
-            ptRegBCIndir, ptRegDEIndir, ptRegHLIndir, ptRegSPIndir,
+            ptRegE, ptRegH, ptRegL, ptRegR, ptRegI,
+            ptRegAF, ptRegBC, ptRegDE, ptRegHL, ptRegSP, ptRegIX, ptRegIY,
+            ptRegAFPair, ptRegBCPair, ptRegDEPair, ptRegHLPair,
+            ptFlagZ, ptFlagNZ, ptFlagC, ptFlagNC, ptFlagP, ptFlagPO, ptFlagPE, ptFlagM,
+            ptRegBCIndir, ptRegDEIndir, ptRegHLIndir, ptRegSPIndir, ptRegCIndir,
             pt00, pt08, pt10, pt18, pt20, pt28, pt30, pt38,
             pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7] then begin

trunk/Z80/InstructionSetGen.pas

@@ -129 +129 @@
       while Params <> '' do begin
         ParamsPart := GetStringPart(Params, ',');
-        ParamType := StrToParamType(ParamsPart);
+        ParamType := StrToParamType(ParamsPart, NameOnly);
         if ParamType <> ptNone then
           InfoParams := InfoParams + ', ' + GetEnumName(TypeInfo(TParamType), Integer(ParamType));

trunk/Z80/Z80.pas

@@ -57 +57 @@
     MessageText: string;
     procedure Error(Message: string);
+    function GetCarry: Boolean;
+    function GetParityOverflow: Boolean;
+    function GetSignNegative: Boolean;
+    function GetZero: Boolean;
+    procedure SetCarry(AValue: Boolean);
+    procedure SetParityOverflow(AValue: Boolean);
+    procedure SetSignNegative(AValue: Boolean);
+    procedure SetZero(AValue: Boolean);
     procedure SetRunning(AValue: Boolean);
     function DoRead(Address: Word): Byte;
@@ -72 +80 @@
     procedure Call(Address: Word);
     procedure CallCond(Address: Word; Condition: Boolean);
-    procedure Cp(Data: Byte);
+    procedure CpByte(Data: Byte);
     procedure Jr(Condition: Boolean);
     procedure Jp(Condition: Boolean);
@@ -808 +816 @@
     RegI: Byte;
     RegR: Byte;
-    Carry: Boolean;
-    Zero: Boolean;
-    ParityOverflow: Boolean;
-    SignNegative: Boolean;
     Memory: TMemory;
     Ticks: Cardinal;
@@ -823 +827 @@
     constructor Create;
     destructor Destroy; override;
+    property Carry: Boolean read GetCarry write SetCarry;
+    property Zero: Boolean read GetZero write SetZero;
+    property ParityOverflow: Boolean read GetParityOverflow
+      write SetParityOverflow;
+    property SignNegative: Boolean read GetSignNegative write SetSignNegative;
     property Thread: TCpuThread read FThread;
     property Running: Boolean read FRunning write SetRunning;
@@ -858 +867 @@
   DoMessage(Message + ' on address ' + IntToHex(Word(PC), 4));
   Halt;
+end;
+
+function TCpuZ80.GetCarry: Boolean;
+begin
+  Result := (AF.F and $1) <> 0;
+end;
+
+function TCpuZ80.GetParityOverflow: Boolean;
+begin
+  Result := (AF.F and $4) <> 0;
+end;
+
+function TCpuZ80.GetSignNegative: Boolean;
+begin
+  Result := (AF.F and $80) <> 0;
+end;
+
+function TCpuZ80.GetZero: Boolean;
+begin
+  Result := (AF.F and $40) <> 0;
+end;
+
+procedure TCpuZ80.SetCarry(AValue: Boolean);
+begin
+  AF.F := (AF.F and $fe) or Byte(AValue);
+end;
+
+procedure TCpuZ80.SetParityOverflow(AValue: Boolean);
+begin
+  AF.F := (AF.F and $fb) or (Byte(AValue) shl 2);
+end;
+
+procedure TCpuZ80.SetSignNegative(AValue: Boolean);
+begin
+  AF.F := (AF.F and $7f) or (Byte(AValue) shl 7);
+end;
+
+procedure TCpuZ80.SetZero(AValue: Boolean);
+begin
+  AF.F := (AF.F and $bf) or (Byte(AValue) shl 6);
 end;
 
@@ -968 +1017 @@
 end;
 
-procedure TCpuZ80.Cp(Data: Byte);
+procedure TCpuZ80.CpByte(Data: Byte);
 var
-  TempByte: Byte;
-begin
-  Carry := Data > AF.A;
-  TempByte := Byte(ShortInt(AF.A) - ShortInt(Data));
-  Zero := TempByte = 0;
+  Temp: Byte;
+begin
+  Temp := AF.A;
+  SubByte(Temp, Data);
 end;
 
@@ -1011 +1059 @@
 
 procedure TCpuZ80.AddByte(var Target: Byte; Second: Byte);
-begin
-  Target := Byte(Target + Second);
+var
+  Temp: Word;
+begin
+  Temp := Target + Second;
+  ParityOverflow := ((Target and $80) = (Second and $80)) and
+    ((Target and $80) <> (Temp and $80));
+  Carry := (Temp and $100) <> 0;
+  Zero := Byte(Temp) = 0;
+  SignNegative := (Temp and $80) <> 0;
+  Target := Byte(Temp);
 end;
 
 procedure TCpuZ80.AddWord(var Target: Word; Second: Word);
-begin
-  Target := Word(Target + Second);
+var
+  Temp: Cardinal;
+begin
+  Temp := Target + Second;
+  Carry := Temp > $ffff;
+  Target := Word(Temp + Second);
 end;
 
 procedure TCpuZ80.AdcByte(var Target: Byte; Second: Byte);
-begin
-  Target := Target + Second;
+var
+  Temp: Word;
+begin
+  Temp := Target + Second + Byte(Carry);
+  ParityOverflow := ((Target and $80) = (Second and $80)) and
+    ((Target and $80) <> (Temp and $80));
+  Carry := (Temp and $100) <> 0;
+  Zero := Byte(Temp) = 0;
+  SignNegative := (Temp and $80) <> 0;
+  Target := Byte(Temp);
 end;
 
 procedure TCpuZ80.AdcWord(var Target: Word; Second: Word);
-begin
-  Target := Target - Second;
+var
+  Temp: Cardinal;
+begin
+  Temp := Target + Second + Byte(Carry);
+  Carry := Temp > $ffff;
+  Target := Word(Temp + Second);
 end;
 
 procedure TCpuZ80.SubByte(var Target: Byte; Second: Byte);
-begin
-  Target := Byte(Target - Second);
+var
+  Temp: SmallInt;
+begin
+  Temp := ShortInt(Target) - ShortInt(Second);
+  ParityOverflow := ((Target and $80) <> (Second and $80)) and
+    ((Target and $80) <> (Temp and $80));
+  Carry := (Temp and $100) <> 0;
+  Zero := Byte(Temp) = 0;
+  SignNegative := (Temp and $80) <> 0;
+  Target := Byte(Temp);
 end;
 
 procedure TCpuZ80.SbcByte(var Target: Byte; Second: Byte);
-begin
-  Target := Target - Second;
+var
+  Temp: SmallInt;
+begin
+  Temp := ShortInt(Target) - ShortInt(Second) - Byte(Carry);
+  ParityOverflow := ((Target and $80) <> (Second and $80)) and
+    ((Target and $80) <> (Temp and $80));
+  Carry := (Temp and $100) <> 0;
+  Zero := Byte(Temp) = 0;
+  SignNegative := (Temp and $80) <> 0;
+  Target := Byte(Temp);
 end;
 
 procedure TCpuZ80.SbcWord(var Target: Word; Second: Word);
-begin
-  Target := Target - Second;
+var
+  Temp: Integer;
+begin
+  Temp := SmallInt(Target) - SmallInt(Second);
+  ParityOverflow := ((Target and $8000) <> (Second and $8000)) and
+    ((Target and $8000) <> (Temp and $8000));
+  Carry := (Temp and $10000) <> 0;
+  Zero := Word(Temp) = 0;
+  SignNegative := (Temp and $8000) <> 0;
+  Target := Word(Temp);
 end;
 
@@ -1048 +1144 @@
 begin
   Target := Target xor Second;
+  Carry := False;
+  Zero := Target = 0;
+  ParityOverflow := not Odd(Target);
+  SignNegative := (Target and $80) <> 0;
 end;
 
@@ -1053 +1153 @@
 begin
   Target := Target or Second;
+  Carry := False;
+  Zero := Target = 0;
+  ParityOverflow := not Odd(Target);
+  SignNegative := (Target and $80) <> 0;
 end;
 
@@ -1058 +1162 @@
 begin
   Target := Target and Second;
+  Carry := False;
+  Zero := Target = 0;
+  ParityOverflow := not Odd(Target);
+  SignNegative := (Target and $80) <> 0;
 end;
 
 procedure TCpuZ80.IncByte(var Reg: Byte);
 begin
+  ParityOverflow := Reg = $7f;
+
   if Reg = High(Reg) then Reg := 0
     else Inc(Reg);
+
+  Zero := Reg = 0;
+  SignNegative := (Reg and $80) <> 0;
 end;
 
@@ -1074 +1187 @@
 procedure TCpuZ80.DecByte(var Reg: Byte);
 begin
+  ParityOverflow := Reg = $80;
+
   if Reg = 0 then Reg := High(Reg)
-    else Dec(Reg)
+    else Dec(Reg);
+
+  Zero := Reg = 0;
+  SignNegative := (Reg and $80) <> 0;
 end;
 
@@ -1081 +1199 @@
 begin
   if Reg = 0 then Reg := High(Reg)
-    else Dec(Reg)
+    else Dec(Reg);
 end;
 
@@ -1087 +1205 @@
 begin
   Carry := (Data and $80) <> 0;
-  Data := (Data shl 1) or Byte(Carry);
+  Data := ((Data shl 1) and $ff) or Byte(Carry);
 end;
 
@@ -1884 +2002 @@
   Temp: ShortInt;
 begin
-  Dec(BC.B);
+  if BC.B = 0 then BC.B := $ff
+    else Dec(BC.B);
   Temp := ShortInt(ReadByte);
   if BC.B <> 0 then
@@ -2743 +2862 @@
 procedure TCpuZ80.CP_B;
 begin
-  Cp(BC.B);
+  CpByte(BC.B);
 end;
 
 procedure TCpuZ80.CP_C;
 begin
-  Cp(BC.C);
+  CpByte(BC.C);
 end;
 
 procedure TCpuZ80.CP_D;
 begin
-  Cp(DE.D);
+  CpByte(DE.D);
 end;
 
 procedure TCpuZ80.CP_E;
 begin
-  Cp(DE.E);
+  CpByte(DE.E);
 end;
 
 procedure TCpuZ80.CP_H;
 begin
-  Cp(HL.H);
+  CpByte(HL.H);
 end;
 
 procedure TCpuZ80.CP_L;
 begin
-  Cp(HL.L);
+  CpByte(HL.L);
 end;
 
 procedure TCpuZ80.CP_HL_Indirect;
 begin
-  CP(DoRead(HL.Value));
+  CpByte(DoRead(HL.Value));
 end;
 
 procedure TCpuZ80.CP_A;
 begin
-  CP(AF.A);
+  CpByte(AF.A);
 end;
 
@@ -3091 +3210 @@
 procedure TCpuZ80.CP_N;
 begin
-  Cp(ReadByte);
+  CpByte(ReadByte);
 end;
 
@@ -3121 +3240 @@
 procedure TCpuZ80.NEG;
 begin
+  ParityOverflow := AF.A = $80;
+  Carry := AF.A <> $0;
   AF.A := AF.A xor $ff;
   IncByte(AF.A);
+  SignNegative := (AF.A and $80) <> 1;
+  Zero := AF.A = 0;
 end;
 
@@ -3312 +3435 @@
 procedure TCpuZ80.CPI;
 begin
-  Cp(DoRead(HL.Value));
+  CpByte(DoRead(HL.Value));
   IncWord(HL.Value);
   DecWord(BC.Value);
@@ -3341 +3464 @@
 procedure TCpuZ80.CPD;
 begin
-  Cp(DoRead(HL.Value));
+  CpByte(DoRead(HL.Value));
   DecWord(HL.Value);
   DecWord(BC.Value);
@@ -5372 +5495 @@
   Opcode := ReadByte;
   if Opcode = $CB then begin
+    Opcode := ReadByte;
     Instruction := TInstruction($100 or ReadByte);
   end
   else if Opcode = $DD then begin
-    Instruction := TInstruction($200 or ReadByte);
+    Opcode := ReadByte;
+    if Opcode = $CB then begin
+      Opcode := ReadByte;
+      Instruction := TInstruction($500 or Opcode);
+    end else Instruction := TInstruction($200 or Opcode);
   end
   else if Opcode = $ED then begin
-    Instruction := TInstruction($300 or ReadByte);
+    Opcode := ReadByte;
+    Instruction := TInstruction($300 or Opcode);
   end
   else if Opcode = $FD then begin
-    Instruction := TInstruction($400 or ReadByte);
+    Opcode := ReadByte;
+    if Opcode = $CB then begin
+      Opcode := ReadByte;
+      Instruction := TInstruction($600 or Opcode);
+    end else Instruction := TInstruction($400 or Opcode);
   end
   else Instruction := TInstruction(Opcode);

trunk/Z80/Z80InstructionInfo.pas

@@ -8 +8 @@
 type
   TParamType = (ptNone, ptNumberByte, ptNumberByteIndir,
-    ptNumberWord, ptNumberWordIndir, ptRegA,
-    ptRegB, ptRegC, ptRegD, ptRegE, ptRegH, ptRegL, ptRegBC, ptRegDE, ptRegHL,
-    ptRegSP, ptRegIX, ptRegIY, ptRegBCIndir, ptRegDEIndir, ptRegHLIndir,
-    ptRegSPIndir,
-    ptFlagZ, ptFlagNZ, ptFlagC, ptFlagNC, ptFlagP, ptFlagPO,
+    ptNumberWord, ptNumberWordIndir, ptDisplacement,
+    ptRegA, ptRegB, ptRegC, ptRegD, ptRegE, ptRegH, ptRegL, ptRegR, ptRegI,
+    ptRegAF, ptRegBC, ptRegDE, ptRegHL, ptRegSP, ptRegIX, ptRegIY,
+    ptRegAFPair, ptRegBCPair, ptRegDEPair, ptRegHLPair,
+    ptRegBCIndir, ptRegDEIndir, ptRegHLIndir, ptRegSPIndir, ptRegCIndir,
+    ptFlagZ, ptFlagNZ, ptFlagC, ptFlagNC, ptFlagP, ptFlagPO, ptFlagPE, ptFlagM,
     pt00, pt08, pt10, pt18, pt20, pt28, pt30, pt38,
     pt0, pt1, pt2, pt3, pt4, pt5, pt6, pt7);
@@ -41 +42 @@
 
 
-function StrToParamType(Text: string): TParamType;
+function StrToParamType(Text, InstructionName: string): TParamType;
 
 const
-  ParamTypeText: array[TParamType] of string = ('', 'n', '(n)', 'nn', '(nn)', 'A', 'B',
-    'C', 'D', 'E', 'H', 'L', 'BC', 'DE', 'HL', 'SP', 'IX', 'IY', '(BC)',
-    '(DE)', '(HL)', '(SP)', 'Z', 'NZ', 'C', 'NC', 'P', 'PO',
+  ParamTypeText: array[TParamType] of string = (
+    '', 'n', '(n)', 'nn', '(nn)', 'disp',
+    'A', 'B', 'C', 'D', 'E', 'H', 'L', 'R', 'I',
+    'AF', 'BC', 'DE', 'HL', 'SP', 'IX', 'IY',
+    'AF''', 'BC''', 'DE''', 'HL''',
+    '(BC)', '(DE)', '(HL)', '(SP)', '(C)',
+    'Z', 'NZ', 'C', 'NC', 'P', 'PO', 'PE', 'M',
     '00H', '08H', '10H', '18H', '20h', '28H', '30H', '38H',
     '0', '1', '2', '3', '4', '5', '6', '7');
@@ -106 +111 @@
 end;
 
-function StrToParamType(Text: string): TParamType;
+function StrToParamType(Text, InstructionName: string): TParamType;
 var
   ParamType: TParamType;
 begin
+  Result := ptNone;
   Text := Text.ToLower;
   for ParamType := Low(TParamType) to High(TParamType) do
     if Text = ParamTypeText[ParamType].ToLower then begin
-      Result := ParamType;
+      if (ParamType = ptRegD) and ((InstructionName = 'jr') or (InstructionName = 'djnz')) then
+        Result := ptDisplacement
+        else Result := ParamType;
       Break;
     end;
@@ -129 +137 @@
   AddNew(in_LD_B_N, 'LD', [ptRegB, ptNumberByte], 'Loads n into B.', 7, 0);
   AddNew(in_RLCA, 'RLCA', [], 'The contents of A are rotated left one bit position. The contents of bit 7 are copied to the carry flag and bit 0.', 4, 0);
-  AddNew(in_EX_AF_AF_Pair, 'EX', [], 'Exchanges the 16-bit contents of AF and AF''.', 4, 0);
+  AddNew(in_EX_AF_AF_Pair, 'EX', [ptRegAF, ptRegAFPair], 'Exchanges the 16-bit contents of AF and AF''.', 4, 0);
   AddNew(in_ADD_HL_BC, 'ADD', [ptRegHL, ptRegBC], 'The value of BC is added to HL.', 11, 0);
   AddNew(in_LD_A_BC_Indirect, 'LD', [ptRegA, ptRegBCIndir], 'Loads the value pointed to by BC into A.', 7, 0);
@@ -137 +145 @@
   AddNew(in_LD_C_N, 'LD', [ptRegC, ptNumberByte], 'Loads n into C.', 7, 0);
   AddNew(in_RRCA, 'RRCA', [], 'The contents of A are rotated right one bit position. The contents of bit 0 are copied to the carry flag and bit 7.', 4, 0);
-  AddNew(in_DJNZ_D, 'DJNZ', [ptRegD], 'The B register is decremented, and if not zero, the signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 13, 8);
+  AddNew(in_DJNZ_D, 'DJNZ', [ptDisplacement], 'The B register is decremented, and if not zero, the signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 13, 8);
   AddNew(in_LD_DE_NN, 'LD', [ptRegDE, ptNumberWord], 'Loads nn into DE.', 10, 0);
   AddNew(in_LD_DE_Indirect_A, 'LD', [ptRegDEIndir, ptRegA], 'Stores A into the memory location pointed to by DE.', 7, 0);
@@ -145 +153 @@
   AddNew(in_LD_D_N, 'LD', [ptRegD, ptNumberByte], 'Loads n into D.', 7, 0);
   AddNew(in_RLA, 'RLA', [], 'The contents of A are rotated left one bit position. The contents of bit 7 are copied to the carry flag and the previous contents of the carry flag are copied to bit 0.', 4, 0);
-  AddNew(in_JR_D, 'JR', [ptRegD], 'The signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 12, 0);
+  AddNew(in_JR_D, 'JR', [ptDisplacement], 'The signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 12, 0);
   AddNew(in_ADD_HL_DE, 'ADD', [ptRegHL, ptRegDE], 'The value of DE is added to HL.', 11, 0);
   AddNew(in_LD_A_DE_Indirect, 'LD', [ptRegA, ptRegDEIndir], 'Loads the value pointed to by DE into A.', 7, 0);
@@ -153 +161 @@
   AddNew(in_LD_E_N, 'LD', [ptRegE, ptNumberByte], 'Loads n into E.', 7, 0);
   AddNew(in_RRA, 'RRA', [], 'The contents of A are rotated right one bit position. The contents of bit 0 are copied to the carry flag and the previous contents of the carry flag are copied to bit 7.', 4, 0);
-  AddNew(in_JR_NZ_D, 'JR', [ptFlagNZ, ptRegD], 'If the zero flag is unset, the signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 12, 7);
+  AddNew(in_JR_NZ_D, 'JR', [ptFlagNZ, ptDisplacement], 'If the zero flag is unset, the signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 12, 7);
   AddNew(in_LD_HL_NN, 'LD', [ptRegHL, ptNumberWord], 'Loads nn into HL.', 10, 0);
   AddNew(in_LD_NN_Indirect_HL, 'LD', [ptNumberWordIndir, ptRegHL], 'Stores HL into the memory location pointed to by nn.', 16, 0);
@@ -161 +169 @@
   AddNew(in_LD_H_N, 'LD', [ptRegH, ptNumberByte], 'Loads n into H.', 7, 0);
   AddNew(in_DAA, 'DAA', [], 'Adjusts A for BCD addition and subtraction operations.', 4, 0);
-  AddNew(in_JR_Z_D, 'JR', [ptFlagZ, ptRegD], 'If the zero flag is set, the signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 12, 7);
+  AddNew(in_JR_Z_D, 'JR', [ptFlagZ, ptDisplacement], 'If the zero flag is set, the signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 12, 7);
   AddNew(in_ADD_HL_HL, 'ADD', [ptRegHL, ptRegHL], 'The value of HL is added to HL.', 11, 0);
   AddNew(in_LD_HL_NN_Indirect, 'LD', [ptRegHL, ptNumberWordIndir], 'Loads the value pointed to by nn into HL.', 16, 0);
@@ -169 +177 @@
   AddNew(in_LD_L_N, 'LD', [ptRegL, ptNumberByte], 'Loads n into L.', 7, 0);
   AddNew(in_CPL, 'CPL', [], 'The contents of A are inverted (one''s complement).', 4, 0);
-  AddNew(in_JR_NC_D, 'JR', [ptFlagNC, ptRegD], 'If the carry flag is unset, the signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 12, 7);
+  AddNew(in_JR_NC_D, 'JR', [ptFlagNC, ptDisplacement], 'If the carry flag is unset, the signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 12, 7);
   AddNew(in_LD_SP_NN, 'LD', [ptRegSP, ptNumberWord], 'Loads nn into SP.', 10, 0);
   AddNew(in_LD_NN_Indirect_A, 'LD', [ptNumberWordIndir, ptRegA], 'Stores A into the memory location pointed to by nn.', 13, 0);
@@ -177 +185 @@
   AddNew(in_LD_HL_Indirect_N, 'LD', [ptRegHLIndir, ptNumberByte], 'Loads n into (HL).', 10, 0);
   AddNew(in_SCF, 'SCF', [], 'Sets the carry flag.', 4, 0);
-  AddNew(in_JR_C_D, 'JR', [ptRegC, ptRegD], 'If the carry flag is set, the signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 12, 7);
+  AddNew(in_JR_C_D, 'JR', [ptRegC, ptDisplacement], 'If the carry flag is set, the signed value d is added to PC. The jump is measured from the start of the instruction opcode.', 12, 7);
   AddNew(in_ADD_HL_SP, 'ADD', [ptRegHL, ptRegSP], 'The value of SP is added to HL.', 11, 0);
   AddNew(in_LD_A_NN_Indirect, 'LD', [ptRegA, ptNumberWordIndir], 'Loads the value pointed to by nn into A.', 13, 0);
@@ -351 +359 @@
   AddNew(in_AND_N, 'AND', [ptNumberByte], 'Bitwise AND on A with n.', 7, 0);
   AddNew(in_RST_20H, 'RST', [pt20], 'The current PC value plus one is pushed onto the stack, then is loaded with 32.', 11, 0);
-  AddNew(in_RET_PE, 'RET', [], 'If the parity/overflow flag is set, the top stack entry is popped into PC.', 11, 5);
+  AddNew(in_RET_PE, 'RET', [ptFlagPE], 'If the parity/overflow flag is set, the top stack entry is popped into PC.', 11, 5);
   AddNew(in_JP_HL_Indirect, 'JP', [ptRegHLIndir], 'Loads the value of HL into PC.', 4, 0);
-  AddNew(in_JP_PE_NN, 'JP', [ptNumberWord], 'If the parity/overflow flag is set, nn is copied to PC.', 10, 0);
+  AddNew(in_JP_PE_NN, 'JP', [ptFlagPE, ptNumberWord], 'If the parity/overflow flag is set, nn is copied to PC.', 10, 0);
   AddNew(in_EX_DE_HL, 'EX', [ptRegDE, ptRegHL], 'Exchanges the 16-bit contents of DE and HL.', 4, 0);
-  AddNew(in_CALL_PE_NN, 'CALL', [ptNumberWord], 'If the parity/overflow flag is set, the current PC value plus three is pushed onto the stack, then is loaded with nn.', 17, 10);
+  AddNew(in_CALL_PE_NN, 'CALL', [ptFlagPE, ptNumberWord], 'If the parity/overflow flag is set, the current PC value plus three is pushed onto the stack, then is loaded with nn.', 17, 10);
   AddNew(in_XOR_N, 'XOR', [ptNumberByte], 'Bitwise XOR on A with n.', 7, 0);
   AddNew(in_RST_28H, 'RST', [pt28], 'The current PC value plus one is pushed onto the stack, then is loaded with 40.', 11, 0);
   AddNew(in_RET_P, 'RET', [ptFlagP], 'If the sign flag is unset, the top stack entry is popped into PC.', 11, 5);
-  AddNew(in_POP_AF, 'POP', [], 'The memory location pointed to by SP is stored into F and SP is incremented. The memory location pointed to by SP is stored into A and SP is incremented again.', 10, 0);
+  AddNew(in_POP_AF, 'POP', [ptRegAF], 'The memory location pointed to by SP is stored into F and SP is incremented. The memory location pointed to by SP is stored into A and SP is incremented again.', 10, 0);
   AddNew(in_JP_P_NN, 'JP', [ptFlagP, ptNumberWord], 'If the sign flag is unset, nn is copied to PC.', 10, 0);
   AddNew(in_DI, 'DI', [], 'Resets both interrupt flip-flops, thus preventing maskable interrupts from triggering.', 4, 0);
   AddNew(in_CALL_P_NN, 'CALL', [ptFlagP, ptNumberWord], 'If the sign flag is unset, the current PC value plus three is pushed onto the stack, then is loaded with nn.', 17, 10);
-  AddNew(in_PUSH_AF, 'PUSH', [], 'SP is decremented and A is stored into the memory location pointed to by SP. SP is decremented again and F is stored into the memory location pointed to by SP.', 11, 0);
+  AddNew(in_PUSH_AF, 'PUSH', [ptRegAF], 'SP is decremented and A is stored into the memory location pointed to by SP. SP is decremented again and F is stored into the memory location pointed to by SP.', 11, 0);
   AddNew(in_OR_N, 'OR', [ptNumberByte], 'Bitwise OR on A with n.', 7, 0);
   AddNew(in_RST_30H, 'RST', [pt30], 'The current PC value plus one is pushed onto the stack, then is loaded with 48.', 11, 0);
-  AddNew(in_RET_M, 'RET', [], 'If the sign flag is set, the top stack entry is popped into PC.', 11, 5);
+  AddNew(in_RET_M, 'RET', [ptFlagM], 'If the sign flag is set, the top stack entry is popped into PC.', 11, 5);
   AddNew(in_LD_SP_HL, 'LD', [ptRegSP, ptRegHL], 'Loads the value of HL into SP.', 6, 0);
-  AddNew(in_JP_M_NN, 'JP', [ptNumberWord], 'If the sign flag is set, nn is copied to PC.', 10, 0);
+  AddNew(in_JP_M_NN, 'JP', [ptFlagM, ptNumberWord], 'If the sign flag is set, nn is copied to PC.', 10, 0);
   AddNew(in_EI, 'EI', [], 'Sets both interrupt flip-flops, thus allowing maskable interrupts to occur. An interrupt will not occur until after the immediately following instruction.', 4, 0);
-  AddNew(in_CALL_M_NN, 'CALL', [ptNumberWord], 'If the sign flag is set, the current PC value plus three is pushed onto the stack, then is loaded with nn.', 17, 10);
+  AddNew(in_CALL_M_NN, 'CALL', [ptFlagM, ptNumberWord], 'If the sign flag is set, the current PC value plus three is pushed onto the stack, then is loaded with nn.', 17, 10);
   AddNew(in_CP_N, 'CP', [ptNumberByte], 'Subtracts n from A and affects flags according to the result. A is not modified.', 7, 0);
   AddNew(in_RST_38H, 'RST', [pt38], 'The current PC value plus one is pushed onto the stack, then is loaded with 56.', 11, 0);
-  AddNew(in_IN_B_C_Indirect, 'IN', [ptRegB], 'A byte from the port at the 16-bit address contained in the BC register pair is written to B.', 12, 0);
-  AddNew(in_OUT_C_Indirect_B, 'OUT', [ptRegB], 'The value of B is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
+  AddNew(in_IN_B_C_Indirect, 'IN', [ptRegB, ptRegCIndir], 'A byte from the port at the 16-bit address contained in the BC register pair is written to B.', 12, 0);
+  AddNew(in_OUT_C_Indirect_B, 'OUT', [ptRegCIndir, ptRegB], 'The value of B is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
   AddNew(in_SBC_HL_BC, 'SBC', [ptRegHL, ptRegBC], 'Subtracts BC and the carry flag from HL.', 15, 0);
   AddNew(in_LD_NN_Indirect_BC, 'LD', [ptNumberWordIndir, ptRegBC], 'Stores BC into the memory location pointed to by nn.', 20, 0);
@@ -380 +388 @@
   AddNew(in_RETN, 'RETN', [], 'Used at the end of a non-maskable interrupt service routine (located at 0066h) to pop the top stack entry into PC. The value of IFF2 is copied to IFF1 so that maskable interrupts are allowed to continue as before. NMIs are not enabled on the TI.', 14, 0);
   AddNew(in_IM_0, 'IM', [pt0], 'Sets interrupt mode 0.', 8, 0);
-  AddNew(in_LD_I_A, 'LD', [ptRegA], 'Stores the value of A into register I.', 9, 0);
-  AddNew(in_IN_C_C_Indirect, 'IN', [ptRegC], 'A byte from the port at the 16-bit address contained in the BC register pair is written to C.', 12, 0);
-  AddNew(in_OUT_C_Indirect_C, 'OUT', [ptRegC], 'The value of C is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
+  AddNew(in_LD_I_A, 'LD', [ptRegI, ptRegA], 'Stores the value of A into register I.', 9, 0);
+  AddNew(in_IN_C_C_Indirect, 'IN', [ptRegC, ptRegCIndir], 'A byte from the port at the 16-bit address contained in the BC register pair is written to C.', 12, 0);
+  AddNew(in_OUT_C_Indirect_C, 'OUT', [ptRegCIndir, ptRegC], 'The value of C is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
   AddNew(in_ADC_HL_BC, 'ADC', [ptRegHL, ptRegBC], 'Adds BC and the carry flag to HL.', 15, 0);
   AddNew(in_LD_BC_NN_Indirect, 'LD', [ptRegBC, ptNumberWordIndir], 'Loads the value pointed to by nn into BC.', 20, 0);
   AddNew(in_RETI, 'RETI', [], 'Used at the end of a maskable interrupt service routine. The top stack entry is popped into PC, and signals an I/O device that the interrupt has finished, allowing nested interrupts (not a consideration on the TI).', 14, 0);
-  AddNew(in_LD_R_A, 'LD', [ptRegA], 'Stores the value of A into register R.', 9, 0);
-  AddNew(in_IN_D_C_Indirect, 'IN', [ptRegD], 'A byte from the port at the 16-bit address contained in the BC register pair is written to D.', 12, 0);
-  AddNew(in_OUT_C_Indirect_D, 'OUT', [ptRegD], 'The value of D is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
+  AddNew(in_LD_R_A, 'LD', [ptRegR, ptRegA], 'Stores the value of A into register R.', 9, 0);
+  AddNew(in_IN_D_C_Indirect, 'IN', [ptRegD, ptRegCIndir], 'A byte from the port at the 16-bit address contained in the BC register pair is written to D.', 12, 0);
+  AddNew(in_OUT_C_Indirect_D, 'OUT', [ptRegCIndir, ptRegD], 'The value of D is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
   AddNew(in_SBC_HL_DE, 'SBC', [ptRegHL, ptRegDE], 'Subtracts DE and the carry flag from HL.', 15, 0);
   AddNew(in_LD_NN_Indirect_DE, 'LD', [ptNumberWordIndir, ptRegDE], 'Stores DE into the memory location pointed to by nn.', 20, 0);
   AddNew(in_IM_1, 'IM', [pt1], 'Sets interrupt mode 1.', 8, 0);
-  AddNew(in_LD_A_I, 'LD', [ptRegA], 'Stores the value of register I into A.', 9, 0);
-  AddNew(in_IN_E_C_Indirect, 'IN', [ptRegE], 'A byte from the port at the 16-bit address contained in the BC register pair is written to E.', 12, 0);
-  AddNew(in_OUT_C_Indirect_E, 'OUT', [ptRegE], 'The value of E is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
+  AddNew(in_LD_A_I, 'LD', [ptRegA, ptRegI], 'Stores the value of register I into A.', 9, 0);
+  AddNew(in_IN_E_C_Indirect, 'IN', [ptRegE, ptRegCIndir], 'A byte from the port at the 16-bit address contained in the BC register pair is written to E.', 12, 0);
+  AddNew(in_OUT_C_Indirect_E, 'OUT', [ptRegCIndir, ptRegE], 'The value of E is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
   AddNew(in_ADC_HL_DE, 'ADC', [ptRegHL, ptRegDE], 'Adds DE and the carry flag to HL.', 15, 0);
   AddNew(in_LD_DE_NN_Indirect, 'LD', [ptRegDE, ptNumberWordIndir], 'Loads the value pointed to by nn into DE.', 20, 0);
   AddNew(in_IM_2, 'IM', [pt2], 'Sets interrupt mode 2.', 8, 0);
-  AddNew(in_LD_A_R, 'LD', [ptRegA], 'Stores the value of register R into A.', 9, 0);
-  AddNew(in_IN_H_C_Indirect, 'IN', [ptRegH], 'A byte from the port at the 16-bit address contained in the BC register pair is written to H.', 12, 0);
-  AddNew(in_OUT_C_Indirect_H, 'OUT', [ptRegH], 'The value of H is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
+  AddNew(in_LD_A_R, 'LD', [ptRegA, ptRegR], 'Stores the value of register R into A.', 9, 0);
+  AddNew(in_IN_H_C_Indirect, 'IN', [ptRegH, ptRegCIndir], 'A byte from the port at the 16-bit address contained in the BC register pair is written to H.', 12, 0);
+  AddNew(in_OUT_C_Indirect_H, 'OUT', [ptRegCIndir, ptRegH], 'The value of H is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
   AddNew(in_SBC_HL_HL, 'SBC', [ptRegHL, ptRegHL], 'Subtracts HL and the carry flag from HL.', 15, 0);
   AddNew(in_RRD, 'RRD', [], 'The contents of the low-order nibble of (HL) are copied to the low-order nibble of A. The previous contents are copied to the high-order nibble of (HL). The previous contents are copied to the low-order nibble of (HL).', 18, 0);
-  AddNew(in_IN_L_C_Indirect, 'IN', [ptRegL], 'A byte from the port at the 16-bit address contained in the BC register pair is written to L.', 12, 0);
-  AddNew(in_OUT_C_Indirect_L, 'OUT', [ptRegL], 'The value of L is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
+  AddNew(in_IN_L_C_Indirect, 'IN', [ptRegL, ptRegCIndir], 'A byte from the port at the 16-bit address contained in the BC register pair is written to L.', 12, 0);
+  AddNew(in_OUT_C_Indirect_L, 'OUT', [ptRegCIndir, ptRegL], 'The value of L is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
   AddNew(in_ADC_HL_HL, 'ADC', [ptRegHL, ptRegHL], 'Adds HL and the carry flag to HL.', 15, 0);
   AddNew(in_RLD, 'RLD', [], 'The contents of the low-order nibble of (HL) are copied to the high-order nibble of (HL). The previous contents are copied to the low-order nibble of A. The previous contents are copied to the low-order nibble of (HL).', 18, 0);
   AddNew(in_SBC_HL_SP, 'SBC', [ptRegHL, ptRegSP], 'Subtracts SP and the carry flag from HL.', 15, 0);
   AddNew(in_LD_NN_Indirect_SP, 'LD', [ptNumberWordIndir, ptRegSP], 'Stores SP into the memory location pointed to by nn.', 20, 0);
-  AddNew(in_IN_A_C_Indirect, 'IN', [ptRegA], 'A byte from the port at the 16-bit address contained in the BC register pair is written to A.', 12, 0);
-  AddNew(in_OUT_C_Indirect_A, 'OUT', [ptRegA], 'The value of A is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
+  AddNew(in_IN_A_C_Indirect, 'IN', [ptRegA, ptRegCIndir], 'A byte from the port at the 16-bit address contained in the BC register pair is written to A.', 12, 0);
+  AddNew(in_OUT_C_Indirect_A, 'OUT', [ptRegCIndir, ptRegA], 'The value of A is written to the port at the 16-bit address contained in the BC register pair.', 12, 0);
   AddNew(in_ADC_HL_SP, 'ADC', [ptRegHL, ptRegSP], 'Adds SP and the carry flag to HL.', 15, 0);
   AddNew(in_LD_SP_NN_Indirect, 'LD', [ptRegSP, ptNumberWordIndir], 'Loads the value pointed to by nn into SP.', 20, 0);

trunk/Z80/Z80Instructions.pas

@@ -7 +7 @@
 
 type
-  TInstructionTable = (itBase, itCB, itDD, itED, itFD);
+  TInstructionTable = (itBase, itCB, itDD, itED, itFD, itDDCB, itFDCB);
 
   TInstruction = (