home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2075 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  29.6 KB
  1. From: darcy@druid.uucp (D'Arcy J.M. Cain)
  2. Newsgroups: alt.sources
  3. Subject: Yet another CP/M emulator part 2 of 3
  4. Message-ID: <1990Nov15.203736.10568@druid.uucp>
  5. Date: 15 Nov 90 20:37:36 GMT
  6. >from: darcy@druid.uucp (D'Arcy J.M. Cain)
  7.  
  8. #!/bin/sh
  9. # this is cpm.02 (part 2 of a multipart archive)
  10. # do not concatenate these parts, unpack them in order with /bin/sh
  11. # file cpm.c continued
  12. #
  13. if test ! -r _shar_seq_.tmp; then
  14.     echo 'Please unpack part 1 first!'
  15.     exit 1
  16. fi
  17. (read Scheck
  18.  if test "$Scheck" != 2; then
  19.     echo Please unpack part "$Scheck" next!
  20.     exit 1
  21.  else
  22.     exit 0
  23.  fi
  24. ) < _shar_seq_.tmp || exit 1
  25. sed 's/^X//' << 'SHAR_EOF' >> 'cpm.c' &&
  26. X            return(-1);
  27. X        }
  28. X
  29. X        def_drive = *entry;
  30. X        strcpy(cpm_drive[0],cpm_drive[def_drive]);
  31. X        entry[0] = entry[1] = ' ';
  32. X        tail = chop_cmd(entry);
  33. X    }
  34. X
  35. X    if (*entry == 0)
  36. X        return(0);
  37. X
  38. X    debug(entry);
  39. X
  40. X    if (strcmp(entry, "DIR") == 0)
  41. X        fsystem("ls -C %s", tail);
  42. X    else if (strcmp(entry, "DUMP") == 0)
  43. X        fsystem("hd %s", tail);
  44. X    else if (strcmp(entry, "ED") == 0)
  45. X        fsystem("$EDITOR %s", tail);
  46. X    else if (strcmp(entry, "ERA") == 0)
  47. X        fsystem("rm %s", tail);
  48. #ifdef    CPM_DEBUG
  49. X    else if (strcmp(entry, "DASM") == 0)
  50. X    {
  51. X        if(++dasm_flag > 2)
  52. X            dasm_flag = 0;
  53. X
  54. X        fprintf(stderr, "DASM is %d\r\n", dasm_flag);
  55. X    }
  56. #endif
  57. X    else if (strcmp(entry, "SAVE") == 0)
  58. X    {
  59. X        char    *fname = chop_cmd(tail);
  60. X        int        p = atoi(tail);
  61. X
  62. X        if ((p == 0) || (*fname == 0))
  63. X            fprintf(stderr, "Usage: SAVE #pages filename\r\n");
  64. X        else
  65. X        {
  66. X            if ((fp = fopen(real_name(fname), "wb")) == NULL)
  67. X                perror("\aCan't open save file");
  68. X            else
  69. X            {
  70. X                if (fwrite(ram + 256, 256, p, fp) != p)
  71. X                    perror("\aCan't write to file");
  72. X
  73. X                fclose(fp);
  74. X            }
  75. X        }
  76. X    }
  77. X    else if (strcmp(entry, "TYPE") == 0)
  78. X    {
  79. X        char    *ptr;
  80. X
  81. X        while (*tail)
  82. X        {
  83. X            ptr = tail;
  84. X            tail = chop_cmd(ptr);
  85. X            fsystem("cat %s", ptr);
  86. X        }
  87. X    }
  88. X    else if (strcmp(entry, "EXIT") == 0)
  89. X        cleanup(0);
  90. X    else
  91. #ifdef    CPM_DEBUG
  92. X    {
  93. X        time_t    start = time(NULL);
  94. X        int        r = run(real_name(entry));
  95. X
  96. X        fprintf(stderr, "Run took %ld seconds\n\r", time(NULL) - start);
  97. X        return(r);
  98. X    }
  99. #else
  100. X        return(run(real_name(entry)));
  101. #endif
  102. X
  103. X    return(0);
  104. }
  105. #endif
  106. X
  107. void    main(int argc, char **argv)
  108. {
  109. #ifdef    COMPILE_TEST
  110. X    /* test code useful for testing different architectures */
  111. X    int        test;
  112. X
  113. X    test = (int)(&acc);
  114. X    printf("Position of A = %d\n", (int)(&A) - test);
  115. X    printf("Position of FLAGS = %d\n", (int)(&FLAGS) - test);
  116. X
  117. X    test = (int)(&gr);
  118. X    printf("Position of B = %d\n", (int)(&B) - test);
  119. X    printf("Position of C = %d\n", (int)(&C) - test);
  120. X    printf("Position of BC = %d\n", (int)(&BC) - test);
  121. X    printf("Position of D = %d\n", (int)(&D) - test);
  122. X    printf("Position of E = %d\n", (int)(&E) - test);
  123. X    printf("Position of DE = %d\n", (int)(&DE) - test);
  124. X    printf("Position of H = %d\n", (int)(&H) - test);
  125. X    printf("Position of L = %d\n", (int)(&L) - test);
  126. X    printf("Position of HL = %d\n", (int)(&HL) - test);
  127. X
  128. X    AF = 0x1234;
  129. X    printf("AF = %04.4x, A = %02.2x, FLAGS = %02.2x\n", AF, A, FLAGS);
  130. X    printf("Flags: S=%d Z=%d H=%d P=%d N=%d C=%d\n",
  131. X            SIGN, ZERO, HALF_CARRY, PARITY, BCD, CARRY);
  132. X    acc_bank = 1;
  133. X    AF = 0x4321;
  134. X    printf("AF = %04.4x, A = %02.2x, FLAGS = %02.2x\n", AF, A, FLAGS);
  135. X    printf("Flags: S=%d Z=%d H=%d P=%d N=%d C=%d\n",
  136. X            SIGN, ZERO, HALF_CARRY, PARITY, BCD, CARRY);
  137. X
  138. X    BC = 0x2345;
  139. X    printf("BC = %04.4x, B = %02.2x, C = %02.2x\n", BC, B, C);
  140. X    gr_bank = 1;
  141. X    BC = 0x5432;
  142. X    printf("BC = %04.4x, B = %02.2x, C = %02.2x\n", BC, B, C);
  143. X    gr_bank = 0;
  144. X
  145. X    DE = 0x3456;
  146. X    printf("DE = %04.4x, D = %02.2x, E = %02.2x\n", DE, D, E);
  147. X    gr_bank = 1;
  148. X    DE = 0x6543;
  149. X    printf("DE = %04.4x, D = %02.2x, E = %02.2x\n", DE, D, E);
  150. X    gr_bank = 0;
  151. X
  152. X    HL = 0x4567;
  153. X    printf("HL = %04.4x, H = %02.2x, L = %02.2x\n", HL, H, L);
  154. X    gr_bank = 1;
  155. X    HL = 0x7654;
  156. X    printf("HL = %04.4x, H = %02.2x, L = %02.2x\n", HL, H, L);
  157. X    gr_bank = 0;
  158. X
  159. X    A = BC = DE = HL = SP = PC = 0;
  160. X
  161. X    while (PC < TEST_SIZE)
  162. X    {
  163. X        dump_registers(stdout);
  164. X
  165. X        if (decode())
  166. X        {
  167. X            printf("* * * Processor error * * *\n");
  168. X            exit(1);
  169. X        }
  170. X    }
  171. X
  172. X    dump_registers(stdout);
  173. X
  174. X    for (test = 0; test < 0x10; test++)
  175. X        printf("%02.2x ", ram[test]);
  176. X
  177. X    printf("\n");
  178. X    for (test = 0xfff0; test < 0x10000; test++)
  179. X        printf("%02.2x ", ram[test]);
  180. X
  181. X    printf("\nTest code ended normally\n");
  182. X    exit(0);
  183. #else
  184. X
  185. X    char    entry[256];
  186. X    int        c;
  187. X
  188. X    getcwd(cpm_drive[1], 127);
  189. X    entry[0] = 0;
  190. X    debug("");
  191. X
  192. X    while ((c = getopt(argc, argv, "d:c:r:p:h")) != -1)
  193. X    {
  194. X        char    *ptr;
  195. X        int        k;
  196. X
  197. X        switch (c)
  198. X        {
  199. X            case 'd':
  200. X                ptr = optarg + 2;
  201. X
  202. X                if (optarg[1] == ':')
  203. X                    k = toupper(*optarg) - '@';
  204. X                else
  205. X                {
  206. X                    k = 1;
  207. X                    ptr = optarg;
  208. X
  209. X                    while ((k < 17) && (*cpm_drive[k]))
  210. X                        k++;
  211. X                }
  212. X
  213. X                if ((k < 1) || (k > 16))
  214. X                {
  215. X                    fprintf(stderr, "Can't set up %s\n", optarg);
  216. X                    exit(1);
  217. X                }
  218. X
  219. X                strcpy(cpm_drive[k], ptr);
  220. X                break;
  221. X
  222. X            case 'c':
  223. X                strcpy(entry, optarg);
  224. X                break;
  225. X
  226. X            case 'r':
  227. X                reader = open_device(optarg, "r");
  228. X                break;
  229. X
  230. X            case 'p':
  231. X                punch = open_device(optarg, "w");
  232. X                break;
  233. X
  234. X            case 'l':
  235. X                list = open_device(optarg, "w");
  236. X                break;
  237. X
  238. X            default:
  239. X                fprintf(stderr,
  240. "Usage:\n");
  241. X                fprintf(stderr,
  242. "cpm [options]\n");
  243. X                fprintf(stderr,
  244. "  Options:\n");
  245. X                fprintf(stderr,
  246. "    -d [d:]directory    map CP/M drive to Unix directory.  If the\n");
  247. X                fprintf(stderr,
  248. "                        second character is not a colon then the next\n");
  249. X                fprintf(stderr,
  250. "                        available drive letter is used otherwise the\n");
  251. X                fprintf(stderr,
  252. "                        letter preceding the colon is used.\n");
  253. X                fprintf(stderr,
  254. "    -c command          runs the command file then exits.  builtins\n");
  255. X                fprintf(stderr,
  256. "                        not supported.  COM file must exist\n");
  257. X                fprintf(stderr,
  258. "    -[r|p|l] dev        This allows the I/O to be routed through the\n");
  259. X                fprintf(stderr,
  260. "                        Unix file system.  The devices mapped are as\n");
  261. X                fprintf(stderr,
  262. "                        follows: r = RDR input, p = PUN output and l for\n");
  263. X                fprintf(stderr,
  264. "                        LST output.  The dev argument is opened as a Unix\n");
  265. X                fprintf(stderr,
  266. "                        file and I/O for specified device is done through\n");
  267. X                fprintf(stderr,
  268. "                        it.  If the first character is '!' then the rest\n");
  269. X                fprintf(stderr,
  270. "                        of the line is taken as a command and popen() is\n");
  271. X                fprintf(stderr,
  272. "                        called to handle the I/O.\n");
  273. X                fprintf(stderr,
  274. "    -h                  Show this help screen\n");
  275. X
  276. X                exit(1);
  277. X        }
  278. X    }
  279. X 
  280. X    strcpy(cpm_drive[0], cpm_drive[1]);
  281. X    def_drive = 1;
  282. X
  283. X    if ((console = open("/dev/tty", O_RDWR)) == -1)
  284. X    {
  285. X        perror("Can't open terminal");
  286. X        exit(1);
  287. X    }
  288. X
  289. X    if (ioctl(console, TCGETA, &old_term) == -1)
  290. X    {
  291. X        perror("Can't get terminal parameters");
  292. X        exit(-1);
  293. X    }
  294. X
  295. X    termp = old_term;
  296. X    termp.c_oflag =  0;
  297. X    termp.c_lflag =  ISIG;
  298. X    termp.c_cc[VEOF] = 1;
  299. X    termp.c_cc[VSWTCH] = 0xff;
  300. X    
  301. X    if (ioctl(console, TCSETA, &termp) == -1)
  302. X    {
  303. X        perror("Can't set terminal parameters");
  304. X        exit(1);
  305. X    }
  306. X
  307. X    signal(SIGHUP, cleanup);
  308. X    signal(SIGINT, cleanup);
  309. X    signal(SIGQUIT, cleanup);
  310. X    signal(SIGTERM, cleanup);
  311. X    debug("Signals captured");
  312. X
  313. X    setbuf(stdout, NULL);
  314. X
  315. X    fprintf(stderr, "\nCP/U - Control Program for Unix\r\n");
  316. X    fprintf(stderr, "CP/M emulator Version 0.900\r\n");
  317. X    fprintf(stderr, "Written by D'Arcy J.M. Cain\r\n");
  318. X    fprintf(stderr, "darcy@druid.UUCP\r\n");
  319. X
  320. X    if (*entry)
  321. X    {
  322. X        do_command(entry);
  323. X        ioctl(console, TCSETA, &old_term);
  324. X        exit(0);
  325. X    }
  326. X
  327. X    debug("Start main loop");
  328. X
  329. X    for (;;)
  330. X    {
  331. X        fprintf(stderr, "%c> ", def_drive + '@');
  332. X        entry[get_str(entry, 128)] = 0;
  333. X
  334. X        if (*entry)
  335. X        {
  336. X            if (do_command(entry) == -1)
  337. X            {
  338. X                debug("chop_cmd(entry)");
  339. X                chop_cmd(entry);
  340. X                debug("strtoup(entry)");
  341. X                strtoup(entry);
  342. X                debug("fprintf(stderr, \"%s?\r\n\", entry)");
  343. X                fprintf(stderr, "%s?\r\n", entry);
  344. X            }
  345. X        }
  346. X    }
  347. #endif
  348. }
  349. SHAR_EOF
  350. chmod 0640 cpm.c ||
  351. echo 'restore of cpm.c failed'
  352. Wc_c="`wc -c < 'cpm.c'`"
  353. test 26758 -eq "$Wc_c" ||
  354.     echo 'cpm.c: original size 26758, current size' "$Wc_c"
  355. # ============= dasm.c ==============
  356. sed 's/^X//' << 'SHAR_EOF' > 'dasm.c' &&
  357. /*
  358. dasm
  359. X
  360. CP/M emulator - instruction disassembler
  361. Written by D'Arcy J.M. Cain
  362. darcy@druid
  363. X
  364. */
  365. X
  366. #include    <stdio.h>
  367. #include    <string.h>
  368. #include    "cpm.h"
  369. X
  370. #define        get_prog_word(buf)    (buf[1] + (buf[2] << 8))
  371. #define        get_prog_byte(buf)    (*buf)
  372. X
  373. static char        *get_b_reg(int reg)
  374. {
  375. X    switch(reg & 0x07)
  376. X    {
  377. X        case 7:        return("A");
  378. X        case 6:        return("(HL)");
  379. X        case 0:        return("B");
  380. X        case 1:        return("C");
  381. X        case 2:        return("D");
  382. X        case 3:        return("E");
  383. X        case 4:        return("H");
  384. X        case 5:        return("L");
  385. X    }
  386. X
  387. X    return(NULL);
  388. }
  389. X
  390. static char        *get_w_reg(int reg)
  391. {
  392. X    switch (reg & 0x03)
  393. X    {
  394. X        case 2:        return("HL");
  395. X        case 1:        return("DE");
  396. X        case 0:        return("BC");
  397. X        case 3:        return("SP");
  398. X    }
  399. X
  400. X    return(NULL);
  401. }
  402. X
  403. static char        *get_s_reg(int reg)
  404. {
  405. X    switch (reg & 0x03)
  406. X    {
  407. X        case 2:        return("HL");
  408. X        case 1:        return("DE");
  409. X        case 0:        return("BC");
  410. X        case 3:        return("AF");
  411. X    }
  412. X
  413. X    return(NULL);
  414. }
  415. X
  416. static int        relative(int r)
  417. {
  418. X    if (r & 0x80)
  419. X        r |= -256;
  420. X
  421. X    return(PC + r + 2);
  422. }
  423. X
  424. static char        *condition(int word)
  425. {
  426. X    switch (word & 0x07)
  427. X    {
  428. X        case 0:        return("NZ");
  429. X        case 1:        return("Z");
  430. X        case 2:        return("NC");
  431. X        case 3:        return("C");
  432. X        case 4:        return("PO");
  433. X        case 5:        return("PE");
  434. X        case 6:        return("P");
  435. X        case 7:        return("M");
  436. X    }
  437. X
  438. X    return("\a* * * Internal error (condition()) * * *");
  439. }
  440. X
  441. const char     *dasm(const byte *buf)
  442. {
  443. X    static char    str[32];
  444. X    char        s[32];
  445. X
  446. X    switch (*buf & 0xc0)                /* get class of opcode */
  447. X    {
  448. X        case 0x40:                        /* data transfer */
  449. X            if (*buf == 0x76)            /* HALT - special case */
  450. X                return("HALT");
  451. X
  452. X            sprintf(str, "LD\t%s, %s", get_b_reg(*buf >> 3), get_b_reg(*buf));
  453. X            return(str);
  454. X
  455. X        case 0x80:                        /* 8 bit math & logic */
  456. X            strcpy(s, get_b_reg(*buf));
  457. X            strcpy(str, "* * * Internal error * * *");
  458. X
  459. math_immediate:                            /* comes from misc instructions */
  460. X            switch ((*buf >> 3) & 7)        /* logic op */
  461. X            {
  462. X                case 1:                    /* ADC */
  463. X                    sprintf(str, "ADC\tA, %s", s);
  464. X                    break;
  465. X
  466. X                case 0:                    /* ADD */
  467. X                    sprintf(str, "ADD\tA, %s", s);
  468. X                    break;
  469. X    
  470. X                case 3:                    /* SBC */
  471. X                    sprintf(str, "SBC\tA, %s", s);
  472. X                    break;
  473. X
  474. X                case 2:                    /* SUB */
  475. X                    sprintf(str, "SUB\tA, %s", s);
  476. X                    break;
  477. X
  478. X                case 4:                    /* AND */
  479. X                    sprintf(str, "AND\tA, %s", s);
  480. X                    break;
  481. X
  482. X                case 5:                    /* XOR */
  483. X                    sprintf(str, "XOR\tA, %s", s);
  484. X                    break;
  485. X
  486. X                case 6:                    /* OR */
  487. X                    sprintf(str, "OR\tA, %s", s);
  488. X                    break;
  489. X
  490. X                case 7:                    /* CP */
  491. X                    sprintf(str, "CP\tA, %s", s);
  492. X                    break;
  493. X            }                            /* end - logic op */
  494. X
  495. X            return(str);
  496. X
  497. X        case 0xc0:                        /* Misc */
  498. X            if ((*buf & 0x07) == 0x06)
  499. X            {
  500. X                sprintf(s, "0%02.2xH", buf[1]);
  501. X                goto math_immediate;    /* sometimes they're necessary */
  502. X            }
  503. X
  504. X            if ((*buf & 0x0f) == 1)        /* POP */
  505. X            {
  506. X                sprintf(str, "POP\t%s", get_s_reg(*buf >> 4));
  507. X                return(str);
  508. X            }
  509. X
  510. X            if ((*buf & 0x0f) == 5)        /* PUSH */
  511. X            {
  512. X                sprintf(str, "PUSH\t%s", get_s_reg(*buf >> 4));
  513. X                return(str);
  514. X            }
  515. X
  516. X
  517. X            switch (*buf & 0x07)        /* BRANCH */
  518. X            {
  519. X                case 0:                    /* RET cc */
  520. X                    sprintf(str, "RET\t%s", condition(*buf >> 3));
  521. X                    return(str);
  522. X
  523. X                case 2:                    /* JP cc */
  524. X                    sprintf(str, "JP\t%s, 0%02.2x%02.2xH",
  525. X                                condition(*buf >> 3), buf[2], buf[1]);
  526. X                    return(str);
  527. X
  528. X                case 4:                    /* CALL cc */
  529. X                    sprintf(str, "CALL\t%s, 0%02.2x%02.2xH",
  530. X                                condition(*buf >> 3), buf[2], buf[1]);
  531. X                    return(str);
  532. X
  533. X                case 7:                    /* RST n */
  534. X                    sprintf(str, "RST\t%d", (*buf >> 3) & 0x07);
  535. X                    return(str);
  536. X            }                            /* end - BRANCH */
  537. X
  538. X            switch (*buf)                /* misc */
  539. X            {
  540. X                case 0xcd:                /* CALL */
  541. X                    sprintf(str, "CALL\t0%02.2x%02.2xH", buf[2], buf[1]);
  542. X                    return(str);
  543. X
  544. X                case 0xc3:                /* JP */
  545. X                    sprintf(str, "JP\t0%02.2x%02.2xH", buf[2], buf[1]);
  546. X                    return(str);
  547. X
  548. X                case 0xc9:                /* RET */
  549. X                    sprintf(str, "RET");
  550. X                    return(str);
  551. X
  552. X                case 0xeb:                /* EX DE, HL */
  553. X                    return("EX\tDE, HL");
  554. X
  555. X                case 0xe9:                /* JP (HL) */
  556. X                    return("JP\t(HL)");
  557. X
  558. X                case 0xe3:                /* EX (SP), HL */
  559. X                    return("EX\t(SP), HL");
  560. X
  561. X                case 0xf9:                /* LD SP, HL */
  562. X                    return("LD\tSP, HL");
  563. X
  564. X                case 0xf3:                /* DI */
  565. X                    return("DI");
  566. X
  567. X                case 0xfb:                /* EI */
  568. X                    return("EI");
  569. X            }                                /* misc */
  570. X
  571. X            sprintf(str, "Unrecognized command (0x%02.2x)", *buf);
  572. X            return(str);
  573. X
  574. X        case 0:
  575. X            switch (*buf & 0x07)            /* misc data (3) */
  576. X            {
  577. X                case 4:                        /* INC byte */
  578. X                    sprintf(str, "INC\t%s", get_b_reg(*buf >> 3));
  579. X                    return(str);
  580. X
  581. X                case 5:                        /* DEC byte */
  582. X                    sprintf(str, "DEC\t%s", get_b_reg(*buf >> 3));
  583. X                    return(str);
  584. X
  585. X                case 6:                        /* LD byte immediate */
  586. X                    sprintf(str, "LD\t%s, 0%02.2xH",
  587. X                                get_b_reg(*buf >> 3), buf[1]);
  588. X                    return(str);
  589. X            }                                /* end - misc data (3) */
  590. X
  591. X            switch (*buf & 0x0f)            /* misc data (4) */
  592. X            {
  593. X                case 1:                        /* LD word immediate */
  594. X                    sprintf(str, "LD\t%s, 0%02.2x%02.2xH",
  595. X                                get_w_reg(*buf >> 4), buf[2], buf[1]);
  596. X                    return(str);
  597. X
  598. X                case 0x03:                    /* INC word */
  599. X                    sprintf(str, "INC\t%s", get_w_reg(*buf >> 4));
  600. X                    return(str);
  601. X
  602. X                case 0x0b:                    /* DEC word */
  603. X                    sprintf(str, "DEC\t%s", get_w_reg(*buf >> 4));
  604. X                    return(str);
  605. X
  606. X                case 0x09:                    /* ADD HL, ss */
  607. X                    sprintf(str, "ADD\tHL, %s", get_w_reg(*buf >> 4));
  608. X                    return(str);
  609. X            }                                /* end - misc date (4) */
  610. X
  611. X            switch (*buf)                    /* misc data */
  612. X            {
  613. X                case 0:                        /* NOP */
  614. X                    return("NOP");
  615. X
  616. X                case 0x02:                    /* LD (BC), A */
  617. X                    return("LD\t(BC), A");
  618. X
  619. X                case 0x10:
  620. X                    sprintf(str, "DJNZ\t0%04.4xH", relative(buf[1]));
  621. X                    return(str);
  622. X
  623. X                case 0x20:
  624. X                    sprintf(str, "JR\tNZ, 0%04.4xH", relative(buf[1]));
  625. X                    return(str);
  626. X
  627. X                case 0x30:
  628. X                    sprintf(str, "JR\tNC, 0%04.4xH", relative(buf[1]));
  629. X                    return(str);
  630. X
  631. X                case 0x18:
  632. X                    sprintf(str, "JR\t, 0%04.4xH", relative(buf[1]));
  633. X                    return(str);
  634. X
  635. X                case 0x28:
  636. X                    sprintf(str, "JR\tZ, 0%04.4xH", relative(buf[1]));
  637. X                    return(str);
  638. X
  639. X                case 0x38:
  640. X                    sprintf(str, "JR\tC, 0%04.4xH", relative(buf[1]));
  641. X                    return(str);
  642. X
  643. X                case 0x12:                    /* LD (DE), A */
  644. X                    return("LD\t(DE), A");
  645. X
  646. X                case 0x22:                    /* LD (nn), HL */
  647. X                    sprintf(str, "LD\t(0%02.2x%02.2xH), HL", buf[2], buf[1]);
  648. X                    return(str);
  649. X
  650. X                case 0x32:                    /* LD (nn), A */
  651. X                    sprintf(str, "LD\t(0%02.2x%02.2xH), A", buf[2], buf[1]);
  652. X                    return(str);
  653. X
  654. X                case 0x0a:                    /* LD A, (BC) */
  655. X                    return("LD\tA, (BC)");
  656. X
  657. X                case 0x1a:                    /* LD A, (DE) */
  658. X                    return("LD\tA, (DE)");
  659. X
  660. X                case 0x2a:                    /* LD HL, (nn) */
  661. X                    sprintf(str, "LD\tHL, (0%02.2x%02.2xH)", buf[2], buf[1]);
  662. X                    return(str);
  663. X
  664. X                case 0x3a:                    /* LD A, (nn) */
  665. X                    sprintf(str, "LD\tA, (0%02.2x%02.2xH)", buf[2], buf[1]);
  666. X                    return(str);
  667. X
  668. X                case 7:                        /* RLCA */
  669. X                    return("RLCA");
  670. X
  671. X                case 0x0f:                    /* RRCA */
  672. X                    return("RRCA");
  673. X
  674. X                case 0x17:                    /* RLA */
  675. X                    return("RLA");
  676. X
  677. X                case 0x1f:                    /* RRA */
  678. X                    return("RRA");
  679. X
  680. X                case 0x27:                    /* DAA */
  681. X                    return("DAA");
  682. X
  683. X                case 0x2f:                    /* CPL */
  684. X                    return("CPL");
  685. X
  686. X                case 0x37:                    /* SCF */
  687. X                    return("SCF");
  688. X
  689. X                case 0x3f:                    /* CCF */
  690. X                    return("CCF");
  691. X            }                                /* end - misc date */
  692. X
  693. X            return("* * * Internal error * * *");
  694. X    }                                        /* end class */
  695. X
  696. X    return("* * * Internal error * * *");
  697. }
  698. SHAR_EOF
  699. chmod 0640 dasm.c ||
  700. echo 'restore of dasm.c failed'
  701. Wc_c="`wc -c < 'dasm.c'`"
  702. test 7099 -eq "$Wc_c" ||
  703.     echo 'dasm.c: original size 7099, current size' "$Wc_c"
  704. # ============= decode.c ==============
  705. sed 's/^X//' << 'SHAR_EOF' > 'decode.c' &&
  706. /*
  707. X * execute()
  708. X *
  709. X * There are 256 possible opcodes.  The switch statement selects one.
  710. X * $Header: /g/zmob/zrun/RCS/execute.c,v 1.1.1.5 84/04/19 17:51:14 bennet Exp $
  711. X */
  712. X
  713. #include    "cpm.h"
  714. X
  715. static byte    partab[256]=        /* Parity table, 1=even */
  716. {
  717. X    1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  718. X    0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  719. X    0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  720. X    1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  721. X    0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  722. X    1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  723. X    1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  724. X    0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  725. X    0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  726. X    1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  727. X    1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  728. X    0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  729. X    1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  730. X    0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  731. X    0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  732. X    1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  733. };
  734. X
  735. static byte    setmask[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
  736. static byte    resmask[] = { ~1, ~2, ~4, ~8, ~16, ~32, ~64, ~128 };
  737. X
  738. int        pop(void)
  739. {
  740. X    long    r = ram[SP++];
  741. X    return(r + (ram[SP++] << 8));
  742. }
  743. X
  744. void    push(int v)
  745. {
  746. X    ram[--SP] = v >> 8;
  747. X    ram[--SP] = v & 0xff;
  748. }
  749. X
  750. int        decode(void)
  751. {
  752. X    byte    *ptr;
  753. X    long    a, s, s1;
  754. X    byte    opcode = ram[PC++];
  755. X
  756. X    if (PC >= BDOS)
  757. X    {
  758. X        PC = pop();
  759. X        return(0);
  760. X    }
  761. X
  762. X    switch(opcode)
  763. X    {
  764. X    case 0:            /* 00 NOP */
  765. X    when 1:            /* 01 LD BC,nn */
  766. X        C = ram[PC++];
  767. X        B = ram[PC++];
  768. X    when 2:            /* 02 LD (BC),A */
  769. X        ram[BC] = A;
  770. X    when 3:            /* 03 INC BC */
  771. X        ++BC;
  772. X    when 4:            /* 04 INC B */
  773. X        HALF_CARRY = (lonyb(B) == 0xf);
  774. X        ++B;
  775. X        SIGN = B >> 7;
  776. X        ZERO = B == 0;
  777. X        PARITY = B == 0x80;
  778. X        BCD = 0;
  779. X    when 5:            /* 05 DEC B */
  780. X        HALF_CARRY = lonyb(B) != 0;
  781. X        --B;
  782. X        SIGN = B >> 7;
  783. X        ZERO = B == 0;
  784. X        PARITY = B == 0x7f;
  785. X        BCD = 1;
  786. X    when 6:            /* 06 LD B,n */
  787. X        B = ram[PC++];
  788. X    when 7:            /* 07 RLCA */
  789. X        HALF_CARRY = BCD = 0;
  790. X        CARRY = A >> 7;
  791. X        A = (A << 1);
  792. X        if (CARRY) ++A;
  793. X    when 8:            /* 08 EX AF,AF' */
  794. X        acc_bank = acc_bank ? 0 : 1;
  795. X    when 9:            /* 09 ADD HL,BC */
  796. X        s = BC;
  797. X        a = (HL & 0xfff) + (s & 0xfff);
  798. X        s += HL;
  799. X        HL = s;
  800. X        BCD = 0;
  801. X        CARRY = s >> 16;
  802. X        HALF_CARRY = a >> 12;
  803. X    when 10:        /* 0a LD A,(BC) */
  804. X        A = ram[BC];
  805. X    when 11:        /* 0b DEC BC */
  806. X        --BC;
  807. X    when 12:        /* 0c INC C */
  808. X        HALF_CARRY = lonyb(C) == 0xf;
  809. X        ++C;
  810. X        SIGN = C >> 7;
  811. X        ZERO = C == 0;
  812. X        PARITY = C == 0x80;
  813. X        BCD = 0;
  814. X    when 13:        /* 0d DEC C */
  815. X        HALF_CARRY = lonyb(C) != 0;
  816. X        --C;
  817. X        SIGN = C >> 7;
  818. X        ZERO = C == 0;
  819. X        PARITY = C == 0x7f;
  820. X        BCD = 1;
  821. X    when 14:        /* 0e LD C,n */
  822. X        C = ram[PC++];
  823. X    when 15:        /* 0f RRCA */
  824. X        BCD = HALF_CARRY = 0;
  825. X        CARRY = A;
  826. X        A = (A >> 1) | (CARRY ? 128 : 0);
  827. X    when 16:        /* 10 DJNZ e */
  828. X        s = (int)(ram[PC++]);
  829. X        if (--B) PC += s;
  830. X    when 17:        /* 11 LD DE,nn */
  831. X        E = ram[PC++];
  832. X        D = ram[PC++];
  833. X    when 18:        /* 12 LD (DE),A */
  834. X        ram[DE] = A;
  835. X    when 19:        /* 13 INC DE */
  836. X        ++DE;
  837. X    when 20:        /* 14 INC D */
  838. X        HALF_CARRY = lonyb(D) == 0xf;
  839. X        ++D;
  840. X        SIGN = D >> 7;
  841. X        ZERO = D == 0;
  842. X        PARITY = D == 0x80;
  843. X        BCD = 0;
  844. X    when 21:        /* 15 DEC D */
  845. X        HALF_CARRY = lonyb(D) != 0;
  846. X        --D;
  847. X        SIGN = D >> 7;
  848. X        ZERO = D == 0;
  849. X        PARITY = D == 0x7f;
  850. X        BCD = 1;
  851. X    when 22:        /* 16 LD D,n */
  852. X        D = ram[PC++];
  853. X    when 23:        /* 17 RLA */
  854. X        s = A << 1;
  855. X        A = s | CARRY;
  856. X        CARRY = s >> 8;
  857. X        BCD = HALF_CARRY = 0;
  858. X    when 24:        /* 18 JR e */
  859. X        PC += (int)(ram[PC]);
  860. X    when 25:        /* 19 ADD HL,DE */
  861. X        s = DE;
  862. X        a = (HL & 0xfff) + (s & 0xfff);
  863. X        s += HL;
  864. X        HL = s;
  865. X        BCD = 0;
  866. X        CARRY = s >> 16;
  867. X        HALF_CARRY = a >> 12;
  868. X    when 26:        /* 1a LD A,(DE) */
  869. X        A = ram[DE];
  870. X    when 27:        /* 1b DEC DE */
  871. X        --DE;
  872. X    when 28:        /* 1c INC E */
  873. X        HALF_CARRY = lonyb(E) == 0xf;
  874. X        ++E;
  875. X        SIGN = E >> 7;
  876. X        ZERO = E == 0;
  877. X        PARITY = E == 0x80;
  878. X        BCD = 0;
  879. X    when 29:        /* 1d DEC E */
  880. X        HALF_CARRY = lonyb(E) != 0;
  881. X        --E;
  882. X        SIGN = E >> 7;
  883. X        ZERO = E == 0;
  884. X        PARITY = E == 0x7f;
  885. X        BCD = 1;
  886. X    when 30:        /* 1e LD E,n */
  887. X        E = ram[PC++];
  888. X    when 31:        /* 1f RRA */
  889. X        CARRY = (s = A | (CARRY << 8));
  890. X        A = s >> 1;
  891. X        BCD = HALF_CARRY = 0;
  892. X    when 32:        /* 20 JR NZ,e */
  893. X        if (ZERO) ++PC;
  894. X        else PC += (int)(ram[PC]);
  895. X    when 33:        /* 21 LD HL,nn */
  896. X        L = ram[PC++];
  897. X        H = ram[PC++];
  898. X    when 34:        /* 22 LD (nn),HL */
  899. X        TEMPL = ram[PC++];
  900. X        TEMPH = ram[PC++];
  901. X        ram[TEMP] = L;
  902. X        ram[TEMP + 1] = H;
  903. X    when 35:        /* 23 INC HL */
  904. X        ++HL;
  905. X    when 36:        /* 24 INC H */
  906. X        HALF_CARRY = lonyb(H) == 0xf;
  907. X        ++H;
  908. X        SIGN = H >> 7;
  909. X        ZERO = H == 0;
  910. X        PARITY = H == 0x80;
  911. X        BCD = 0;
  912. X    when 37:        /* 25 DEC H */
  913. X        HALF_CARRY = lonyb(H) != 0;
  914. X        --H;
  915. X        SIGN = H >> 7;
  916. X        ZERO = H == 0;
  917. X        PARITY = H == 0x7f;
  918. X        BCD = 1;
  919. X    when 38:        /* 26 LD H,n */
  920. X        H = ram[PC++];
  921. X    when 39:        /* 27 DAA */
  922. X        s = A & 0x0f;
  923. X        a = (A >> 4) & 0x0f;
  924. X        s1 = 0;
  925. X
  926. X        if (BCD)
  927. X        {
  928. X            if (CARRY)
  929. X            {
  930. X                if (HALF_CARRY)
  931. X                    s1 = ((a > 5) && (s > 5)) ? 0x9a : 0;
  932. X                else
  933. X                    s1 = ((a > 6) && (s < 10)) ? 0xa0 : 0;
  934. X            }
  935. X            else
  936. X                if(HALF_CARRY)
  937. X                    s1 = ((a < 9) && (s > 5)) ? 0xfa : 0;
  938. X        }
  939. X        else
  940. X        {
  941. X            if (CARRY)
  942. X            {
  943. X                if(HALF_CARRY)
  944. X                    s1 = ((a < 4) && (s < 4)) ? 0x66 : 0;
  945. X                else if (a < 3)
  946. X                    s1 = (s < 10) ? 0x60 : 0x66;
  947. X            }
  948. X            else
  949. X            {
  950. X                if(HALF_CARRY)
  951. X                {
  952. X                    if (s < 4)
  953. X                        if (a > 9)
  954. X                        {
  955. X                            s1 = 0x66;
  956. X                            CARRY = 1;
  957. X                        }
  958. X                        else s1 = 0x06;
  959. X                }
  960. X                else
  961. X                {
  962. X                    if ((a > 8) && (s > 9))
  963. X                    {
  964. X                        s1 = 0x66;
  965. X                        CARRY = 1;
  966. X                    }
  967. X                    else if ((a > 9) && (s < 10))
  968. X                    {
  969. X                        s1 = 0x60;
  970. X                        CARRY = 1;
  971. X                    }
  972. X                    else if ((a < 10) && (s < 10))
  973. X                            ;
  974. X                    else if ((a < 9) && (s > 9))
  975. X                        s1 = 6;
  976. X                }
  977. X            }
  978. X        }
  979. X
  980. X        HALF_CARRY = ((int)(A) + (int)(s1)) > 0xf;
  981. X        A += s1;
  982. X        SIGN = A >> 7;
  983. X        ZERO = (A == 0);
  984. X        PARITY = partab[A];
  985. X    when 40:        /* 28 JR Z,e */
  986. X        if (ZERO) PC += (int)(ram[PC]);
  987. X        else ++PC;
  988. X    when 41:        /* 29 ADD HL,HL */
  989. X        s = HL;
  990. X        a = (HL & 0xfff) + (s & 0xfff);
  991. X        s += HL;
  992. X        HL = s;
  993. X        BCD = 0;
  994. X        CARRY = s >> 16;
  995. X        HALF_CARRY = a >> 12;
  996. X    when 42:        /* 2a LD HL,(nn) */
  997. X        TEMPL = ram[PC++];
  998. X        TEMPH = ram[PC++];
  999. X        L = ram[TEMP];
  1000. X        H = ram[TEMP + 1];
  1001. X    when 43:        /* 2b DEC HL */
  1002. X        --HL;
  1003. X    when 44:        /* 2c INC L */
  1004. X        HALF_CARRY = lonyb(L) == 0xf;
  1005. X        ++L;
  1006. X        SIGN = L >> 7;
  1007. X        ZERO = L == 0;
  1008. X        PARITY = L == 0x80;
  1009. X        BCD = 0;
  1010. X    when 45:        /* 2d DEC L */
  1011. X        HALF_CARRY = lonyb(L) != 0;
  1012. X        --L;
  1013. X        SIGN = L >> 7;
  1014. X        ZERO = L == 0;
  1015. X        PARITY = L == 0x7f;
  1016. X        BCD = 1;
  1017. X    when 46:        /* 2e LD L,n */
  1018. X        L = ram[PC++];
  1019. X    when 47:        /* 2f CPL */
  1020. X        A = ~A;
  1021. X        HALF_CARRY = BCD = 1;
  1022. X    when 48:        /* 30 JR NC,e */
  1023. X        if(CARRY) ++PC;
  1024. X        else PC += (int)(ram[PC]);
  1025. X    when 49:        /* 31 LD SP,nn */
  1026. X        SPL = ram[PC++];
  1027. X        SPH = ram[PC++];
  1028. X    when 50:        /* 32 LD (nn),A */
  1029. X        TEMPL = ram[PC++];
  1030. X        TEMPH = ram[PC++];
  1031. X        ram[TEMP] = A;
  1032. X    when 51:        /* 33 INC SP */
  1033. X        ++SP;
  1034. X    when 52:        /* 34 INC (HL) */
  1035. X        HALF_CARRY = lonyb(ram[HL]) == 0xf;
  1036. X        ++ram[HL];
  1037. X        SIGN = ram[HL] >> 7;
  1038. X        ZERO = ram[HL] == 0;
  1039. X        PARITY = ram[HL] == 0x80;
  1040. X        BCD = 0;
  1041. X    when 53:        /* 35 DEC (HL) */
  1042. X        HALF_CARRY = lonyb(ram[HL]) != 0;
  1043. X        --ram[HL];
  1044. X        SIGN = ram[HL] >> 7;
  1045. X        ZERO = ram[HL] == 0;
  1046. X        PARITY = ram[HL] == 0x7f;
  1047. X        BCD = 1;
  1048. X    when 54:        /* 36 LD (HL),n */
  1049. X        ram[HL] = ram[PC++];
  1050. X    when 55:        /* 37 SCF */
  1051. X        HALF_CARRY = BCD = 0;
  1052. X        CARRY = 1;
  1053. X    when 56:        /* 38 JR C,e */
  1054. X        if (CARRY) PC += (int)(ram[PC]);
  1055. X        else ++PC;
  1056. X    when 57:        /* 39 ADD HL,SP */
  1057. X        s = SP;
  1058. X        a = (HL & 0xfff) + (s & 0xfff);
  1059. X        s += HL;
  1060. X        HL = s;
  1061. X        BCD = 0;
  1062. X        CARRY = s >> 16;
  1063. X        HALF_CARRY = a >> 12;
  1064. X    when 58:        /* 3a LD A,(nn) */
  1065. X        TEMPL = ram[PC++];
  1066. X        TEMPH = ram[PC++];
  1067. X        A = ram[TEMP];
  1068. X    when 59:        /* 3b DEC SP */
  1069. X        --SP;
  1070. X    when 60:        /* 3c INC A */
  1071. X        HALF_CARRY = lonyb(A) == 0xf;
  1072. X        ++A;
  1073. X        SIGN = A >> 7;
  1074. X        ZERO = A == 0;
  1075. X        PARITY = A == 0x80;
  1076. X        BCD = 0;
  1077. X    when 61:        /* 3d DEC A */
  1078. X        HALF_CARRY = lonyb(A) != 0;
  1079. X        --A;
  1080. X        SIGN = A >> 7;
  1081. X        ZERO = A == 0;
  1082. X        PARITY = A == 0x7f;
  1083. X        BCD = 1;
  1084. X    when 62:        /* 3e LD A,n */
  1085. X        A = ram[PC++];
  1086. X    when 63:        /* 3f CCF */
  1087. X        HALF_CARRY = CARRY;
  1088. X        CARRY = ~CARRY;
  1089. X        BCD = 0;
  1090. X    when 64:        /* 40 LD B,B */
  1091. X    when 65:        /* 41 LD B,C */
  1092. X        B = C;
  1093. X    when 66:        /* 42 LD B,D */
  1094. X        B = D;
  1095. X    when 67:        /* 43 LD B,E */
  1096. X        B = E;
  1097. X    when 68:        /* 44 LD B,H */
  1098. X        B = H;
  1099. X    when 69:        /* 45 LD B,L */
  1100. X        B = L;
  1101. X    when 70:        /* 46 LD B, (HL) */
  1102. X        B = ram[HL];
  1103. X    when 71:        /* 47 LD B,A */
  1104. X        B = A;
  1105. X    when 72:        /* 48 LD C,B */
  1106. X        C = B;
  1107. X    when 73:        /* 49 LD C,C */
  1108. X    when 74:        /* 4a LD C,D */
  1109. X        C = D;
  1110. X    when 75:        /* 4b LD C,E */
  1111. X        C = E;
  1112. X    when 76:        /* 4c LD C,H */
  1113. X        C = H;
  1114. X    when 77:        /* 4d LD C,L */
  1115. X        C = L;
  1116. X    when 78:        /* 4e LD C, (HL) */
  1117. X        C = ram[HL];
  1118. X    when 79:        /* 4f LD C,A */
  1119. X        C = A;
  1120. X    when 80:        /* 50 LD D,B */
  1121. X        D = B;
  1122. X    when 81:        /* 51 LD D,C */
  1123. X        D = C;
  1124. X    when 82:        /* 52 LD D,D */
  1125. X    when 83:        /* 53 LD D,E */
  1126. X        D = E;
  1127. X    when 84:        /* 54 LD D,H */
  1128. X        D = H;
  1129. X    when 85:        /* 55 LD D,L */
  1130. X        D = L;
  1131. X    when 86:        /* 56 LD D, (HL) */
  1132. X        D = ram[HL];
  1133. X    when 87:        /* 57 LD D,A */
  1134. X        D = A;
  1135. X    when 88:        /* 58 LD E,B */
  1136. X        E = B;
  1137. X    when 89:        /* 59 LD E,C */
  1138. X        E = C;
  1139. X    when 90:        /* 5a LD E,D */
  1140. X        E = D;
  1141. X    when 91:        /* 5b LD E,E */
  1142. X    when 92:        /* 5c LD E,H */
  1143. X        E = H;
  1144. X    when 93:        /* 5d LD E,L */
  1145. X        E = L;
  1146. X    when 94:        /* 5e LD E, (HL) */
  1147. X        E = ram[HL];
  1148. X    when 95:        /* 5f LD E,A */
  1149. X        E = A;
  1150. X    when 96:        /* 60 LD H,B */
  1151. X        H = B;
  1152. X    when 97:        /* 61 LD H,C */
  1153. X        H = C;
  1154. X    when 98:        /* 62 LD H,D */
  1155. X        H = D;
  1156. X    when 99:        /* 63 LD H,E */
  1157. X        H = E;
  1158. X    when 100:        /* 64 LD H,H */
  1159. X    when 101:        /* 65 LD H,L */
  1160. X        H = L;
  1161. X    when 102:        /* 66 LD H, (HL) */
  1162. X        H = ram[HL];
  1163. X    when 103:        /* 67 LD H,A */
  1164. X        H = A;
  1165. X    when 104:        /* 68 LD L,B */
  1166. X        L = B;
  1167. X    when 105:        /* 69 LD L,C */
  1168. X        L = C;
  1169. X    when 106:        /* 6a LD L,D */
  1170. X        L = D;
  1171. X    when 107:        /* 6b LD L,E */
  1172. X        L = E;
  1173. X    when 108:        /* 6c LD L,H */
  1174. X        L = H;
  1175. X    when 109:        /* 6d LD L,L */
  1176. X    when 110:        /* 6e LD L,(HL) */
  1177. X        L = ram[HL];
  1178. X    when 111:        /* 6f LD L,A */
  1179. X        L = A;
  1180. X    when 112:        /* 70 LD (HL),B */
  1181. X        ram[HL] = B;
  1182. X    when 113:        /* 71 LD (HL),C */
  1183. X        ram[HL] = C;
  1184. X    when 114:        /* 72 LD (HL),D */
  1185. X        ram[HL] = D;
  1186. X    when 115:        /* 73 LD (HL),E */
  1187. X        ram[HL] = E;
  1188. X    when 116:        /* 74 LD (HL),H */
  1189. X        ram[HL] = H;
  1190. X    when 117:        /* 75 LD (HL),L */
  1191. X        ram[HL] = L;
  1192. X    when 118:        /* 76 HALT */
  1193. X        return(0x76);
  1194. X    when 119:        /* 77 LD (HL),A */
  1195. X        ram[HL] = A;
  1196. X    when 120:        /* 78 LD A,B */
  1197. X        A = B;
  1198. X    when 121:        /* 79 LD A,C */
  1199. X        A = C;
  1200. X    when 122:        /* 7a LD A,D */
  1201. X        A = D;
  1202. X    when 123:        /* 7b LD A,E */
  1203. X        A = E;
  1204. X    when 124:        /* 7c LD A,H */
  1205. X        A = H;
  1206. X    when 125:        /* 7d LD A,L */
  1207. X        A = L;
  1208. X    when 126:        /* 7e LD A,(HL) */
  1209. X        A = ram[HL];
  1210. X    when 127:        /* 7f LD A,A */
  1211. X    when 128:        /* 80 ADD A,B */
  1212. X        s = B;
  1213. X        goto add;
  1214. X    case 129:        /* 81 ADD A,C */
  1215. X        s = C;
  1216. X        goto add;
  1217. X    case 130:        /* 82 ADD A,D */
  1218. X        s = D;
  1219. X        goto add;
  1220. X    case 131:        /* 83 ADD A,E */
  1221. X        s = E;
  1222. X        goto add;
  1223. X    case 132:        /* 84 ADD A,H */
  1224. X        s = H;
  1225. X        goto add;
  1226. X    case 133:        /* 85 ADD A,L */
  1227. X        s = L;
  1228. X        goto add;
  1229. X    case 134:        /* 86 ADD A,(HL) */
  1230. X        s = ram[HL];
  1231. X        goto add;
  1232. X    case 135:        /* 87 ADD A,A */
  1233. X        s = A;
  1234. X        goto add;
  1235. X    case 136:        /* 88 ADC A,B */
  1236. X        s = B;
  1237. X        goto adc;
  1238. X    case 137:        /* 89 ADC A,C */
  1239. X        s = C;
  1240. X        goto adc;
  1241. X    case 138:        /* 8a ADC A,D */
  1242. X        s = D;
  1243. X        goto adc;
  1244. X    case 139:        /* 8b ADC A,E */
  1245. X        s = E;
  1246. X        goto adc;
  1247. X    case 140:        /* 8c ADC A,H */
  1248. X        s = H;
  1249. X        goto adc;
  1250. X    case 141:        /* 8d ADC A,L */
  1251. X        s = L;
  1252. X        goto adc;
  1253. X    case 142:        /* 8e ADC A,(HL) */
  1254. X        s = ram[HL];
  1255. X        goto adc;
  1256. X    case 143:        /* 8f ADC A,A */
  1257. X        s = A;
  1258. X
  1259. adc:
  1260. X        a = A & 0x0f;
  1261. X        s1 = s & 0x0f;
  1262. X        if (CARRY) { s++; a++; }
  1263. X        goto add1;
  1264. X
  1265. add:
  1266. X        a = A & 0x0f;
  1267. X        s1 = s & 0x0f;
  1268. X
  1269. add1:
  1270. X        BCD = 0;
  1271. X        s += A;
  1272. X        A = s;
  1273. X        a += s1;
  1274. X
  1275. set_flags:
  1276. X        CARRY = s >> 8;
  1277. X        HALF_CARRY = a >> 4;
  1278. X        SIGN = s >> 7;
  1279. X        ZERO = s ? 0 : 1;
  1280. X        PARITY = partab[A];
  1281. X
  1282. X    when 144:        /* 90 SUB A,B */
  1283. X        s = B;
  1284. X        goto sub;
  1285. X    case 145:        /* 91 SUB A,C */
  1286. X        s = C;
  1287. X        goto sub;
  1288. X    case 146:        /* 92 SUB A,D */
  1289. X        s = D;
  1290. X        goto sub;
  1291. X    case 147:        /* 93 SUB A,E */
  1292. X        s = E;
  1293. X        goto sub;
  1294. X    case 148:        /* 94 SUB A,H */
  1295. X        s = H;
  1296. X        goto sub;
  1297. X    case 149:        /* 95 SUB A,L */
  1298. X        s = L;
  1299. X        goto sub;
  1300. X    case 150:        /* 96 SUB A,(HL) */
  1301. X        s = ram[HL];
  1302. X        goto sub;
  1303. X    case 151:        /* 97 SUB A,A */
  1304. X        s = A;
  1305. X        goto sub;
  1306. X    case 152:        /* 98 SBC A,B */
  1307. X        s = B;
  1308. X        goto sbc;
  1309. X    case 153:        /* 99 SBC A,C */
  1310. X        s = C;
  1311. X        goto sbc;
  1312. X    case 154:        /* 9a SBC A,D */
  1313. X        s = D;
  1314. X        goto sbc;
  1315. X    case 155:        /* 9b SBC A,E */
  1316. X        s = E;
  1317. X        goto sbc;
  1318. X    case 156:        /* 9c SBC A,H */
  1319. X        s = H;
  1320. X        goto sbc;
  1321. X    case 157:        /* 9d SBC A,L */
  1322. X        s = L;
  1323. X        goto sbc;
  1324. X    case 158:        /* 9e SBC A,(HL) */
  1325. X        s = ram[HL];
  1326. X        goto sbc;
  1327. X    when 159:        /* 9f SBC A,A */
  1328. X        s = A;
  1329. X
  1330. sbc:
  1331. X        a = A & 0x0f;
  1332. X        s1 = s & 0x0f;
  1333. X        if (CARRY) { s--; a--; }
  1334. X        goto sub1;
  1335. X
  1336. sub:
  1337. X        a = A & 0x0f;
  1338. X        s1 = s & 0x0f;
  1339. X
  1340. sub1:
  1341. X        s = A - s;
  1342. X        A = s;
  1343. X        a -= s1;
  1344. X        BCD = 1;
  1345. X        goto set_flags;
  1346. X
  1347. X    when 160:        /* a0 AND A,B */
  1348. X        s = B;
  1349. X        goto and;
  1350. X    case 161:        /* a1 AND A,C */
  1351. X        s = C;
  1352. X        goto and;
  1353. X    case 162:        /* a2 AND A,D */
  1354. X        s = D;
  1355. X        goto and;
  1356. X    case 163:        /* a3 AND A,E */
  1357. X        s = E;
  1358. X        goto and;
  1359. X    case 164:        /* a4 AND A,H */
  1360. X        s = H;
  1361. X        goto and;
  1362. X    case 165:        /* a5 AND A,L */
  1363. X        s = L;
  1364. X        goto and;
  1365. X    case 166:        /* a6 AND A,(HL) */
  1366. X        s = ram[HL];
  1367. X        goto and;
  1368. X    case 167:        /* a7 AND A,A */
  1369. X        s = A;
  1370. X
  1371. and:
  1372. X        a = A & 0x0f;
  1373. X        s1 = s & 0x0f;
  1374. X
  1375. X        s &= A;
  1376. X        A = s;
  1377. X        a &= s;
  1378. X        goto set_flags;
  1379. X        
  1380. X    when 168:        /* a8 XOR A,B */
  1381. X        s = B;
  1382. X        goto xor;
  1383. X    case 169:        /* a9 XOR A,C */
  1384. X        s = C;
  1385. X        goto xor;
  1386. X    case 170:        /* aa XOR A,D */
  1387. X        s = D;
  1388. X        goto xor;
  1389. X    case 171:        /* ab XOR A,E */
  1390. X        s = E;
  1391. X        goto xor;
  1392. X    case 172:        /* ac XOR A,H */
  1393. X        s = H;
  1394. X        goto xor;
  1395. X    case 173:        /* ad XOR A,L */
  1396. X        s = L;
  1397. X        goto xor;
  1398. X    case 174:        /* ae XOR A,(HL) */
  1399. X        s = ram[HL];
  1400. X        goto xor;
  1401. X    case 175:        /* af XOR A,A */
  1402. X        s = A;
  1403. X
  1404. xor:
  1405. X        a = A & 0x0f;
  1406. X        s1 = s & 0x0f;
  1407. X
  1408. X        s ^= A;
  1409. X        A = s;
  1410. X        a ^= s;
  1411. X        goto set_flags;
  1412. X
  1413. X    when 176:        /* b1 OR B */
  1414. X        s = B;
  1415. X        goto or;
  1416. X    case 177:        /* b1 OR C */
  1417. X        s = C;
  1418. X        goto or;
  1419. X    case 178:        /* b2 OR D */
  1420. X        s = D;
  1421. X        goto or;
  1422. X    case 179:        /* b3 OR E */
  1423. X        s = E;
  1424. X        goto or;
  1425. X    case 180:        /* b4 OR H */
  1426. X        s = H;
  1427. X        goto or;
  1428. X    case 181:        /* b5 OR L */
  1429. X        s = L;
  1430. X        goto or;
  1431. X    case 182:        /* b6 OR (HL) */
  1432. SHAR_EOF
  1433. true || echo 'restore of decode.c failed'
  1434. echo 'End of part 2, continue with part 3'
  1435. echo 3 > _shar_seq_.tmp
  1436. exit 0
  1437.  
  1438. -- 
  1439. D'Arcy J.M. Cain (darcy@druid)     |
  1440. D'Arcy Cain Consulting             |   I support gun control.
  1441. West Hill, Ontario, Canada         |   Let's start with the government!
  1442. + 416 281 6094                     |
  1443.