Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /********************************************************************************/
  2. /*                                                                              */
  3. /* CZ80 XYCB opcode include source file                                         */
  4. /* C Z80 emulator version 0.91                                                  */
  5. /* Copyright 2004-2005 Stephane Dallongeville                                   */
  6. /*                                                                              */
  7. /********************************************************************************/
  8.  
  9. #if CZ80_USE_JUMPTABLE
  10.     goto *JumpTableXYCB[Opcode];
  11. #else
  12. switch (Opcode)
  13. {
  14. #endif
  15.  
  16.     OPXYCB(0x00):   // RLC  (Ix+d), B
  17.     OPXYCB(0x01):   // RLC  (Ix+d), C
  18.     OPXYCB(0x02):   // RLC  (Ix+d), D
  19.     OPXYCB(0x03):   // RLC  (Ix+d), E
  20.     OPXYCB(0x04):   // RLC  (Ix+d), H
  21.     OPXYCB(0x05):   // RLC  (Ix+d), L
  22.     OPXYCB(0x07):   // RLC  (Ix+d), A
  23. #if CZ80_EXACT
  24.         PRE_IO
  25.         READ_BYTE(adr, src)
  26.         res = ((src << 1) | (src >> 7)) & 0xFF;
  27.         zR8(Opcode) = res;
  28.         zF = SZXYP[res] | (src >> 7);
  29.         WRITE_BYTE(adr, res)
  30.         POST_IO
  31.         RET(15 + 4)
  32. #endif
  33.  
  34.     OPXYCB(0x06):   // RLC  (Ix+d)
  35.         PRE_IO
  36.         READ_BYTE(adr, src)
  37.         res = ((src << 1) | (src >> 7)) & 0xFF;
  38.         zF = SZXYP[res] | (src >> 7);
  39.         WRITE_BYTE(adr, res)
  40.         POST_IO
  41.         RET(15 + 4)
  42.  
  43.  
  44.     OPXYCB(0x08):   // RRC  (Ix+d), B
  45.     OPXYCB(0x09):   // RRC  (Ix+d), C
  46.     OPXYCB(0x0a):   // RRC  (Ix+d), D
  47.     OPXYCB(0x0b):   // RRC  (Ix+d), E
  48.     OPXYCB(0x0c):   // RRC  (Ix+d), H
  49.     OPXYCB(0x0d):   // RRC  (Ix+d), L
  50.     OPXYCB(0x0f):   // RRC  (Ix+d), A
  51. #if CZ80_EXACT
  52.         PRE_IO
  53.         READ_BYTE(adr, src)
  54.         res = ((src >> 1) | (src << 7)) & 0xFF;
  55.         zR8(Opcode & 7) = res;
  56.         zF = SZXYP[res] | (src & CZ80_CF);
  57.         WRITE_BYTE(adr, res)
  58.         POST_IO
  59.         RET(15 + 4)
  60. #endif
  61.  
  62.     OPXYCB(0x0e):   // RRC  (Ix+d)
  63.         PRE_IO
  64.         READ_BYTE(adr, src)
  65.         res = ((src >> 1) | (src << 7)) & 0xFF;
  66.         zF = SZXYP[res] | (src & CZ80_CF);
  67.         WRITE_BYTE(adr, res)
  68.         POST_IO
  69.         RET(15 + 4)
  70.  
  71.  
  72.     OPXYCB(0x10):   // RL   (Ix+d), B
  73.     OPXYCB(0x11):   // RL   (Ix+d), C
  74.     OPXYCB(0x12):   // RL   (Ix+d), D
  75.     OPXYCB(0x13):   // RL   (Ix+d), E
  76.     OPXYCB(0x14):   // RL   (Ix+d), H
  77.     OPXYCB(0x15):   // RL   (Ix+d), L
  78.     OPXYCB(0x17):   // RL   (Ix+d), A
  79. #if CZ80_EXACT
  80.         PRE_IO
  81.         READ_BYTE(adr, src)
  82.         res = ((src << 1) | (zF & CZ80_CF)) & 0xFF;
  83.         zR8(Opcode & 7) = res;
  84.         zF = SZXYP[res] | (src >> 7);
  85.         WRITE_BYTE(adr, res)
  86.         POST_IO
  87.         RET(15 + 4)
  88. #endif
  89.  
  90.     OPXYCB(0x16):   // RL   (Ix+d)
  91.         PRE_IO
  92.         READ_BYTE(adr, src)
  93.         res = ((src << 1) | (zF & CZ80_CF)) & 0xFF;
  94.         zF = SZXYP[res] | (src >> 7);
  95.         WRITE_BYTE(adr, res)
  96.         POST_IO
  97.         RET(15 + 4)
  98.  
  99.  
  100.     OPXYCB(0x18):   // RR   (Ix+d), B
  101.     OPXYCB(0x19):   // RR   (Ix+d), C
  102.     OPXYCB(0x1a):   // RR   (Ix+d), D
  103.     OPXYCB(0x1b):   // RR   (Ix+d), E
  104.     OPXYCB(0x1c):   // RR   (Ix+d), H
  105.     OPXYCB(0x1d):   // RR   (Ix+d), L
  106.     OPXYCB(0x1f):   // RR   (Ix+d), A
  107. #if CZ80_EXACT
  108.         PRE_IO
  109.         READ_BYTE(adr, src)
  110.         res = ((src >> 1) | (zF << 7)) & 0xFF;
  111.         zR8(Opcode & 7) = res;
  112.         zF = SZXYP[res] | (src & CZ80_CF);
  113.         WRITE_BYTE(adr, res)
  114.         POST_IO
  115.         RET(15 + 4)
  116. #endif
  117.  
  118.     OPXYCB(0x1e):   // RR   (Ix+d)
  119.         PRE_IO
  120.         READ_BYTE(adr, src)
  121.         res = ((src >> 1) | (zF << 7)) & 0xFF;
  122.         zF = SZXYP[res] | (src & CZ80_CF);
  123.         WRITE_BYTE(adr, res)
  124.         POST_IO
  125.         RET(15 + 4)
  126.  
  127.  
  128.     OPXYCB(0x20):   // SLA  (Ix+d), B
  129.     OPXYCB(0x21):   // SLA  (Ix+d), C
  130.     OPXYCB(0x22):   // SLA  (Ix+d), D
  131.     OPXYCB(0x23):   // SLA  (Ix+d), E
  132.     OPXYCB(0x24):   // SLA  (Ix+d), H
  133.     OPXYCB(0x25):   // SLA  (Ix+d), L
  134.     OPXYCB(0x27):   // SLA  (Ix+d), A
  135. #if CZ80_EXACT
  136.         PRE_IO
  137.         READ_BYTE(adr, src)
  138.         res = (src << 1) & 0xFF;
  139.         zR8(Opcode & 7) = res;
  140.         zF = SZXYP[res] | (src >> 7);
  141.         WRITE_BYTE(adr, res)
  142.         POST_IO
  143.         RET(15 + 4)
  144. #endif
  145.  
  146.     OPXYCB(0x26):   // SLA  (Ix+d)
  147.         PRE_IO
  148.         READ_BYTE(adr, src)
  149.         res = (src << 1) & 0xFF;
  150.         zF = SZXYP[res] | (src >> 7);
  151.         WRITE_BYTE(adr, res)
  152.         POST_IO
  153.         RET(15 + 4)
  154.  
  155.  
  156.     OPXYCB(0x28):   // SRA  (Ix+d), B
  157.     OPXYCB(0x29):   // SRA  (Ix+d), C
  158.     OPXYCB(0x2a):   // SRA  (Ix+d), D
  159.     OPXYCB(0x2b):   // SRA  (Ix+d), E
  160.     OPXYCB(0x2c):   // SRA  (Ix+d), H
  161.     OPXYCB(0x2d):   // SRA  (Ix+d), L
  162.     OPXYCB(0x2f):   // SRA  (Ix+d), A
  163. #if CZ80_EXACT
  164.         PRE_IO
  165.         READ_BYTE(adr, src)
  166.         res = (uint8_t)(((int8_t)(src)) >> 1);
  167.         zR8(Opcode & 7) = res;
  168.         zF = SZXYP[res] | (src & CZ80_CF);
  169.         WRITE_BYTE(adr, res)
  170.         POST_IO
  171.         RET(15 + 4)
  172. #endif
  173.  
  174.     OPXYCB(0x2e):   // SRA  (Ix+d)
  175.         PRE_IO
  176.         READ_BYTE(adr, src)
  177.         res = (uint8_t)(((int8_t)(src)) >> 1);
  178.         zF = SZXYP[res] | (src & CZ80_CF);
  179.         WRITE_BYTE(adr, res)
  180.         POST_IO
  181.         RET(15 + 4)
  182.  
  183.  
  184.     OPXYCB(0x30):   // SLL  (Ix+d), B
  185.     OPXYCB(0x31):   // SLL  (Ix+d), C
  186.     OPXYCB(0x32):   // SLL  (Ix+d), D
  187.     OPXYCB(0x33):   // SLL  (Ix+d), E
  188.     OPXYCB(0x34):   // SLL  (Ix+d), H
  189.     OPXYCB(0x35):   // SLL  (Ix+d), L
  190.     OPXYCB(0x37):   // SLL  (Ix+d), A
  191. #if CZ80_EXACT
  192.         PRE_IO
  193.         READ_BYTE(adr, src)
  194.         res = ((src << 1) | 1) & 0xFF;
  195.         zR8(Opcode & 7) = res;
  196.         zF = SZXYP[res] | (src >> 7);
  197.         WRITE_BYTE(adr, res)
  198.         POST_IO
  199.         RET(15 + 4)
  200. #endif
  201.  
  202.     OPXYCB(0x36):   // SLL  (Ix+d)
  203.         PRE_IO
  204.         READ_BYTE(adr, src)
  205.         res = ((src << 1) | 1) & 0xFF;
  206.         zF = SZXYP[res] | (src >> 7);
  207.         WRITE_BYTE(adr, res)
  208.         POST_IO
  209.         RET(15 + 4)
  210.  
  211.  
  212.     OPXYCB(0x38):   // SRL  (Ix+d), B
  213.     OPXYCB(0x39):   // SRL  (Ix+d), C
  214.     OPXYCB(0x3a):   // SRL  (Ix+d), D
  215.     OPXYCB(0x3b):   // SRL  (Ix+d), E
  216.     OPXYCB(0x3c):   // SRL  (Ix+d), H
  217.     OPXYCB(0x3d):   // SRL  (Ix+d), L
  218.     OPXYCB(0x3f):   // SRL  (Ix+d), A
  219. #if CZ80_EXACT
  220.         PRE_IO
  221.         READ_BYTE(adr, src)
  222.         res = src >> 1;
  223.         zR8(Opcode & 7) = res;
  224.         zF = SZXYP[res] | (src & CZ80_CF);
  225.         WRITE_BYTE(adr, res)
  226.         POST_IO
  227.         RET(15 + 4)
  228. #endif
  229.  
  230.     OPXYCB(0x3e):   // SRL  (Ix+d)
  231.         PRE_IO
  232.         READ_BYTE(adr, src)
  233.         res = src >> 1;
  234.         zF = SZXYP[res] | (src & CZ80_CF);
  235.         WRITE_BYTE(adr, res)
  236.         POST_IO
  237.         RET(15 + 4)
  238.  
  239.  
  240.     OPXYCB(0x40):   // BIT  0,(Ix+d)
  241.     OPXYCB(0x41):   // BIT  0,(Ix+d)
  242.     OPXYCB(0x42):   // BIT  0,(Ix+d)
  243.     OPXYCB(0x43):   // BIT  0,(Ix+d)
  244.     OPXYCB(0x44):   // BIT  0,(Ix+d)
  245.     OPXYCB(0x45):   // BIT  0,(Ix+d)
  246.     OPXYCB(0x47):   // BIT  0,(Ix+d)
  247.  
  248.     OPXYCB(0x48):   // BIT  1,(Ix+d)
  249.     OPXYCB(0x49):   // BIT  1,(Ix+d)
  250.     OPXYCB(0x4a):   // BIT  1,(Ix+d)
  251.     OPXYCB(0x4b):   // BIT  1,(Ix+d)
  252.     OPXYCB(0x4c):   // BIT  1,(Ix+d)
  253.     OPXYCB(0x4d):   // BIT  1,(Ix+d)
  254.     OPXYCB(0x4f):   // BIT  1,(Ix+d)
  255.  
  256.     OPXYCB(0x50):   // BIT  2,(Ix+d)
  257.     OPXYCB(0x51):   // BIT  2,(Ix+d)
  258.     OPXYCB(0x52):   // BIT  2,(Ix+d)
  259.     OPXYCB(0x53):   // BIT  2,(Ix+d)
  260.     OPXYCB(0x54):   // BIT  2,(Ix+d)
  261.     OPXYCB(0x55):   // BIT  2,(Ix+d)
  262.     OPXYCB(0x57):   // BIT  2,(Ix+d)
  263.  
  264.     OPXYCB(0x58):   // BIT  3,(Ix+d)
  265.     OPXYCB(0x59):   // BIT  3,(Ix+d)
  266.     OPXYCB(0x5a):   // BIT  3,(Ix+d)
  267.     OPXYCB(0x5b):   // BIT  3,(Ix+d)
  268.     OPXYCB(0x5c):   // BIT  3,(Ix+d)
  269.     OPXYCB(0x5d):   // BIT  3,(Ix+d)
  270.     OPXYCB(0x5f):   // BIT  3,(Ix+d)
  271.  
  272.     OPXYCB(0x60):   // BIT  4,(Ix+d)
  273.     OPXYCB(0x61):   // BIT  4,(Ix+d)
  274.     OPXYCB(0x62):   // BIT  4,(Ix+d)
  275.     OPXYCB(0x63):   // BIT  4,(Ix+d)
  276.     OPXYCB(0x64):   // BIT  4,(Ix+d)
  277.     OPXYCB(0x65):   // BIT  4,(Ix+d)
  278.     OPXYCB(0x67):   // BIT  4,(Ix+d)
  279.  
  280.     OPXYCB(0x68):   // BIT  5,(Ix+d)
  281.     OPXYCB(0x69):   // BIT  5,(Ix+d)
  282.     OPXYCB(0x6a):   // BIT  5,(Ix+d)
  283.     OPXYCB(0x6b):   // BIT  5,(Ix+d)
  284.     OPXYCB(0x6c):   // BIT  5,(Ix+d)
  285.     OPXYCB(0x6d):   // BIT  5,(Ix+d)
  286.     OPXYCB(0x6f):   // BIT  5,(Ix+d)
  287.  
  288.     OPXYCB(0x70):   // BIT  6,(Ix+d)
  289.     OPXYCB(0x71):   // BIT  6,(Ix+d)
  290.     OPXYCB(0x72):   // BIT  6,(Ix+d)
  291.     OPXYCB(0x73):   // BIT  6,(Ix+d)
  292.     OPXYCB(0x74):   // BIT  6,(Ix+d)
  293.     OPXYCB(0x75):   // BIT  6,(Ix+d)
  294.     OPXYCB(0x77):   // BIT  6,(Ix+d)
  295.  
  296.     OPXYCB(0x78):   // BIT  7,(Ix+d)
  297.     OPXYCB(0x79):   // BIT  7,(Ix+d)
  298.     OPXYCB(0x7a):   // BIT  7,(Ix+d)
  299.     OPXYCB(0x7b):   // BIT  7,(Ix+d)
  300.     OPXYCB(0x7c):   // BIT  7,(Ix+d)
  301.     OPXYCB(0x7d):   // BIT  7,(Ix+d)
  302.     OPXYCB(0x7f):   // BIT  7,(Ix+d)
  303.  
  304.     OPXYCB(0x46):   // BIT  0,(Ix+d)
  305.     OPXYCB(0x4e):   // BIT  1,(Ix+d)
  306.     OPXYCB(0x56):   // BIT  2,(Ix+d)
  307.     OPXYCB(0x5e):   // BIT  3,(Ix+d)
  308.     OPXYCB(0x66):   // BIT  4,(Ix+d)
  309.     OPXYCB(0x6e):   // BIT  5,(Ix+d)
  310.     OPXYCB(0x76):   // BIT  6,(Ix+d)
  311.     OPXYCB(0x7e):   // BIT  7,(Ix+d)
  312.     {
  313.         uint8_t bitm;
  314.        
  315.         PRE_IO
  316.         bitm = 1 << ((Opcode >> 3) & 7);
  317.         READ_BYTE(adr, src)
  318.         zF = (zF & CZ80_CF) | CZ80_HF |                         // C/H flag
  319.              (SZXY_BIT[src & bitm] & ~(CZ80_XF | CZ80_YF)) |    // Z/V/N flag
  320.              ((adr >> 8) & (CZ80_XF | CZ80_YF));                // X/Y flag
  321.         POST_IO
  322.         RET(12 + 4)
  323.     }
  324.  
  325.     OPXYCB(0x80):   // RES  0,(Ix+d),B
  326.     OPXYCB(0x81):   // RES  0,(Ix+d),C
  327.     OPXYCB(0x82):   // RES  0,(Ix+d),D
  328.     OPXYCB(0x83):   // RES  0,(Ix+d),E
  329.     OPXYCB(0x84):   // RES  0,(Ix+d),H
  330.     OPXYCB(0x85):   // RES  0,(Ix+d),L
  331.     OPXYCB(0x87):   // RES  0,(Ix+d),A
  332.  
  333.     OPXYCB(0x88):   // RES  1,(Ix+d),B
  334.     OPXYCB(0x89):   // RES  1,(Ix+d),C
  335.     OPXYCB(0x8a):   // RES  1,(Ix+d),D
  336.     OPXYCB(0x8b):   // RES  1,(Ix+d),E
  337.     OPXYCB(0x8c):   // RES  1,(Ix+d),H
  338.     OPXYCB(0x8d):   // RES  1,(Ix+d),L
  339.     OPXYCB(0x8f):   // RES  1,(Ix+d),A
  340.  
  341.     OPXYCB(0x90):   // RES  2,(Ix+d),B
  342.     OPXYCB(0x91):   // RES  2,(Ix+d),C
  343.     OPXYCB(0x92):   // RES  2,(Ix+d),D
  344.     OPXYCB(0x93):   // RES  2,(Ix+d),E
  345.     OPXYCB(0x94):   // RES  2,(Ix+d),H
  346.     OPXYCB(0x95):   // RES  2,(Ix+d),L
  347.     OPXYCB(0x97):   // RES  2,(Ix+d),A
  348.  
  349.     OPXYCB(0x98):   // RES  3,(Ix+d),B
  350.     OPXYCB(0x99):   // RES  3,(Ix+d),C
  351.     OPXYCB(0x9a):   // RES  3,(Ix+d),D
  352.     OPXYCB(0x9b):   // RES  3,(Ix+d),E
  353.     OPXYCB(0x9c):   // RES  3,(Ix+d),H
  354.     OPXYCB(0x9d):   // RES  3,(Ix+d),L
  355.     OPXYCB(0x9f):   // RES  3,(Ix+d),A
  356.  
  357.     OPXYCB(0xa0):   // RES  4,(Ix+d),B
  358.     OPXYCB(0xa1):   // RES  4,(Ix+d),C
  359.     OPXYCB(0xa2):   // RES  4,(Ix+d),D
  360.     OPXYCB(0xa3):   // RES  4,(Ix+d),E
  361.     OPXYCB(0xa4):   // RES  4,(Ix+d),H
  362.     OPXYCB(0xa5):   // RES  4,(Ix+d),L
  363.     OPXYCB(0xa7):   // RES  4,(Ix+d),A
  364.  
  365.     OPXYCB(0xa8):   // RES  5,(Ix+d),B
  366.     OPXYCB(0xa9):   // RES  5,(Ix+d),C
  367.     OPXYCB(0xaa):   // RES  5,(Ix+d),D
  368.     OPXYCB(0xab):   // RES  5,(Ix+d),E
  369.     OPXYCB(0xac):   // RES  5,(Ix+d),H
  370.     OPXYCB(0xad):   // RES  5,(Ix+d),L
  371.     OPXYCB(0xaf):   // RES  5,(Ix+d),A
  372.  
  373.     OPXYCB(0xb0):   // RES  6,(Ix+d),B
  374.     OPXYCB(0xb1):   // RES  6,(Ix+d),C
  375.     OPXYCB(0xb2):   // RES  6,(Ix+d),D
  376.     OPXYCB(0xb3):   // RES  6,(Ix+d),E
  377.     OPXYCB(0xb4):   // RES  6,(Ix+d),H
  378.     OPXYCB(0xb5):   // RES  6,(Ix+d),L
  379.     OPXYCB(0xb7):   // RES  6,(Ix+d),A
  380.  
  381.     OPXYCB(0xb8):   // RES  7,(Ix+d),B
  382.     OPXYCB(0xb9):   // RES  7,(Ix+d),C
  383.     OPXYCB(0xba):   // RES  7,(Ix+d),D
  384.     OPXYCB(0xbb):   // RES  7,(Ix+d),E
  385.     OPXYCB(0xbc):   // RES  7,(Ix+d),H
  386.     OPXYCB(0xbd):   // RES  7,(Ix+d),L
  387.     OPXYCB(0xbf):   // RES  7,(Ix+d),A
  388. #if CZ80_EXACT
  389.         PRE_IO
  390.         READ_BYTE(adr, res)
  391.         res &= ~(1 << ((Opcode >> 3) & 7));
  392.         zR8(Opcode & 7) = res;
  393.         WRITE_BYTE(adr, res)
  394.         POST_IO
  395.         RET(15 + 4)
  396. #endif
  397.  
  398.     OPXYCB(0x86):   // RES  0,(Ix+d)
  399.     OPXYCB(0x8e):   // RES  1,(Ix+d)
  400.     OPXYCB(0x96):   // RES  2,(Ix+d)
  401.     OPXYCB(0x9e):   // RES  3,(Ix+d)
  402.     OPXYCB(0xa6):   // RES  4,(Ix+d)
  403.     OPXYCB(0xae):   // RES  5,(Ix+d)
  404.     OPXYCB(0xb6):   // RES  6,(Ix+d)
  405.     OPXYCB(0xbe):   // RES  7,(Ix+d)
  406.     {
  407.         uint8_t bitm;
  408.  
  409.         PRE_IO
  410.         bitm = ~(1 << ((Opcode >> 3) & 7));
  411.         READ_BYTE(adr, res)
  412.         res &= bitm;
  413.         WRITE_BYTE(adr, res)
  414.         POST_IO
  415.         RET(15 + 4)
  416.     }
  417.  
  418.  
  419.     OPXYCB(0xc0):   // SET  0,(Ix+d),B
  420.     OPXYCB(0xc1):   // SET  0,(Ix+d),C
  421.     OPXYCB(0xc2):   // SET  0,(Ix+d),D
  422.     OPXYCB(0xc3):   // SET  0,(Ix+d),E
  423.     OPXYCB(0xc4):   // SET  0,(Ix+d),H
  424.     OPXYCB(0xc5):   // SET  0,(Ix+d),L
  425.     OPXYCB(0xc7):   // SET  0,(Ix+d),A
  426.  
  427.     OPXYCB(0xc8):   // SET  1,(Ix+d),B
  428.     OPXYCB(0xc9):   // SET  1,(Ix+d),C
  429.     OPXYCB(0xca):   // SET  1,(Ix+d),D
  430.     OPXYCB(0xcb):   // SET  1,(Ix+d),E
  431.     OPXYCB(0xcc):   // SET  1,(Ix+d),H
  432.     OPXYCB(0xcd):   // SET  1,(Ix+d),L
  433.     OPXYCB(0xcf):   // SET  1,(Ix+d),A
  434.  
  435.     OPXYCB(0xd0):   // SET  2,(Ix+d),B
  436.     OPXYCB(0xd1):   // SET  2,(Ix+d),C
  437.     OPXYCB(0xd2):   // SET  2,(Ix+d),D
  438.     OPXYCB(0xd3):   // SET  2,(Ix+d),E
  439.     OPXYCB(0xd4):   // SET  2,(Ix+d),H
  440.     OPXYCB(0xd5):   // SET  2,(Ix+d),L
  441.     OPXYCB(0xd7):   // SET  2,(Ix+d),A
  442.  
  443.     OPXYCB(0xd8):   // SET  3,(Ix+d),B
  444.     OPXYCB(0xd9):   // SET  3,(Ix+d),C
  445.     OPXYCB(0xda):   // SET  3,(Ix+d),D
  446.     OPXYCB(0xdb):   // SET  3,(Ix+d),E
  447.     OPXYCB(0xdc):   // SET  3,(Ix+d),H
  448.     OPXYCB(0xdd):   // SET  3,(Ix+d),L
  449.     OPXYCB(0xdf):   // SET  3,(Ix+d),A
  450.  
  451.     OPXYCB(0xe0):   // SET  4,(Ix+d),B
  452.     OPXYCB(0xe1):   // SET  4,(Ix+d),C
  453.     OPXYCB(0xe2):   // SET  4,(Ix+d),D
  454.     OPXYCB(0xe3):   // SET  4,(Ix+d),E
  455.     OPXYCB(0xe4):   // SET  4,(Ix+d),H
  456.     OPXYCB(0xe5):   // SET  4,(Ix+d),L
  457.     OPXYCB(0xe7):   // SET  4,(Ix+d),A
  458.  
  459.     OPXYCB(0xe8):   // SET  5,(Ix+d),B
  460.     OPXYCB(0xe9):   // SET  5,(Ix+d),C
  461.     OPXYCB(0xea):   // SET  5,(Ix+d),D
  462.     OPXYCB(0xeb):   // SET  5,(Ix+d),E
  463.     OPXYCB(0xec):   // SET  5,(Ix+d),H
  464.     OPXYCB(0xed):   // SET  5,(Ix+d),L
  465.     OPXYCB(0xef):   // SET  5,(Ix+d),A
  466.  
  467.     OPXYCB(0xf0):   // SET  6,(Ix+d),B
  468.     OPXYCB(0xf1):   // SET  6,(Ix+d),C
  469.     OPXYCB(0xf2):   // SET  6,(Ix+d),D
  470.     OPXYCB(0xf3):   // SET  6,(Ix+d),E
  471.     OPXYCB(0xf4):   // SET  6,(Ix+d),H
  472.     OPXYCB(0xf5):   // SET  6,(Ix+d),L
  473.     OPXYCB(0xf7):   // SET  6,(Ix+d),A
  474.  
  475.     OPXYCB(0xf8):   // SET  7,(Ix+d),B
  476.     OPXYCB(0xf9):   // SET  7,(Ix+d),C
  477.     OPXYCB(0xfa):   // SET  7,(Ix+d),D
  478.     OPXYCB(0xfb):   // SET  7,(Ix+d),E
  479.     OPXYCB(0xfc):   // SET  7,(Ix+d),H
  480.     OPXYCB(0xfd):   // SET  7,(Ix+d),L
  481.     OPXYCB(0xff):   // SET  7,(Ix+d),A
  482. #if CZ80_EXACT
  483.         PRE_IO
  484.         READ_BYTE(adr, res)
  485.         res |= 1 << ((Opcode >> 3) & 7);
  486.         zR8(Opcode & 7) = res;
  487.         WRITE_BYTE(adr, res)
  488.         POST_IO
  489.         RET(15 + 4)
  490. #endif
  491.  
  492.     OPXYCB(0xc6):   // SET  0,(Ix+d)
  493.     OPXYCB(0xce):   // SET  1,(Ix+d)
  494.     OPXYCB(0xd6):   // SET  2,(Ix+d)
  495.     OPXYCB(0xde):   // SET  3,(Ix+d)
  496.     OPXYCB(0xe6):   // SET  4,(Ix+d)
  497.     OPXYCB(0xee):   // SET  5,(Ix+d)
  498.     OPXYCB(0xf6):   // SET  6,(Ix+d)
  499.     OPXYCB(0xfe):   // SET  7,(Ix+d)
  500.     {
  501.         uint8_t bitm;
  502.  
  503.         PRE_IO
  504.         bitm = 1 << ((Opcode >> 3) & 7);
  505.         READ_BYTE(adr, res)
  506.         res |= bitm;
  507.         WRITE_BYTE(adr, res)
  508.         POST_IO
  509.         RET(15 + 4)
  510.     }
  511.  
  512. #if CZ80_USE_JUMPTABLE
  513. #else
  514. }
  515. #endif
  516.  
  517.