cpu/cz80/cz80_opED.c

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