home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1987 / 11 / z80_info.inc < prev    next >
Encoding:
Text File  |  1987-09-06  |  8.5 KB  |  143 lines
  1. (* ----------------------------------------------------------------------- *)
  2. (*                               Z80-INFO.INC                              *)
  3. (*    ein Modul zum Austesten von Inline - Anweisungen der Sprache TURBO   *)
  4. (*                    PASCAL, hier fuer den Prozessor Z80                  *)
  5. (* ----------------------------------------------------------------------- *)
  6. PROCEDURE Z80_INFO;
  7.  
  8. TYPE str1 = STRING [10];
  9.  
  10. (* ----------------------------------------------------------------------- *)
  11. (* Die Hauptregister des Z80 - Prozessors A, B, C, D, H, L und das Flag-   *)
  12. (* register F sind als Byte definiert, ebenso die Hintergrundregister      *)
  13. (* A', B', ...                                                             *)
  14. (* Die Reihenfolge der Definitionen darf nicht veraendert werden,da in den *)
  15. (* Inline - Anweisungen ausgenutzt wird, das F hinter A, C hinter B etc.   *)
  16. (* liegt !                                                                 *)
  17. (* Die Indexregister IX und IY sind als Integer definiert, welche 2 Bytes  *)
  18. (* belegen, ebenso der Stack - Pointer (Stapel - Zeiger SP) und der Pro-   *)
  19. (* gramm - Counter (Programm - Zaehler PC).                                *)
  20. (* ----------------------------------------------------------------------- *)
  21. VAR
  22.     A, F, B, C, D, E, H, L,                   (* Hauptregister             *)
  23.     As,Fs,Bs,Cs,Ds,Es,Hs,Ls  : BYTE;          (* Hintergrundregister       *)
  24.                                               (* des Z - 80 Prozessors     *)
  25.     IX,IY,SP,PC              : INTEGER;       (* Index- und Adressregister *)
  26. (* ----------------------------------------------------------------------- *)
  27. (*            Gibt den Hex.-Wert, eines Byte als String zurueck            *)
  28. FUNCTION hexbyte (B : BYTE) : str1;
  29.                         (* Gibt den Hexcode eines Nibbles (4 Bit) zurueck) *)
  30.   FUNCTION hexteil (x : BYTE): CHAR;
  31.   CONST  null = 48;                                       (* ASCII von 0   *)
  32.          A    = 55;                                       (*   "   von A   *)
  33.   BEGIN
  34.      CASE x OF
  35.         0.. 9 : hexteil := Chr(x + null);                 (* Ziffer 0 .. 9 *)
  36.        10..15 : hexteil := Chr(x + A   );                 (* Ziffer A .. F *)
  37.      END;
  38.   END (* hexteil *);
  39.  
  40. BEGIN  (* hexbyte *)
  41.   hexbyte := hexteil(B SHR 4) + hexteil(B AND $0F)
  42. END;
  43. (* ----------------------------------------------------------------------- *)
  44. (*          Gibt den Hex.-Wert zweier Bytes als String zurueck             *)
  45. FUNCTION hexint (i : INTEGER) : str1;
  46. BEGIN  hexint := hexbyte(i SHR 8) + hexbyte(i AND $00FF);  END;
  47. (* ----------------------------------------------------------------------- *)
  48. (*           Gibt den Binaerwert eines Bytes als String zurueck            *)
  49. FUNCTION binaerbyte (A : BYTE) : str1;
  50. VAR i : BYTE;  s : str1;
  51. BEGIN
  52.   s := '';  i := $80;
  53.   REPEAT
  54.     IF ((i AND A) <> 0) THEN s := s + '1'           (* Ausblenden mit i    *)
  55.     ELSE s := s + '0';
  56.     IF i = $10 THEN s := s + '.';                  (* In der Mitte einen . *)
  57.     i := i SHR 1                                    (* naechstes Bit       *)
  58.   UNTIL i = $00;                                    (* Herausgeschoben     *)
  59.   binaerbyte := s + ' ';                   (* Blank fuer Ausgabe anhaengen *)
  60. END;
  61. (* ----------------------------------------------------------------------- *)
  62. (* Ausgabe auf dem Bildschirm der einzelnen Register. A, F, B, C, ... sind *)
  63. (* als lokale Variablen (inerhalb der Procedure Z80_info) definiert.       *)
  64. PROCEDURE ausgabe;
  65. VAR ch : CHAR;
  66. BEGIN
  67.   ClrScr;  Write('':32);  WriteLn('Z 80 - STATUS');  WriteLn;
  68.   WriteLn('Erstregister:');  WriteLn;
  69.   WriteLn('    A     SZ-H.-PNC     B         C         D         E     ',
  70.           '    H         L');
  71.   WriteLn;
  72.   WriteLn(binaerbyte(A),binaerbyte(F),binaerbyte(B),binaerbyte(C),
  73.           binaerbyte(D),binaerbyte(E),binaerbyte(H),binaerbyte(L));
  74.   WriteLn('$' + hexbyte(A): 6,'$' + hexbyte(F):10,'$' + hexbyte(B):10,
  75.           '$' + hexbyte(C):10,'$' + hexbyte(D):10,'$' + hexbyte(E):10,
  76.           '$' + hexbyte(H):10,'$' + hexbyte(L):10);
  77.   WriteLn;  WriteLn;  WriteLn('Zweitregister');  WriteLn;
  78.   WriteLn('    A     SZ-H.-PNC     B         C         D         E     ',
  79.           '    H         L');
  80.   WriteLn;
  81.   WriteLn(binaerbyte(As),binaerbyte(Fs),binaerbyte(Bs),binaerbyte(Cs),
  82.           binaerbyte(Ds),binaerbyte(Es),binaerbyte(Hs),binaerbyte(Ls));
  83.   WriteLn('$' + hexbyte(As): 6,'$' + hexbyte(Fs):10,'$' + hexbyte(Bs):10,
  84.           '$' + hexbyte(Cs):10,'$' + hexbyte(Ds):10,'$' + hexbyte(Es):10,
  85.           '$' + hexbyte(Hs):10,'$' + hexbyte(Ls):10);
  86.   WriteLn;  WriteLn;  WriteLn('Index- und Adressregister ');  WriteLn;
  87.   WriteLn('    IX        IY        SP        PC');  WriteLn;
  88.   WriteLn('$' + hexint(IX):7,'$' + hexint(IY):10,'$' + hexint(SP):10,
  89.           '$' + hexint(PC):10);
  90.   WriteLn;  WriteLn;
  91.   Write('Weiter / Halt (W/H) ? ');
  92.   REPEAT  Read(Kbd,ch);  ch := UpCase(ch);  UNTIL ch IN ['H','W'];
  93.   IF ch = 'H' THEN Halt;                             (* Programm abbrechen *)
  94. END;
  95. (* ----------------------------------------------------------------------- *)
  96. BEGIN (* Z80_info *)
  97.   INLINE(
  98.                 (* Registerinhalte in die entsprechenen Variablen bringen: *)
  99.     $ED/$53/E/    (* LD     (E);DE          ;Lade D und E mit Reg. DE      *)
  100.     $22/L/        (* LD     (L);HL          ;Lade H und L mit Reg. HL      *)
  101.     $ED/$43/C/    (* LD     (C);BC          ;Lade B und C mit Reg. BC      *)
  102.     $F5/          (* PUSH   AF              ;Flags u. A                    *)
  103.     $E1/          (* POP    HL              ;nach HL bringen               *)
  104.     $22/F/        (* LD     (F),HL          ;Lade (A) u. (F) mit HL = AF ! *)
  105.     $08/          (* EX     AF,AF'          ;Tausche Register AF mit AF'   *)
  106.     $D9/          (* EXX                    ;   "       "                  *)
  107.     $ED/$53/Es/   (* LD     (Es);DE         ;Lade Ds und Es mit Reg. DE'   *)
  108.     $22/Ls/       (* LD     (Ls);HL         ;Lade Hs und Ls mit Reg. HL'   *)
  109.     $ED/$43/Cs/   (* LD     (Cs);BC         ;Lade Bs und Cs mit Reg. BC'   *)
  110.     $F5/          (* PUSH   AF              ;Flags und Reg. A nach         *)
  111.     $E1/          (* POP    HL              ;HL bringen                    *)
  112.     $22/Fs/       (* LD     (Fs),A          ;Lade (As) u.(Fs) mit Reg. HL  *)
  113.     $DD/$22/IX/   (* LD     (IX),IX         ;Lade (IX)    mit Reg. IX      *)
  114.     $FD/$22/IY/   (* LD     (IY),IY         ;Lade (IY)    mit Reg. IY      *)
  115.     $ED/$73/SP/   (* LD     (SP),SP         ;Lade (SP)    mit Reg. SP      *)
  116.     $E1/          (* POP    HL              ;Rueckkehradresse holen        *)
  117.     $E5/          (* PUSH   HL              ;und retten                    *)
  118.     $22/PC/       (* LD     (PC),HL         ;Lade (PC) mit Reg. HL         *)
  119.     $CD/ausgabe/  (* CALL   AUSGABE                                        *)
  120.    (* Da bei der Ausgabe die Register veraendert werden, wird im folgenden *)
  121.    (* der urspruengliche Zustand wiederhergestellt.                        *)
  122.     $2A/Fs/       (* LD     HL,(Fs)         ;Lade HL mit Speicher As u. Fs *)
  123.     $E5/          (* PUSH   HL              ;          und                 *)
  124.     $F1/          (* POP    AF              ;bringe dieses nach AF         *)
  125.     $ED/$5B/Es/   (* LD     DE,(Es)         ;Lade DE mit Speicher Ds u. Es *)
  126.     $2A/Ls/       (* LD     HL,(Ls)         ;Lade HL mit Speicher Hs u. Ls *)
  127.     $ED/$4B/Cs/   (* LD     BC,(Cs)         ;Lade BC mit Speicher Bs u. Cs *)
  128.     $08/          (* EX     AF,AF'          ;Tausche Register AF mit AF'   *)
  129.     $D9/          (* EXX                    ;   "       "                  *)
  130.     $2A/F/        (* LD     HL,(F)          ;Lade HL mit Speicher A u. F   *)
  131.     $E5/          (* PUSH   HL              ;          und                 *)
  132.     $F1/          (* POP    AF              ;bringe dieses nach AF         *)
  133.     $ED/$5B/E/    (* LD     DE,(E)          ;Lade DE mit Speicher D u. E   *)
  134.     $2A/L/        (* LD     HL,(L)          ;Lade HL mit Speicher H u. L   *)
  135.     $ED/$4B/C/    (* LD     BC,(C)          ;Lade BC mit Speicher B u. C   *)
  136.     $DD/$2A/IX/   (* LD     IX,(IX)         ;Lade IX mit Speicher IX       *)
  137.     $FD/$2A/IY/   (* LD     IY,(IY)         ;Lade IY mit Speicher IY       *)
  138.     $ED/$7B/SP    (* LD     SP,(SP)         ;Lade SP mit Speicher SP       *)
  139.   );
  140. END;
  141. (* ----------------------------------------------------------------------- *)
  142. (*                               Z80-INFO.INC                              *)
  143.