home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1987 / 12 / dis8080.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1987-09-29  |  23.4 KB  |  420 lines
  1. (* ----------------------------------------------------------------------- *)
  2. (*                               DIS8080.PAS                               *)
  3. (* Version: 1.0,  Autor: Born B.,  Prog. Spr.: Turbo Pascal V3.x,          *)
  4. (* Betr. Sys.:  MSDOS, CP/M 80, CP/M 86                                    *)
  5. (* Tabellengesteuerter Disassembler fuer den 8080 Prozessor. Der Haupt-    *)
  6. (* speicherbereich zwischen Startadresse u. Endadresse wird disassembliert *)
  7. (* und auf der Standardausgabe ausgegeben. Start- und Endadresse werden    *)
  8. (* entweder als Dezimal- oder als Hexadezimalzahl ($xxxx) ueber die        *)
  9. (* Standardeingabe eingegeben.                                             *)
  10. (* Implementierungshinweis:                                                *)
  11. (* Der Type Integer ist in Turbo Pascal als 2 Byte mit Vorzeichen imple-   *)
  12. (* mentiert. Ganzzahlen > 32767 werden als negativ aufgefasst. Deshalb     *)
  13. (* sind alle Operationen auf 16 Bit Werte unter diesem Aspekt vorzunehmen. *)
  14. (*                                                                         *)
  15. (* Aufbau der Tabellen mit den mnemotechnischen Abkuerzungen der Befehle,  *)
  16. (* sowie Informationen ueber Befehlstyp und -laenge. Die Tabelle ist als   *)
  17. (* Record mit folgender Struktur defininiert:                              *)
  18. (*   Befehl()    = 4 Zeichen der mnemotechnischen Abkuerzung               *)
  19. (*   Bytes()     = Zahl der Befehlsbytes                                   *)
  20. (*   Register(1) = Codierung 1. Register                                   *)
  21. (*   Register(2) = Codierung 2. Register                                   *)
  22. (*                                                                         *)
  23. (*  Registercodierung: 0 -> %, 1 -> DB, 2 -> DW, 3 -> A                    *)
  24. (*                     4 -> B, 5 -> C,  6 -> D,  7 -> E                    *)
  25. (*                     8 -> H, 9 -> L, 10 -> M, 11 -> BC                   *)
  26. (*                    12 -> DE, 13 -> HL, 14 -> SP, 15 -> PSW              *)
  27. (* Zur Initialisierung der Tabelle wird hier eine typisierte Konstante     *)
  28. (* (Turbo-spezifisch !!) benutzt. Bei anderen Pascal-Compilern muss eine   *)
  29. (* Initialisierung ueber Zuweisungen im Anweisungsteil geschehen.          *)
  30.  
  31. PROGRAM DisAsm8080 (Input,Output);
  32.  
  33. LABEL 999;
  34.  
  35. CONST bytelen = 1;
  36.       wordlen = 2;
  37.  
  38. TYPE  Code = RECORD
  39.                Befehl   : STRING [4];
  40.                Bytes    : INTEGER;
  41.                Register : ARRAY [1..2] OF INTEGER;
  42.              END;
  43.  
  44. VAR  Startadr, Endadr, Currentadr,
  45.      Segment, Column, Opcode, SecOpcode, i : INTEGER;
  46.  
  47. CONST Table: ARRAY [0..255] OF Code =
  48.                ((Befehl: 'NOP '; Bytes: 1; Register: (0,0)),
  49.                 (Befehl: 'LXI '; Bytes: 3; Register: (4,2)),
  50.                 (Befehl: 'STAX'; Bytes: 1; Register: (4,0)),
  51.                 (Befehl: 'INX '; Bytes: 1; Register: (4,0)),
  52.                 (Befehl: 'INR '; Bytes: 1; Register: (4,0)),
  53.                 (Befehl: 'DCR '; Bytes: 1; Register: (4,0)),
  54.                 (Befehl: 'MVI '; Bytes: 2; Register: (4,1)),
  55.                 (Befehl: 'RLC '; Bytes: 1; Register: (0,0)),
  56.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  57.                 (Befehl: 'DAD '; Bytes: 1; Register: (4,0)),
  58.                 (Befehl: 'LDAX'; Bytes: 1; Register: (4,0)),
  59.                 (Befehl: 'DCX '; Bytes: 1; Register: (4,0)),
  60.                 (Befehl: 'INR '; Bytes: 1; Register: (5,0)),
  61.                 (Befehl: 'DCR '; Bytes: 1; Register: (5,0)),
  62.                 (Befehl: 'MVI '; Bytes: 2; Register: (5,1)),
  63.                 (Befehl: 'RRC '; Bytes: 1; Register: (0,0)),
  64.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  65.                 (Befehl: 'LXI '; Bytes: 3; Register: (6,2)),
  66.                 (Befehl: 'STAX'; Bytes: 1; Register: (6,0)),
  67.                 (Befehl: 'INX '; Bytes: 1; Register: (6,0)),
  68.                 (Befehl: 'INR '; Bytes: 1; Register: (6,0)),
  69.                 (Befehl: 'DCR '; Bytes: 1; Register: (6,0)),
  70.                 (Befehl: 'MVI '; Bytes: 2; Register: (6,1)),
  71.                 (Befehl: 'RAL '; Bytes: 1; Register: (0,0)),
  72.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  73.                 (Befehl: 'DAD '; Bytes: 1; Register: (6,0)),
  74.                 (Befehl: 'LDAX'; Bytes: 1; Register: (6,0)),
  75.                 (Befehl: 'DCX '; Bytes: 1; Register: (6,0)),
  76.                 (Befehl: 'INR '; Bytes: 1; Register: (7,0)),
  77.                 (Befehl: 'DCR '; Bytes: 1; Register: (7,0)),
  78.                 (Befehl: 'MVI '; Bytes: 2; Register: (7,1)),
  79.                 (Befehl: 'RAR '; Bytes: 1; Register: (0,0)),
  80.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  81.                 (Befehl: 'LXI '; Bytes: 3; Register: (8,2)),
  82.                 (Befehl: 'SHLD'; Bytes: 3; Register: (2,0)),
  83.                 (Befehl: 'INX '; Bytes: 1; Register: (8,0)),
  84.                 (Befehl: 'INR '; Bytes: 1; Register: (8,0)),
  85.                 (Befehl: 'DCR '; Bytes: 1; Register: (8,0)),
  86.                 (Befehl: 'MVI '; Bytes: 1; Register: (8,1)),
  87.                 (Befehl: 'DAA '; Bytes: 1; Register: (0,0)),
  88.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  89.                 (Befehl: 'DAD '; Bytes: 1; Register: (8,0)),
  90.                 (Befehl: 'LHLD'; Bytes: 3; Register: (2,0)),
  91.                 (Befehl: 'DCX '; Bytes: 1; Register: (8,0)),
  92.                 (Befehl: 'INR '; Bytes: 1; Register: (9,0)),
  93.                 (Befehl: 'DCR '; Bytes: 1; Register: (9,0)),
  94.                 (Befehl: 'MVI '; Bytes: 2; Register: (9,1)),
  95.                 (Befehl: 'CMA '; Bytes: 1; Register: (0,0)),
  96.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  97.                 (Befehl: 'LXI '; Bytes: 3; Register:(14,2)),
  98.                 (Befehl: 'STA '; Bytes: 3; Register: (2,0)),
  99.                 (Befehl: 'INX '; Bytes: 1; Register:(14,0)),
  100.                 (Befehl: 'INR '; Bytes: 1; Register:(10,0)),
  101.                 (Befehl: 'DCR '; Bytes: 1; Register:(10,0)),
  102.                 (Befehl: 'MVI '; Bytes: 2; Register:(10,1)),
  103.                 (Befehl: 'STC '; Bytes: 1; Register: (0,0)),
  104.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  105.                 (Befehl: 'DAD '; Bytes: 1; Register:(14,0)),
  106.                 (Befehl: 'LDA '; Bytes: 3; Register: (2,0)),
  107.                 (Befehl: 'DCX '; Bytes: 1; Register:(14,0)),
  108.                 (Befehl: 'INR '; Bytes: 1; Register: (3,0)),
  109.                 (Befehl: 'DCR '; Bytes: 1; Register: (3,0)),
  110.                 (Befehl: 'MVI '; Bytes: 2; Register: (3,1)),
  111.                 (Befehl: 'CMC '; Bytes: 1; Register: (0,0)),
  112.                 (Befehl: 'MOV '; Bytes: 1; Register: (4,4)),
  113.                 (Befehl: 'MOV '; Bytes: 1; Register: (4,5)),
  114.                 (Befehl: 'MOV '; Bytes: 1; Register: (4,6)),
  115.                 (Befehl: 'MOV '; Bytes: 1; Register: (4,7)),
  116.                 (Befehl: 'MOV '; Bytes: 1; Register: (4,8)),
  117.                 (Befehl: 'MOV '; Bytes: 1; Register: (4,9)),
  118.                 (Befehl: 'MOV '; Bytes: 1; Register: (4,10)),
  119.                 (Befehl: 'MOV '; Bytes: 1; Register: (4,3)),
  120.                 (Befehl: 'MOV '; Bytes: 1; Register: (5,4)),
  121.                 (Befehl: 'MOV '; Bytes: 1; Register: (5,5)),
  122.                 (Befehl: 'MOV '; Bytes: 1; Register: (5,6)),
  123.                 (Befehl: 'MOV '; Bytes: 1; Register: (5,7)),
  124.                 (Befehl: 'MOV '; Bytes: 1; Register: (5,8)),
  125.                 (Befehl: 'MOV '; Bytes: 1; Register: (5,9)),
  126.                 (Befehl: 'MOV '; Bytes: 1; Register: (5,10)),
  127.                 (Befehl: 'MOV '; Bytes: 1; Register: (5,3)),
  128.                 (Befehl: 'MOV '; Bytes: 1; Register: (6,4)),
  129.                 (Befehl: 'MOV '; Bytes: 1; Register: (6,5)),
  130.                 (Befehl: 'MOV '; Bytes: 1; Register: (6,6)),
  131.                 (Befehl: 'MOV '; Bytes: 1; Register: (6,7)),
  132.                 (Befehl: 'MOV '; Bytes: 1; Register: (6,8)),
  133.                 (Befehl: 'MOV '; Bytes: 1; Register: (6,9)),
  134.                 (Befehl: 'MOV '; Bytes: 1; Register: (6,10)),
  135.                 (Befehl: 'MOV '; Bytes: 1; Register: (6,3)),
  136.                 (Befehl: 'MOV '; Bytes: 1; Register: (7,4)),
  137.                 (Befehl: 'MOV '; Bytes: 1; Register: (7,5)),
  138.                 (Befehl: 'MOV '; Bytes: 1; Register: (7,6)),
  139.                 (Befehl: 'MOV '; Bytes: 1; Register: (7,7)),
  140.                 (Befehl: 'MOV '; Bytes: 1; Register: (7,8)),
  141.                 (Befehl: 'MOV '; Bytes: 1; Register: (7,9)),
  142.                 (Befehl: 'MOV '; Bytes: 1; Register: (7,10)),
  143.                 (Befehl: 'MOV '; Bytes: 1; Register: (7,3)),
  144.                 (Befehl: 'MOV '; Bytes: 1; Register: (8,4)),
  145.                 (Befehl: 'MOV '; Bytes: 1; Register: (8,5)),
  146.                 (Befehl: 'MOV '; Bytes: 1; Register: (8,6)),
  147.                 (Befehl: 'MOV '; Bytes: 1; Register: (8,7)),
  148.                 (Befehl: 'MOV '; Bytes: 1; Register: (8,8)),
  149.                 (Befehl: 'MOV '; Bytes: 1; Register: (8,9)),
  150.                 (Befehl: 'MOV '; Bytes: 1; Register: (8,10)),
  151.                 (Befehl: 'MOV '; Bytes: 1; Register: (8,3)),
  152.                 (Befehl: 'MOV '; Bytes: 1; Register: (9,4)),
  153.                 (Befehl: 'MOV '; Bytes: 1; Register: (9,5)),
  154.                 (Befehl: 'MOV '; Bytes: 1; Register: (9,6)),
  155.                 (Befehl: 'MOV '; Bytes: 1; Register: (9,7)),
  156.                 (Befehl: 'MOV '; Bytes: 1; Register: (9,8)),
  157.                 (Befehl: 'MOV '; Bytes: 1; Register: (9,9)),
  158.                 (Befehl: 'MOV '; Bytes: 1; Register: (9,10)),
  159.                 (Befehl: 'MOV '; Bytes: 1; Register: (9,3)),
  160.                 (Befehl: 'MOV '; Bytes: 1; Register:(10,4)),
  161.                 (Befehl: 'MOV '; Bytes: 1; Register:(10,5)),
  162.                 (Befehl: 'MOV '; Bytes: 1; Register:(10,6)),
  163.                 (Befehl: 'MOV '; Bytes: 1; Register:(10,7)),
  164.                 (Befehl: 'MOV '; Bytes: 1; Register:(10,8)),
  165.                 (Befehl: 'MOV '; Bytes: 1; Register:(10,9)),
  166.                 (Befehl: 'HLT '; Bytes: 1; Register: (0,0)),
  167.                 (Befehl: 'MOV '; Bytes: 1; Register:(10,3)),
  168.                 (Befehl: 'MOV '; Bytes: 1; Register: (3,4)),
  169.                 (Befehl: 'MOV '; Bytes: 1; Register: (3,5)),
  170.                 (Befehl: 'MOV '; Bytes: 1; Register: (3,6)),
  171.                 (Befehl: 'MOV '; Bytes: 1; Register: (3,7)),
  172.                 (Befehl: 'MOV '; Bytes: 1; Register: (3,8)),
  173.                 (Befehl: 'MOV '; Bytes: 1; Register: (3,9)),
  174.                 (Befehl: 'MOV '; Bytes: 1; Register: (3,10)),
  175.                 (Befehl: 'MOV '; Bytes: 1; Register: (3,3)),
  176.                 (Befehl: 'ADD '; Bytes: 1; Register: (4,0)),
  177.                 (Befehl: 'ADD '; Bytes: 1; Register: (5,0)),
  178.                 (Befehl: 'ADD '; Bytes: 1; Register: (6,0)),
  179.                 (Befehl: 'ADD '; Bytes: 1; Register: (7,0)),
  180.                 (Befehl: 'ADD '; Bytes: 1; Register: (8,0)),
  181.                 (Befehl: 'ADD '; Bytes: 1; Register: (9,0)),
  182.                 (Befehl: 'ADD '; Bytes: 1; Register:(10,0)),
  183.                 (Befehl: 'ADD '; Bytes: 1; Register: (3,0)),
  184.                 (Befehl: 'ADC '; Bytes: 1; Register: (4,0)),
  185.                 (Befehl: 'ADC '; Bytes: 1; Register: (5,0)),
  186.                 (Befehl: 'ADC '; Bytes: 1; Register: (6,0)),
  187.                 (Befehl: 'ADC '; Bytes: 1; Register: (7,0)),
  188.                 (Befehl: 'ADC '; Bytes: 1; Register: (8,0)),
  189.                 (Befehl: 'ADC '; Bytes: 1; Register: (9,0)),
  190.                 (Befehl: 'ADC '; Bytes: 1; Register:(10,0)),
  191.                 (Befehl: 'ADC '; Bytes: 1; Register: (3,0)),
  192.                 (Befehl: 'SUB '; Bytes: 1; Register: (4,0)),
  193.                 (Befehl: 'SUB '; Bytes: 1; Register: (5,0)),
  194.                 (Befehl: 'SUB '; Bytes: 1; Register: (6,0)),
  195.                 (Befehl: 'SUB '; Bytes: 1; Register: (7,0)),
  196.                 (Befehl: 'SUB '; Bytes: 1; Register: (8,0)),
  197.                 (Befehl: 'SUB '; Bytes: 1; Register: (9,0)),
  198.                 (Befehl: 'SUB '; Bytes: 1; Register:(10,0)),
  199.                 (Befehl: 'SUB '; Bytes: 1; Register: (3,0)),
  200.                 (Befehl: 'SBB '; Bytes: 1; Register: (4,0)),
  201.                 (Befehl: 'SBB '; Bytes: 1; Register: (5,0)),
  202.                 (Befehl: 'SBB '; Bytes: 1; Register: (6,0)),
  203.                 (Befehl: 'SBB '; Bytes: 1; Register: (7,0)),
  204.                 (Befehl: 'SBB '; Bytes: 1; Register: (8,0)),
  205.                 (Befehl: 'SBB '; Bytes: 1; Register: (9,0)),
  206.                 (Befehl: 'SBB '; Bytes: 1; Register:(10,0)),
  207.                 (Befehl: 'SBB '; Bytes: 1; Register: (3,0)),
  208.                 (Befehl: 'ANA '; Bytes: 1; Register: (4,0)),
  209.                 (Befehl: 'ANA '; Bytes: 1; Register: (5,0)),
  210.                 (Befehl: 'ANA '; Bytes: 1; Register: (6,0)),
  211.                 (Befehl: 'ANA '; Bytes: 1; Register: (7,0)),
  212.                 (Befehl: 'ANA '; Bytes: 1; Register: (8,0)),
  213.                 (Befehl: 'ANA '; Bytes: 1; Register: (9,0)),
  214.                 (Befehl: 'ANA '; Bytes: 1; Register:(10,0)),
  215.                 (Befehl: 'ANA '; Bytes: 1; Register: (3,0)),
  216.                 (Befehl: 'XRA '; Bytes: 1; Register: (4,0)),
  217.                 (Befehl: 'XRA '; Bytes: 1; Register: (5,0)),
  218.                 (Befehl: 'XRA '; Bytes: 1; Register: (6,0)),
  219.                 (Befehl: 'XRA '; Bytes: 1; Register: (7,0)),
  220.                 (Befehl: 'XRA '; Bytes: 1; Register: (8,0)),
  221.                 (Befehl: 'XRA '; Bytes: 1; Register: (9,0)),
  222.                 (Befehl: 'XRA '; Bytes: 1; Register:(10,0)),
  223.                 (Befehl: 'XRA '; Bytes: 1; Register: (3,0)),
  224.                 (Befehl: 'ORA '; Bytes: 1; Register: (4,0)),
  225.                 (Befehl: 'ORA '; Bytes: 1; Register: (5,0)),
  226.                 (Befehl: 'ORA '; Bytes: 1; Register: (6,0)),
  227.                 (Befehl: 'ORA '; Bytes: 1; Register: (7,0)),
  228.                 (Befehl: 'ORA '; Bytes: 1; Register: (8,0)),
  229.                 (Befehl: 'ORA '; Bytes: 1; Register: (9,0)),
  230.                 (Befehl: 'ORA '; Bytes: 1; Register:(10,0)),
  231.                 (Befehl: 'ORA '; Bytes: 1; Register: (3,0)),
  232.                 (Befehl: 'CMP '; Bytes: 1; Register: (4,0)),
  233.                 (Befehl: 'CMP '; Bytes: 1; Register: (5,0)),
  234.                 (Befehl: 'CMP '; Bytes: 1; Register: (6,0)),
  235.                 (Befehl: 'CMP '; Bytes: 1; Register: (7,0)),
  236.                 (Befehl: 'CMP '; Bytes: 1; Register: (8,0)),
  237.                 (Befehl: 'CMP '; Bytes: 1; Register: (9,0)),
  238.                 (Befehl: 'CMP '; Bytes: 1; Register:(10,0)),
  239.                 (Befehl: 'CMP '; Bytes: 1; Register: (3,0)),
  240.                 (Befehl: 'RNZ '; Bytes: 1; Register: (0,0)),
  241.                 (Befehl: 'POP '; Bytes: 1; Register: (4,0)),
  242.                 (Befehl: 'JNZ '; Bytes: 3; Register: (2,0)),
  243.                 (Befehl: 'JMP '; Bytes: 3; Register: (2,0)),
  244.                 (Befehl: 'CNZ '; Bytes: 3; Register: (2,0)),
  245.                 (Befehl: 'PUSH'; Bytes: 1; Register: (4,0)),
  246.                 (Befehl: 'ADI '; Bytes: 2; Register: (1,0)),
  247.                 (Befehl: 'RST0'; Bytes: 1; Register: (0,0)),
  248.                 (Befehl: 'RZ  '; Bytes: 1; Register: (0,0)),
  249.                 (Befehl: 'RET '; Bytes: 1; Register: (0,0)),
  250.                 (Befehl: 'JZ  '; Bytes: 3; Register: (0,0)),
  251.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  252.                 (Befehl: 'CZ  '; Bytes: 3; Register: (2,0)),
  253.                 (Befehl: 'CALL'; Bytes: 3; Register: (2,0)),
  254.                 (Befehl: 'ACI '; Bytes: 2; Register: (1,0)),
  255.                 (Befehl: 'RST1'; Bytes: 1; Register: (0,0)),
  256.                 (Befehl: 'RNC '; Bytes: 1; Register: (0,0)),
  257.                 (Befehl: 'POP '; Bytes: 1; Register: (6,0)),
  258.                 (Befehl: 'JNC '; Bytes: 3; Register: (2,0)),
  259.                 (Befehl: 'OUT '; Bytes: 2; Register: (1,0)),
  260.                 (Befehl: 'CNC '; Bytes: 3; Register: (2,0)),
  261.                 (Befehl: 'PUSH'; Bytes: 1; Register: (6,0)),
  262.                 (Befehl: 'SUI '; Bytes: 2; Register: (1,0)),
  263.                 (Befehl: 'RST2'; Bytes: 1; Register: (0,0)),
  264.                 (Befehl: 'RC  '; Bytes: 1; Register: (0,0)),
  265.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  266.                 (Befehl: 'JC  '; Bytes: 3; Register: (2,0)),
  267.                 (Befehl: 'IN  '; Bytes: 2; Register: (1,0)),
  268.                 (Befehl: 'CC  '; Bytes: 3; Register: (2,0)),
  269.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  270.                 (Befehl: 'SBI '; Bytes: 2; Register: (1,0)),
  271.                 (Befehl: 'RST3'; Bytes: 1; Register: (0,0)),
  272.                 (Befehl: 'RPO '; Bytes: 1; Register: (0,0)),
  273.                 (Befehl: 'POP '; Bytes: 1; Register: (8,0)),
  274.                 (Befehl: 'JPO '; Bytes: 3; Register: (2,0)),
  275.                 (Befehl: 'XTHL'; Bytes: 1; Register: (0,0)),
  276.                 (Befehl: 'CPO '; Bytes: 3; Register: (2,0)),
  277.                 (Befehl: 'PUSH'; Bytes: 1; Register: (8,0)),
  278.                 (Befehl: 'ANI '; Bytes: 2; Register: (1,0)),
  279.                 (Befehl: 'RST4'; Bytes: 1; Register: (0,0)),
  280.                 (Befehl: 'RPE '; Bytes: 1; Register: (0,0)),
  281.                 (Befehl: 'PCHL'; Bytes: 1; Register: (0,0)),
  282.                 (Befehl: 'JPE '; Bytes: 3; Register: (2,0)),
  283.                 (Befehl: 'XCHG'; Bytes: 1; Register: (0,0)),
  284.                 (Befehl: 'CPE '; Bytes: 3; Register: (2,0)),
  285.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  286.                 (Befehl: 'XRI '; Bytes: 2; Register: (1,0)),
  287.                 (Befehl: 'RST5'; Bytes: 1; Register: (0,0)),
  288.                 (Befehl: 'RP  '; Bytes: 1; Register: (0,0)),
  289.                 (Befehl: 'POP '; Bytes: 1; Register:(15,0)),
  290.                 (Befehl: 'JP  '; Bytes: 3; Register: (2,0)),
  291.                 (Befehl: 'DI  '; Bytes: 1; Register: (0,0)),
  292.                 (Befehl: 'CP  '; Bytes: 3; Register: (2,0)),
  293.                 (Befehl: 'PUSH'; Bytes: 1; Register:(15,0)),
  294.                 (Befehl: 'ORI '; Bytes: 2; Register: (1,0)),
  295.                 (Befehl: 'RST6'; Bytes: 1; Register: (0,0)),
  296.                 (Befehl: 'RM  '; Bytes: 1; Register: (0,0)),
  297.                 (Befehl: 'SPHL'; Bytes: 1; Register: (0,0)),
  298.                 (Befehl: 'JM  '; Bytes: 3; Register: (2,0)),
  299.                 (Befehl: 'EI  '; Bytes: 1; Register: (0,0)),
  300.                 (Befehl: 'CM  '; Bytes: 3; Register: (2,0)),
  301.                 (Befehl: '----'; Bytes: 1; Register: (0,0)),
  302.                 (Befehl: 'CPI '; Bytes: 2; Register: (1,0)),
  303.                 (Befehl: 'RST7'; Bytes: 1; Register: (0,0)));
  304. (* ----------------------------------------------------------------------- *)
  305. (* Ausgabe eines Wertes als Hexzahl auf der Standardausgabe. Durch "len"   *)
  306. (* wird festgelegt, ob ein Byte (len = 1) oder Worte (len = 2) ausgegeben  *)
  307. (* werden sollen.                                                          *)
  308. PROCEDURE WriteHex (len, value : INTEGER);
  309. CONST HexZif : ARRAY [0..15] OF CHAR = '0123456789ABCDEF';
  310. VAR  temp, i : INTEGER;
  311. BEGIN
  312.   FOR i := len DOWNTO 1 DO BEGIN                        (* 1 oder 2 bytes  *)
  313.     IF i = 2 THEN temp := Swap(value) AND $0FF          (* high byte holen *)
  314.     ELSE temp := value AND $0FF;                        (* low byte holen  *)
  315.                                       (* Ausgabe von jeweils 2 Hexziffern: *)
  316.     Write(HexZif[temp DIV 16]:1,HexZif[temp MOD 16]:1);
  317.   END;
  318. END;
  319. (* ----------------------------------------------------------------------- *)
  320. (* Lese 1 oder 2 Bytes aus dem Speicher ab "adr" und gebe das Ergebnis an  *)
  321. (* "GetVal" zurueck. Die gelesenen Bytes werden als Hexziffern auf der     *)
  322. (* Standardausgabe angezeigt. Fuer CP/M 80 muss der Zugriff auf den Spei-  *)
  323. (* cher mit "Mem[adr]" erfolgen, die Spezifizierung des Segments kann ent- *)
  324. (* fallen. Fuer die 8088 etc. ist dagegen das Segment anzugeben.           *)
  325. FUNCTION getval (VAR adr : INTEGER; len : INTEGER) : INTEGER;
  326. VAR temp : INTEGER;
  327. BEGIN
  328.   temp := Mem[Segment:adr];                               (* lese low Byte *)
  329.   WriteHex(1,temp);                                       (* Hex Ausgabe   *)
  330.   Write (' ');
  331.   adr := Succ(adr);
  332.   IF len = 2 THEN BEGIN                                   (* Wort einlesen *)
  333.     temp := temp OR 256 * Mem[Segment:adr];
  334.     WriteHex (1,Mem[Segment:adr]);                        (* Hex Ausgabe   *)
  335.     Write (' ');
  336.     adr := Succ(adr);
  337.   END;
  338.   getval := temp;
  339. END;
  340. (* ----------------------------------------------------------------------- *)
  341. (* vergleiche, ob Wert1 < Wert2 ist, beachte die Implementierung des Typs  *)
  342. (* Integer in Turbo Pascal                                                 *)
  343. FUNCTION greather (Wert1,Wert2 : INTEGER) : BOOLEAN;
  344. BEGIN
  345.   IF Hi(Wert1) < Hi(Wert2) THEN                   (* high Byte vergleichen *)
  346.     greather := TRUE
  347.   ELSE IF Lo(Wert1) < Lo(Wert2) THEN              (* low Byte vergleichen  *)
  348.     greather := TRUE
  349.   ELSE
  350.     greather := FALSE;
  351. END;
  352. (* ----------------------------------------------------------------------- *)
  353. BEGIN (* DisAsm8080 *)
  354.   WriteLn;  WriteLn;  WriteLn;
  355.   WriteLn('8080 Disassembler v1.0   (C) 1987  B.Born & PASCAL INT.');
  356.   WriteLn;
  357.   REPEAT                         (* Programmende, wenn StartAdr > EndAdr ! *)
  358.     Write('Segment       (Hex = $XXXX) :');  ReadLn(Segment);
  359.     Write('Start Adresse (Hex = $XXXX) :');  ReadLn(Startadr);
  360.     Write('End Adresse   (Hex = $XXXX) :');  ReadLn(Endadr);
  361.     Currentadr := Startadr;
  362.                                   (* while currentadr < Endadr do          *)
  363.                                   (* vergleiche Datentype Word [0 .. FFFF] *)
  364.     WHILE greather(Currentadr,Endadr) DO BEGIN        (* Disassembler-Loop *)
  365.       WriteHex(wordlen,Segment);                      (* Segment ausgeben  *)
  366.       Write(':');
  367.       WriteHex(wordlen,Currentadr);                   (* Adresse ausgeben  *)
  368.       Write(' ');
  369.       Opcode := getval(Currentadr,bytelen);           (* lese Opcodebyte   *)
  370.       WITH Table[Opcode] DO BEGIN                     (* decodiere Befehl  *)
  371.         IF Bytes = 3 THEN
  372.           BEGIN                                       (* lese Wort         *)
  373.             SecOpcode := getval(Currentadr,wordlen);
  374.             Column := 15;                             (* Ausgabespalte     *)
  375.           END
  376.         ELSE IF Bytes = 2 THEN
  377.           BEGIN                                       (* lese Byte         *)
  378.             SecOpcode := getval(Currentadr,bytelen);
  379.             Column := 12;
  380.           END
  381.         ELSE
  382.           Column := 9;
  383.         FOR i := Column TO 20 DO    (* Ausgabe auf Spalte 20 positionieren *)
  384.           Write (' ');
  385.         Write (Befehl,'  ');                           (* Befehl ausgeben  *)
  386.                     (* bestimme die Konstanten- und Registerbezeichnungen: *)
  387.         FOR i := 1 TO 2 DO BEGIN
  388.           CASE Register[i] OF
  389.             0: GOTO 999;
  390.             1: BEGIN                             (* code DB z.B. ORI 15    *)
  391.                  WriteHex(bytelen,SecOpcode);
  392.                  GOTO 999;
  393.                END;
  394.             2: BEGIN                             (* code DW z.B. SHLD 1234 *)
  395.                  WriteHex(wordlen,SecOpcode);
  396.                  GOTO 999;
  397.                END;
  398.             3: Write ('A');                           (* Registercodes     *)
  399.             4: Write ('B');
  400.             5: Write ('C');
  401.             6: Write ('D');
  402.             7: Write ('E');
  403.             8: Write ('H');
  404.             9: Write ('L');
  405.            10: Write ('M');
  406.            11: Write ('BC');
  407.            12: Write ('DE');
  408.            13: Write ('HL');
  409.            14: Write ('SP');
  410.            15: Write ('PSW');
  411.           END; (* CASE *)
  412.           IF Register[2] = 0 THEN GOTO 999;
  413.           IF i = 1 THEN Write (',');
  414.         END; (* FOR *)
  415.       END; (* WITH *)
  416.       999: WriteLn;
  417.     END; (* WHILE CurrentAdr < Endadr *)
  418.   UNTIL greather(Endadr,Startadr);
  419. END.
  420.