Subversion Repositories pentevo

Rev

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

  1. #include "defs.h"
  2. #include "op_noprefix.h"
  3. #include "tables.h"
  4. /* CB opcodes */
  5.  
  6. //#ifdef Z80_COMMON
  7. static Z80OPCODE opl_00(Z80 *cpu) { // rlc b
  8.    cpu->f = rlcf[cpu->b];
  9.    cpu->b = rol[cpu->b];
  10. }
  11. static Z80OPCODE opl_01(Z80 *cpu) { // rlc c
  12.    cpu->f = rlcf[cpu->c];
  13.    cpu->c = rol[cpu->c];
  14. }
  15. static Z80OPCODE opl_02(Z80 *cpu) { // rlc d
  16.    cpu->f = rlcf[cpu->d];
  17.    cpu->d = rol[cpu->d];
  18. }
  19. static Z80OPCODE opl_03(Z80 *cpu) { // rlc e
  20.    cpu->f = rlcf[cpu->e];
  21.    cpu->e = rol[cpu->e];
  22. }
  23. static Z80OPCODE opl_04(Z80 *cpu) { // rlc h
  24.    cpu->f = rlcf[cpu->h];
  25.    cpu->h = rol[cpu->h];
  26. }
  27. static Z80OPCODE opl_05(Z80 *cpu) { // rlc l
  28.    cpu->f = rlcf[cpu->l];
  29.    cpu->l = rol[cpu->l];
  30. }
  31. //#endif
  32. //#ifndef Z80_COMMON
  33. static Z80OPCODE opl_06(Z80 *cpu) { // rlc (hl) | M:4 T:15(4, 4, 4, 3)
  34.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  35.    cpu->f = rlcf[t];
  36.    cpu->MemIf->wm(cpu->hl, rol[t]);
  37.    cpu->t += 7;
  38. }
  39. //#endif
  40. //#ifdef Z80_COMMON
  41. static Z80OPCODE opl_07(Z80 *cpu) { // rlc a
  42.    cpu->f = rlcf[cpu->a];
  43.    cpu->a = rol[cpu->a];
  44. }
  45. static Z80OPCODE opl_08(Z80 *cpu) { // rrc b
  46.    cpu->f = rrcf[cpu->b];
  47.    cpu->b = ror[cpu->b];
  48. }
  49. static Z80OPCODE opl_09(Z80 *cpu) { // rrc c
  50.    cpu->f = rrcf[cpu->c];
  51.    cpu->c = ror[cpu->c];
  52. }
  53. static Z80OPCODE opl_0A(Z80 *cpu) { // rrc d
  54.    cpu->f = rrcf[cpu->d];
  55.    cpu->d = ror[cpu->d];
  56. }
  57. static Z80OPCODE opl_0B(Z80 *cpu) { // rrc e
  58.    cpu->f = rrcf[cpu->e];
  59.    cpu->e = ror[cpu->e];
  60. }
  61. static Z80OPCODE opl_0C(Z80 *cpu) { // rrc h
  62.    cpu->f = rrcf[cpu->h];
  63.    cpu->h = ror[cpu->h];
  64. }
  65. static Z80OPCODE opl_0D(Z80 *cpu) { // rrc l
  66.    cpu->f = rrcf[cpu->l];
  67.    cpu->l = ror[cpu->l];
  68. }
  69. //#endif
  70. //#ifndef Z80_COMMON
  71. static Z80OPCODE opl_0E(Z80 *cpu) { // rrc (hl) | M:4 T:15 (4, 4, 4, 3)
  72.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  73.    cpu->f = rrcf[t];
  74.    cpu->MemIf->wm(cpu->hl, ror[t]);
  75.    cpu->t += 7;
  76. }
  77. //#endif
  78. //#ifdef Z80_COMMON
  79. static Z80OPCODE opl_0F(Z80 *cpu) { // rrc a
  80.    cpu->f = rrcf[cpu->a];
  81.    cpu->a = ror[cpu->a];
  82. }
  83. static Z80OPCODE opl_10(Z80 *cpu) { // rl b
  84.     if(cpu->f & CF)
  85.     {
  86.         cpu->f = rl1[cpu->b];
  87.         cpu->b = u8((cpu->b << 1) | 1);
  88.     }
  89.     else
  90.     {
  91.         cpu->f = rl0[cpu->b];
  92.         cpu->b = u8((cpu->b << 1));
  93.     }
  94. }
  95. static Z80OPCODE opl_11(Z80 *cpu) { // rl c
  96.     if(cpu->f & CF)
  97.     {
  98.         cpu->f = rl1[cpu->c];
  99.         cpu->c = u8((cpu->c << 1) | 1);
  100.     }
  101.     else
  102.     {
  103.         cpu->f = rl0[cpu->c];
  104.         cpu->c = u8(cpu->c << 1);
  105.     }
  106. }
  107. static Z80OPCODE opl_12(Z80 *cpu) { // rl d
  108.     if(cpu->f & CF)
  109.     {
  110.         cpu->f = rl1[cpu->d];
  111.         cpu->d = u8((cpu->d << 1) | 1);
  112.     }
  113.     else
  114.     {
  115.         cpu->f = rl0[cpu->d];
  116.         cpu->d = u8(cpu->d << 1);
  117.     }
  118. }
  119. static Z80OPCODE opl_13(Z80 *cpu) { // rl e
  120.     if(cpu->f & CF)
  121.     {
  122.         cpu->f = rl1[cpu->e];
  123.         cpu->e = u8((cpu->e << 1) | 1);
  124.     }
  125.     else
  126.     {
  127.         cpu->f = rl0[cpu->e];
  128.         cpu->e = u8(cpu->e << 1);
  129.     }
  130. }
  131. static Z80OPCODE opl_14(Z80 *cpu) { // rl h
  132.     if(cpu->f & CF)
  133.     {
  134.         cpu->f = rl1[cpu->h];
  135.         cpu->h = u8((cpu->h << 1) | 1);
  136.     }
  137.     else
  138.     {
  139.         cpu->f = rl0[cpu->h];
  140.         cpu->h = u8(cpu->h << 1);
  141.     }
  142. }
  143. static Z80OPCODE opl_15(Z80 *cpu) { // rl l
  144.     if(cpu->f & CF)
  145.     {
  146.         cpu->f = rl1[cpu->l];
  147.         cpu->l = u8((cpu->l << 1) | 1);
  148.     }
  149.    else
  150.    {
  151.        cpu->f = rl0[cpu->l];
  152.        cpu->l = u8(cpu->l << 1);
  153.    }
  154. }
  155. //#endif
  156. //#ifndef Z80_COMMON
  157. static Z80OPCODE opl_16(Z80 *cpu) { // rl (hl) | M:4 T:15(4, 4, 4, 3)
  158.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  159.    if(cpu->f & CF)
  160.    {
  161.        cpu->f = rl1[t];
  162.        t = u8((t << 1) | 1);
  163.    }
  164.    else
  165.    {
  166.        cpu->f = rl0[t];
  167.        t = u8(t << 1);
  168.    }
  169.    cpu->MemIf->wm(cpu->hl, t);
  170.    cpu->t += 7;
  171. }
  172. //#endif
  173. //#ifdef Z80_COMMON
  174. static Z80OPCODE opl_17(Z80 *cpu) { // rl a
  175.     if(cpu->f & CF)
  176.     {
  177.         cpu->f = rl1[cpu->a];
  178.         cpu->a = u8((cpu->a << 1) | 1);
  179.     }
  180.     else
  181.     {
  182.         cpu->f = rl0[cpu->a];
  183.         cpu->a = u8(cpu->a << 1);
  184.     }
  185. }
  186. static Z80OPCODE opl_18(Z80 *cpu) { // rr b
  187.     if(cpu->f & CF)
  188.     {
  189.         cpu->f = rr1[cpu->b];
  190.         cpu->b = (cpu->b >> 1) | 0x80;
  191.     }
  192.     else
  193.     {
  194.         cpu->f = rr0[cpu->b];
  195.         cpu->b = (cpu->b >> 1);
  196.     }
  197. }
  198. static Z80OPCODE opl_19(Z80 *cpu) { // rr c
  199.     if(cpu->f & CF)
  200.     {
  201.         cpu->f = rr1[cpu->c];
  202.         cpu->c = (cpu->c >> 1) | 0x80;
  203.     }
  204.     else
  205.     {
  206.         cpu->f = rr0[cpu->c];
  207.         cpu->c = (cpu->c >> 1);
  208.     }
  209. }
  210. static Z80OPCODE opl_1A(Z80 *cpu) { // rr d
  211.     if(cpu->f & CF)
  212.     {
  213.         cpu->f = rr1[cpu->d];
  214.         cpu->d = (cpu->d >> 1) | 0x80;
  215.     }
  216.     else
  217.     {
  218.         cpu->f = rr0[cpu->d];
  219.         cpu->d = (cpu->d >> 1);
  220.     }
  221. }
  222. static Z80OPCODE opl_1B(Z80 *cpu) { // rr e
  223.     if(cpu->f & CF)
  224.     {
  225.         cpu->f = rr1[cpu->e];
  226.         cpu->e = (cpu->e >> 1) | 0x80;
  227.     }
  228.     else
  229.     {
  230.         cpu->f = rr0[cpu->e];
  231.         cpu->e = (cpu->e >> 1);
  232.     }
  233. }
  234. static Z80OPCODE opl_1C(Z80 *cpu) { // rr h
  235.     if(cpu->f & CF)
  236.     {
  237.         cpu->f = rr1[cpu->h];
  238.         cpu->h = (cpu->h >> 1) | 0x80;
  239.     }
  240.     else
  241.     {
  242.         cpu->f = rr0[cpu->h];
  243.         cpu->h = (cpu->h >> 1);
  244.     }
  245. }
  246. static Z80OPCODE opl_1D(Z80 *cpu) { // rr l
  247.     if(cpu->f & CF)
  248.     {
  249.         cpu->f = rr1[cpu->l];
  250.         cpu->l = (cpu->l >> 1) | 0x80;
  251.     }
  252.     else
  253.     {
  254.         cpu->f = rr0[cpu->l];
  255.         cpu->l = (cpu->l >> 1);
  256.     }
  257. }
  258. //#endif
  259. //#ifndef Z80_COMMON
  260. static Z80OPCODE opl_1E(Z80 *cpu) { // rr (hl) | M:4 T:15 (4, 4, 4, 3)
  261.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  262.    if(cpu->f & CF)
  263.    {
  264.        cpu->f = rr1[t];
  265.        t = (t >> 1) | 0x80;
  266.    }
  267.    else
  268.    {
  269.        cpu->f = rr0[t];
  270.        t = (t >> 1);
  271.    }
  272.    cpu->MemIf->wm(cpu->hl, t);
  273.    cpu->t += 7;
  274. }
  275. //#endif
  276. //#ifdef Z80_COMMON
  277. static Z80OPCODE opl_1F(Z80 *cpu) { // rr a
  278.     if(cpu->f & CF)
  279.     {
  280.         cpu->f = rr1[cpu->a];
  281.         cpu->a = (cpu->a >> 1) | 0x80;
  282.     }
  283.     else
  284.     {
  285.         cpu->f = rr0[cpu->a];
  286.         cpu->a = (cpu->a >> 1);
  287.     }
  288. }
  289. static Z80OPCODE opl_20(Z80 *cpu) { // sla b
  290.     cpu->f = rl0[cpu->b];
  291.     cpu->b = u8(cpu->b << 1);
  292. }
  293. static Z80OPCODE opl_21(Z80 *cpu) { // sla c
  294.     cpu->f = rl0[cpu->c];
  295.     cpu->c = u8(cpu->c << 1);
  296. }
  297. static Z80OPCODE opl_22(Z80 *cpu) { // sla d
  298.     cpu->f = rl0[cpu->d];
  299.     cpu->d = u8(cpu->d << 1);
  300. }
  301. static Z80OPCODE opl_23(Z80 *cpu) { // sla e
  302.     cpu->f = rl0[cpu->e];
  303.     cpu->e = u8(cpu->e << 1);
  304. }
  305. static Z80OPCODE opl_24(Z80 *cpu) { // sla h
  306.     cpu->f = rl0[cpu->h];
  307.     cpu->h = u8(cpu->h << 1);
  308. }
  309. static Z80OPCODE opl_25(Z80 *cpu) { // sla l
  310.     cpu->f = rl0[cpu->l];
  311.     cpu->l = u8(cpu->l << 1);
  312. }
  313. //#endif
  314. //#ifndef Z80_COMMON
  315. static Z80OPCODE opl_26(Z80 *cpu) { // sla (hl) | M:4 T:15 (4, 4, 4, 3)
  316.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  317.    cpu->f = rl0[t];
  318.    t = u8(t << 1);
  319.    cpu->MemIf->wm(cpu->hl, t);
  320.    cpu->t += 7;
  321. }
  322. //#endif
  323. //#ifdef Z80_COMMON
  324. static Z80OPCODE opl_27(Z80 *cpu) { // sla a
  325.     cpu->f = rl0[cpu->a];
  326.     cpu->a = u8(cpu->a << 1);
  327. }
  328. static Z80OPCODE opl_28(Z80 *cpu) { // sra b
  329.     cpu->f = sraf[cpu->b];
  330.     cpu->b = (cpu->b >> 1) + (cpu->b & 0x80);
  331. }
  332. static Z80OPCODE opl_29(Z80 *cpu) { // sra c
  333.     cpu->f = sraf[cpu->c];
  334.     cpu->c = (cpu->c >> 1) + (cpu->c & 0x80);
  335. }
  336. static Z80OPCODE opl_2A(Z80 *cpu) { // sra d
  337.     cpu->f = sraf[cpu->d]; cpu->d = (cpu->d >> 1) + (cpu->d & 0x80);
  338. }
  339. static Z80OPCODE opl_2B(Z80 *cpu) { // sra e
  340.     cpu->f = sraf[cpu->e]; cpu->e = (cpu->e >> 1) + (cpu->e & 0x80);
  341. }
  342. static Z80OPCODE opl_2C(Z80 *cpu) { // sra h
  343.     cpu->f = sraf[cpu->h];
  344.     cpu->h = (cpu->h >> 1) + (cpu->h & 0x80);
  345. }
  346. static Z80OPCODE opl_2D(Z80 *cpu) { // sra l
  347.     cpu->f = sraf[cpu->l];
  348.     cpu->l = (cpu->l >> 1) + (cpu->l & 0x80);
  349. }
  350. //#endif
  351. //#ifndef Z80_COMMON
  352. static Z80OPCODE opl_2E(Z80 *cpu) { // sra (hl) | M:4 T:15 (4, 4, 4, 3)
  353.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  354.    cpu->f = sraf[t];
  355.    t = (t >> 1) + (t & 0x80);
  356.    cpu->MemIf->wm(cpu->hl, t);
  357.    cpu->t += 7;
  358. }
  359. //#endif
  360. //#ifdef Z80_COMMON
  361. static Z80OPCODE opl_2F(Z80 *cpu) { // sra a
  362.     cpu->f = sraf[cpu->a];
  363.     cpu->a = (cpu->a >> 1) + (cpu->a & 0x80);
  364. }
  365. static Z80OPCODE opl_30(Z80 *cpu) { // sli b
  366.     cpu->f = rl1[cpu->b];
  367.     cpu->b = u8((cpu->b << 1) | 1);
  368. }
  369. static Z80OPCODE opl_31(Z80 *cpu) { // sli c
  370.     cpu->f = rl1[cpu->c];
  371.     cpu->c = u8((cpu->c << 1) | 1);
  372. }
  373. static Z80OPCODE opl_32(Z80 *cpu) { // sli d
  374.     cpu->f = rl1[cpu->d];
  375.     cpu->d = u8((cpu->d << 1) | 1);
  376. }
  377. static Z80OPCODE opl_33(Z80 *cpu) { // sli e
  378.     cpu->f = rl1[cpu->e];
  379.     cpu->e = u8((cpu->e << 1) | 1);
  380. }
  381. static Z80OPCODE opl_34(Z80 *cpu) { // sli h
  382.     cpu->f = rl1[cpu->h];
  383.     cpu->h = u8((cpu->h << 1) | 1);
  384. }
  385. static Z80OPCODE opl_35(Z80 *cpu) { // sli l
  386.     cpu->f = rl1[cpu->l];
  387.     cpu->l = u8((cpu->l << 1) | 1);
  388. }
  389. //#endif
  390. //#ifndef Z80_COMMON
  391. static Z80OPCODE opl_36(Z80 *cpu) { // sli (hl)
  392.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  393.    cpu->f = rl1[t];
  394.    t = u8((t << 1) | 1);
  395.    cpu->MemIf->wm(cpu->hl, t);
  396.    cpu->t += 7;
  397. }
  398. //#endif
  399. //#ifdef Z80_COMMON
  400. static Z80OPCODE opl_37(Z80 *cpu) { // sli a
  401.     cpu->f = rl1[cpu->a];
  402.     cpu->a = u8((cpu->a << 1) | 1);
  403. }
  404. static Z80OPCODE opl_38(Z80 *cpu) { // srl b
  405.     cpu->f = rr0[cpu->b];
  406.     cpu->b = (cpu->b >> 1);
  407. }
  408. static Z80OPCODE opl_39(Z80 *cpu) { // srl c
  409.     cpu->f = rr0[cpu->c];
  410.     cpu->c = (cpu->c >> 1);
  411. }
  412. static Z80OPCODE opl_3A(Z80 *cpu) { // srl d
  413.     cpu->f = rr0[cpu->d];
  414.     cpu->d = (cpu->d >> 1);
  415. }
  416. static Z80OPCODE opl_3B(Z80 *cpu) { // srl e
  417.     cpu->f = rr0[cpu->e];
  418.     cpu->e = (cpu->e >> 1);
  419. }
  420. static Z80OPCODE opl_3C(Z80 *cpu) { // srl h
  421.     cpu->f = rr0[cpu->h];
  422.     cpu->h = (cpu->h >> 1);
  423. }
  424. static Z80OPCODE opl_3D(Z80 *cpu) { // srl l
  425.     cpu->f = rr0[cpu->l];
  426.     cpu->l = (cpu->l >> 1);
  427. }
  428. //#endif
  429. //#ifndef Z80_COMMON
  430. static Z80OPCODE opl_3E(Z80 *cpu) { // srl (hl) | M:4 T:15 (4, 4, 4, 3)
  431.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  432.    cpu->f = rr0[t];
  433.    t = (t >> 1);
  434.    cpu->MemIf->wm(cpu->hl, t);
  435.    cpu->t += 7;
  436. }
  437. //#endif
  438. //#ifdef Z80_COMMON
  439. static Z80OPCODE opl_3F(Z80 *cpu) { // srl a
  440.     cpu->f = rr0[cpu->a];
  441.     cpu->a = (cpu->a >> 1);
  442. }
  443. static Z80OPCODE opl_40(Z80 *cpu) { // bit 0,b
  444.    bit(cpu, cpu->b, 0);
  445. }
  446. static Z80OPCODE opl_41(Z80 *cpu) { // bit 0,c
  447.    bit(cpu, cpu->c, 0);
  448. }
  449. static Z80OPCODE opl_42(Z80 *cpu) { // bit 0,d
  450.    bit(cpu, cpu->d, 0);
  451. }
  452. static Z80OPCODE opl_43(Z80 *cpu) { // bit 0,e
  453.    bit(cpu, cpu->e, 0);
  454. }
  455. static Z80OPCODE opl_44(Z80 *cpu) { // bit 0,h
  456.    bit(cpu, cpu->h, 0);
  457. }
  458. static Z80OPCODE opl_45(Z80 *cpu) { // bit 0,l
  459.    bit(cpu, cpu->l, 0);
  460. }
  461. //#endif
  462. //#ifndef Z80_COMMON
  463. static Z80OPCODE opl_46(Z80 *cpu) { // bit 0,(hl)
  464.    bitmem(cpu, cpu->MemIf->rm(cpu->hl), 0);
  465.    cpu->t += 4;
  466. }
  467. //#endif
  468. //#ifdef Z80_COMMON
  469. static Z80OPCODE opl_47(Z80 *cpu) { // bit 0,a
  470.    bit(cpu, cpu->a, 0);
  471. }
  472. static Z80OPCODE opl_48(Z80 *cpu) { // bit 1,b
  473.    bit(cpu, cpu->b, 1);
  474. }
  475. static Z80OPCODE opl_49(Z80 *cpu) { // bit 1,c
  476.    bit(cpu, cpu->c, 1);
  477. }
  478. static Z80OPCODE opl_4A(Z80 *cpu) { // bit 1,d
  479.    bit(cpu, cpu->d, 1);
  480. }
  481. static Z80OPCODE opl_4B(Z80 *cpu) { // bit 1,e
  482.    bit(cpu, cpu->e, 1);
  483. }
  484. static Z80OPCODE opl_4C(Z80 *cpu) { // bit 1,h
  485.    bit(cpu, cpu->h, 1);
  486. }
  487. static Z80OPCODE opl_4D(Z80 *cpu) { // bit 1,l
  488.    bit(cpu, cpu->l, 1);
  489. }
  490. //#endif
  491. //#ifndef Z80_COMMON
  492. static Z80OPCODE opl_4E(Z80 *cpu) { // bit 1,(hl)
  493.    bitmem(cpu, cpu->MemIf->rm(cpu->hl), 1);
  494.    cpu->t += 4;
  495. }
  496. //#endif
  497. //#ifdef Z80_COMMON
  498. static Z80OPCODE opl_4F(Z80 *cpu) { // bit 1,a
  499.    bit(cpu, cpu->a, 1);
  500. }
  501. static Z80OPCODE opl_50(Z80 *cpu) { // bit 2,b
  502.    bit(cpu, cpu->b, 2);
  503. }
  504. static Z80OPCODE opl_51(Z80 *cpu) { // bit 2,c
  505.    bit(cpu, cpu->c, 2);
  506. }
  507. static Z80OPCODE opl_52(Z80 *cpu) { // bit 2,d
  508.    bit(cpu, cpu->d, 2);
  509. }
  510. static Z80OPCODE opl_53(Z80 *cpu) { // bit 2,e
  511.    bit(cpu, cpu->e, 2);
  512. }
  513. static Z80OPCODE opl_54(Z80 *cpu) { // bit 2,h
  514.    bit(cpu, cpu->h, 2);
  515. }
  516. static Z80OPCODE opl_55(Z80 *cpu) { // bit 2,l
  517.    bit(cpu, cpu->l, 2);
  518. }
  519. //#endif
  520. //#ifndef Z80_COMMON
  521. static Z80OPCODE opl_56(Z80 *cpu) { // bit 2,(hl)
  522.    bitmem(cpu, cpu->MemIf->rm(cpu->hl), 2);
  523.    cpu->t += 4;
  524. }
  525. //#endif
  526. //#ifdef Z80_COMMON
  527. static Z80OPCODE opl_57(Z80 *cpu) { // bit 2,a
  528.    bit(cpu, cpu->a, 2);
  529. }
  530. static Z80OPCODE opl_58(Z80 *cpu) { // bit 3,b
  531.    bit(cpu, cpu->b, 3);
  532. }
  533. static Z80OPCODE opl_59(Z80 *cpu) { // bit 3,c
  534.    bit(cpu, cpu->c, 3);
  535. }
  536. static Z80OPCODE opl_5A(Z80 *cpu) { // bit 3,d
  537.    bit(cpu, cpu->d, 3);
  538. }
  539. static Z80OPCODE opl_5B(Z80 *cpu) { // bit 3,e
  540.    bit(cpu, cpu->e, 3);
  541. }
  542. static Z80OPCODE opl_5C(Z80 *cpu) { // bit 3,h
  543.    bit(cpu, cpu->h, 3);
  544. }
  545. static Z80OPCODE opl_5D(Z80 *cpu) { // bit 3,l
  546.    bit(cpu, cpu->l, 3);
  547. }
  548. //#endif
  549. //#ifndef Z80_COMMON
  550. static Z80OPCODE opl_5E(Z80 *cpu) { // bit 3,(hl)
  551.    bitmem(cpu, cpu->MemIf->rm(cpu->hl), 3);
  552.    cpu->t += 4;
  553. }
  554. //#endif
  555. //#ifdef Z80_COMMON
  556. static Z80OPCODE opl_5F(Z80 *cpu) { // bit 3,a
  557.    bit(cpu, cpu->a, 3);
  558. }
  559. static Z80OPCODE opl_60(Z80 *cpu) { // bit 4,b
  560.    bit(cpu, cpu->b, 4);
  561. }
  562. static Z80OPCODE opl_61(Z80 *cpu) { // bit 4,c
  563.    bit(cpu, cpu->c, 4);
  564. }
  565. static Z80OPCODE opl_62(Z80 *cpu) { // bit 4,d
  566.    bit(cpu, cpu->d, 4);
  567. }
  568. static Z80OPCODE opl_63(Z80 *cpu) { // bit 4,e
  569.    bit(cpu, cpu->e, 4);
  570. }
  571. static Z80OPCODE opl_64(Z80 *cpu) { // bit 4,h
  572.    bit(cpu, cpu->h, 4);
  573. }
  574. static Z80OPCODE opl_65(Z80 *cpu) { // bit 4,l
  575.    bit(cpu, cpu->l, 4);
  576. }
  577. //#endif
  578. //#ifndef Z80_COMMON
  579. static Z80OPCODE opl_66(Z80 *cpu) { // bit 4,(hl)
  580.    bitmem(cpu, cpu->MemIf->rm(cpu->hl), 4);
  581.    cpu->t += 4;
  582. }
  583. //#endif
  584. //#ifdef Z80_COMMON
  585. static Z80OPCODE opl_67(Z80 *cpu) { // bit 4,a
  586.    bit(cpu, cpu->a, 4);
  587. }
  588. static Z80OPCODE opl_68(Z80 *cpu) { // bit 5,b
  589.    bit(cpu, cpu->b, 5);
  590. }
  591. static Z80OPCODE opl_69(Z80 *cpu) { // bit 5,c
  592.    bit(cpu, cpu->c, 5);
  593. }
  594. static Z80OPCODE opl_6A(Z80 *cpu) { // bit 5,d
  595.    bit(cpu, cpu->d, 5);
  596. }
  597. static Z80OPCODE opl_6B(Z80 *cpu) { // bit 5,e
  598.    bit(cpu, cpu->e, 5);
  599. }
  600. static Z80OPCODE opl_6C(Z80 *cpu) { // bit 5,h
  601.    bit(cpu, cpu->h, 5);
  602. }
  603. static Z80OPCODE opl_6D(Z80 *cpu) { // bit 5,l
  604.    bit(cpu, cpu->l, 5);
  605. }
  606. //#endif
  607. //#ifndef Z80_COMMON
  608. static Z80OPCODE opl_6E(Z80 *cpu) { // bit 5,(hl)
  609.    bitmem(cpu, cpu->MemIf->rm(cpu->hl), 5);
  610.    cpu->t += 4;
  611. }
  612. //#endif
  613. //#ifdef Z80_COMMON
  614. static Z80OPCODE opl_6F(Z80 *cpu) { // bit 5,a
  615.    bit(cpu, cpu->a, 5);
  616. }
  617. static Z80OPCODE opl_70(Z80 *cpu) { // bit 6,b
  618.    bit(cpu, cpu->b, 6);
  619. }
  620. static Z80OPCODE opl_71(Z80 *cpu) { // bit 6,c
  621.    bit(cpu, cpu->c, 6);
  622. }
  623. static Z80OPCODE opl_72(Z80 *cpu) { // bit 6,d
  624.    bit(cpu, cpu->d, 6);
  625. }
  626. static Z80OPCODE opl_73(Z80 *cpu) { // bit 6,e
  627.    bit(cpu, cpu->e, 6);
  628. }
  629. static Z80OPCODE opl_74(Z80 *cpu) { // bit 6,h
  630.    bit(cpu, cpu->h, 6);
  631. }
  632. static Z80OPCODE opl_75(Z80 *cpu) { // bit 6,l
  633.    bit(cpu, cpu->l, 6);
  634. }
  635. //#endif
  636. //#ifndef Z80_COMMON
  637. static Z80OPCODE opl_76(Z80 *cpu) { // bit 6,(hl)
  638.    bitmem(cpu, cpu->MemIf->rm(cpu->hl), 6);
  639.    cpu->t += 4;
  640. }
  641. //#endif
  642. //#ifdef Z80_COMMON
  643. static Z80OPCODE opl_77(Z80 *cpu) { // bit 6,a
  644.    bit(cpu, cpu->a, 6);
  645. }
  646. static Z80OPCODE opl_78(Z80 *cpu) { // bit 7,b
  647.    bit(cpu, cpu->b, 7);
  648. }
  649. static Z80OPCODE opl_79(Z80 *cpu) { // bit 7,c
  650.    bit(cpu, cpu->c, 7);
  651. }
  652. static Z80OPCODE opl_7A(Z80 *cpu) { // bit 7,d
  653.    bit(cpu, cpu->d, 7);
  654. }
  655. static Z80OPCODE opl_7B(Z80 *cpu) { // bit 7,e
  656.    bit(cpu, cpu->e, 7);
  657. }
  658. static Z80OPCODE opl_7C(Z80 *cpu) { // bit 7,h
  659.    bit(cpu, cpu->h, 7);
  660. }
  661. static Z80OPCODE opl_7D(Z80 *cpu) { // bit 7,l
  662.    bit(cpu, cpu->l, 7);
  663. }
  664. //#endif
  665. //#ifndef Z80_COMMON
  666. static Z80OPCODE opl_7E(Z80 *cpu) { // bit 7,(hl)
  667.    bitmem(cpu, cpu->MemIf->rm(cpu->hl), 7);
  668.    cpu->t += 4;
  669. }
  670. //#endif
  671. //#ifdef Z80_COMMON
  672. static Z80OPCODE opl_7F(Z80 *cpu) { // bit 7,a
  673.    bit(cpu, cpu->a, 7);
  674. }
  675. static Z80OPCODE opl_80(Z80 *cpu) { // res 0,b
  676.    res(cpu->b, 0);
  677. }
  678. static Z80OPCODE opl_81(Z80 *cpu) { // res 0,c
  679.    res(cpu->c, 0);
  680. }
  681. static Z80OPCODE opl_82(Z80 *cpu) { // res 0,d
  682.    res(cpu->d, 0);
  683. }
  684. static Z80OPCODE opl_83(Z80 *cpu) { // res 0,e
  685.    res(cpu->e, 0);
  686. }
  687. static Z80OPCODE opl_84(Z80 *cpu) { // res 0,h
  688.    res(cpu->h, 0);
  689. }
  690. static Z80OPCODE opl_85(Z80 *cpu) { // res 0,l
  691.    res(cpu->l, 0);
  692. }
  693. //#endif
  694. //#ifndef Z80_COMMON
  695. static Z80OPCODE opl_86(Z80 *cpu) { // res 0,(hl) | M:4 T:15 (4, 4, 4, 3)
  696.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  697.    res(t, 0);
  698.    cpu->MemIf->wm(cpu->hl, t);
  699.    cpu->t += 7;
  700. }
  701. //#endif
  702. //#ifdef Z80_COMMON
  703. static Z80OPCODE opl_87(Z80 *cpu) { // res 0,a
  704.    res(cpu->a, 0);
  705. }
  706. static Z80OPCODE opl_88(Z80 *cpu) { // res 1,b
  707.    res(cpu->b, 1);
  708. }
  709. static Z80OPCODE opl_89(Z80 *cpu) { // res 1,c
  710.    res(cpu->c, 1);
  711. }
  712. static Z80OPCODE opl_8A(Z80 *cpu) { // res 1,d
  713.    res(cpu->d, 1);
  714. }
  715. static Z80OPCODE opl_8B(Z80 *cpu) { // res 1,e
  716.    res(cpu->e, 1);
  717. }
  718. static Z80OPCODE opl_8C(Z80 *cpu) { // res 1,h
  719.    res(cpu->h, 1);
  720. }
  721. static Z80OPCODE opl_8D(Z80 *cpu) { // res 1,l
  722.    res(cpu->l, 1);
  723. }
  724. //#endif
  725. //#ifndef Z80_COMMON
  726. static Z80OPCODE opl_8E(Z80 *cpu) { // res 1,(hl) | M:4 T:15 (4, 4, 4, 3)
  727.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  728.    res(t, 1);
  729.    cpu->MemIf->wm(cpu->hl, t);
  730.    cpu->t += 7;
  731. }
  732. //#endif
  733. //#ifdef Z80_COMMON
  734. static Z80OPCODE opl_8F(Z80 *cpu) { // res 1,a
  735.    res(cpu->a, 1);
  736. }
  737. static Z80OPCODE opl_90(Z80 *cpu) { // res 2,b
  738.    res(cpu->b, 2);
  739. }
  740. static Z80OPCODE opl_91(Z80 *cpu) { // res 2,c
  741.    res(cpu->c, 2);
  742. }
  743. static Z80OPCODE opl_92(Z80 *cpu) { // res 2,d
  744.    res(cpu->d, 2);
  745. }
  746. static Z80OPCODE opl_93(Z80 *cpu) { // res 2,e
  747.    res(cpu->e, 2);
  748. }
  749. static Z80OPCODE opl_94(Z80 *cpu) { // res 2,h
  750.    res(cpu->h, 2);
  751. }
  752. static Z80OPCODE opl_95(Z80 *cpu) { // res 2,l
  753.    res(cpu->l, 2);
  754. }
  755. //#endif
  756. //#ifndef Z80_COMMON
  757. static Z80OPCODE opl_96(Z80 *cpu) { // res 2,(hl) | M:4 T:15 (4, 4, 4, 3)
  758.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  759.    res(t, 2);
  760.    cpu->MemIf->wm(cpu->hl, t);
  761.    cpu->t += 7;
  762. }
  763. //#endif
  764. //#ifdef Z80_COMMON
  765. static Z80OPCODE opl_97(Z80 *cpu) { // res 2,a
  766.    res(cpu->a, 2);
  767. }
  768. static Z80OPCODE opl_98(Z80 *cpu) { // res 3,b
  769.    res(cpu->b, 3);
  770. }
  771. static Z80OPCODE opl_99(Z80 *cpu) { // res 3,c
  772.    res(cpu->c, 3);
  773. }
  774. static Z80OPCODE opl_9A(Z80 *cpu) { // res 3,d
  775.    res(cpu->d, 3);
  776. }
  777. static Z80OPCODE opl_9B(Z80 *cpu) { // res 3,e
  778.    res(cpu->e, 3);
  779. }
  780. static Z80OPCODE opl_9C(Z80 *cpu) { // res 3,h
  781.    res(cpu->h, 3);
  782. }
  783. static Z80OPCODE opl_9D(Z80 *cpu) { // res 3,l
  784.    res(cpu->l, 3);
  785. }
  786. //#endif
  787. //#ifndef Z80_COMMON
  788. static Z80OPCODE opl_9E(Z80 *cpu) { // res 3,(hl) | M:4 T:15 (4, 4, 4, 3)
  789.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  790.    res(t, 3);
  791.    cpu->MemIf->wm(cpu->hl, t);
  792.    cpu->t += 7;
  793. }
  794. //#endif
  795. //#ifdef Z80_COMMON
  796. static Z80OPCODE opl_9F(Z80 *cpu) { // res 3,a
  797.    res(cpu->a, 3);
  798. }
  799. static Z80OPCODE opl_A0(Z80 *cpu) { // res 4,b
  800.    res(cpu->b, 4);
  801. }
  802. static Z80OPCODE opl_A1(Z80 *cpu) { // res 4,c
  803.    res(cpu->c, 4);
  804. }
  805. static Z80OPCODE opl_A2(Z80 *cpu) { // res 4,d
  806.    res(cpu->d, 4);
  807. }
  808. static Z80OPCODE opl_A3(Z80 *cpu) { // res 4,e
  809.    res(cpu->e, 4);
  810. }
  811. static Z80OPCODE opl_A4(Z80 *cpu) { // res 4,h
  812.    res(cpu->h, 4);
  813. }
  814. static Z80OPCODE opl_A5(Z80 *cpu) { // res 4,l
  815.    res(cpu->l, 4);
  816. }
  817. //#endif
  818. //#ifndef Z80_COMMON
  819. static Z80OPCODE opl_A6(Z80 *cpu) { // res 4,(hl) | M:4 T:15 (4, 4, 4, 3)
  820.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  821.    res(t, 4);
  822.    cpu->MemIf->wm(cpu->hl, t);
  823.    cpu->t += 7;
  824. }
  825. //#endif
  826. //#ifdef Z80_COMMON
  827. static Z80OPCODE opl_A7(Z80 *cpu) { // res 4,a
  828.    res(cpu->a, 4);
  829. }
  830. static Z80OPCODE opl_A8(Z80 *cpu) { // res 5,b
  831.    res(cpu->b, 5);
  832. }
  833. static Z80OPCODE opl_A9(Z80 *cpu) { // res 5,c
  834.    res(cpu->c, 5);
  835. }
  836. static Z80OPCODE opl_AA(Z80 *cpu) { // res 5,d
  837.    res(cpu->d, 5);
  838. }
  839. static Z80OPCODE opl_AB(Z80 *cpu) { // res 5,e
  840.    res(cpu->e, 5);
  841. }
  842. static Z80OPCODE opl_AC(Z80 *cpu) { // res 5,h
  843.    res(cpu->h, 5);
  844. }
  845. static Z80OPCODE opl_AD(Z80 *cpu) { // res 5,l
  846.    res(cpu->l, 5);
  847. }
  848. //#endif
  849. //#ifndef Z80_COMMON
  850. static Z80OPCODE opl_AE(Z80 *cpu) { // res 5,(hl) | M:4 T:15 (4, 4, 4, 3)
  851.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  852.    res(t, 5);
  853.    cpu->MemIf->wm(cpu->hl, t);
  854.    cpu->t += 7;
  855. }
  856. //#endif
  857. //#ifdef Z80_COMMON
  858. static Z80OPCODE opl_AF(Z80 *cpu) { // res 5,a
  859.    res(cpu->a, 5);
  860. }
  861. static Z80OPCODE opl_B0(Z80 *cpu) { // res 6,b
  862.    res(cpu->b, 6);
  863. }
  864. static Z80OPCODE opl_B1(Z80 *cpu) { // res 6,c
  865.    res(cpu->c, 6);
  866. }
  867. static Z80OPCODE opl_B2(Z80 *cpu) { // res 6,d
  868.    res(cpu->d, 6);
  869. }
  870. static Z80OPCODE opl_B3(Z80 *cpu) { // res 6,e
  871.    res(cpu->e, 6);
  872. }
  873. static Z80OPCODE opl_B4(Z80 *cpu) { // res 6,h
  874.    res(cpu->h, 6);
  875. }
  876. static Z80OPCODE opl_B5(Z80 *cpu) { // res 6,l
  877.    res(cpu->l, 6);
  878. }
  879. //#endif
  880. //#ifndef Z80_COMMON
  881. static Z80OPCODE opl_B6(Z80 *cpu) { // res 6,(hl) | M:4 T:15 (4, 4, 4, 3)
  882.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  883.    res(t, 6);
  884.    cpu->MemIf->wm(cpu->hl, t);
  885.    cpu->t += 7;
  886. }
  887. //#endif
  888. //#ifdef Z80_COMMON
  889. static Z80OPCODE opl_B7(Z80 *cpu) { // res 6,a
  890.    res(cpu->a, 6);
  891. }
  892. static Z80OPCODE opl_B8(Z80 *cpu) { // res 7,b
  893.    res(cpu->b, 7);
  894. }
  895. static Z80OPCODE opl_B9(Z80 *cpu) { // res 7,c
  896.    res(cpu->c, 7);
  897. }
  898. static Z80OPCODE opl_BA(Z80 *cpu) { // res 7,d
  899.    res(cpu->d, 7);
  900. }
  901. static Z80OPCODE opl_BB(Z80 *cpu) { // res 7,e
  902.    res(cpu->e, 7);
  903. }
  904. static Z80OPCODE opl_BC(Z80 *cpu) { // res 7,h
  905.    res(cpu->h, 7);
  906. }
  907. static Z80OPCODE opl_BD(Z80 *cpu) { // res 7,l
  908.    res(cpu->l, 7);
  909. }
  910. //#endif
  911. //#ifndef Z80_COMMON
  912. static Z80OPCODE opl_BE(Z80 *cpu) { // res 7,(hl) | M:4 T:15 (4, 4, 4, 3)
  913.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  914.    res(t, 7);
  915.    cpu->MemIf->wm(cpu->hl, t);
  916.    cpu->t += 7;
  917. }
  918. //#endif
  919. //#ifdef Z80_COMMON
  920. static Z80OPCODE opl_BF(Z80 *cpu) { // res 7,a
  921.    res(cpu->a, 7);
  922. }
  923. static Z80OPCODE opl_C0(Z80 *cpu) { // set 0,b
  924.    set(cpu->b, 0);
  925. }
  926. static Z80OPCODE opl_C1(Z80 *cpu) { // set 0,c
  927.    set(cpu->c, 0);
  928. }
  929. static Z80OPCODE opl_C2(Z80 *cpu) { // set 0,d
  930.    set(cpu->d, 0);
  931. }
  932. static Z80OPCODE opl_C3(Z80 *cpu) { // set 0,e
  933.    set(cpu->e, 0);
  934. }
  935. static Z80OPCODE opl_C4(Z80 *cpu) { // set 0,h
  936.    set(cpu->h, 0);
  937. }
  938. static Z80OPCODE opl_C5(Z80 *cpu) { // set 0,l
  939.    set(cpu->l, 0);
  940. }
  941. //#endif
  942. //#ifndef Z80_COMMON
  943. static Z80OPCODE opl_C6(Z80 *cpu) { // set 0,(hl) | M:4 T:15 (4, 4, 4, 3)
  944.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  945.    set(t, 0);
  946.    cpu->MemIf->wm(cpu->hl, t);
  947.    cpu->t += 7;
  948. }
  949. //#endif
  950. //#ifdef Z80_COMMON
  951. static Z80OPCODE opl_C7(Z80 *cpu) { // set 0,a
  952.    set(cpu->a, 0);
  953. }
  954. static Z80OPCODE opl_C8(Z80 *cpu) { // set 1,b
  955.    set(cpu->b, 1);
  956. }
  957. static Z80OPCODE opl_C9(Z80 *cpu) { // set 1,c
  958.    set(cpu->c, 1);
  959. }
  960. static Z80OPCODE opl_CA(Z80 *cpu) { // set 1,d
  961.    set(cpu->d, 1);
  962. }
  963. static Z80OPCODE opl_CB(Z80 *cpu) { // set 1,e
  964.    set(cpu->e, 1);
  965. }
  966. static Z80OPCODE opl_CC(Z80 *cpu) { // set 1,h
  967.    set(cpu->h, 1);
  968. }
  969. static Z80OPCODE opl_CD(Z80 *cpu) { // set 1,l
  970.    set(cpu->l, 1);
  971. }
  972. //#endif
  973. //#ifndef Z80_COMMON
  974. static Z80OPCODE opl_CE(Z80 *cpu) { // set 1,(hl) | M:4 T:15 (4, 4, 4, 3)
  975.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  976.    set(t, 1);
  977.    cpu->MemIf->wm(cpu->hl, t);
  978.    cpu->t += 7;
  979. }
  980. //#endif
  981. //#ifdef Z80_COMMON
  982. static Z80OPCODE opl_CF(Z80 *cpu) { // set 1,a
  983.    set(cpu->a, 1);
  984. }
  985. static Z80OPCODE opl_D0(Z80 *cpu) { // set 2,b
  986.    set(cpu->b, 2);
  987. }
  988. static Z80OPCODE opl_D1(Z80 *cpu) { // set 2,c
  989.    set(cpu->c, 2);
  990. }
  991. static Z80OPCODE opl_D2(Z80 *cpu) { // set 2,d
  992.    set(cpu->d, 2);
  993. }
  994. static Z80OPCODE opl_D3(Z80 *cpu) { // set 2,e
  995.    set(cpu->e, 2);
  996. }
  997. static Z80OPCODE opl_D4(Z80 *cpu) { // set 2,h
  998.    set(cpu->h, 2);
  999. }
  1000. static Z80OPCODE opl_D5(Z80 *cpu) { // set 2,l
  1001.    set(cpu->l, 2);
  1002. }
  1003. //#endif
  1004. //#ifndef Z80_COMMON
  1005. static Z80OPCODE opl_D6(Z80 *cpu) { // set 2,(hl) | M:4 T:15 (4, 4, 4, 3)
  1006.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  1007.    set(t, 2);
  1008.    cpu->MemIf->wm(cpu->hl, t);
  1009.    cpu->t += 7;
  1010. }
  1011. //#endif
  1012. //#ifdef Z80_COMMON
  1013. static Z80OPCODE opl_D7(Z80 *cpu) { // set 2,a
  1014.    set(cpu->a, 2);
  1015. }
  1016. static Z80OPCODE opl_D8(Z80 *cpu) { // set 3,b
  1017.    set(cpu->b, 3);
  1018. }
  1019. static Z80OPCODE opl_D9(Z80 *cpu) { // set 3,c
  1020.    set(cpu->c, 3);
  1021. }
  1022. static Z80OPCODE opl_DA(Z80 *cpu) { // set 3,d
  1023.    set(cpu->d, 3);
  1024. }
  1025. static Z80OPCODE opl_DB(Z80 *cpu) { // set 3,e
  1026.    set(cpu->e, 3);
  1027. }
  1028. static Z80OPCODE opl_DC(Z80 *cpu) { // set 3,h
  1029.    set(cpu->h, 3);
  1030. }
  1031. static Z80OPCODE opl_DD(Z80 *cpu) { // set 3,l
  1032.    set(cpu->l, 3);
  1033. }
  1034. //#endif
  1035. //#ifndef Z80_COMMON
  1036. static Z80OPCODE opl_DE(Z80 *cpu) { // set 3,(hl) | M:4 T:15 (4, 4, 4, 3)
  1037.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  1038.    set(t, 3);
  1039.    cpu->MemIf->wm(cpu->hl, t);
  1040.    cpu->t += 7;
  1041. }
  1042. //#endif
  1043. //#ifdef Z80_COMMON
  1044. static Z80OPCODE opl_DF(Z80 *cpu) { // set 3,a
  1045.    set(cpu->a, 3);
  1046. }
  1047. static Z80OPCODE opl_E0(Z80 *cpu) { // set 4,b
  1048.    set(cpu->b, 4);
  1049. }
  1050. static Z80OPCODE opl_E1(Z80 *cpu) { // set 4,c
  1051.    set(cpu->c, 4);
  1052. }
  1053. static Z80OPCODE opl_E2(Z80 *cpu) { // set 4,d
  1054.    set(cpu->d, 4);
  1055. }
  1056. static Z80OPCODE opl_E3(Z80 *cpu) { // set 4,e
  1057.    set(cpu->e, 4);
  1058. }
  1059. static Z80OPCODE opl_E4(Z80 *cpu) { // set 4,h
  1060.    set(cpu->h, 4);
  1061. }
  1062. static Z80OPCODE opl_E5(Z80 *cpu) { // set 4,l
  1063.    set(cpu->l, 4);
  1064. }
  1065. //#endif
  1066. //#ifndef Z80_COMMON
  1067. static Z80OPCODE opl_E6(Z80 *cpu) { // set 4,(hl) | M:4 T:15 (4, 4, 4, 3)
  1068.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  1069.    set(t, 4);
  1070.    cpu->MemIf->wm(cpu->hl, t);
  1071.    cpu->t += 7;
  1072. }
  1073. //#endif
  1074. //#ifdef Z80_COMMON
  1075. static Z80OPCODE opl_E7(Z80 *cpu) { // set 4,a
  1076.    set(cpu->a, 4);
  1077. }
  1078. static Z80OPCODE opl_E8(Z80 *cpu) { // set 5,b
  1079.    set(cpu->b, 5);
  1080. }
  1081. static Z80OPCODE opl_E9(Z80 *cpu) { // set 5,c
  1082.    set(cpu->c, 5);
  1083. }
  1084. static Z80OPCODE opl_EA(Z80 *cpu) { // set 5,d
  1085.    set(cpu->d, 5);
  1086. }
  1087. static Z80OPCODE opl_EB(Z80 *cpu) { // set 5,e
  1088.    set(cpu->e, 5);
  1089. }
  1090. static Z80OPCODE opl_EC(Z80 *cpu) { // set 5,h
  1091.    set(cpu->h, 5);
  1092. }
  1093. static Z80OPCODE opl_ED(Z80 *cpu) { // set 5,l
  1094.    set(cpu->l, 5);
  1095. }
  1096. //#endif
  1097. //#ifndef Z80_COMMON
  1098. static Z80OPCODE opl_EE(Z80 *cpu) { // set 5,(hl) | M:4 T:15 (4, 4, 4, 3)
  1099.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  1100.    set(t, 5);
  1101.    cpu->MemIf->wm(cpu->hl, t);
  1102.    cpu->t += 7;
  1103. }
  1104. //#endif
  1105. //#ifdef Z80_COMMON
  1106. static Z80OPCODE opl_EF(Z80 *cpu) { // set 5,a
  1107.    set(cpu->a, 5);
  1108. }
  1109. static Z80OPCODE opl_F0(Z80 *cpu) { // set 6,b
  1110.    set(cpu->b, 6);
  1111. }
  1112. static Z80OPCODE opl_F1(Z80 *cpu) { // set 6,c
  1113.    set(cpu->c, 6);
  1114. }
  1115. static Z80OPCODE opl_F2(Z80 *cpu) { // set 6,d
  1116.    set(cpu->d, 6);
  1117. }
  1118. static Z80OPCODE opl_F3(Z80 *cpu) { // set 6,e
  1119.    set(cpu->e, 6);
  1120. }
  1121. static Z80OPCODE opl_F4(Z80 *cpu) { // set 6,h
  1122.    set(cpu->h, 6);
  1123. }
  1124. static Z80OPCODE opl_F5(Z80 *cpu) { // set 6,l
  1125.    set(cpu->l, 6);
  1126. }
  1127. //#endif
  1128. //#ifndef Z80_COMMON
  1129. static Z80OPCODE opl_F6(Z80 *cpu) { // set 6,(hl) | M:4 T:15 (4, 4, 4, 3)
  1130.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  1131.    set(t, 6);
  1132.    cpu->MemIf->wm(cpu->hl, t);
  1133.    cpu->t += 7;
  1134. }
  1135. //#endif
  1136. //#ifdef Z80_COMMON
  1137. static Z80OPCODE opl_F7(Z80 *cpu) { // set 6,a
  1138.    set(cpu->a, 6);
  1139. }
  1140. static Z80OPCODE opl_F8(Z80 *cpu) { // set 7,b
  1141.    set(cpu->b, 7);
  1142. }
  1143. static Z80OPCODE opl_F9(Z80 *cpu) { // set 7,c
  1144.    set(cpu->c, 7);
  1145. }
  1146. static Z80OPCODE opl_FA(Z80 *cpu) { // set 7,d
  1147.    set(cpu->d, 7);
  1148. }
  1149. static Z80OPCODE opl_FB(Z80 *cpu) { // set 7,e
  1150.    set(cpu->e, 7);
  1151. }
  1152. static Z80OPCODE opl_FC(Z80 *cpu) { // set 7,h
  1153.    set(cpu->h, 7);
  1154. }
  1155. static Z80OPCODE opl_FD(Z80 *cpu) { // set 7,l
  1156.    set(cpu->l, 7);
  1157. }
  1158. //#endif
  1159. //#ifndef Z80_COMMON
  1160. static Z80OPCODE opl_FE(Z80 *cpu) { // set 7,(hl) | M:4 T:15 (4, 4, 4, 3)
  1161.    unsigned char t = cpu->MemIf->rm(cpu->hl);
  1162.    set(t, 7);
  1163.    cpu->MemIf->wm(cpu->hl, t);
  1164.    cpu->t += 7;
  1165. }
  1166. //#endif
  1167. //#ifdef Z80_COMMON
  1168. static Z80OPCODE opl_FF(Z80 *cpu) { // set 7,a
  1169.    set(cpu->a, 7);
  1170. }
  1171. //#endif
  1172. //#ifndef Z80_COMMON
  1173.  
  1174. STEPFUNC const logic_opcode[0x100] = {
  1175.  
  1176.    opl_00, opl_01, opl_02, opl_03, opl_04, opl_05, opl_06, opl_07,
  1177.    opl_08, opl_09, opl_0A, opl_0B, opl_0C, opl_0D, opl_0E, opl_0F,
  1178.    opl_10, opl_11, opl_12, opl_13, opl_14, opl_15, opl_16, opl_17,
  1179.    opl_18, opl_19, opl_1A, opl_1B, opl_1C, opl_1D, opl_1E, opl_1F,
  1180.    opl_20, opl_21, opl_22, opl_23, opl_24, opl_25, opl_26, opl_27,
  1181.    opl_28, opl_29, opl_2A, opl_2B, opl_2C, opl_2D, opl_2E, opl_2F,
  1182.    opl_30, opl_31, opl_32, opl_33, opl_34, opl_35, opl_36, opl_37,
  1183.    opl_38, opl_39, opl_3A, opl_3B, opl_3C, opl_3D, opl_3E, opl_3F,
  1184.  
  1185.    opl_40, opl_41, opl_42, opl_43, opl_44, opl_45, opl_46, opl_47,
  1186.    opl_48, opl_49, opl_4A, opl_4B, opl_4C, opl_4D, opl_4E, opl_4F,
  1187.    opl_50, opl_51, opl_52, opl_53, opl_54, opl_55, opl_56, opl_57,
  1188.    opl_58, opl_59, opl_5A, opl_5B, opl_5C, opl_5D, opl_5E, opl_5F,
  1189.    opl_60, opl_61, opl_62, opl_63, opl_64, opl_65, opl_66, opl_67,
  1190.    opl_68, opl_69, opl_6A, opl_6B, opl_6C, opl_6D, opl_6E, opl_6F,
  1191.    opl_70, opl_71, opl_72, opl_73, opl_74, opl_75, opl_76, opl_77,
  1192.    opl_78, opl_79, opl_7A, opl_7B, opl_7C, opl_7D, opl_7E, opl_7F,
  1193.  
  1194.    opl_80, opl_81, opl_82, opl_83, opl_84, opl_85, opl_86, opl_87,
  1195.    opl_88, opl_89, opl_8A, opl_8B, opl_8C, opl_8D, opl_8E, opl_8F,
  1196.    opl_90, opl_91, opl_92, opl_93, opl_94, opl_95, opl_96, opl_97,
  1197.    opl_98, opl_99, opl_9A, opl_9B, opl_9C, opl_9D, opl_9E, opl_9F,
  1198.    opl_A0, opl_A1, opl_A2, opl_A3, opl_A4, opl_A5, opl_A6, opl_A7,
  1199.    opl_A8, opl_A9, opl_AA, opl_AB, opl_AC, opl_AD, opl_AE, opl_AF,
  1200.    opl_B0, opl_B1, opl_B2, opl_B3, opl_B4, opl_B5, opl_B6, opl_B7,
  1201.    opl_B8, opl_B9, opl_BA, opl_BB, opl_BC, opl_BD, opl_BE, opl_BF,
  1202.  
  1203.    opl_C0, opl_C1, opl_C2, opl_C3, opl_C4, opl_C5, opl_C6, opl_C7,
  1204.    opl_C8, opl_C9, opl_CA, opl_CB, opl_CC, opl_CD, opl_CE, opl_CF,
  1205.    opl_D0, opl_D1, opl_D2, opl_D3, opl_D4, opl_D5, opl_D6, opl_D7,
  1206.    opl_D8, opl_D9, opl_DA, opl_DB, opl_DC, opl_DD, opl_DE, opl_DF,
  1207.    opl_E0, opl_E1, opl_E2, opl_E3, opl_E4, opl_E5, opl_E6, opl_E7,
  1208.    opl_E8, opl_E9, opl_EA, opl_EB, opl_EC, opl_ED, opl_EE, opl_EF,
  1209.    opl_F0, opl_F1, opl_F2, opl_F3, opl_F4, opl_F5, opl_F6, opl_F7,
  1210.    opl_F8, opl_F9, opl_FA, opl_FB, opl_FC, opl_FD, opl_FE, opl_FF,
  1211.  
  1212. };
  1213.  
  1214. Z80OPCODE op_CB(Z80 *cpu)
  1215. {
  1216.    unsigned char opcode = cpu->m1_cycle();
  1217.    (logic_opcode[opcode])(cpu);
  1218. }
  1219. //#endif
  1220.