Subversion Repositories Kolibri OS

Rev

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

  1. /********************************************************************************/
  2. /*                                                                              */
  3. /* CZ80 ED 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 *JumpTableED[Opcode];
  11. #else
  12. switch (Opcode)
  13. {
  14. #endif
  15.  
  16.     // ILLEGAL
  17.    
  18.     OPED(0x00):
  19.     OPED(0x01):
  20.     OPED(0x02):
  21.     OPED(0x03):
  22.     OPED(0x04):
  23.     OPED(0x05):
  24.     OPED(0x06):
  25.     OPED(0x07):
  26.     OPED(0x08):
  27.     OPED(0x09):
  28.     OPED(0x0a):
  29.     OPED(0x0b):
  30.     OPED(0x0c):
  31.     OPED(0x0d):
  32.     OPED(0x0e):
  33.     OPED(0x0f):
  34.     OPED(0x10):
  35.     OPED(0x11):
  36.     OPED(0x12):
  37.     OPED(0x13):
  38.     OPED(0x14):
  39.     OPED(0x15):
  40.     OPED(0x16):
  41.     OPED(0x17):
  42.     OPED(0x18):
  43.     OPED(0x19):
  44.     OPED(0x1a):
  45.     OPED(0x1b):
  46.     OPED(0x1c):
  47.     OPED(0x1d):
  48.     OPED(0x1e):
  49.     OPED(0x1f):
  50.     OPED(0x20):
  51.     OPED(0x21):
  52.     OPED(0x22):
  53.     OPED(0x23):
  54.     OPED(0x24):
  55.     OPED(0x25):
  56.     OPED(0x26):
  57.     OPED(0x27):
  58.     OPED(0x28):
  59.     OPED(0x29):
  60.     OPED(0x2a):
  61.     OPED(0x2b):
  62.     OPED(0x2c):
  63.     OPED(0x2d):
  64.     OPED(0x2e):
  65.     OPED(0x2f):
  66.     OPED(0x30):
  67.     OPED(0x31):
  68.     OPED(0x32):
  69.     OPED(0x33):
  70.     OPED(0x34):
  71.     OPED(0x35):
  72.     OPED(0x36):
  73.     OPED(0x37):
  74.     OPED(0x38):
  75.     OPED(0x39):
  76.     OPED(0x3a):
  77.     OPED(0x3b):
  78.     OPED(0x3c):
  79.     OPED(0x3d):
  80.     OPED(0x3e):
  81.     OPED(0x3f):
  82.     OPED(0xbc):
  83.     OPED(0xbd):
  84.     OPED(0xbe):
  85.     OPED(0xbf):
  86.     OPED(0xc0):
  87.     OPED(0xc1):
  88.     OPED(0xc2):
  89.     OPED(0xc3):
  90.     OPED(0xc4):
  91.     OPED(0xc5):
  92.     OPED(0xc6):
  93.     OPED(0xc7):
  94.     OPED(0xc8):
  95.     OPED(0xc9):
  96.     OPED(0xca):
  97.     OPED(0xcb):
  98.     OPED(0xcc):
  99.     OPED(0xcd):
  100.     OPED(0xce):
  101.     OPED(0xcf):
  102.     OPED(0xd0):
  103.     OPED(0xd1):
  104.     OPED(0xd2):
  105.     OPED(0xd3):
  106.     OPED(0xd4):
  107.     OPED(0xd5):
  108.     OPED(0xd6):
  109.     OPED(0xd7):
  110.     OPED(0xd8):
  111.     OPED(0xd9):
  112.     OPED(0xda):
  113.     OPED(0xdb):
  114.     OPED(0xdc):
  115.     OPED(0xdd):
  116.     OPED(0xde):
  117.     OPED(0xdf):
  118.     OPED(0xe0):
  119.     OPED(0xe1):
  120.     OPED(0xe2):
  121.     OPED(0xe3):
  122.     OPED(0xe4):
  123.     OPED(0xe5):
  124.     OPED(0xe6):
  125.     OPED(0xe7):
  126.     OPED(0xe8):
  127.     OPED(0xe9):
  128.     OPED(0xea):
  129.     OPED(0xeb):
  130.     OPED(0xec):
  131.     OPED(0xed):
  132.     OPED(0xee):
  133.     OPED(0xef):
  134.     OPED(0xf0):
  135.     OPED(0xf1):
  136.     OPED(0xf2):
  137.     OPED(0xf3):
  138.     OPED(0xf4):
  139.     OPED(0xf5):
  140.     OPED(0xf6):
  141.     OPED(0xf7):
  142.     OPED(0xf8):
  143.     OPED(0xf9):
  144.     OPED(0xfa):
  145.     OPED(0xfb):
  146.     OPED(0xfc):
  147.     OPED(0xfd):
  148.     OPED(0xfe):
  149.     OPED(0xff):
  150.     OPED(0x77):
  151.     OPED(0x7f):
  152.     OPED(0x80):
  153.     OPED(0x81):
  154.     OPED(0x82):
  155.     OPED(0x83):
  156.     OPED(0x84):
  157.     OPED(0x85):
  158.     OPED(0x86):
  159.     OPED(0x87):
  160.     OPED(0x88):
  161.     OPED(0x89):
  162.     OPED(0x8a):
  163.     OPED(0x8b):
  164.     OPED(0x8c):
  165.     OPED(0x8d):
  166.     OPED(0x8e):
  167.     OPED(0x8f):
  168.     OPED(0x90):
  169.     OPED(0x91):
  170.     OPED(0x92):
  171.     OPED(0x93):
  172.     OPED(0x94):
  173.     OPED(0x95):
  174.     OPED(0x96):
  175.     OPED(0x97):
  176.     OPED(0x98):
  177.     OPED(0x99):
  178.     OPED(0x9a):
  179.     OPED(0x9b):
  180.     OPED(0x9c):
  181.     OPED(0x9d):
  182.     OPED(0x9e):
  183.     OPED(0x9f):
  184.     OPED(0xa4):
  185.     OPED(0xa5):
  186.     OPED(0xa6):
  187.     OPED(0xa7):
  188.     OPED(0xac):
  189.     OPED(0xad):
  190.     OPED(0xae):
  191.     OPED(0xaf):
  192.     OPED(0xb4):
  193.     OPED(0xb5):
  194.     OPED(0xb6):
  195.     OPED(0xb7):
  196.         goto OP_NOP;
  197.  
  198.     OPED(0x43): // LD   (w),BC
  199.         data = pzBC;
  200.         goto OP_LD_mNN_xx;
  201.  
  202.     OPED(0x53): // LD   (w),DE
  203.         data = pzDE;
  204.         goto OP_LD_mNN_xx;
  205.  
  206.     OPED(0x63): // LD   (w),HL
  207.         data = pzHL;
  208.         goto OP_LD_mNN_xx;
  209.  
  210.     OPED(0x73): // LD   (w),SP
  211.         data = pzSP;
  212.         goto OP_LD_mNN_xx;
  213.  
  214.     OPED(0x4b): // LD   BC,(w)
  215.         data = pzBC;
  216.         goto OP_LD_xx_mNN;
  217.  
  218.     OPED(0x5b): // LD   DE,(w)
  219.         data = pzDE;
  220.         goto OP_LD_xx_mNN;
  221.  
  222.     OPED(0x6b): // LD   HL,(w)
  223.         data = pzHL;
  224.         goto OP_LD_xx_mNN;
  225.  
  226.     OPED(0x7b): // LD   SP,(w)
  227.         data = pzSP;
  228.         goto OP_LD_xx_mNN;
  229.  
  230.  
  231.     OPED(0x47): // LD   I,A
  232.         zI = zA;
  233.         RET(5)
  234.  
  235.     OPED(0x4f): // LD   R,A
  236.         zR = zA - ((CPU->CycleToDo - CCnt) / 4);
  237.         zR2 = zA & 0x80;
  238.         RET(5)
  239.  
  240.     OPED(0x57): // LD   A,I
  241.     {
  242.         uint8_t F;
  243.  
  244.         zA = zI;
  245.         F = zF & CZ80_CF;
  246.         F |= zA & (CZ80_SF | CZ80_YF | CZ80_XF);
  247.         F |= zIFF2;
  248.         if (!zA) F |= CZ80_ZF;
  249.         zF = F;
  250.         RET(5)
  251.     }
  252.  
  253.     OPED(0x5f): // LD   A,R
  254.     {
  255.         uint8_t F;
  256.  
  257.         zA = zR2 + ((zR + ((CPU->CycleToDo - CCnt) / 4)) & 0x7F);
  258.         F = zF & CZ80_CF;
  259.         F |= zA & (CZ80_SF | CZ80_YF | CZ80_XF);
  260.         F |= zIFF2;
  261.         if (!zA) F |= CZ80_ZF;
  262.         zF = F;
  263.         RET(5)
  264.     }
  265.  
  266.     OPED(0x5c): // NEG
  267.     OPED(0x54): // NEG
  268.     OPED(0x4c): // NEG
  269.     OPED(0x44): // NEG
  270.     OPED(0x64): // NEG
  271.     OPED(0x6c): // NEG
  272.     OPED(0x74): // NEG
  273.     OPED(0x7c): // NEG
  274.     {
  275.         uint16_t val;
  276.         uint16_t res;
  277.  
  278.         val = zA;
  279.         res = 0 - val;
  280.         zF = SZXY[res & 0xFF] |                     // S/Z/X/Y flag
  281.             ((res ^ val) & CZ80_HF) |               // H flag
  282.             (((val & res) & 0x80) >> 5) |           // V flag
  283.             ((res >> 8) & CZ80_CF) | CZ80_NF;       // C/N flag
  284.         zA = res;
  285.         RET(4)
  286.     }
  287.  
  288.  
  289.     OPED(0x67): // RRD  (HL)
  290.     {
  291.         uint16_t adr;
  292.         uint8_t src;
  293.  
  294.         PRE_IO
  295.         adr = zHL;
  296.         READ_BYTE(adr, src)
  297.         WRITE_BYTE(adr, (src >> 4) | (zA << 4))
  298.         zA = (zA & 0xF0) | (src & 0x0F);
  299.         zF = SZXYP[zA] | (zF & CZ80_CF);
  300.         POST_IO
  301.         RET(14)
  302.     }
  303.  
  304.     OPED(0x6f): // RLD  (HL)
  305.     {
  306.         uint16_t adr;
  307.         uint8_t src;
  308.  
  309.         PRE_IO
  310.         adr = zHL;
  311.         READ_BYTE(adr, src)
  312.         WRITE_BYTE(adr, (src << 4) | (zA & 0x0F))
  313.         zA = (zA & 0xF0) | (src >> 4);
  314.         zF = SZXYP[zA] | (zF & CZ80_CF);
  315.         POST_IO
  316.         RET(14)
  317.     }
  318.  
  319.  
  320.     {
  321.         uint16_t src;
  322.         uint32_t res;
  323.  
  324.     OPED(0x7a): // ADC  HL,SP
  325.         src = zSP;
  326.         goto OP_ADC_HL;
  327.  
  328.     OPED(0x4a): // ADC  HL,BC
  329.     OPED(0x5a): // ADC  HL,DE
  330.     OPED(0x6a): // ADC  HL,HL
  331.         src = zR16((Opcode >> 4) & 3);
  332.  
  333. OP_ADC_HL:
  334.         res = zHL + src + (zF & CZ80_CF);
  335.         zF = (((src ^ zHL ^ res) >> 8) & CZ80_HF) |                     // H flag
  336.             (((src ^ zHL ^ 0x8000) & (src ^ res) & 0x8000) >> 13) |     // V flag
  337.             ((res >> 8) & (CZ80_SF | CZ80_XF | CZ80_YF)) |              // S/X/Y flag
  338.             ((res >> 16) & CZ80_CF) |                                   // C flag
  339.             ((res & 0xFFFF) ? 0 : CZ80_ZF);                             // Z flag
  340.         zHL = res;
  341.         RET(11)
  342.        
  343.  
  344.     OPED(0x72): // SBC  HL,SP
  345.         src = zSP;
  346.         goto OP_SBC_HL;
  347.  
  348.     OPED(0x42): // SBC  HL,BC
  349.     OPED(0x52): // SBC  HL,DE
  350.     OPED(0x62): // SBC  HL,HL
  351.         src = zR16((Opcode >> 4) & 3);
  352.  
  353. OP_SBC_HL:
  354.         res = zHL - src + (zF & CZ80_CF);
  355. #if CZ80_DEBUG
  356.         zF = (((src ^ zHL ^ res) >> 8) & CZ80_HF) | CZ80_NF |           // H/N flag
  357.             (((src ^ zHL) & (zHL ^ res) & 0x8000) >> 13) |              // V flag
  358.             ((res >> 8) & CZ80_SF) |                                    // S flag
  359.             ((res >> 16) & CZ80_CF) |                                   // C flag
  360.             ((res & 0xFFFF) ? 0 : CZ80_ZF);                             // Z flag
  361. #else
  362.         zF = (((src ^ zHL ^ res) >> 8) & CZ80_HF) | CZ80_NF |           // H/N flag
  363.             (((src ^ zHL) & (zHL ^ res) & 0x8000) >> 13) |              // V flag
  364.             ((res >> 8) & (CZ80_SF | CZ80_XF | CZ80_YF)) |              // S/X/Y flag
  365.             ((res >> 16) & CZ80_CF) |                                   // C flag
  366.             ((res & 0xFFFF) ? 0 : CZ80_ZF);                             // Z flag
  367. #endif
  368.         zHL = res;
  369.         RET(11)
  370.     }
  371.  
  372.  
  373.     {
  374.         uint8_t res;
  375.  
  376.     OPED(0x40): // IN   B,(C)
  377.     OPED(0x48): // IN   C,(C)
  378.     OPED(0x50): // IN   D,(C)
  379.     OPED(0x58): // IN   E,(C)
  380.     OPED(0x60): // IN   H,(C)
  381.     OPED(0x68): // IN   L,(C)
  382.     OPED(0x78): // IN   E,(C)
  383.  
  384.         IN(zBC, res);
  385.         zR8((Opcode >> 3) & 7) = res;
  386.         zF = (zF & CZ80_CF) | SZXYP[res];
  387.         RET(8)
  388.  
  389.     OPED(0x70): // IN   0,(C)
  390.  
  391.         IN(zBC, res);
  392.         zF = (zF & CZ80_CF) | SZXYP[res];
  393.         RET(8)
  394.     }
  395.  
  396.  
  397.     {
  398.         uint8_t src;
  399.  
  400.     OPED(0x71): // OUT  (C),0
  401.         src = 0;
  402.         goto OP_OUT_mBC;
  403.  
  404.     OPED(0x51): // OUT  (C),D
  405.     OPED(0x41): // OUT  (C),B
  406.     OPED(0x49): // OUT  (C),C
  407.     OPED(0x59): // OUT  (C),E
  408.     OPED(0x61): // OUT  (C),H
  409.     OPED(0x69): // OUT  (C),L
  410.     OPED(0x79): // OUT  (C),E
  411.         src = zR8((Opcode >> 3) & 7);
  412.  
  413. OP_OUT_mBC:
  414.         OUT(zBC, src);
  415.         RET(8)
  416.     }
  417.  
  418.     {
  419.         uint16_t newPC;
  420.  
  421.     OPED(0x4d): // RETI
  422.     OPED(0x5d): // RETI
  423.     OPED(0x6d): // RETI
  424.     OPED(0x7d): // RETI
  425.         if (CPU->RetI) CPU->RetI(CPU->ctx);
  426.  
  427.     OPED(0x45): // RETN;
  428.     OPED(0x55): // RETN;
  429.     OPED(0x65): // RETN;
  430.     OPED(0x75): // RETN;
  431.         PRE_IO
  432.         POP_16(newPC);
  433.         SET_PC(newPC);
  434.         POST_IO
  435.         zIFF1 = zIFF2;
  436.         CCnt -= 10;
  437.         // we need to test for interrupt
  438.         goto Cz80_Exec_End;
  439.     }
  440.  
  441.     OPED(0x46): // IM   0
  442.     OPED(0x4e): // IM   0
  443.     OPED(0x66): // IM   0
  444.     OPED(0x6e): // IM   0
  445.         zIM = 0;
  446.         RET(4)
  447.  
  448.     OPED(0x76): // IM   1
  449.     OPED(0x56): // IM   1
  450.         zIM = 1;
  451.         RET(4)
  452.  
  453.     OPED(0x5e): // IM   2
  454.     OPED(0x7e): // IM   2
  455.         zIM = 2;
  456.         RET(4)
  457.  
  458.  
  459.     {
  460.         uint8_t val;
  461.         uint8_t F;
  462.  
  463.     OPED(0xa8): // LDD
  464.         PRE_IO
  465.         READ_BYTE(zHL--, val)
  466.         WRITE_BYTE(zDE--, val)
  467.         goto OP_LDX;
  468.  
  469.     OPED(0xa0): // LDI
  470.         PRE_IO
  471.         READ_BYTE(zHL++, val)
  472.         WRITE_BYTE(zDE++, val)
  473.  
  474. OP_LDX:
  475. #if CZ80_EXACT
  476.         val += zA;
  477.         F = (zF & (CZ80_SF | CZ80_ZF | CZ80_CF)) |
  478.             (val & CZ80_XF) | ((val << 4) & CZ80_YF);
  479. #else
  480.         F = zF & (CZ80_SF | CZ80_ZF | CZ80_YF | CZ80_XF | CZ80_CF);
  481. #endif
  482.         if (--zBC) F |= CZ80_PF;
  483.         zF = F;
  484.         POST_IO
  485.         RET(12)
  486.     }
  487.  
  488.     {
  489.         uint8_t val;
  490.         uint8_t F;
  491.  
  492.     OPED(0xb8): // LDDR
  493.         do
  494.         {
  495.             PRE_IO
  496.             READ_BYTE(zHL--, val)
  497.             WRITE_BYTE(zDE--, val)
  498.             POST_IO
  499.             zBC--;
  500.             CCnt -= 21;
  501.         } while ((zBC) && (CCnt > -4));
  502.         goto OP_LDXR;
  503.  
  504.     OPED(0xb0): // LDIR
  505.         do
  506.         {
  507.             PRE_IO
  508.             READ_BYTE(zHL++, val)
  509.             WRITE_BYTE(zDE++, val)
  510.             POST_IO
  511.             zBC--;
  512.             CCnt -= 21;
  513.         } while ((zBC) && (CCnt > -4));
  514.  
  515. OP_LDXR:
  516. #if CZ80_EXACT
  517.         val += zA;
  518.         F = (zF & (CZ80_SF | CZ80_ZF | CZ80_CF)) |
  519.             (val & CZ80_XF) | ((val << 4) & CZ80_YF);
  520. #else
  521.         F = zF & (CZ80_SF | CZ80_ZF | CZ80_YF | CZ80_XF | CZ80_CF);
  522. #endif
  523.  
  524.         if (zBC)
  525.         {
  526.             // instruction not yet completed...
  527.             // we will continu it at next CZ80_Exec
  528.             zF = F | CZ80_PF;
  529.             zPC -= 2;
  530.             CCnt += 4;
  531.             goto Cz80_Exec_End;
  532.         }
  533.  
  534.         // instruction completed...
  535.         zF = F;
  536.         RET(-(5 + 4))
  537.     }
  538.  
  539.  
  540.     {
  541.         uint8_t val;
  542.         uint8_t res;
  543.         uint8_t F;
  544.  
  545.     OPED(0xa9): // CPD
  546.         PRE_IO
  547.         READ_BYTE(zHL--, val)
  548.         goto OP_CPX;
  549.  
  550.     OPED(0xa1): // CPI
  551.         PRE_IO
  552.         READ_BYTE(zHL++, val)
  553.  
  554. OP_CPX:
  555.         res = zA - val;
  556. #if CZ80_EXACT
  557.         F = (zF & CZ80_CF) | (SZXY[res] & ~(CZ80_YF | CZ80_XF)) |
  558.             ((zA ^ val ^ res) & CZ80_HF) | CZ80_NF;
  559.         if (F & CZ80_HF) res--;
  560.         F |= (res & CZ80_XF) | ((res >> 4) & CZ80_YF);
  561. #else
  562.         F = (zF & CZ80_CF) | SZXY[res] |
  563.             ((zA ^ val ^ res) & CZ80_HF) | CZ80_NF;
  564. #endif
  565.         if (--zBC) F |= CZ80_PF;
  566.         zF = F;
  567.         POST_IO
  568.         RET(12)
  569.     }
  570.  
  571.     {
  572.         uint8_t val;
  573.         uint8_t res;
  574.         uint8_t F;
  575.  
  576.     OPED(0xb9): // CPDR
  577.         do
  578.         {
  579.             PRE_IO
  580.             READ_BYTE(zHL--, val)
  581.             res = zA - val;
  582.             POST_IO
  583.             zBC--;
  584.             CCnt -= 21;
  585.         } while ((zBC) && (res) && (CCnt > -4));
  586.         goto OP_CPXR;
  587.  
  588.     OPED(0xb1): // CPIR
  589.         do
  590.         {
  591.             PRE_IO
  592.             READ_BYTE(zHL++, val)
  593.             res = zA - val;
  594.             POST_IO
  595.             zBC--;
  596.             CCnt -= 21;
  597.         } while ((zBC) && (res) && (CCnt > -4));
  598.  
  599. OP_CPXR:
  600. #if CZ80_EXACT
  601.         F = (zF & CZ80_CF) | (SZXY[res] & ~(CZ80_YF | CZ80_XF)) |
  602.             ((zA ^ val ^ res) & CZ80_HF) | CZ80_NF;
  603.         if (F & CZ80_HF) res--;
  604.         F |= (res & CZ80_XF) | ((res >> 4) & CZ80_YF);
  605. #else
  606.         F = (zF & CZ80_CF) | SZXY[res] |
  607.             ((zA ^ val ^ res) & CZ80_HF) | CZ80_NF;
  608. #endif
  609.  
  610.         if (zBC)
  611.         {
  612.             // instruction not yet completed...
  613.             // we will continu it at next CZ80_Exec
  614.             zF = F | CZ80_PF;
  615.             zPC -= 2;
  616.             CCnt += 4;
  617.             goto Cz80_Exec_End;
  618.         }
  619.  
  620.         // instruction completed...
  621.         zF = F;
  622.         RET(-(3 + 4))
  623.     }
  624.  
  625.  
  626.     {
  627.         uint8_t val;
  628. #if CZ80_EXACT
  629.         uint8_t F;
  630. #endif
  631.  
  632.     OPED(0xaa): // IND
  633.         PRE_IO
  634.         IN(zBC, val)
  635.         WRITE_BYTE(zHL--, val)
  636. #if CZ80_EXACT
  637.         if ((((zC - 1) & 0xFF) + val) & 0x100)
  638.         {
  639.             F = CZ80_HF | CZ80_CF;
  640.             goto OP_INX;
  641.         }
  642.         F = 0;
  643. #endif
  644.         goto OP_INX;
  645.  
  646.     OPED(0xa2): // INI
  647.         PRE_IO
  648.         IN(zBC, val)
  649.         WRITE_BYTE(zHL++, val)
  650. #if CZ80_EXACT
  651.         if ((((zC + 1) & 0xFF) + val) & 0x100)
  652.         {
  653.             F = CZ80_HF | CZ80_CF;
  654.             goto OP_INX;
  655.         }
  656.         F = 0;
  657. #endif
  658.  
  659. OP_INX:
  660. #if CZ80_EXACT
  661.         // P FLAG isn't correct here !
  662.        zF = F | (SZXY[--zB] + ((val >> 6) & CZ80_NF) + (val & CZ80_PF));
  663. #else
  664.        zF = SZXY[--zB] + ((val >> 6) & CZ80_NF);
  665. #endif
  666.        POST_IO
  667.        RET(12)
  668.    }
  669.  
  670.    {
  671.        uint8_t val;
  672. #if CZ80_EXACT
  673.        uint8_t F;
  674. #endif
  675.  
  676.    OPED(0xba): // INDR
  677.        do
  678.        {
  679.            PRE_IO
  680.            IN(zBC, val)
  681.            WRITE_BYTE(zHL--, val)
  682.            POST_IO
  683.            zB--;
  684.            CCnt -= 21;
  685.        } while ((zB) && (CCnt > -4));
  686. #if CZ80_EXACT
  687.        if ((((zC - 1) & 0xFF) + val) & 0x100)
  688.        {
  689.            F = CZ80_HF | CZ80_CF;
  690.            goto OP_INXR;
  691.        }
  692.        F = 0;
  693. #endif
  694.        goto OP_INXR;
  695.  
  696.    OPED(0xb2): // INIR
  697.        do
  698.        {
  699.            PRE_IO
  700.            IN(zBC, val)
  701.            WRITE_BYTE(zHL++, val)
  702.            POST_IO
  703.            zB--;
  704.            CCnt -= 21;
  705.        } while ((zB) && (CCnt > -4));
  706. #if CZ80_EXACT
  707.        if ((((zC + 1) & 0xFF) + val) & 0x100)
  708.        {
  709.            F = CZ80_HF | CZ80_CF;
  710.            goto OP_INXR;
  711.        }
  712.        F = 0;
  713. #endif
  714.  
  715. OP_INXR:
  716. #if CZ80_EXACT
  717.        // P FLAG isn't correct here !
  718.         zF = F | (SZXY[zB] + ((val >> 6) & CZ80_NF) + (val & CZ80_PF));
  719. #else
  720.         zF = SZXY[zB] + ((val >> 6) & CZ80_NF);
  721. #endif
  722.  
  723.         if (zB)
  724.         {
  725.             // instruction not yet completed...
  726.             // we will continu it at next CZ80_Exec
  727.             zPC -= 2;
  728.             CCnt += 4;
  729.             goto Cz80_Exec_End;
  730.         }
  731.  
  732.         // instruction completed...
  733.         RET(-(5 + 4))
  734.     }
  735.  
  736.  
  737.     {
  738.         uint8_t val;
  739. #if CZ80_EXACT
  740.         uint8_t F;
  741. #endif
  742.  
  743.     OPED(0xab): // OUTD
  744.         PRE_IO
  745.         READ_BYTE(zHL--, val)
  746.         OUT(zBC, val)
  747.         goto OP_OUTX;
  748.  
  749.     OPED(0xa3): // OUTI
  750.         PRE_IO
  751.         READ_BYTE(zHL++, val)
  752.         OUT(zBC, val)
  753.  
  754. OP_OUTX:
  755. #if CZ80_EXACT
  756.         // P FLAG isn't correct here !
  757.        F = SZXY[--zB] + ((val >> 6) & CZ80_NF) + (val & CZ80_PF);
  758.        if ((val + zL) & 0x100) F |= CZ80_HF | CZ80_CF;
  759.        zF = F;
  760. #else
  761.        zF = SZXY[--zB] + ((val >> 6) & CZ80_NF);
  762. #endif
  763.        POST_IO
  764.        RET(12)
  765.    }
  766.  
  767.  
  768.    {
  769.        uint8_t val;
  770. #if CZ80_EXACT
  771.        uint8_t F;
  772. #endif
  773.  
  774.    OPED(0xbb): // OUTDR
  775.        do
  776.        {
  777.            PRE_IO
  778.            READ_BYTE(zHL--, val)
  779.            OUT(zBC, val)
  780.            POST_IO
  781.            zB--;
  782.            CCnt -= 21;
  783.        } while ((zB) && (CCnt > -4));
  784.        goto OP_OUTXR;
  785.  
  786.    OPED(0xb3): // OUTIR
  787.        do
  788.        {
  789.            PRE_IO
  790.            READ_BYTE(zHL++, val)
  791.            OUT(zBC, val)
  792.            POST_IO
  793.            zB--;
  794.            CCnt -= 21;
  795.        } while ((zB) && (CCnt > -4));
  796.  
  797. OP_OUTXR:
  798. #if CZ80_EXACT
  799.        // P FLAG isn't correct here !
  800.         F = SZXY[zB] + ((val >> 6) & CZ80_NF) + (val & CZ80_PF);
  801.         if ((val + zL) & 0x100) F |= CZ80_HF | CZ80_CF;
  802.         zF = F;
  803. #else
  804.         zF = SZXY[zB] + ((val >> 6) & CZ80_NF);
  805. #endif
  806.  
  807.         if (zB)
  808.         {
  809.             // instruction not yet completed...
  810.             // we will continu it at next CZ80_Exec
  811.             zPC -= 2;
  812.             CCnt += 4;
  813.             goto Cz80_Exec;
  814.         }
  815.  
  816.         // instruction not yet completed...
  817.         RET(-(5 + 4))
  818.     }
  819.  
  820. #if CZ80_USE_JUMPTABLE
  821. #else
  822. }
  823. #endif
  824.  
  825.