Changeset 10 for trunk/Z80/Z80.pas

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.

File:

• trunk/Z80/Z80.pas (modified) (20 diffs)

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);