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 / z80out.c < prev   
Encoding:
C/C++ Source or Header  |  1994-06-06  |  12.2 KB  |  315 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. #include "cpmemu.h"
  15.  
  16. #define X   12      /* offset for memnonic */
  17. static const char *dtab1[] = { "B", "C", "D", "E", "H", "L", "(HL)", "A" };
  18. static const char *dtab2[] = { "BC", "DE", "HL", "SP" };
  19. /*static const char *dtab3[] = { "BC", "DE", "HL", "AF" }; */
  20. static const char *dtab4[] = { "NZ", "Z", "NC", "C", "PO", "PE", "P", "M" };
  21. static const char *dtab5[] = { "ADD A,", "ADC A,", "SUB ", "SBC A,", "AND ", "XOR ", "OR ", "CP " };
  22. static const char *op1tab[] = {
  23.     "NOP",        "LD BC,%04x", "LD (BC),A",   "INC BC", NULL, NULL, NULL, "RLCA", "EX AF,AF'",     "ADD HL,BC", "LD A,(BC)",   "DEC BC", NULL, NULL, NULL, "RRCA",
  24.     "DJNZ %04x",  "LD DE,%04x", "LD (DE),A",   "INC DE", NULL, NULL, NULL, "RLA",  "JR %04x",       "ADD HL,DE", "LD A,(DE)",   "DEC DE", NULL, NULL, NULL, "RRA",
  25.     "JR NZ,%04x", "LD HL,%04x", "LD (%04x),HL","INC HL", NULL, NULL, NULL, "DAA",  "JR Z,%04x",     "ADD HL,HL", "LD HL,(%04x)","DEC HL", NULL, NULL, NULL, "CPL",
  26.     "JR NC,%04x", "LD SP,%04x", "LD (%04x),A", "INC SP", NULL, NULL, NULL, "SCF",  "JR C,%04x",     "ADD HL,SP", "LD A,(%04x)", "DEC SP", NULL, NULL, NULL, "CCF" };
  27. static const char *op2tab[] = {
  28.     NULL, "POP BC", NULL, "JP %04x",      NULL, "PUSH BC", NULL, NULL,   NULL, "RET",     NULL, "???",         NULL, "CALL %04x", NULL, NULL,
  29.     NULL, "POP DE", NULL, "OUT (%03x),A", NULL, "PUSH DE", NULL, NULL,   NULL, "EXX",     NULL, "IN A,(%03x)", NULL, "???",       NULL, NULL,
  30.     NULL, "POP HL", NULL, "EX (SP),HL",   NULL, "PUSH HL", NULL, NULL,   NULL, "JP (HL)", NULL, "EX DE,HL",    NULL, "???",       NULL, NULL,
  31.     NULL, "POP AF", NULL, "DI",           NULL, "PUSH AF", NULL, NULL,   NULL, "LD SP,HL",NULL, "EI",          NULL, "???",       NULL, NULL };
  32. static const char *cbtab1[] = {
  33.     "RLC", "RRC", "RL", "RR", "SLA", "SRA", "? SLIA", "SRL" };
  34. static const char *cbtab2[] = {
  35.     NULL, "BIT", "RES", "SET" };
  36.  
  37. static int numbytes;
  38.  
  39. static void byte1(char *s, unsigned o) {
  40.     static char hextab[] = "0123456789abcdef";
  41.     s[3] = hextab[o >> 4];
  42.     s[4] = hextab[o & 15];
  43.     numbytes = 2;
  44. }
  45. static void byte2(char *s, unsigned o) {
  46.     static char hextab[] = "0123456789abcdef";
  47.     s[6] = hextab[o >> 4];
  48.     s[7] = hextab[o & 15];
  49.     numbytes = 3;
  50. }
  51. static void byte3(char *s, unsigned o) {
  52.     static char hextab[] = "0123456789abcdef";
  53.     s[9] = hextab[o >> 4];
  54.     s[10] = hextab[o & 15];
  55.     numbytes = 4;
  56. }
  57. static void word1(char *s, unsigned w) {
  58.     byte1(s, w & 0xff);
  59.     byte2(s, w >> 8);
  60. }
  61. static void word2(char *s, unsigned w) {
  62.     byte2(s, w & 0xff);
  63.     byte3(s, w >> 8);
  64. }
  65.  
  66. static const char *bdosfunc[] = {
  67.     /* 00 */ "System Reset", "Console Input", "Console Output",
  68.     /* 03 */ "Aux. Input", "Aux. Output", "List Output",
  69.     /* 06 */ "Direct I/O", "Aux. Input Status", "Aux. Output Status",
  70.     /* 09 */ "Print String", "Read Console Buffer", "Get Console Status",
  71.     /* 12 */ "Return Version Number", "Reset Disk System",
  72.     /* 14 */ "Select Disk", "Open File", "Close File",
  73.     /* 17 */ "Search for First", "Search for Next", "Delete File",
  74.     /* 20 */ "Read Sequential", "Write Sequential", "Make File",
  75.     /* 23 */ "Rename File",    "Return Login Vector", "Return Current Disk",
  76.     /* 26 */ "Set DMA Address", "Get Addr(Alloc)", "Write Protect Disk",
  77.     /* 29 */ "Get R/O-Vector", "Set File Attributes", "Get Addr. of DPB",
  78.     /* 32 */ "Set/Get User Code", "Read Random", "Write Random",
  79.     /* 35 */ "Compute File Size", "Set Random Record", "Reset Drive",
  80.     /* 38 */ "Access Drive", "Free Drive" };
  81. /* extension: 40: change directory */
  82.  
  83. static char *disassemble(unsigned pc) {
  84.     static char s[60];
  85.     int o, m, r, b, w;
  86.  
  87.     numbytes = 1;
  88.     if (pc >= BIOS) {
  89.         switch (pc) {
  90.     case 0xff6c:
  91.         case BIOS:      sprintf(s, "BIOS COLDBOOT");
  92.                         break;
  93.     case 0xff6d:
  94.         case BIOS+3:    sprintf(s, "BIOS WARMBOOT");
  95.                         break;
  96.     case 0xff6e:
  97.         case BIOS+6:    sprintf(s, "BIOS Console Status");
  98.                         break;
  99.     case 0xff6f:
  100.         case BIOS+9:    sprintf(s, "BIOS Console Input");
  101.                         break;
  102.     case 0xff70:
  103.         case BIOS+0x0c: sprintf(s, "BIOS Console Output");
  104.                         break;
  105.     case 0xff71:
  106.         case BIOS+0x0f: sprintf(s, "BIOS List Output");
  107.                         break;
  108.     case 0xff72:
  109.         case BIOS+0x12: sprintf(s, "BIOS Punch Output");
  110.                         break;
  111.     case 0xff73:
  112.         case BIOS+0x15: sprintf(s, "BIOS Reader Input");
  113.                         break;
  114.     case 0xff74:
  115.         case BIOS+0x18: sprintf(s, "BIOS Home");
  116.                         break;
  117.     case 0xff75:
  118.         case BIOS+0x1b: sprintf(s, "BIOS Select Disk");
  119.                         break;
  120.     case 0xff76:
  121.         case BIOS+0x1e: sprintf(s, "BIOS Set Track");
  122.                         break;
  123.     case 0xff77:
  124.         case BIOS+0x21: sprintf(s, "BIOS Set Sector");
  125.                         break;
  126.     case 0xff78:
  127.         case BIOS+0x24: sprintf(s, "BIOS Set DMA");
  128.                         break;
  129.     case 0xff79:
  130.         case BIOS+0x27: sprintf(s, "BIOS Read");
  131.                         break;
  132.     case 0xff7a:
  133.         case BIOS+0x2a: sprintf(s, "BIOS Write");
  134.                         break;
  135.     case 0xff7b:
  136.         case BIOS+0x2d: sprintf(s, "BIOS List Status");
  137.                         break;
  138.     case 0xff7c:
  139.         case BIOS+0x30: sprintf(s, "BIOS Sector Translate");
  140.                         break;
  141.         default:        sprintf(s, "BIOS");
  142.         }
  143.         return s;
  144.     } else if ((pc == BDOS || pc == 5) && z80regs.pc == pc) {
  145.     if ((z80regs.bc & 0xff) < sizeof(bdosfunc) / sizeof(bdosfunc[0]))
  146.             sprintf(s, "BDOS %s", bdosfunc[z80regs.bc & 0xff]);
  147.         else
  148.             sprintf(s, "BDOS (0x%02x)", z80regs.bc & 0xff);
  149.         return s;
  150.     }
  151.     o = z80mem[pc];
  152.     sprintf(s, "%02x             ", o);
  153.     m = (o >> 3) & 7;
  154.     r = o & 7;
  155.     switch (o >> 6) {
  156.     case 0: switch(o & 7) {
  157.             case 4: sprintf(s+X, "INC %s", dtab1[m]);
  158.                     break;
  159.             case 5: sprintf(s+X, "DEC %s", dtab1[m]);
  160.                     break;
  161.             case 6: sprintf(s+X, "LD %s,0%02x", dtab1[m], b = z80mem[pc+1]);
  162.                     byte1(s, b);
  163.                     break;
  164.             default:switch (o) {
  165.                     case 0x22: case 0x2a: case 0x32: case 0x3a:
  166.                     case 0x01: case 0x11: case 0x21: case 0x31:
  167.                             w = z80mem[pc+1] + (z80mem[pc+2] << 8);
  168.                             word1(s, w);
  169.                             break;
  170.                     case 0x08: case 0x10: case 0x18: case 0x20: case 0x28: case 0x30: case 0x38:
  171.                             w = ((char *)z80mem)[pc+1];
  172.                             byte1(s, w & 0xff);
  173.                             w += pc + 2;
  174.                             break;
  175.                     }
  176.                     sprintf(s+X, op1tab[o], w);
  177.                     break;
  178.             }
  179.             break;
  180.     case 1: if (o != 0x76)
  181.                 sprintf(s+X, "LD %s,%s", dtab1[m], dtab1[r]);
  182.             else
  183.                 strcpy(s+X, "HALT");
  184.             break;
  185.     case 2: strcpy(s+X, dtab5[m]);
  186.             strcat(s+X, dtab1[r]);
  187.             break;
  188.     case 3: switch(o & 7) {
  189.             case 0: sprintf(s+X, "RET %s", dtab4[m]);
  190.                     break;
  191.             case 2: w = z80mem[pc+1] + (z80mem[pc+2] << 8);
  192.                     word1(s, w);
  193.                     sprintf(s+X, "JP %s,%04x", dtab4[m], w);
  194.                     break;
  195.             case 4: w = z80mem[pc+1] + (z80mem[pc+2] << 8);
  196.                     word1(s, w);
  197.                     sprintf(s+X, "CALL %s,%04x", dtab4[m], w);
  198.                     break;
  199.             case 6: w = z80mem[pc+1];
  200.                     sprintf(s+X, "%s0%02x", dtab5[m], w);
  201.                     byte1(s, w);
  202.                     break;
  203.             case 7: sprintf(s+X, "RST %03xH", m << 3);
  204.                     break;
  205.             default:switch (o) {
  206.                     case 0xc3: case 0xcd:
  207.                             w = z80mem[pc+1] + (z80mem[pc+2] << 8);
  208.                             word1(s, w);
  209.                             break;
  210.                     case 0xd3: case 0xdb:
  211.                             w = z80mem[pc+1];
  212.                             break;
  213.                     case 0xcb:
  214.                             o = z80mem[pc+1];
  215.                             byte1(s, o);
  216.                             m = (o >> 3) & 7;
  217.                             r = o & 7;
  218.                             if (o & 0xc0)
  219.                                 sprintf(s+X, "%s %d,%s", cbtab2[o >> 6], m, dtab1[r]);
  220.                             else
  221.                                 sprintf(s+X, "%s %s", cbtab1[m], dtab1[r]);
  222.                             return s;
  223.                     case 0xed:
  224.                             o = z80mem[pc+1];
  225.                             byte1(s, o);
  226.                             switch (o & 0xcf) {
  227.                             case 0x42:  sprintf(s+X, "SBC HL,%s", dtab2[(o & 0x30) >> 4]);
  228.                                         break;
  229.                             case 0x43:  w = z80mem[pc+2] + (z80mem[pc+3] << 8);
  230.                                         word2(s, w);
  231.                                         sprintf(s+X, "LD (%04x),%s", w, dtab2[(o & 0x30) >> 4]);
  232.                                         break;
  233.                             case 0x4a:  sprintf(s+X, "ADC HL,%s", dtab2[(o & 0x30) >> 4]);
  234.                                         break;
  235.                             case 0x4b:  w = z80mem[pc+2] + (z80mem[pc+3] << 8);
  236.                                         word2(s, w);
  237.                                         sprintf(s+X, "LD %s,(%04x)", dtab2[(o & 0x30) >> 4], w);
  238.                                         break;
  239.                             default:    switch (o) {
  240.                                         case 0x44:  sprintf(s+X, "NEG");
  241.                                                     break;
  242.                                         case 0xa0:  sprintf(s+X, "LDI");
  243.                                                     break;
  244.                                         case 0xb0:  sprintf(s+X, "LDIR");
  245.                                                     break;
  246.                                         case 0xb8:  sprintf(s+X, "LDDR");
  247.                                                     break;
  248.                                         default:    sprintf(s+X, "unrec.");
  249.                                         }
  250.                             }
  251.                             return s;
  252.                     }
  253.                     sprintf(s+X, op2tab[o & 63], w);
  254.                     break;
  255.             }
  256.             break;
  257.     }
  258.     return s;
  259. }
  260.  
  261. void disassem(unsigned *loc, int num) {
  262.     while (num--) {
  263.     printf("%04x %s\n", *loc, disassemble(*loc));
  264.     *loc = (*loc + numbytes) & 0xffff;
  265.     }
  266. }
  267.  
  268. static char *flags(unsigned f) {
  269.     static char s[10];
  270.     const char *fl = "SZ0H0VNC";
  271.     int i;
  272.     strcpy(s, "        ");
  273.     for (i = 0; i < 8; ++i) {
  274.         if (f & 0x80)
  275.             s[i] = fl[i];
  276.         f <<= 1;
  277.     }
  278.     return s;
  279. }
  280.  
  281. void dispregs(unsigned pc) {
  282.     printf("%s A=%02x BC=%04x DE=%04x HL=%04x SP=%04x PC=%04x  %s\n",
  283.        flags(z80regs.af >> 8), z80regs.af & 0xff,
  284.        z80regs.bc, z80regs.de, z80regs.hl, z80regs.sp,
  285.        pc, disassemble(pc));
  286.     fflush(stdout);
  287. }
  288.  
  289. void dispregs2(void) {
  290.     printf("%s a=%02x bc=%04x de=%04x hl=%04x IX=%04x IY=%04x  I=%02x R=%02x\n",
  291.        flags(z80regs.af2 >> 8), z80regs.af2 & 0xff,
  292.        z80regs.bc2, z80regs.de2, z80regs.hl2, z80regs.ix, z80regs.iy, z80regs.ir >> 8, z80regs.ir & 0xff);
  293.     fflush(stdout);
  294. }
  295.  
  296. void memdump(unsigned addr, int lines) {
  297.     int i, j;
  298.     for (i = 0; i < lines; ++i) {
  299.     printf("%04x ", addr);
  300.     for (j = 0; j < 16; ++j) {
  301.         if (j == 8)
  302.         printf(" -");
  303.         printf(" %02x", z80mem[addr+j]);
  304.     }
  305.     printf("  ");
  306.     for (j = 0; j < 16; ++j) {
  307.         if (j == 8)
  308.         printf(" ");
  309.         printf("%c", z80mem[addr+j] < ' ' ? '.' : z80mem[addr+j]);
  310.     }
  311.     printf("\n");
  312.     addr += 16;
  313.     }
  314. }
  315.