home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / EXTRA-ST / CPM-80-E / CPM-0.2 / CPM-0 / cpm-0.2 / disz80.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-15  |  7.7 KB  |  283 lines
  1. /*****************************************************************************/
  2. /*                                         */
  3. /*                                         */
  4. /*    CP/M emulator version 0.1                         */
  5. /*                                         */
  6. /*    written by Michael Bischoff (mbi@mo.math.nat.tu-bs.de)             */
  7. /*    June-1994                                 */
  8. /*                                         */
  9. /*    This file is distributed under the GNU COPYRIGHT             */
  10. /*    see COPYRIGHT.GNU for Copyright details                     */
  11. /*                                         */
  12. /*                                         */
  13. /*****************************************************************************/
  14. #define _POSIX_SOURCE
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18.  
  19. /* 8-Bit registers */
  20. static const char *dtab1[] = { "B", "C", "D", "E", "H", "L", NULL, "A" };
  21. /* condition codes */
  22. static const char *dtab4[] = { "NZ", "Z", "NC", "C", "PO", "PE", "P", "M" };
  23. /* opcodes */
  24. static const char *dtab5[] = { "ADD A,", "ADC A,", "SUB ", "SBC A,", "AND ", "XOR ", "OR ", "CP " };
  25. static const char *dtabix[] = { "POP %s", "EX (SP),%s", "PUSH %s", "JP(%s)",
  26.                     "EX DE,%s", "LD SP,%s" };
  27. static const char *dtab2[] = { "BC", "DE", NULL, "SP" };
  28. /*static const char *dtab3[] = { "BC", "DE", NULL, "AF" }; */
  29.  
  30. static const char *op1tab[] = {    /* NULLs are handled explicitly */
  31.     "NOP",       NULL,        "LD (BC),A", NULL, NULL, NULL, NULL, "RLCA",
  32.     "EX AF,AF'", NULL,        "LD A,(BC)", NULL, NULL, NULL, NULL, "RRCA",
  33.     "DJNZ %04x", NULL,        "LD (DE),A", NULL, NULL, NULL, NULL, "RLA",
  34.     "JR %04x",   NULL,        "LD A,(DE)", NULL, NULL, NULL, NULL, "RRA",
  35.     "JR NZ,%04x",NULL,          NULL,        NULL, NULL, NULL, NULL, "DAA",
  36.     "JR Z,%04x", NULL,        NULL,        NULL, NULL, NULL, NULL, "CPL",
  37.     "JR NC,%04x",NULL,        NULL,       NULL, NULL, NULL, NULL, "SCF",
  38.     "JR C,%04x", NULL,          NULL,       NULL, NULL, NULL, NULL, "CCF" };
  39.  
  40. static const char *op2tab[] = {
  41.     NULL, "POP BC", NULL, "JP %04x",      NULL, "PUSH BC", NULL, NULL,   NULL, "RET",     NULL, "???",         NULL, "CALL %04x", NULL, NULL,
  42.     NULL, "POP DE", NULL, "OUT (%03x),A", NULL, "PUSH DE", NULL, NULL,   NULL, "EXX",     NULL, "IN A,(%03x)", NULL, "???",       NULL, NULL,
  43.     NULL, "POP HL", NULL, "EX (SP),HL",   NULL, "PUSH HL", NULL, NULL,   NULL, "JP (HL)", NULL, "EX DE,HL",    NULL, "???",       NULL, NULL,
  44.     NULL, "POP AF", NULL, "DI",           NULL, "PUSH AF", NULL, NULL,   NULL, "LD SP,HL",NULL, "EI",          NULL, "???",       NULL, NULL };
  45. static const char *cbtab1[] = {
  46.     "RLC", "RRC", "RL", "RR", "SLA", "SRA", "? SLIA", "SRL" };
  47. static const char *cbtab2[] = {
  48.     NULL, "BIT", "RES", "SET" };
  49. static unsigned char ixy_possible8[32] = {
  50.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00,
  51.     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0xbf, 0x40,
  52.     0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
  53.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  54. };
  55.  
  56. static char edcmds[] = {
  57.     0x44, 0xa0, 0xa8, 0xb0, 0xb8, 0x47, 0x4f, 0x57,
  58.     0x5f, 0xa1, 0xb1, 0xa9, 0xb9, 0x46, 0x56, 0x5e,
  59.     0x67, 0x6f, 0xa3, 0xab, 0xb3, 0xbb, 0x45, 0x4d,
  60. 0 };
  61. static const char *edtxt[] = {
  62.     "NEG", "LDI", "LDD", "LDIR", "LDDR", "LD I,A", "LD R,A", "LD A,I",
  63.     "LD A,R", "CPI", "CPIR", "CPD", "CPDR", "IM 0", "IM 1", "IM 2", "RRD",
  64.     "RLD", "OUTI", "OUTD", "OTIR", "OTDR", "RETN", "RETI"
  65.     };
  66.  
  67. static const unsigned char *edcommand(const unsigned char *PC, char *s) {
  68.     unsigned o, w;
  69.     const char *dr;
  70.     o = *PC;
  71.     
  72.     dtab2[2] = "HL";
  73.     dr = dtab2[(o & 0x30) >> 4];
  74.  
  75.     switch (o & 0xcf) {
  76.     case 0x42:
  77.     sprintf(s, "SBC HL,%s", dr);
  78.     break;
  79.     case 0x43:
  80.     w = *++PC;
  81.     w += *++PC << 8;
  82.     sprintf(s, "LD (%04x),%s", w, dr);
  83.     break;
  84.     case 0x4a:
  85.     sprintf(s, "ADC HL,%s", dr);
  86.     break;
  87.     case 0x4b:
  88.     w = *++PC;
  89.     w += *++PC << 8;
  90.     sprintf(s, "LD %s,(%04x)", dr, w);
  91.     break;
  92.     default:
  93.     if (o && (dr = strchr(edcmds, o))) {
  94.         strcpy(s, edtxt[dr-edcmds]);
  95.         break;
  96.     }
  97.     return PC-1;
  98.     }
  99.     return PC+1;
  100. }
  101.  
  102.  
  103. /* PC is only needed for JR instructions */
  104. const unsigned char *disz80(const unsigned char *PC, char *s, unsigned pc) {
  105.     unsigned o, m, r;
  106.     const char *regh, *regl, *ir;
  107.     char i_offset[8];
  108.     unsigned w;
  109.     
  110.     dtab1[6] = "(HL)";
  111.     ir = "HL";
  112.     o = *PC;
  113.  redo:
  114.     regh = dtab1[m = (o >> 3) & 7];
  115.     regl = dtab1[r = o & 7];
  116.     
  117.     switch (o >> 6) {
  118.     case 0:        /* the lower block */
  119.     switch(o & 7) {
  120.     case 4:
  121.         sprintf(s, "INC %s", regh);
  122.         break;
  123.     case 5:
  124.         sprintf(s, "DEC %s", regh);
  125.         break;
  126.     case 6:
  127.         sprintf(s, "LD %s,0%02x", regh, *++PC);
  128.         break;
  129.     default:
  130.         dtab2[2] = ir;
  131.         switch (o) {
  132.         case 0x01: case 0x11: case 0x21: case 0x31:
  133.         w = *++PC;
  134.         w += *++PC << 8;
  135.         sprintf(s, "LD %s,%04x", dtab2[o>>4], w);
  136.         break;
  137.         case 0x03: case 0x13: case 0x23: case 0x33:
  138.         sprintf(s, "INC %s", dtab2[o>>4]);
  139.         break;
  140.         case 0x0b: case 0x1b: case 0x2b: case 0x3b:
  141.         sprintf(s, "DEC %s", dtab2[o>>4]);
  142.         break;
  143.         case 0x09: case 0x19: case 0x29: case 0x39:
  144.         sprintf(s, "ADD %s,%s", ir, dtab2[o>>4]);
  145.         break;
  146.         case 0x22: case 0x2a: case 0x32: case 0x3a:
  147.         /* commands which use a 16 bit argument */
  148.         w = *++PC;
  149.         w += *++PC << 8;
  150.         switch (o) {
  151.         case 0x22:
  152.             sprintf(s, "LD (%04x),%s", w, ir);
  153.             break;
  154.         case 0x2a:
  155.             sprintf(s, "LD %s,(%04x)", ir, w);
  156.             break;
  157.         case 0x32:
  158.             sprintf(s, "LD (%04x),A", w);
  159.             break;
  160.         case 0x3a:
  161.             sprintf(s, "LD A,(%04x)", w);
  162.             break;
  163.         }
  164.         break;
  165.         case 0x10: case 0x18: case 0x20:
  166.         case 0x28: case 0x30: case 0x38:
  167.         /* jump relative */
  168. #if 1
  169.         if ((w = *++PC) & 0x80)
  170.             w -= 256;
  171.         w += pc + 2;
  172. #else
  173.         w = *++PC;    /* no service for destination address */
  174. #endif
  175.         sprintf(s, op1tab[o], w);
  176.         break;
  177.         default:
  178.         strcpy(s, op1tab[o]);
  179.         break;
  180.         }
  181.     }
  182.     break;    /* lower block done */
  183.     case 1:        /* second block is easy */
  184.     if (o != 0x76)
  185.         sprintf(s, "LD %s,%s", regh, regl);
  186.     else
  187.         strcpy(s, "HALT");
  188.     break;
  189.     case 2:        /* third block is easy */
  190.     strcpy(s, dtab5[m]);
  191.     strcat(s, regl);
  192.     break;
  193.     case 3:        /* fourth block */
  194.     switch(o & 7) {
  195.     case 0:
  196.         sprintf(s, "RET %s", dtab4[m]);
  197.         break;
  198.     case 2:
  199.         w = *++PC;
  200.         w += *++PC << 8;
  201.         sprintf(s, "JP %s,%04x", dtab4[m], w);
  202.         break;
  203.     case 4:
  204.         w = *++PC;
  205.         w += *++PC << 8;
  206.         sprintf(s, "CALL %s,%04x", dtab4[m], w);
  207.         break;
  208.     case 6:
  209.         sprintf(s, "%s0%02x", dtab5[m], *++PC);
  210.         break;
  211.     case 7:
  212.         sprintf(s, "RST %03xH", m << 3);
  213.         break;
  214.     default:
  215.         switch (o) {
  216.         case 0xc3: case 0xcd:
  217.         w = *++PC;
  218.         w += *++PC << 8;
  219.         break;
  220.         case 0xd3: case 0xdb:
  221.         w = *++PC;
  222.         break;
  223.  
  224.         /* SPECIAL Z80 COMMANDS START HERE: */
  225.         case 0xcb:    /* rotate-commands */
  226.         ddcb:
  227.         o = *++PC;
  228.         regl = dtab1[r = o & 7];
  229.         m = (o >> 3) & 7;
  230.         if (o & 0xc0)
  231.             sprintf(s, "%s %d,%s", cbtab2[o >> 6], m, dtab1[r]);
  232.         else
  233.             sprintf(s, "%s %s", cbtab1[m], dtab1[r]);
  234.         return PC+1;
  235.         case 0xed:
  236.         return edcommand(PC+1, s);
  237.         case 0xdd:
  238.         ir = "IX";
  239.         goto ixiy;
  240.         case 0xfd:
  241.         ir = "IY";
  242.         ixiy:
  243.         dtab1[6] = i_offset;
  244.         m = PC[2];    /* offset */
  245.         sprintf(i_offset, "(%s%c%02x)", ir, m&0x80 ? '-' : '+',
  246.             m&0x80 ? 256-m : m);
  247.         o = *++PC;
  248.         if (o == 0xcb) {
  249.             /* rotate with index reg */
  250.             o = PC[2];
  251.             if ((o & 7) != 6)
  252.             return PC-1;    /* invalid opcode! */
  253.             ++PC;    /* skip offset */
  254.             goto ddcb;
  255.         }
  256.         if (ixy_possible8[o >> 3] & (1<<(o&7))) {
  257.             /* is a command which addresses 8 bit index+offset */
  258.             ++PC;    /* skip offset */
  259.             goto redo;
  260.         }
  261.         {   unsigned char *p, xtra1[] = {
  262.             0x21, 0x22, 0x2a, 0x09, 0x19, 0x29, 0x39, 0x23, 0x2b, 0
  263.             }, xtra2[] = {
  264.             0xe1, 0xe3, 0xe5, 0xe9, 0xeb, 0xf9, 0 };
  265.             if (o) {
  266.             if ((p = strchr(xtra1, o)))
  267.                 goto redo;
  268.             else if ((p = strchr(xtra2, o))) {
  269.                 sprintf(s, dtabix[p-xtra2], ir);
  270.                 return PC+1;
  271.             }
  272.             }
  273.         }
  274.         return PC-1;    /* unknown opcode */
  275.         }
  276.         sprintf(s, op2tab[o & 63], w);
  277.         break;
  278.     }
  279.     break;
  280.     }
  281.     return PC+1;
  282. }
  283.