home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / emulator / unix / z80pack / z80sim / sim5.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-11  |  15.9 KB  |  788 lines
  1. /*
  2.  * Z80SIM  -  a    Z80-CPU    simulator
  3.  *
  4.  * Copyright (C) 1987-92 by Udo Munk
  5.  *
  6.  * This module of the Z80-CPU simulator must not be modified by a user,
  7.  * see license agreement!
  8.  *
  9.  * History:
  10.  * 28-SEP-87 Development on TARGON/35 with AT&T Unix System V.3
  11.  * 11-JAN-89 Release 1.1
  12.  * 08-FEB-89 Release 1.2
  13.  * 13-MAR-89 Release 1.3
  14.  * 09-FEB-90 Release 1.4 Ported to TARGON/31 M10/30
  15.  * 20-DEC-90 Release 1.5 Ported to COHERENT 3.0
  16.  * 10-JUN-92 Release 1.6 long casting problem solved with COHERENT 3.2
  17.  *             and some optimization
  18.  * 25-JUN-92 Release 1.7 comments in english
  19.  */
  20.  
  21. /*
  22.  *    Like the function "cpu()" this one emulates multi byte opcodes
  23.  *    starting with 0xfd
  24.  */
  25.  
  26. #include "sim.h"
  27. #include "simglb.h"
  28.  
  29. long op_fd_handel()
  30. {
  31.     long trap_fd();
  32.     long op_popiy(), op_pusiy();
  33.     long op_jpiy();
  34.     long op_exspy();
  35.     long op_ldspy();
  36.     long op_ldiynn(), op_ldiyinn(),    op_ldiny();
  37.     long op_adayd(), op_acayd(), op_suayd(), op_scayd();
  38.     long op_andyd(), op_xoryd(), op_oryd(),    op_cpyd();
  39.     long op_decyd(), op_incyd();
  40.     long op_addyb(), op_addyd(), op_addys(), op_addyy();
  41.     long op_andyd(), op_xoryd(), op_oryd(),    op_cpyd();
  42.     long op_decyd(), op_incyd();
  43.     long op_inciy(), op_deciy();
  44.     long op_ldayd(), op_ldbyd(), op_ldcyd(), op_lddyd(), op_ldeyd();
  45.     long op_ldhyd(), op_ldlyd();
  46.     long op_ldyda(), op_ldydb(), op_ldydc(), op_ldydd(), op_ldyde();
  47.     long op_ldydh(), op_ldydl(), op_ldydn();
  48.     extern long op_fdcb_handel();
  49.  
  50.     static long (*op_fd[256]) () = {
  51.         trap_fd,            /* 0x00    */
  52.         trap_fd,            /* 0x01    */
  53.         trap_fd,            /* 0x02    */
  54.         trap_fd,            /* 0x03    */
  55.         trap_fd,            /* 0x04    */
  56.         trap_fd,            /* 0x05    */
  57.         trap_fd,            /* 0x06    */
  58.         trap_fd,            /* 0x07    */
  59.         trap_fd,            /* 0x08    */
  60.         op_addyb,            /* 0x09    */
  61.         trap_fd,            /* 0x0a    */
  62.         trap_fd,            /* 0x0b    */
  63.         trap_fd,            /* 0x0c    */
  64.         trap_fd,            /* 0x0d    */
  65.         trap_fd,            /* 0x0e    */
  66.         trap_fd,            /* 0x0f    */
  67.         trap_fd,            /* 0x10    */
  68.         trap_fd,            /* 0x11    */
  69.         trap_fd,            /* 0x12    */
  70.         trap_fd,            /* 0x13    */
  71.         trap_fd,            /* 0x14    */
  72.         trap_fd,            /* 0x15    */
  73.         trap_fd,            /* 0x16    */
  74.         trap_fd,            /* 0x17    */
  75.         trap_fd,            /* 0x18    */
  76.         op_addyd,            /* 0x19    */
  77.         trap_fd,            /* 0x1a    */
  78.         trap_fd,            /* 0x1b    */
  79.         trap_fd,            /* 0x1c    */
  80.         trap_fd,            /* 0x1d    */
  81.         trap_fd,            /* 0x1e    */
  82.         trap_fd,            /* 0x1f    */
  83.         trap_fd,            /* 0x20    */
  84.         op_ldiynn,            /* 0x21    */
  85.         op_ldiny,            /* 0x22    */
  86.         op_inciy,            /* 0x23    */
  87.         trap_fd,            /* 0x24    */
  88.         trap_fd,            /* 0x25    */
  89.         trap_fd,            /* 0x26    */
  90.         trap_fd,            /* 0x27    */
  91.         trap_fd,            /* 0x28    */
  92.         op_addyy,            /* 0x29    */
  93.         op_ldiyinn,            /* 0x2a    */
  94.         op_deciy,            /* 0x2b    */
  95.         trap_fd,            /* 0x2c    */
  96.         trap_fd,            /* 0x2d    */
  97.         trap_fd,            /* 0x2e    */
  98.         trap_fd,            /* 0x2f    */
  99.         trap_fd,            /* 0x30    */
  100.         trap_fd,            /* 0x31    */
  101.         trap_fd,            /* 0x32    */
  102.         trap_fd,            /* 0x33    */
  103.         op_incyd,            /* 0x34    */
  104.         op_decyd,            /* 0x35    */
  105.         op_ldydn,            /* 0x36    */
  106.         trap_fd,            /* 0x37    */
  107.         trap_fd,            /* 0x38    */
  108.         op_addys,            /* 0x39    */
  109.         trap_fd,            /* 0x3a    */
  110.         trap_fd,            /* 0x3b    */
  111.         trap_fd,            /* 0x3c    */
  112.         trap_fd,            /* 0x3d    */
  113.         trap_fd,            /* 0x3e    */
  114.         trap_fd,            /* 0x3f    */
  115.         trap_fd,            /* 0x40    */
  116.         trap_fd,            /* 0x41    */
  117.         trap_fd,            /* 0x42    */
  118.         trap_fd,            /* 0x43    */
  119.         trap_fd,            /* 0x44    */
  120.         trap_fd,            /* 0x45    */
  121.         op_ldbyd,            /* 0x46    */
  122.         trap_fd,            /* 0x47    */
  123.         trap_fd,            /* 0x48    */
  124.         trap_fd,            /* 0x49    */
  125.         trap_fd,            /* 0x4a    */
  126.         trap_fd,            /* 0x4b    */
  127.         trap_fd,            /* 0x4c    */
  128.         trap_fd,            /* 0x4d    */
  129.         op_ldcyd,            /* 0x4e    */
  130.         trap_fd,            /* 0x4f    */
  131.         trap_fd,            /* 0x50    */
  132.         trap_fd,            /* 0x51    */
  133.         trap_fd,            /* 0x52    */
  134.         trap_fd,            /* 0x53    */
  135.         trap_fd,            /* 0x54    */
  136.         trap_fd,            /* 0x55    */
  137.         op_lddyd,            /* 0x56    */
  138.         trap_fd,            /* 0x57    */
  139.         trap_fd,            /* 0x58    */
  140.         trap_fd,            /* 0x59    */
  141.         trap_fd,            /* 0x5a    */
  142.         trap_fd,            /* 0x5b    */
  143.         trap_fd,            /* 0x5c    */
  144.         trap_fd,            /* 0x5d    */
  145.         op_ldeyd,            /* 0x5e    */
  146.         trap_fd,            /* 0x5f    */
  147.         trap_fd,            /* 0x60    */
  148.         trap_fd,            /* 0x61    */
  149.         trap_fd,            /* 0x62    */
  150.         trap_fd,            /* 0x63    */
  151.         trap_fd,            /* 0x64    */
  152.         trap_fd,            /* 0x65    */
  153.         op_ldhyd,            /* 0x66    */
  154.         trap_fd,            /* 0x67    */
  155.         trap_fd,            /* 0x68    */
  156.         trap_fd,            /* 0x69    */
  157.         trap_fd,            /* 0x6a    */
  158.         trap_fd,            /* 0x6b    */
  159.         trap_fd,            /* 0x6c    */
  160.         trap_fd,            /* 0x6d    */
  161.         op_ldlyd,            /* 0x6e    */
  162.         trap_fd,            /* 0x6f    */
  163.         op_ldydb,            /* 0x70    */
  164.         op_ldydc,            /* 0x71    */
  165.         op_ldydd,            /* 0x72    */
  166.         op_ldyde,            /* 0x73    */
  167.         op_ldydh,            /* 0x74    */
  168.         op_ldydl,            /* 0x75    */
  169.         trap_fd,            /* 0x76    */
  170.         op_ldyda,            /* 0x77    */
  171.         trap_fd,            /* 0x78    */
  172.         trap_fd,            /* 0x79    */
  173.         trap_fd,            /* 0x7a    */
  174.         trap_fd,            /* 0x7b    */
  175.         trap_fd,            /* 0x7c    */
  176.         trap_fd,            /* 0x7d    */
  177.         op_ldayd,            /* 0x7e    */
  178.         trap_fd,            /* 0x7f    */
  179.         trap_fd,            /* 0x80    */
  180.         trap_fd,            /* 0x81    */
  181.         trap_fd,            /* 0x82    */
  182.         trap_fd,            /* 0x83    */
  183.         trap_fd,            /* 0x84    */
  184.         trap_fd,            /* 0x85    */
  185.         op_adayd,            /* 0x86    */
  186.         trap_fd,            /* 0x87    */
  187.         trap_fd,            /* 0x88    */
  188.         trap_fd,            /* 0x89    */
  189.         trap_fd,            /* 0x8a    */
  190.         trap_fd,            /* 0x8b    */
  191.         trap_fd,            /* 0x8c    */
  192.         trap_fd,            /* 0x8d    */
  193.         op_acayd,            /* 0x8e    */
  194.         trap_fd,            /* 0x8f    */
  195.         trap_fd,            /* 0x90    */
  196.         trap_fd,            /* 0x91    */
  197.         trap_fd,            /* 0x92    */
  198.         trap_fd,            /* 0x93    */
  199.         trap_fd,            /* 0x94    */
  200.         trap_fd,            /* 0x95    */
  201.         op_suayd,            /* 0x96    */
  202.         trap_fd,            /* 0x97    */
  203.         trap_fd,            /* 0x98    */
  204.         trap_fd,            /* 0x99    */
  205.         trap_fd,            /* 0x9a    */
  206.         trap_fd,            /* 0x9b    */
  207.         trap_fd,            /* 0x9c    */
  208.         trap_fd,            /* 0x9d    */
  209.         op_scayd,            /* 0x9e    */
  210.         trap_fd,            /* 0x9f    */
  211.         trap_fd,            /* 0xa0    */
  212.         trap_fd,            /* 0xa1    */
  213.         trap_fd,            /* 0xa2    */
  214.         trap_fd,            /* 0xa3    */
  215.         trap_fd,            /* 0xa4    */
  216.         trap_fd,            /* 0xa5    */
  217.         op_andyd,            /* 0xa6    */
  218.         trap_fd,            /* 0xa7    */
  219.         trap_fd,            /* 0xa8    */
  220.         trap_fd,            /* 0xa9    */
  221.         trap_fd,            /* 0xaa    */
  222.         trap_fd,            /* 0xab    */
  223.         trap_fd,            /* 0xac    */
  224.         trap_fd,            /* 0xad    */
  225.         op_xoryd,            /* 0xae    */
  226.         trap_fd,            /* 0xaf    */
  227.         trap_fd,            /* 0xb0    */
  228.         trap_fd,            /* 0xb1    */
  229.         trap_fd,            /* 0xb2    */
  230.         trap_fd,            /* 0xb3    */
  231.         trap_fd,            /* 0xb4    */
  232.         trap_fd,            /* 0xb5    */
  233.         op_oryd,            /* 0xb6    */
  234.         trap_fd,            /* 0xb7    */
  235.         trap_fd,            /* 0xb8    */
  236.         trap_fd,            /* 0xb9    */
  237.         trap_fd,            /* 0xba    */
  238.         trap_fd,            /* 0xbb    */
  239.         trap_fd,            /* 0xbc    */
  240.         trap_fd,            /* 0xbd    */
  241.         op_cpyd,            /* 0xbe    */
  242.         trap_fd,            /* 0xbf    */
  243.         trap_fd,            /* 0xc0    */
  244.         trap_fd,            /* 0xc1    */
  245.         trap_fd,            /* 0xc2    */
  246.         trap_fd,            /* 0xc3    */
  247.         trap_fd,            /* 0xc4    */
  248.         trap_fd,            /* 0xc5    */
  249.         trap_fd,            /* 0xc6    */
  250.         trap_fd,            /* 0xc7    */
  251.         trap_fd,            /* 0xc8    */
  252.         trap_fd,            /* 0xc9    */
  253.         trap_fd,            /* 0xca    */
  254.         op_fdcb_handel,            /* 0xcb    */
  255.         trap_fd,            /* 0xcc    */
  256.         trap_fd,            /* 0xcd    */
  257.         trap_fd,            /* 0xce    */
  258.         trap_fd,            /* 0xcf    */
  259.         trap_fd,            /* 0xd0    */
  260.         trap_fd,            /* 0xd1    */
  261.         trap_fd,            /* 0xd2    */
  262.         trap_fd,            /* 0xd3    */
  263.         trap_fd,            /* 0xd4    */
  264.         trap_fd,            /* 0xd5    */
  265.         trap_fd,            /* 0xd6    */
  266.         trap_fd,            /* 0xd7    */
  267.         trap_fd,            /* 0xd8    */
  268.         trap_fd,            /* 0xd9    */
  269.         trap_fd,            /* 0xda    */
  270.         trap_fd,            /* 0xdb    */
  271.         trap_fd,            /* 0xdc    */
  272.         trap_fd,            /* 0xdd    */
  273.         trap_fd,            /* 0xde    */
  274.         trap_fd,            /* 0xdf    */
  275.         trap_fd,            /* 0xe0    */
  276.         op_popiy,            /* 0xe1    */
  277.         trap_fd,            /* 0xe2    */
  278.         op_exspy,            /* 0xe3    */
  279.         trap_fd,            /* 0xe4    */
  280.         op_pusiy,            /* 0xe5    */
  281.         trap_fd,            /* 0xe6    */
  282.         trap_fd,            /* 0xe7    */
  283.         trap_fd,            /* 0xe8    */
  284.         op_jpiy,            /* 0xe9    */
  285.         trap_fd,            /* 0xea    */
  286.         trap_fd,            /* 0xeb    */
  287.         trap_fd,            /* 0xec    */
  288.         trap_fd,            /* 0xed    */
  289.         trap_fd,            /* 0xee    */
  290.         trap_fd,            /* 0xef    */
  291.         trap_fd,            /* 0xf0    */
  292.         trap_fd,            /* 0xf1    */
  293.         trap_fd,            /* 0xf2    */
  294.         trap_fd,            /* 0xf3    */
  295.         trap_fd,            /* 0xf4    */
  296.         trap_fd,            /* 0xf5    */
  297.         trap_fd,            /* 0xf6    */
  298.         trap_fd,            /* 0xf7    */
  299.         trap_fd,            /* 0xf8    */
  300.         op_ldspy,            /* 0xf9    */
  301.         trap_fd,            /* 0xfa    */
  302.         trap_fd,            /* 0xfb    */
  303.         trap_fd,            /* 0xfc    */
  304.         trap_fd,            /* 0xfd    */
  305.         trap_fd,            /* 0xfe    */
  306.         trap_fd                /* 0xff    */
  307.     };
  308.  
  309. #ifdef WANT_TIM
  310.     register long t;
  311.     t = (*op_fd[*PC++]) ();        /* execute next opcode */
  312. #else
  313.     (*op_fd[*PC++]) ();
  314. #endif
  315.  
  316. #ifdef WANT_PCC
  317.         if (PC > ram + 65535)    /* correct PC overrun */
  318.             PC = ram;
  319. #endif
  320.  
  321. #ifdef WANT_TIM
  322.     return(t);
  323. #endif
  324. }
  325.  
  326. /*
  327.  *    This function traps all illegal opcodes following the
  328.  *    initial 0xfd of a multi byte opcode.
  329.  */
  330. static long trap_fd()
  331. {
  332.     cpu_error = OPTRAP2;
  333.     cpu_state = STOPPED;
  334. #ifdef WANT_TIM
  335.     return(0L);
  336. #endif
  337. }
  338.  
  339. static long op_popiy()             /*    POP IY */
  340. {
  341. #ifdef WANT_SPC
  342.     if (STACK <= ram)
  343.         STACK =    ram + 65536L;
  344. #endif
  345.     IY = *STACK++;
  346. #ifdef WANT_SPC
  347.     if (STACK <= ram)
  348.         STACK =    ram + 65536L;
  349. #endif
  350.     IY += *STACK++ << 8;
  351. #ifdef WANT_TIM
  352.     return(14L);
  353. #endif
  354. }
  355.  
  356. static long op_pusiy()             /*    PUSH IY    */
  357. {
  358. #ifdef WANT_SPC
  359.     if (STACK <= ram)
  360.         STACK =    ram + 65536L;
  361. #endif
  362.     *--STACK = IY >> 8;
  363. #ifdef WANT_SPC
  364.     if (STACK <= ram)
  365.         STACK =    ram + 65536L;
  366. #endif
  367.     *--STACK = IY;
  368. #ifdef WANT_TIM
  369.     return(15L);
  370. #endif
  371. }
  372.  
  373. static long op_jpiy()             /*    JP (IY)    */
  374. {
  375.     PC = ram + IY;
  376. #ifdef WANT_TIM
  377.     return(8L);
  378. #endif
  379. }
  380.  
  381. static long op_exspy()             /*    EX (SP),IY */
  382. {
  383.     register int i;
  384.  
  385.     i = *STACK + (*(STACK +    1) << 8);
  386.     *STACK = IY;
  387.     *(STACK    + 1) = IY >> 8;
  388.     IY = i;
  389. #ifdef WANT_TIM
  390.     return(23L);
  391. #endif
  392. }
  393.  
  394. static long op_ldspy()             /*    LD SP,IY */
  395. {
  396.     STACK =    ram + IY;
  397. #ifdef WANT_TIM
  398.     return(10L);
  399. #endif
  400. }
  401.  
  402. static long op_ldiynn()             /*    LD IY,nn */
  403. {
  404.     IY = *PC++;
  405.     IY += *PC++ << 8;
  406. #ifdef WANT_TIM
  407.     return(14L);
  408. #endif
  409. }
  410.  
  411. static long op_ldiyinn()         /*    LD IY,(nn) */
  412. {
  413.     register BYTE *p;
  414.  
  415.     p = ram    + *PC++;
  416.     p += *PC++ << 8;
  417.     IY = *p++;
  418.     IY += *p << 8;
  419. #ifdef WANT_TIM
  420.     return(20L);
  421. #endif
  422. }
  423.  
  424. static long op_ldiny()             /*    LD (nn),IY */
  425. {
  426.     register BYTE *p;
  427.  
  428.     p = ram    + *PC++;
  429.     p += *PC++ << 8;
  430.     *p++ = IY;
  431.     *p = IY    >> 8;
  432. #ifdef WANT_TIM
  433.     return(20L);
  434. #endif
  435. }
  436.  
  437. static long op_adayd()             /*    ADD A,(IY+d) */
  438. {
  439.     register int i;
  440.     register BYTE P;
  441.  
  442.     P = *(ram + IY + (char)    *PC++);
  443.     ((A & 0xf) + (P    & 0xf) > 0xf) ?    (F |= H_FLAG) :    (F &= ~H_FLAG);
  444.     (A + P > 255) ?    (F |= C_FLAG) :    (F &= ~C_FLAG);
  445.     A = i =    (char) A + (char) P;
  446.     (i < -128 || i > 127) ?    (F |= P_FLAG) :    (F &= ~P_FLAG);
  447.     (i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  448.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  449.     F &= ~N_FLAG;
  450. #ifdef WANT_TIM
  451.     return(19L);
  452. #endif
  453. }
  454.  
  455. static long op_acayd()             /*    ADC A,(IY+d) */
  456. {
  457.     register int i,    carry;
  458.     register BYTE P;
  459.  
  460.     carry =    (F & C_FLAG) ? 1 : 0;
  461.     P = *(ram + IY + (char)    *PC++);
  462.     ((A & 0xf) + (P    & 0xf) + carry > 0xf) ?    (F |= H_FLAG) :    (F &= ~H_FLAG);
  463.     (A + P + carry > 255) ?    (F |= C_FLAG) :    (F &= ~C_FLAG);
  464.     A = i =    (char) A + (char) P + carry;
  465.     (i < -128 || i > 127) ?    (F |= P_FLAG) :    (F &= ~P_FLAG);
  466.     (i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  467.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  468.     F &= ~N_FLAG;
  469. #ifdef WANT_TIM
  470.     return(19L);
  471. #endif
  472. }
  473.  
  474. static long op_suayd()             /*    SUB A,(IY+d) */
  475. {
  476.     register int i;
  477.     register BYTE P;
  478.  
  479.     P = *(ram + IY + (char)    *PC++);
  480.     ((P & 0xf) > (A    & 0xf))    ? (F |=    H_FLAG)    : (F &=    ~H_FLAG);
  481.     (P > A)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  482.     A = i =    (char) A - (char) P;
  483.     (i < -128 || i > 127) ?    (F |= P_FLAG) :    (F &= ~P_FLAG);
  484.     (i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  485.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  486.     F |= N_FLAG;
  487. #ifdef WANT_TIM
  488.     return(19L);
  489. #endif
  490. }
  491.  
  492. static long op_scayd()             /*    SBC A,(IY+d) */
  493. {
  494.     register int i,    carry;
  495.     register BYTE P;
  496.  
  497.     carry =    (F & C_FLAG) ? 1 : 0;
  498.     P = *(ram + IY + (char)    *PC++);
  499.     ((P & 0xf) + carry > (A    & 0xf))    ? (F |=    H_FLAG)    : (F &=    ~H_FLAG);
  500.     (P + carry > A)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  501.     A = i =    (char) A - (char) P - carry;
  502.     (i < -128 || i > 127) ?    (F |= P_FLAG) :    (F &= ~P_FLAG);
  503.     (i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  504.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  505.     F |= N_FLAG;
  506. #ifdef WANT_TIM
  507.     return(19L);
  508. #endif
  509. }
  510.  
  511. static long op_andyd()             /*    AND (IY+d) */
  512. {
  513.     A &= *(ram + IY    + (char) *PC++);
  514.     (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  515.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  516.     F |= H_FLAG;
  517.     (parrity[A]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  518.     F &= ~(N_FLAG |    C_FLAG);
  519. #ifdef WANT_TIM
  520.     return(19L);
  521. #endif
  522. }
  523.  
  524. static long op_xoryd()             /*    XOR (IY+d) */
  525. {
  526.     A ^= *(ram + IY    + (char) *PC++);
  527.     (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  528.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  529.     (parrity[A]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  530.     F &= ~(H_FLAG |    N_FLAG | C_FLAG);
  531. #ifdef WANT_TIM
  532.     return(19L);
  533. #endif
  534. }
  535.  
  536. static long op_oryd()             /*    OR (IY+d) */
  537. {
  538.     A |= *(ram + IY    + (char) *PC++);
  539.     (A & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  540.     (A) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  541.     (parrity[A]) ? (F &= ~P_FLAG) :    (F |= P_FLAG);
  542.     F &= ~(H_FLAG |    N_FLAG | C_FLAG);
  543. #ifdef WANT_TIM
  544.     return(19L);
  545. #endif
  546. }
  547.  
  548. static long op_cpyd()             /*    CP (IY+d) */
  549. {
  550.     register int i;
  551.     register BYTE P;
  552.  
  553.     P = *(ram + IY + (char)    *PC++);
  554.     ((P & 0xf) > (A    & 0xf))    ? (F |=    H_FLAG)    : (F &=    ~H_FLAG);
  555.     (P > A)    ? (F |=    C_FLAG)    : (F &=    ~C_FLAG);
  556.     i = (char) A - (char) P;
  557.     (i < -128 || i > 127) ?    (F |= P_FLAG) :    (F &= ~P_FLAG);
  558.     (i & 128) ? (F |= S_FLAG) : (F &= ~S_FLAG);
  559.     (i) ? (F &= ~Z_FLAG) : (F |= Z_FLAG);
  560.     F |= N_FLAG;
  561. #ifdef WANT_TIM
  562.     return(19L);
  563. #endif
  564. }
  565.  
  566. static long op_incyd()             /*    INC (IY+d) */
  567. {
  568.     register BYTE *p;
  569.  
  570.     p = ram    + IY + (char) *PC++;
  571.     ((*p & 0xf) + 1    > 0xf) ? (F |= H_FLAG) : (F &= ~H_FLAG);
  572.     (*p)++;
  573.     (*p == 128) ? (F |= P_FLAG) : (F &= ~P_FLAG);
  574.     (*p & 128) ? (F    |= S_FLAG) : (F    &= ~S_FLAG);
  575.     (*p) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  576.     F &= ~N_FLAG;
  577. #ifdef WANT_TIM
  578.     return(23L);
  579. #endif
  580. }
  581.  
  582. static long op_decyd()             /*    DEC (IY+d) */
  583. {
  584.     register BYTE *p;
  585.  
  586.     p = ram    + IY + (char) *PC++;
  587.     ((*p - 1 & 0xf)    == 0xf)    ? (F |=    H_FLAG)    : (F &=    ~H_FLAG);
  588.     (*p)--;
  589.     (*p == 127) ? (F |= P_FLAG) : (F &= ~P_FLAG);
  590.     (*p & 128) ? (F    |= S_FLAG) : (F    &= ~S_FLAG);
  591.     (*p) ? (F &= ~Z_FLAG) :    (F |= Z_FLAG);
  592.     F |= N_FLAG;
  593. #ifdef WANT_TIM
  594.     return(23L);
  595. #endif
  596. }
  597.  
  598. static long op_addyb()             /*    ADD IY,BC */
  599. {
  600.     register long i;
  601.  
  602.     i = (((long)IY) + (((long)B) << 8) + C);
  603.     (i > 0xffffL) ?    (F |= C_FLAG) :    (F &= ~C_FLAG);
  604.     IY = i;
  605.     F &= ~N_FLAG;
  606. #ifdef WANT_TIM
  607.     return(15L);
  608. #endif
  609. }
  610.  
  611. static long op_addyd()             /*    ADD IY,DE */
  612. {
  613.     register long i;
  614.  
  615.     i = (((long)IY) + (((long)D) << 8) + E);
  616.     (i > 0xffffL) ?    (F |= C_FLAG) :    (F &= ~C_FLAG);
  617.     IY = i;
  618.     F &= ~N_FLAG;
  619. #ifdef WANT_TIM
  620.     return(15L);
  621. #endif
  622. }
  623.  
  624. static long op_addys()             /*    ADD IY,SP */
  625. {
  626.     register long i;
  627.  
  628.     i = ((long)IY) + ((long)STACK) - ((long)ram);
  629.     (i > 0xffffL) ?    (F |= C_FLAG) :    (F &= ~C_FLAG);
  630.     IY = i;
  631.     F &= ~N_FLAG;
  632. #ifdef WANT_TIM
  633.     return(15L);
  634. #endif
  635. }
  636.  
  637. static long op_addyy()             /*    ADD IY,IY */
  638. {
  639.     register long i;
  640.  
  641.     i = (((long)IY) << 1);
  642.     (i > 0xffffL) ?    (F |= C_FLAG) :    (F &= ~C_FLAG);
  643.     IY = i;
  644.     F &= ~N_FLAG;
  645. #ifdef WANT_TIM
  646.     return(15L);
  647. #endif
  648. }
  649.  
  650. static long op_inciy()             /*    INC IY */
  651. {
  652.     IY++;
  653. #ifdef WANT_TIM
  654.     return(10L);
  655. #endif
  656. }
  657.  
  658. static long op_deciy()             /*    DEC IY */
  659. {
  660.     IY--;
  661. #ifdef WANT_TIM
  662.     return(10L);
  663. #endif
  664. }
  665.  
  666. static long op_ldayd()             /*    LD A,(IY+d) */
  667. {
  668.     A = *(IY + (char) *PC++    + ram);
  669. #ifdef WANT_TIM
  670.     return(19L);
  671. #endif
  672. }
  673.  
  674. static long op_ldbyd()             /*    LD B,(IY+d) */
  675. {
  676.     B = *(IY + (char) *PC++    + ram);
  677. #ifdef WANT_TIM
  678.     return(19L);
  679. #endif
  680. }
  681.  
  682. static long op_ldcyd()             /*    LD C,(IY+d) */
  683. {
  684.     C = *(IY + (char) *PC++    + ram);
  685. #ifdef WANT_TIM
  686.     return(19L);
  687. #endif
  688. }
  689.  
  690. static long op_lddyd()             /*    LD D,(IY+d) */
  691. {
  692.     D = *(IY + (char) *PC++    + ram);
  693. #ifdef WANT_TIM
  694.     return(19L);
  695. #endif
  696. }
  697.  
  698. static long op_ldeyd()             /*    LD E,(IY+d) */
  699. {
  700.     E = *(IY + (char) *PC++    + ram);
  701. #ifdef WANT_TIM
  702.     return(19L);
  703. #endif
  704. }
  705.  
  706. static long op_ldhyd()             /*    LD H,(IY+d) */
  707. {
  708.     H = *(IY + (char) *PC++    + ram);
  709. #ifdef WANT_TIM
  710.     return(19L);
  711. #endif
  712. }
  713.  
  714. static long op_ldlyd()             /*    LD L,(IY+d) */
  715. {
  716.     L = *(IY + (char) *PC++    + ram);
  717. #ifdef WANT_TIM
  718.     return(19L);
  719. #endif
  720. }
  721.  
  722. static long op_ldyda()             /*    LD (IY+d),A */
  723. {
  724.     *(IY + (char) *PC++ + ram) = A;
  725. #ifdef WANT_TIM
  726.     return(19L);
  727. #endif
  728. }
  729.  
  730. static long op_ldydb()             /*    LD (IY+d),B */
  731. {
  732.     *(IY + (char) *PC++ + ram) = B;
  733. #ifdef WANT_TIM
  734.     return(19L);
  735. #endif
  736. }
  737.  
  738. static long op_ldydc()             /*    LD (IY+d),C */
  739. {
  740.     *(IY + (char) *PC++ + ram) = C;
  741. #ifdef WANT_TIM
  742.     return(19L);
  743. #endif
  744. }
  745.  
  746. static long op_ldydd()             /*    LD (IY+d),D */
  747. {
  748.     *(IY + (char) *PC++ + ram) = D;
  749. #ifdef WANT_TIM
  750.     return(19L);
  751. #endif
  752. }
  753.  
  754. static long op_ldyde()             /*    LD (IY+d),E */
  755. {
  756.     *(IY + (char) *PC++ + ram) = E;
  757. #ifdef WANT_TIM
  758.     return(19L);
  759. #endif
  760. }
  761.  
  762. static long op_ldydh()             /*    LD (IY+d),H */
  763. {
  764.     *(IY + (char) *PC++ + ram) = H;
  765. #ifdef WANT_TIM
  766.     return(19L);
  767. #endif
  768. }
  769.  
  770. static long op_ldydl()             /*    LD (IY+d),L */
  771. {
  772.     *(IY + (char) *PC++ + ram) = L;
  773. #ifdef WANT_TIM
  774.     return(19L);
  775. #endif
  776. }
  777.  
  778. static long op_ldydn()             /*    LD (IY+d),n */
  779. {
  780.     register int d;
  781.  
  782.     d = (char) *PC++;
  783.     *(IY + d + ram)    = *PC++;
  784. #ifdef WANT_TIM
  785.     return(19L);
  786. #endif
  787. }
  788.