home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / walnut-creek-CDROM / EMULATOR / UNIX / CAIN1 / DECODE.C < prev    next >
C/C++ Source or Header  |  2000-06-30  |  32KB  |  1,647 lines
  1. /*
  2.  * execute()
  3.  *
  4.  * There are 256 possible opcodes.  The switch statement selects one.
  5.  * $Header: /g/zmob/zrun/RCS/execute.c,v 1.1.1.5 84/04/19 17:51:14 bennet Exp $
  6.  */
  7.  
  8. #include    "cpm.h"
  9.  
  10. static byte    partab[256]=        /* Parity table, 1=even */
  11. {
  12.     1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  13.     0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  14.     0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  15.     1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  16.     0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  17.     1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  18.     1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  19.     0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  20.     0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  21.     1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  22.     1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  23.     0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  24.     1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  25.     0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  26.     0,1,1,0,1,0,0,1, 1,0,0,1,0,1,1,0,
  27.     1,0,0,1,0,1,1,0, 0,1,1,0,1,0,0,1,
  28. };
  29.  
  30. static byte    setmask[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
  31. static byte    resmask[] = { ~1, ~2, ~4, ~8, ~16, ~32, ~64, ~128 };
  32.  
  33. int        pop(void)
  34. {
  35.     long    r = ram[SP++];
  36.     return(r + (ram[SP++] << 8));
  37. }
  38.  
  39. void    push(int v)
  40. {
  41.     ram[--SP] = v >> 8;
  42.     ram[--SP] = v & 0xff;
  43. }
  44.  
  45. int        decode(void)
  46. {
  47.     byte    *ptr;
  48.     long    a, s, s1;
  49.     byte    opcode = ram[PC++];
  50.  
  51.     if (PC >= BDOS)
  52.     {
  53.         PC = pop();
  54.         return(0);
  55.     }
  56.  
  57.     switch(opcode)
  58.     {
  59.     case 0:            /* 00 NOP */
  60.     when 1:            /* 01 LD BC,nn */
  61.         C = ram[PC++];
  62.         B = ram[PC++];
  63.     when 2:            /* 02 LD (BC),A */
  64.         ram[BC] = A;
  65.     when 3:            /* 03 INC BC */
  66.         ++BC;
  67.     when 4:            /* 04 INC B */
  68.         HALF_CARRY = (lonyb(B) == 0xf);
  69.         ++B;
  70.         SIGN = B >> 7;
  71.         ZERO = B == 0;
  72.         PARITY = B == 0x80;
  73.         BCD = 0;
  74.     when 5:            /* 05 DEC B */
  75.         HALF_CARRY = lonyb(B) != 0;
  76.         --B;
  77.         SIGN = B >> 7;
  78.         ZERO = B == 0;
  79.         PARITY = B == 0x7f;
  80.         BCD = 1;
  81.     when 6:            /* 06 LD B,n */
  82.         B = ram[PC++];
  83.     when 7:            /* 07 RLCA */
  84.         HALF_CARRY = BCD = 0;
  85.         CARRY = A >> 7;
  86.         A = (A << 1);
  87.         if (CARRY) ++A;
  88.     when 8:            /* 08 EX AF,AF' */
  89.         acc_bank = acc_bank ? 0 : 1;
  90.     when 9:            /* 09 ADD HL,BC */
  91.         s = BC;
  92.         a = (HL & 0xfff) + (s & 0xfff);
  93.         s += HL;
  94.         HL = s;
  95.         BCD = 0;
  96.         CARRY = s >> 16;
  97.         HALF_CARRY = a >> 12;
  98.     when 10:        /* 0a LD A,(BC) */
  99.         A = ram[BC];
  100.     when 11:        /* 0b DEC BC */
  101.         --BC;
  102.     when 12:        /* 0c INC C */
  103.         HALF_CARRY = lonyb(C) == 0xf;
  104.         ++C;
  105.         SIGN = C >> 7;
  106.         ZERO = C == 0;
  107.         PARITY = C == 0x80;
  108.         BCD = 0;
  109.     when 13:        /* 0d DEC C */
  110.         HALF_CARRY = lonyb(C) != 0;
  111.         --C;
  112.         SIGN = C >> 7;
  113.         ZERO = C == 0;
  114.         PARITY = C == 0x7f;
  115.         BCD = 1;
  116.     when 14:        /* 0e LD C,n */
  117.         C = ram[PC++];
  118.     when 15:        /* 0f RRCA */
  119.         BCD = HALF_CARRY = 0;
  120.         CARRY = A;
  121.         A = (A >> 1) | (CARRY ? 128 : 0);
  122.     when 16:        /* 10 DJNZ e */
  123.         s = (signed char)(ram[PC++] + 1);
  124.         if (--B) PC += s;
  125.     when 17:        /* 11 LD DE,nn */
  126.         E = ram[PC++];
  127.         D = ram[PC++];
  128.     when 18:        /* 12 LD (DE),A */
  129.         ram[DE] = A;
  130.     when 19:        /* 13 INC DE */
  131.         ++DE;
  132.     when 20:        /* 14 INC D */
  133.         HALF_CARRY = lonyb(D) == 0xf;
  134.         ++D;
  135.         SIGN = D >> 7;
  136.         ZERO = D == 0;
  137.         PARITY = D == 0x80;
  138.         BCD = 0;
  139.     when 21:        /* 15 DEC D */
  140.         HALF_CARRY = lonyb(D) != 0;
  141.         --D;
  142.         SIGN = D >> 7;
  143.         ZERO = D == 0;
  144.         PARITY = D == 0x7f;
  145.         BCD = 1;
  146.     when 22:        /* 16 LD D,n */
  147.         D = ram[PC++];
  148.     when 23:        /* 17 RLA */
  149.         s = A << 1;
  150.         A = s | CARRY;
  151.         CARRY = s >> 8;
  152.         BCD = HALF_CARRY = 0;
  153.     when 24:        /* 18 JR e */
  154.         PC += (signed char)(ram[PC] + 1);
  155.     when 25:        /* 19 ADD HL,DE */
  156.         s = DE;
  157.         a = (HL & 0xfff) + (s & 0xfff);
  158.         s += HL;
  159.         HL = s;
  160.         BCD = 0;
  161.         CARRY = s >> 16;
  162.         HALF_CARRY = a >> 12;
  163.     when 26:        /* 1a LD A,(DE) */
  164.         A = ram[DE];
  165.     when 27:        /* 1b DEC DE */
  166.         --DE;
  167.     when 28:        /* 1c INC E */
  168.         HALF_CARRY = lonyb(E) == 0xf;
  169.         ++E;
  170.         SIGN = E >> 7;
  171.         ZERO = E == 0;
  172.         PARITY = E == 0x80;
  173.         BCD = 0;
  174.     when 29:        /* 1d DEC E */
  175.         HALF_CARRY = lonyb(E) != 0;
  176.         --E;
  177.         SIGN = E >> 7;
  178.         ZERO = E == 0;
  179.         PARITY = E == 0x7f;
  180.         BCD = 1;
  181.     when 30:        /* 1e LD E,n */
  182.         E = ram[PC++];
  183.     when 31:        /* 1f RRA */
  184.         CARRY = (s = A | (CARRY << 8));
  185.         A = s >> 1;
  186.         BCD = HALF_CARRY = 0;
  187.     when 32:        /* 20 JR NZ,e */
  188.         if (ZERO) ++PC;
  189.         else PC += (signed char)(ram[PC] + 1);
  190.     when 33:        /* 21 LD HL,nn */
  191.         L = ram[PC++];
  192.         H = ram[PC++];
  193.     when 34:        /* 22 LD (nn),HL */
  194.         TEMPL = ram[PC++];
  195.         TEMPH = ram[PC++];
  196.         ram[TEMP] = L;
  197.         ram[TEMP + 1] = H;
  198.     when 35:        /* 23 INC HL */
  199.         ++HL;
  200.     when 36:        /* 24 INC H */
  201.         HALF_CARRY = lonyb(H) == 0xf;
  202.         ++H;
  203.         SIGN = H >> 7;
  204.         ZERO = H == 0;
  205.         PARITY = H == 0x80;
  206.         BCD = 0;
  207.     when 37:        /* 25 DEC H */
  208.         HALF_CARRY = lonyb(H) != 0;
  209.         --H;
  210.         SIGN = H >> 7;
  211.         ZERO = H == 0;
  212.         PARITY = H == 0x7f;
  213.         BCD = 1;
  214.     when 38:        /* 26 LD H,n */
  215.         H = ram[PC++];
  216.     when 39:        /* 27 DAA */
  217.         s = A & 0x0f;
  218.         a = (A >> 4) & 0x0f;
  219.         s1 = 0;
  220.  
  221.         if (BCD)
  222.         {
  223.             if (CARRY)
  224.             {
  225.                 if (HALF_CARRY)
  226.                     s1 = ((a > 5) && (s > 5)) ? 0x9a : 0;
  227.                 else
  228.                     s1 = ((a > 6) && (s < 10)) ? 0xa0 : 0;
  229.             }
  230.             else
  231.                 if(HALF_CARRY)
  232.                     s1 = ((a < 9) && (s > 5)) ? 0xfa : 0;
  233.         }
  234.         else
  235.         {
  236.             if (CARRY)
  237.             {
  238.                 if(HALF_CARRY)
  239.                     s1 = ((a < 4) && (s < 4)) ? 0x66 : 0;
  240.                 else if (a < 3)
  241.                     s1 = (s < 10) ? 0x60 : 0x66;
  242.             }
  243.             else
  244.             {
  245.                 if(HALF_CARRY)
  246.                 {
  247.                     if (s < 4)
  248.                         if (a > 9)
  249.                         {
  250.                             s1 = 0x66;
  251.                             CARRY = 1;
  252.                         }
  253.                         else s1 = 0x06;
  254.                 }
  255.                 else
  256.                 {
  257.                     if ((a > 8) && (s > 9))
  258.                     {
  259.                         s1 = 0x66;
  260.                         CARRY = 1;
  261.                     }
  262.                     else if ((a > 9) && (s < 10))
  263.                     {
  264.                         s1 = 0x60;
  265.                         CARRY = 1;
  266.                     }
  267.                     else if ((a < 10) && (s < 10))
  268.                             ;
  269.                     else if ((a < 9) && (s > 9))
  270.                         s1 = 6;
  271.                 }
  272.             }
  273.         }
  274.  
  275.         HALF_CARRY = ((int)(A) + (int)(s1)) > 0xf;
  276.         A += s1;
  277.         SIGN = A >> 7;
  278.         ZERO = (A == 0);
  279.         PARITY = partab[A];
  280.     when 40:        /* 28 JR Z,e */
  281.         if (ZERO) PC += (signed char)(ram[PC] + 1);
  282.         else ++PC;
  283.     when 41:        /* 29 ADD HL,HL */
  284.         s = HL;
  285.         a = (HL & 0xfff) + (s & 0xfff);
  286.         s += HL;
  287.         HL = s;
  288.         BCD = 0;
  289.         CARRY = s >> 16;
  290.         HALF_CARRY = a >> 12;
  291.     when 42:        /* 2a LD HL,(nn) */
  292.         TEMPL = ram[PC++];
  293.         TEMPH = ram[PC++];
  294.         L = ram[TEMP];
  295.         H = ram[TEMP + 1];
  296.     when 43:        /* 2b DEC HL */
  297.         --HL;
  298.     when 44:        /* 2c INC L */
  299.         HALF_CARRY = lonyb(L) == 0xf;
  300.         ++L;
  301.         SIGN = L >> 7;
  302.         ZERO = L == 0;
  303.         PARITY = L == 0x80;
  304.         BCD = 0;
  305.     when 45:        /* 2d DEC L */
  306.         HALF_CARRY = lonyb(L) != 0;
  307.         --L;
  308.         SIGN = L >> 7;
  309.         ZERO = L == 0;
  310.         PARITY = L == 0x7f;
  311.         BCD = 1;
  312.     when 46:        /* 2e LD L,n */
  313.         L = ram[PC++];
  314.     when 47:        /* 2f CPL */
  315.         A = ~A;
  316.         HALF_CARRY = BCD = 1;
  317.     when 48:        /* 30 JR NC,e */
  318.         if(CARRY) ++PC;
  319.         else PC += (signed char)(ram[PC] + 1);
  320.     when 49:        /* 31 LD SP,nn */
  321.         SPL = ram[PC++];
  322.         SPH = ram[PC++];
  323.     when 50:        /* 32 LD (nn),A */
  324.         TEMPL = ram[PC++];
  325.         TEMPH = ram[PC++];
  326.         ram[TEMP] = A;
  327.     when 51:        /* 33 INC SP */
  328.         ++SP;
  329.     when 52:        /* 34 INC (HL) */
  330.         HALF_CARRY = lonyb(ram[HL]) == 0xf;
  331.         ++ram[HL];
  332.         SIGN = ram[HL] >> 7;
  333.         ZERO = ram[HL] == 0;
  334.         PARITY = ram[HL] == 0x80;
  335.         BCD = 0;
  336.     when 53:        /* 35 DEC (HL) */
  337.         HALF_CARRY = lonyb(ram[HL]) != 0;
  338.         --ram[HL];
  339.         SIGN = ram[HL] >> 7;
  340.         ZERO = ram[HL] == 0;
  341.         PARITY = ram[HL] == 0x7f;
  342.         BCD = 1;
  343.     when 54:        /* 36 LD (HL),n */
  344.         ram[HL] = ram[PC++];
  345.     when 55:        /* 37 SCF */
  346.         HALF_CARRY = BCD = 0;
  347.         CARRY = 1;
  348.     when 56:        /* 38 JR C,e */
  349.         if (CARRY) PC += (signed char)(ram[PC] + 1);
  350.         else ++PC;
  351.     when 57:        /* 39 ADD HL,SP */
  352.         s = SP;
  353.         a = (HL & 0xfff) + (s & 0xfff);
  354.         s += HL;
  355.         HL = s;
  356.         BCD = 0;
  357.         CARRY = s >> 16;
  358.         HALF_CARRY = a >> 12;
  359.     when 58:        /* 3a LD A,(nn) */
  360.         TEMPL = ram[PC++];
  361.         TEMPH = ram[PC++];
  362.         A = ram[TEMP];
  363.     when 59:        /* 3b DEC SP */
  364.         --SP;
  365.     when 60:        /* 3c INC A */
  366.         HALF_CARRY = lonyb(A) == 0xf;
  367.         ++A;
  368.         SIGN = A >> 7;
  369.         ZERO = A == 0;
  370.         PARITY = A == 0x80;
  371.         BCD = 0;
  372.     when 61:        /* 3d DEC A */
  373.         HALF_CARRY = lonyb(A) != 0;
  374.         --A;
  375.         SIGN = A >> 7;
  376.         ZERO = A == 0;
  377.         PARITY = A == 0x7f;
  378.         BCD = 1;
  379.     when 62:        /* 3e LD A,n */
  380.         A = ram[PC++];
  381.     when 63:        /* 3f CCF */
  382.         HALF_CARRY = CARRY;
  383.         CARRY = ~CARRY;
  384.         BCD = 0;
  385.     when 64:        /* 40 LD B,B */
  386.     when 65:        /* 41 LD B,C */
  387.         B = C;
  388.     when 66:        /* 42 LD B,D */
  389.         B = D;
  390.     when 67:        /* 43 LD B,E */
  391.         B = E;
  392.     when 68:        /* 44 LD B,H */
  393.         B = H;
  394.     when 69:        /* 45 LD B,L */
  395.         B = L;
  396.     when 70:        /* 46 LD B, (HL) */
  397.         B = ram[HL];
  398.     when 71:        /* 47 LD B,A */
  399.         B = A;
  400.     when 72:        /* 48 LD C,B */
  401.         C = B;
  402.     when 73:        /* 49 LD C,C */
  403.     when 74:        /* 4a LD C,D */
  404.         C = D;
  405.     when 75:        /* 4b LD C,E */
  406.         C = E;
  407.     when 76:        /* 4c LD C,H */
  408.         C = H;
  409.     when 77:        /* 4d LD C,L */
  410.         C = L;
  411.     when 78:        /* 4e LD C, (HL) */
  412.         C = ram[HL];
  413.     when 79:        /* 4f LD C,A */
  414.         C = A;
  415.     when 80:        /* 50 LD D,B */
  416.         D = B;
  417.     when 81:        /* 51 LD D,C */
  418.         D = C;
  419.     when 82:        /* 52 LD D,D */
  420.     when 83:        /* 53 LD D,E */
  421.         D = E;
  422.     when 84:        /* 54 LD D,H */
  423.         D = H;
  424.     when 85:        /* 55 LD D,L */
  425.         D = L;
  426.     when 86:        /* 56 LD D, (HL) */
  427.         D = ram[HL];
  428.     when 87:        /* 57 LD D,A */
  429.         D = A;
  430.     when 88:        /* 58 LD E,B */
  431.         E = B;
  432.     when 89:        /* 59 LD E,C */
  433.         E = C;
  434.     when 90:        /* 5a LD E,D */
  435.         E = D;
  436.     when 91:        /* 5b LD E,E */
  437.     when 92:        /* 5c LD E,H */
  438.         E = H;
  439.     when 93:        /* 5d LD E,L */
  440.         E = L;
  441.     when 94:        /* 5e LD E, (HL) */
  442.         E = ram[HL];
  443.     when 95:        /* 5f LD E,A */
  444.         E = A;
  445.     when 96:        /* 60 LD H,B */
  446.         H = B;
  447.     when 97:        /* 61 LD H,C */
  448.         H = C;
  449.     when 98:        /* 62 LD H,D */
  450.         H = D;
  451.     when 99:        /* 63 LD H,E */
  452.         H = E;
  453.     when 100:        /* 64 LD H,H */
  454.     when 101:        /* 65 LD H,L */
  455.         H = L;
  456.     when 102:        /* 66 LD H, (HL) */
  457.         H = ram[HL];
  458.     when 103:        /* 67 LD H,A */
  459.         H = A;
  460.     when 104:        /* 68 LD L,B */
  461.         L = B;
  462.     when 105:        /* 69 LD L,C */
  463.         L = C;
  464.     when 106:        /* 6a LD L,D */
  465.         L = D;
  466.     when 107:        /* 6b LD L,E */
  467.         L = E;
  468.     when 108:        /* 6c LD L,H */
  469.         L = H;
  470.     when 109:        /* 6d LD L,L */
  471.     when 110:        /* 6e LD L,(HL) */
  472.         L = ram[HL];
  473.     when 111:        /* 6f LD L,A */
  474.         L = A;
  475.     when 112:        /* 70 LD (HL),B */
  476.         ram[HL] = B;
  477.     when 113:        /* 71 LD (HL),C */
  478.         ram[HL] = C;
  479.     when 114:        /* 72 LD (HL),D */
  480.         ram[HL] = D;
  481.     when 115:        /* 73 LD (HL),E */
  482.         ram[HL] = E;
  483.     when 116:        /* 74 LD (HL),H */
  484.         ram[HL] = H;
  485.     when 117:        /* 75 LD (HL),L */
  486.         ram[HL] = L;
  487.     when 118:        /* 76 HALT */
  488.         return(0x76);
  489.     when 119:        /* 77 LD (HL),A */
  490.         ram[HL] = A;
  491.     when 120:        /* 78 LD A,B */
  492.         A = B;
  493.     when 121:        /* 79 LD A,C */
  494.         A = C;
  495.     when 122:        /* 7a LD A,D */
  496.         A = D;
  497.     when 123:        /* 7b LD A,E */
  498.         A = E;
  499.     when 124:        /* 7c LD A,H */
  500.         A = H;
  501.     when 125:        /* 7d LD A,L */
  502.         A = L;
  503.     when 126:        /* 7e LD A,(HL) */
  504.         A = ram[HL];
  505.     when 127:        /* 7f LD A,A */
  506.     when 128:        /* 80 ADD A,B */
  507.         s = B;
  508.         goto add;
  509.     case 129:        /* 81 ADD A,C */
  510.         s = C;
  511.         goto add;
  512.     case 130:        /* 82 ADD A,D */
  513.         s = D;
  514.         goto add;
  515.     case 131:        /* 83 ADD A,E */
  516.         s = E;
  517.         goto add;
  518.     case 132:        /* 84 ADD A,H */
  519.         s = H;
  520.         goto add;
  521.     case 133:        /* 85 ADD A,L */
  522.         s = L;
  523.         goto add;
  524.     case 134:        /* 86 ADD A,(HL) */
  525.         s = ram[HL];
  526.         goto add;
  527.     case 135:        /* 87 ADD A,A */
  528.         s = A;
  529.         goto add;
  530.     case 136:        /* 88 ADC A,B */
  531.         s = B;
  532.         goto adc;
  533.     case 137:        /* 89 ADC A,C */
  534.         s = C;
  535.         goto adc;
  536.     case 138:        /* 8a ADC A,D */
  537.         s = D;
  538.         goto adc;
  539.     case 139:        /* 8b ADC A,E */
  540.         s = E;
  541.         goto adc;
  542.     case 140:        /* 8c ADC A,H */
  543.         s = H;
  544.         goto adc;
  545.     case 141:        /* 8d ADC A,L */
  546.         s = L;
  547.         goto adc;
  548.     case 142:        /* 8e ADC A,(HL) */
  549.         s = ram[HL];
  550.         goto adc;
  551.     case 143:        /* 8f ADC A,A */
  552.         s = A;
  553.  
  554. adc:
  555.         a = A & 0x0f;
  556.         s1 = s & 0x0f;
  557.         if (CARRY) { s++; a++; }
  558.         goto add1;
  559.  
  560. add:
  561.         a = A & 0x0f;
  562.         s1 = s & 0x0f;
  563.  
  564. add1:
  565.         BCD = 0;
  566.         s += A;
  567.         A = s;
  568.         a += s1;
  569.  
  570. set_flags:
  571.         CARRY = s >> 8;
  572.         HALF_CARRY = a >> 4;
  573.         SIGN = s >> 7;
  574.         ZERO = s ? 0 : 1;
  575.         PARITY = partab[A];
  576.  
  577.     when 144:        /* 90 SUB A,B */
  578.         s = B;
  579.         goto sub;
  580.     case 145:        /* 91 SUB A,C */
  581.         s = C;
  582.         goto sub;
  583.     case 146:        /* 92 SUB A,D */
  584.         s = D;
  585.         goto sub;
  586.     case 147:        /* 93 SUB A,E */
  587.         s = E;
  588.         goto sub;
  589.     case 148:        /* 94 SUB A,H */
  590.         s = H;
  591.         goto sub;
  592.     case 149:        /* 95 SUB A,L */
  593.         s = L;
  594.         goto sub;
  595.     case 150:        /* 96 SUB A,(HL) */
  596.         s = ram[HL];
  597.         goto sub;
  598.     case 151:        /* 97 SUB A,A */
  599.         s = A;
  600.         goto sub;
  601.     case 152:        /* 98 SBC A,B */
  602.         s = B;
  603.         goto sbc;
  604.     case 153:        /* 99 SBC A,C */
  605.         s = C;
  606.         goto sbc;
  607.     case 154:        /* 9a SBC A,D */
  608.         s = D;
  609.         goto sbc;
  610.     case 155:        /* 9b SBC A,E */
  611.         s = E;
  612.         goto sbc;
  613.     case 156:        /* 9c SBC A,H */
  614.         s = H;
  615.         goto sbc;
  616.     case 157:        /* 9d SBC A,L */
  617.         s = L;
  618.         goto sbc;
  619.     case 158:        /* 9e SBC A,(HL) */
  620.         s = ram[HL];
  621.         goto sbc;
  622.     when 159:        /* 9f SBC A,A */
  623.         s = A;
  624.  
  625. sbc:
  626.         a = A & 0x0f;
  627.         s1 = s & 0x0f;
  628.         if (CARRY) { s--; a--; }
  629.         goto sub1;
  630.  
  631. sub:
  632.         a = A & 0x0f;
  633.         s1 = s & 0x0f;
  634.  
  635. sub1:
  636.         s = A - s;
  637.         A = s;
  638.         a -= s1;
  639.         BCD = 1;
  640.         goto set_flags;
  641.  
  642.     when 160:        /* a0 AND A,B */
  643.         s = B;
  644.         goto and;
  645.     case 161:        /* a1 AND A,C */
  646.         s = C;
  647.         goto and;
  648.     case 162:        /* a2 AND A,D */
  649.         s = D;
  650.         goto and;
  651.     case 163:        /* a3 AND A,E */
  652.         s = E;
  653.         goto and;
  654.     case 164:        /* a4 AND A,H */
  655.         s = H;
  656.         goto and;
  657.     case 165:        /* a5 AND A,L */
  658.         s = L;
  659.         goto and;
  660.     case 166:        /* a6 AND A,(HL) */
  661.         s = ram[HL];
  662.         goto and;
  663.     case 167:        /* a7 AND A,A */
  664.         s = A;
  665.  
  666. and:
  667.         a = A & 0x0f;
  668.         s1 = s & 0x0f;
  669.  
  670.         s &= A;
  671.         A = s;
  672.         a &= s;
  673.         goto set_flags;
  674.         
  675.     when 168:        /* a8 XOR A,B */
  676.         s = B;
  677.         goto xor;
  678.     case 169:        /* a9 XOR A,C */
  679.         s = C;
  680.         goto xor;
  681.     case 170:        /* aa XOR A,D */
  682.         s = D;
  683.         goto xor;
  684.     case 171:        /* ab XOR A,E */
  685.         s = E;
  686.         goto xor;
  687.     case 172:        /* ac XOR A,H */
  688.         s = H;
  689.         goto xor;
  690.     case 173:        /* ad XOR A,L */
  691.         s = L;
  692.         goto xor;
  693.     case 174:        /* ae XOR A,(HL) */
  694.         s = ram[HL];
  695.         goto xor;
  696.     case 175:        /* af XOR A,A */
  697.         s = A;
  698.  
  699. xor:
  700.         a = A & 0x0f;
  701.         s1 = s & 0x0f;
  702.  
  703.         s ^= A;
  704.         A = s;
  705.         a ^= s;
  706.         goto set_flags;
  707.  
  708.     when 176:        /* b1 OR B */
  709.         s = B;
  710.         goto or;
  711.     case 177:        /* b1 OR C */
  712.         s = C;
  713.         goto or;
  714.     case 178:        /* b2 OR D */
  715.         s = D;
  716.         goto or;
  717.     case 179:        /* b3 OR E */
  718.         s = E;
  719.         goto or;
  720.     case 180:        /* b4 OR H */
  721.         s = H;
  722.         goto or;
  723.     case 181:        /* b5 OR L */
  724.         s = L;
  725.         goto or;
  726.     case 182:        /* b6 OR (HL) */
  727.         s = ram[HL];
  728.         goto or;
  729.     case 183:        /* b7 OR A */
  730.         s = A;
  731.  
  732. or:
  733.         a = A & 0x0f;
  734.         s1 = s & 0x0f;
  735.  
  736.         s |= A;
  737.         A = s;
  738.         a |= s;
  739.         goto set_flags;
  740.  
  741.     when 184:        /* b8 CP B */
  742.         s = B;
  743.         goto cp;
  744.     when 185:        /* b9 CP C */
  745.         s = C;
  746.         goto cp;
  747.     when 186:        /* ba CP D */
  748.         s = D;
  749.         goto cp;
  750.     when 187:        /* bb CP E */
  751.         s = E;
  752.         goto cp;
  753.     when 188:        /* bc CP H */
  754.         s = H;
  755.         goto cp;
  756.     when 189:        /* bd CP L */
  757.         s = L;
  758.         goto cp;
  759.     when 190:        /* be CP (HL) */
  760.         s = A;
  761.         goto cp;
  762.     when 191:        /* bf CP A */
  763.         s = ram[HL];
  764.  
  765. cp:
  766.         a = A & 0x0f;
  767.         s1 = s & 0x0f;
  768.         s = A - s;
  769.         a -= s1;
  770.         BCD = 1;
  771.         goto set_flags;
  772.  
  773.     when 192:        /* c0 RET NZ */
  774.         if (!ZERO) PC = pop();
  775.     when 193:        /* c1 POP BC */
  776.         BC = pop();
  777.     when 194:        /* c2 JP NZ,nn */
  778.         if (ZERO) { PC += 2; break;}
  779.     case 195:        /* c3 JP nn */
  780.         TEMPL = ram[PC++];
  781.         TEMPH = ram[PC++];
  782.         PC = TEMP;
  783.     when 196:        /* c4 CALL NZ,nn */
  784.         if (ZERO) PC += 2;
  785.         else
  786.         {
  787.             TEMPL = ram[PC++];
  788.             TEMPH = ram[PC++];
  789.             push(PC);
  790.             PC = TEMP;
  791.         }
  792.     when 197:        /* c5 PUSH BC */
  793.         push(BC);
  794.     when 198:        /* c6 ADD A,n */
  795.         s = ram[PC++];
  796.         goto add;
  797.     case 199:        /* c7 RST 0 */
  798.         push(PC);
  799.         PC = 0;
  800.     when 200:        /* c8 RET Z */
  801.         if (!ZERO) break;
  802.     case 201:        /* c9 RET */
  803.         PC = pop();
  804.     when 202:        /* ca JP Z,nn */
  805.         if (ZERO)
  806.         {
  807.             TEMPL = ram[PC++];
  808.             TEMPH = ram[PC++];
  809.             PC = TEMP;
  810.         }
  811.         else PC += 2;
  812.     when 203:        /* cb oh boy */
  813.         switch (ram[PC] & 0x03)
  814.         {
  815.             case 0: ptr = &B;
  816.             case 1: ptr = &C;
  817.             case 2: ptr = &D;
  818.             case 3: ptr = &E;
  819.             case 4: ptr = &H;
  820.             case 5: ptr = &L;
  821.             case 6: ptr = ram + HL;
  822.             case 7: ptr = &A;
  823.             default: ptr = (void *)(0);
  824.         }
  825.  
  826. cb_stuff:
  827.         if ((s1 = ((s = ram[PC++]) & 0xc0)) != 0)
  828.         {
  829.             a = 1 << ((s & 0x3f) >> 3);
  830.  
  831.             switch (s1)
  832.             {
  833.                 case 0x40:        /* BIT */
  834.                     ZERO = *ptr & a;
  835.                     HALF_CARRY = 1;
  836.                     BCD = 0;
  837.                 when 0x80:        /* RES */
  838.                     *ptr &= ~a;
  839.                 when 0xb0:        /* SET */
  840.                     *ptr |= a;
  841.             }
  842.         }
  843.         else
  844.         {
  845.             switch (s & 0xf8)
  846.             {
  847.                 case 0x00:            /* RLC */
  848.                     CARRY= *ptr >> 7;
  849.                     *ptr <<= 1;
  850.                     if (CARRY) ++*ptr;
  851.                 when 0x08:            /* RRC */
  852.                     CARRY = *ptr;
  853.                     *ptr >>= 1;
  854.                     if (CARRY) *ptr |= 0x80;
  855.                 when 0x10:            /* RL */
  856.                     a = CARRY;
  857.                     CARRY = *ptr >> 7;
  858.                     *ptr <<= 1;
  859.                     *ptr += a;
  860.                 when 0x18:            /* RR */
  861.                     a = CARRY;
  862.                     CARRY = *ptr;
  863.                     *ptr >>= 1;
  864.                     if (a) *ptr |= 0x80;
  865.                 when 0x20:            /* SLA */
  866.                     CARRY = *ptr >> 7;
  867.                     *ptr <<= 1;
  868.                 when 0x28:            /* SRA */
  869.                     CARRY = *ptr;
  870.                     *ptr >>= 1;
  871.                     if (*ptr & 0x40) *ptr |= 0x80;
  872.                 when 0x30:            /* SLL ???? Oh well.  It fits */
  873.                     CARRY = *ptr >> 7;
  874.                     *ptr <<= 1;
  875.                     *ptr |= 1;
  876.                 when 0x38:            /* SRL */
  877.                     CARRY = *ptr;
  878.                     *ptr >>= 1;
  879.             }
  880.  
  881.             SIGN = *ptr >> 7;
  882.             ZERO = *ptr == 0;
  883.             HALF_CARRY = BCD = 0;
  884.             PARITY = partab[*ptr];
  885.         }
  886.     when 204:        /* cc CALL Z,nn */
  887.         if (ZERO)
  888.         {
  889.             TEMPL = ram[PC++];
  890.             TEMPH = ram[PC++];
  891.             push(PC);
  892.             PC = TEMP;
  893.         }
  894.         else PC += 2;
  895.     when 205:        /* cd CALL nn */
  896.         TEMPL = ram[PC++];
  897.         TEMPH = ram[PC++];
  898.         push(PC);
  899.         PC = TEMP;
  900.     when 206:        /* ce ADC A,n */
  901.         s = ram[PC++];
  902.         goto adc;
  903.     when 207:        /* cf RST 08 */
  904.         push(PC);
  905.         PC = 8;
  906.     when 208:        /* d0 RET NC */
  907.         if (!CARRY)
  908.             PC = pop();
  909.     when 209:        /* d1 POP DE */
  910.         DE = pop();
  911.     when 210:        /* d2 JP NC,nn */
  912.         if (CARRY) PC += 2;
  913.         else
  914.         {
  915.             TEMPL = ram[PC++];
  916.             TEMPH = ram[PC++];
  917.             PC = TEMP;
  918.         }
  919.     when 211:        /* d3 OUT (n),A */
  920.         return(211);
  921.     when 212:        /* d4 CALL NC,nn */
  922.         if (CARRY) PC += 2;
  923.         else
  924.         {
  925.             TEMPL = ram[PC++];
  926.             TEMPH = ram[PC++];
  927.             push(PC);
  928.             PC = TEMP;
  929.         }
  930.     when 213:        /* d5 PUSH DE */
  931.         push(DE);
  932.     when 214:        /* d6 SUB N */
  933.         s = ram[PC++];
  934.         goto sub;
  935.     when 215:        /* d7 RST 10 */
  936.         push(PC);
  937.         PC = 16;
  938.     when 216:        /* d8 RET C */
  939.         if (CARRY)
  940.             PC = pop();
  941.     when 217:        /* d9 EXX */
  942.         gr_bank = gr_bank ? 0 : 1;
  943.     when 218:        /* da JP C,nn */
  944.         if (CARRY)
  945.         {
  946.             TEMPL = ram[PC++];
  947.             TEMPH = ram[PC++];
  948.             PC = TEMP;
  949.         }
  950.         else PC += 2;
  951.     when 219:        /* db IN A,(n) */
  952.         return(219);
  953.     when 220:        /* dc CALL C,nn */
  954.         if (CARRY)
  955.         {
  956.             TEMPL = ram[PC++];
  957.             TEMPH = ram[PC++];
  958.             push(PC);
  959.             PC = TEMP;
  960.         }
  961.         else PC += 2;
  962.     when 221:        /* DD instructions - use IX register */
  963.         opcode = ram[PC++];
  964.         switch (opcode)
  965.         {
  966.             case 0x09:        /* 09 ADD IX,BC */
  967.                 s = BC;
  968.                 a = (IX & 0xfff) + (s & 0xfff);
  969.                 s += IX;
  970.                 IX = s;
  971.                 BCD = 0;
  972.                 CARRY = s >> 16;
  973.                 HALF_CARRY = a >> 12;
  974.             when 0x19:        /* ADD IX, DE */
  975.                 s = DE;
  976.                 a = (IX & 0xfff) + (s & 0xfff);
  977.                 s += IX;
  978.                 IX = s;
  979.                 BCD = 0;
  980.                 CARRY = s >> 16;
  981.                 HALF_CARRY = a >> 12;
  982.             when 0x21:        /* LD IX, nn */
  983.                 IXL = ram[PC++];
  984.                 IXH = ram[PC++];
  985.             when 0x22:        /* LD (nn), IX) */
  986.                 TEMPL = ram[PC++];
  987.                 TEMPH = ram[PC++];
  988.                 ram[TEMP] = IXL;
  989.                 ram[TEMP + 1] = IXH;
  990.             when 0x23:        /* INC IX */
  991.                 IX++;
  992.             when 0x29:        /* ADD IX, IX */
  993.                 s = IX;
  994.                 a = (IX & 0xfff) + (s & 0xfff);
  995.                 s += IX;
  996.                 IX = s;
  997.                 BCD = 0;
  998.                 CARRY = s >> 16;
  999.                 HALF_CARRY = a >> 12;
  1000.             when 0x2a:        /* LD IX, (nn) */
  1001.                 TEMPL = ram[PC++];
  1002.                 TEMPH = ram[PC++];
  1003.                 IXL = ram[TEMP];
  1004.                 IXH = ram[TEMP + 1];
  1005.             when 0x2b:        /* DEC IX */
  1006.                 IX--;
  1007.             when 0x34:        /* INC (IX + d) */
  1008.                 ptr = ram + IX + ram[PC++];
  1009.                 HALF_CARRY = lonyb(*ptr) == 0xf;
  1010.                 ++(*ptr);
  1011.                 SIGN = *ptr >> 7;
  1012.                 ZERO = *ptr == 0;
  1013.                 PARITY = *ptr == 0x80;
  1014.                 BCD = 0;
  1015.             when 0x35:        /* DEC (IX + d) */
  1016.                 ptr = ram + IX + ram[PC++];
  1017.                 HALF_CARRY = lonyb(*ptr) != 0;
  1018.                 --(*ptr);
  1019.                 SIGN = *ptr >> 7;
  1020.                 ZERO = *ptr == 0;
  1021.                 PARITY = *ptr == 0x7f;
  1022.                 BCD = 1;
  1023.             when 0x36:        /* LD (IX + d), n */
  1024.                 TEMP = IX + ram[PC++];
  1025.                 ram[TEMP] = ram[PC++];
  1026.             when 0x39:        /* ADD IX, SP */
  1027.                 s = SP;
  1028.                 a = (IX & 0xfff) + (s & 0xfff);
  1029.                 s += IX;
  1030.                 IX = s;
  1031.                 BCD = 0;
  1032.                 CARRY = s >> 16;
  1033.                 HALF_CARRY = a >> 12;
  1034.             when 0x46:        /* LD B, (IX + d) */
  1035.                 B = ram[IX + ram[PC++]];
  1036.             when 0x4e:        /* LD C, (IX + d) */
  1037.                 C = ram[IX + ram[PC++]];
  1038.             when 0x56:        /* LD D, (IX + d) */
  1039.                 D = ram[IX + ram[PC++]];
  1040.             when 0x5e:        /* LD E, (IX + d) */
  1041.                 E = ram[IX + ram[PC++]];
  1042.             when 0x66:        /* LD H, (IX + d) */
  1043.                 H = ram[IX + ram[PC++]];
  1044.             when 0x6e:        /* LD L, (IX + d) */
  1045.                 L = ram[IX + ram[PC++]];
  1046.             when 0x70:        /* LD (IX + d, B */
  1047.                 ram[IX + ram[PC++]] = B;
  1048.             when 0x71:        /* LD (IX + d, C */
  1049.                 ram[IX + ram[PC++]] = C;
  1050.             when 0x72:        /* LD (IX + d, D */
  1051.                 ram[IX + ram[PC++]] = D;
  1052.             when 0x73:        /* LD (IX + d, E */
  1053.                 ram[IX + ram[PC++]] = E;
  1054.             when 0x74:        /* LD (IX + d, H */
  1055.                 ram[IX + ram[PC++]] = H;
  1056.             when 0x75:        /* LD (IX + d, L */
  1057.                 ram[IX + ram[PC++]] = L;
  1058.             when 0x77:        /* LD (IX + d, A */
  1059.                 ram[IX + ram[PC++]] = A;
  1060.             when 0x7e:        /* LD A, (IX + d) */
  1061.                 A = ram[IX + ram[PC++]];
  1062.             when 0x86:        /* ADD A, (IX + d) */
  1063.                 s = ram[IX + ram[PC++]];
  1064.                 goto add;
  1065.             when 0x8e:        /* ADC A, (IX + d) */
  1066.                 s = ram[IX + ram[PC++]];
  1067.                 goto adc;
  1068.             when 0x96:        /* SUB A, (IX + d) */
  1069.                 s = ram[IX + ram[PC++]];
  1070.                 goto sub;
  1071.             when 0x9e:        /* SBC A, (IX + d) */
  1072.                 s = ram[IX + ram[PC++]];
  1073.                 goto sbc;
  1074.             when 0xa6:        /* AND A, (IX + d) */
  1075.                 s = ram[IX + ram[PC++]];
  1076.                 goto and;
  1077.             when 0xae:        /* XOR A, (IX + d) */
  1078.                 s = ram[IX + ram[PC++]];
  1079.                 goto xor;
  1080.             when 0xb6:        /* OR A, (IX + d) */
  1081.                 s = ram[IX + ram[PC++]];
  1082.                 goto or;
  1083.             when 0xbe:        /* CP A, (IX + d) */
  1084.                 s = ram[IX + ram[PC++]];
  1085.                 goto cp;
  1086.             when 0xcb:
  1087.                 ptr = ram + IX + ram[PC++];
  1088.                 goto cb_stuff;
  1089.             when 0xe1:        /* POP IX */
  1090.                 IX = pop();
  1091.             when 0xe3:        /* EX (SP), IX */
  1092.                 s = IX;
  1093.                 IX = pop();
  1094.                 push(s);
  1095.             when 0xe5:        /* PUSH IX */
  1096.                 push(IX);
  1097.             when 0xe9:        /* JP (IX) */
  1098.                 PC = IX;
  1099.             when 0xf9:        /* LD SP, IX */
  1100.                 SP = IX;
  1101.             break; default: return(-1);
  1102.         }
  1103.     when 222:        /* de SBC A,n */
  1104.         s = ram[PC++];
  1105.         goto sbc;
  1106.     when 223:        /* df RST 18 */
  1107.         push(PC);
  1108.         PC = 0x18;
  1109.     when 224:        /* e0 RET PO */
  1110.         if (!PARITY)
  1111.             PC = pop();
  1112.     when 225:        /* e1 POP HL */
  1113.         HL = pop();
  1114.     when 226:        /* e2 JP PO,nn */
  1115.         if (PARITY) PC += 2;
  1116.         else
  1117.         {
  1118.             TEMPL = ram[PC++];
  1119.             TEMPH = ram[PC++];
  1120.             PC = TEMP;
  1121.         }
  1122.     when 227:        /* e3 EX (SP),HL */
  1123.         s = HL;
  1124.         HL = pop();
  1125.         push(s);
  1126.     when 228:        /* e4 CALL PO,nn */
  1127.         if (PARITY) PC += 2;
  1128.         else
  1129.         {
  1130.             TEMPL = ram[PC++];
  1131.             TEMPH = ram[PC++];
  1132.             push(PC);
  1133.             PC = TEMP;
  1134.         }
  1135.     when 229:        /* e5 PUSH HL */
  1136.         push(HL);
  1137.     when 230:        /* e6 AND n */
  1138.         s = ram[PC++];
  1139.         goto and;
  1140.     when 231:        /* e7 RST 20 */
  1141.         push(PC);
  1142.         PC = 0x20;
  1143.     when 232:        /* e8 RET PE */
  1144.         if (PARITY)
  1145.             PC = pop();
  1146.     when 233:        /* e9 JP (HL) */
  1147.         PC = HL;
  1148.     when 234:        /* ea JP PE,nn */
  1149.         if (PARITY)
  1150.         {
  1151.             TEMPL = ram[PC++];
  1152.             TEMPH = ram[PC++];
  1153.             PC = TEMP;
  1154.         }
  1155.         else PC += 2;
  1156.     when 235:        /* eb EX DE,HL */
  1157.         s = HL;
  1158.         HL = DE;
  1159.         DE = s;
  1160.     when 236:        /* ec CALL PE,nn */
  1161.         if (PARITY)
  1162.         {
  1163.             TEMPL = ram[PC++];
  1164.             TEMPH = ram[PC++];
  1165.             push(PC);
  1166.             PC = TEMP;
  1167.         }
  1168.     when 237:        /* ed oh boy */
  1169.         a = ram[PC++];
  1170.         switch(a)
  1171.         {
  1172.         case 0x40:        /* IN B,(C) */
  1173.         case 0x41:        /* OUT (C),B */
  1174.         case 0x48:        /* IN C,(C) */
  1175.         case 0x49:        /* OUT (C),C */
  1176.         case 0x50:        /* IN D,(C) */
  1177.         case 0x51:        /* OUT (C),D */
  1178.         case 0x58:        /* IN E,(C) */
  1179.         case 0x59:        /* OUT (C),E */
  1180.         case 0x60:        /* IN H,(C) */
  1181.         case 0x61:        /* OUT (C),H */
  1182.         case 0x68:        /* IN L,(C) */
  1183.         case 0x69:        /* OUT (C),L */
  1184.         when 0x78:        /* IN A,(C) */
  1185.         when 0x79:        /* OUT (C),A */
  1186.         case 0xa2:        /* INI */
  1187.         case 0xa3:        /* OUTI */
  1188.         case 0xaa:        /* IND */
  1189.         case 0xab:        /* OUTD */
  1190.         case 0xb2:        /* INIR */
  1191.         case 0xb3:        /* OTIR */
  1192.         case 0xba:        /* INDR */
  1193.         case 0xbb:        /* OTDR */
  1194.             return(0xed00 + a);
  1195.         when 0x42:        /* SBC HL,BC */
  1196.             TEMP = BC;
  1197.             goto edsbc;
  1198.         when 0x43:        /* LD (nn),BC */
  1199.             TEMPL = ram[PC++];
  1200.             TEMPH = ram[PC++];
  1201.             ram[TEMP] = C;
  1202.             ram[TEMP + 1] = B;
  1203.         when 0x44:        /* NEG */
  1204.             HALF_CARRY = lonyb(A) != 0;
  1205.             CARRY = A!= 0;
  1206.             PARITY = A == 0x80;
  1207.             A = 0 - A;
  1208.             SIGN = A >> 7;
  1209.             ZERO = A == 0;
  1210.             BCD = 1;
  1211.         when 0x45:        /* RETN */
  1212.  
  1213.             /*
  1214.              * INTERRUPT: Add restore IFF states
  1215.              */
  1216.  
  1217.             PC = pop();
  1218.         when 0x46:        /* IM 0 */
  1219.  
  1220.             /*
  1221.              * INTERRUPT: Set IM 0
  1222.              */
  1223.             ;
  1224.         when 0x47:        /* LD I,A */
  1225.  
  1226.             /*
  1227.              * INTERRUPT: Load I from A
  1228.              */
  1229.             ;
  1230.         when 0x4a:        /* ADC HL,BC */
  1231.             TEMP = BC;
  1232.             goto edadc;
  1233.         when 0x4b:        /* LD BC,(nn) */
  1234.             TEMPL = ram[PC++];
  1235.             TEMPH = ram[PC++];
  1236.             C = ram[TEMP];
  1237.             B = ram[TEMP + 1];
  1238.         when 0x4d:        /* RETI */
  1239.             PC = pop();
  1240.         when 0x4f:        /* LD R,A */
  1241.             R = A + 1;
  1242.         when 0x52:        /* SBC HL,DE */
  1243.             TEMP = DE;
  1244.             goto edsbc;
  1245.         when 0x53:        /* LD (nn),DE */
  1246.             TEMPL = ram[PC++];
  1247.             TEMPH = ram[PC++];
  1248.             ram[TEMP] = E;
  1249.             ram[TEMP + 1] = D;
  1250.         when 0x56:        /* IM 1 */
  1251.  
  1252.             /*
  1253.              * INTERRUPT: Set IM 1
  1254.              */
  1255.             ;
  1256.         when 0x57:        /* LD A,I */
  1257.  
  1258.             /*
  1259.              * INTERRUPT: A=I
  1260.              */
  1261.             ;
  1262.         when 0x5a:        /* ADC HL,DE */
  1263.             TEMP = DE;
  1264.             goto edadc;
  1265.         when 0x5b:        /* LD DE,(nn) */
  1266.             TEMPL = ram[PC++];
  1267.             TEMPH = ram[PC++];
  1268.             E = ram[TEMP];
  1269.             D = ram[TEMP + 1];
  1270.         when 0x5e:        /* IM 2 */
  1271.  
  1272.             /*
  1273.              * INTERRUPT: Set IM 2
  1274.              */
  1275.             ;
  1276.         when 0x5f:        /* LD A,R */
  1277.             A = ++R;
  1278.             SIGN = A >> 7;
  1279.             ZERO = A == 0;
  1280.             HALF_CARRY = BCD = 0;
  1281.  
  1282.             /*
  1283.              * INTERRUPT: Copy IFF2 into PARITY
  1284.              */
  1285.  
  1286.             PARITY = 0;
  1287.         when 0x62:        /* SBC HL,HL */
  1288.             TEMP = HL;
  1289.             goto edsbc;
  1290.         when 0x63:        /* LD (nn),HL */
  1291.             TEMPL = ram[PC++];
  1292.             TEMPH = ram[PC++];
  1293.             ram[TEMP] = L;
  1294.             ram[TEMP + 1] = H;
  1295.         when 0x67:        /* RRD */
  1296.             s = lonyb(ram[HL]);
  1297.             HL = (ram[HL] >> 4) | (lonyb(A) << 4);
  1298.             A = (A & 0xf0) | s;
  1299.             SIGN = A >> 7;
  1300.             ZERO = A == 0;
  1301.             PARITY = partab[A];
  1302.             HALF_CARRY = BCD = 0;
  1303.         when 0x6a:        /* ADC HL,HL */
  1304.             TEMP = HL;
  1305.             goto edadc;
  1306.         when 0x6b:        /* LD HL,(nn) */
  1307.             TEMPL = ram[PC++];
  1308.             TEMPH = ram[PC++];
  1309.             L = ram[TEMP];
  1310.             H = ram[TEMP + 1];
  1311.         when 0x6f:        /* RLD */
  1312.             s = hinyb(ram[HL]);
  1313.             ram[HL] = (ram[HL] << 4) | lonyb(A);
  1314.             A = ( A & 0xf0) | s;
  1315.             SIGN = A >> 7;
  1316.             ZERO = A == 0;
  1317.             PARITY = partab[A];
  1318.             HALF_CARRY = BCD = 0;
  1319.         when 0x72:        /* SBC HL,SP */
  1320.             TEMP = SP;
  1321. edsbc:
  1322.             s = (HL & 0xfff) - (TEMP & 0xfff);
  1323.             if (CARRY) --s;
  1324.             HALF_CARRY = s < 0;
  1325.             s = (int)(HL - TEMP);
  1326.             if (CARRY) --s;
  1327.             PARITY = s < -32768 || s > 32767;
  1328.             s = (int)(HL - TEMP);
  1329.             if (CARRY) --s;
  1330.             CARRY = s < 0;
  1331.             HL = s;
  1332.             SIGN =HL >> 15;
  1333.             ZERO = HL == 0;
  1334.             BCD = 1;
  1335.         when 0x73:        /* LD (nn),SP */
  1336.             TEMPL = ram[PC++];
  1337.             TEMPH = ram[PC++];
  1338.             ram[TEMP] = SPL;
  1339.             ram[TEMP + 1] = SPH;
  1340.         when 0x7a:        /* ADC HL,SP */
  1341.             TEMP = SP;
  1342. edadc:
  1343.             s = (HL & 0xfff) + (TEMP & 0xfff);
  1344.             if (CARRY) ++s;
  1345.             HALF_CARRY = s > 0xfff;
  1346.             s = (int)(HL + TEMP);
  1347.             if (CARRY) ++s;
  1348.             s1 = s > 0xffff;
  1349.             s = (int)(HL + TEMP);
  1350.             if (CARRY) ++s;
  1351.             PARITY = s < -32768 || s > 32767;
  1352.             HL = s;
  1353.             CARRY = s1;
  1354.             SIGN = HL >> 15;
  1355.             ZERO = HL == 0;
  1356.             BCD = 0;
  1357.         when 0x7b:        /* LD SP,(nn) */
  1358.             TEMPL = ram[PC++];
  1359.             TEMPH = ram[PC++];
  1360.             SPL = ram[TEMP];
  1361.             SPH = ram[TEMP + 1];
  1362.         when 0xa0:        /* LDI */
  1363.             ram[DE++] = ram[HL++];
  1364.             PARITY = --BC != 0;
  1365.             HALF_CARRY = BCD = 0;
  1366.         when 0xa1:        /* CPI */
  1367.             s = ram[HL++];
  1368.             PARITY= --BC!=0;
  1369.             ZERO = A == s;
  1370.             HALF_CARRY = (int)((A & 0xf) - (s & 0xf)) < 0;
  1371.             s = A - s;
  1372.             SIGN = s >> 7;
  1373.             BCD = 0;
  1374.         when 0xa8:        /* LDD */
  1375.             ram[DE--] = ram[HL--];
  1376.             PARITY = --BC != 0;
  1377.             HALF_CARRY = BCD = 0;
  1378.         when 0xa9:        /* CPD */
  1379.             s = ram[HL--];
  1380.             PARITY = --BC != 0;
  1381.             ZERO = A == s;
  1382.             HALF_CARRY = (int)((A & 0xf) - (s & 0xf)) < 0;
  1383.             s = A - s;
  1384.             SIGN = s >> 7;
  1385.             BCD = 0;
  1386.         when 0xb0:        /* LDIR */
  1387.             do
  1388.                 ram[DE++] = ram[HL++];
  1389.             while (--BC);
  1390.             HALF_CARRY = BCD = PARITY = 0;
  1391.  
  1392.             /*
  1393.              * INTERRUPT: Convert for PC-=2
  1394.              * Also conv CPIR,INIR,OTIR,LDDR,CPDR, etc
  1395.              */
  1396.  
  1397.         when 0xb1:        /* CPIR */
  1398.             do
  1399.             {
  1400.                 s = ram[HL++];
  1401.                 PARITY = --BC != 0;
  1402.                 ZERO = A == s;
  1403.             } while(!ZERO && PARITY);
  1404.             HALF_CARRY = (int)((A & 0xf) - (s & 0xf)) < 0;
  1405.             s = A - s;
  1406.             SIGN = s >> 7;
  1407.             BCD = 0;
  1408.         when 0xb8:        /* LDDR */
  1409.             do
  1410.                 ram[DE--] = ram[HL--];
  1411.             while (--BC);
  1412.             HALF_CARRY = BCD = PARITY = 0;
  1413.         when 0xb9:        /* CPDR */
  1414.             do
  1415.             {
  1416.                 s = ram[HL--];
  1417.                 PARITY = --BC != 0;
  1418.                 ZERO = A == s;
  1419.             } while(!ZERO && PARITY);
  1420.             HALF_CARRY = (int)((A & 0xf) - (s & 0xf)) < 0;
  1421.             s = A - s;
  1422.             SIGN = s >> 7;
  1423.             BCD = 0;
  1424.         }
  1425.     when 238:        /* ee XOR n */
  1426.         s = ram[PC++];
  1427.         goto xor;
  1428.     when 239:        /* ef RST 28 */
  1429.         push(PC);
  1430.         PC = 0x28;
  1431.     when 240:        /* f0 RET P */
  1432.         if (!SIGN)
  1433.             PC = pop();
  1434.     when 241:        /* f1 POP AF */
  1435.         AF = pop();
  1436.     when 242:        /* f2 JP P,nn */
  1437.         if (SIGN) PC += 2;
  1438.         else
  1439.         {
  1440.             TEMPL = ram[PC++];
  1441.             TEMPH = ram[PC++];
  1442.             PC = TEMP;
  1443.         }
  1444.     when 243:        /* f3 DI */
  1445.  
  1446.         /*
  1447.          * INTERRUPT: Disable
  1448.          */
  1449.         ;
  1450.     when 244:        /* f4 CALL P,nn */
  1451.         if (SIGN) PC += 2;
  1452.         else
  1453.         {
  1454.             TEMPL = ram[PC++];
  1455.             TEMPH = ram[PC++];
  1456.             push(PC);
  1457.             PC = TEMP;
  1458.         }
  1459.     when 245:        /* f5 PUSH AF */
  1460.         push(AF);
  1461.     when 246:        /* f6 OR n */
  1462.         s = ram[PC++];
  1463.         goto or;
  1464.     when 247:        /* f7 RST 30 */
  1465.         push(PC);
  1466.         PC = 0x30;
  1467.     when 248:        /* f8 RET M */
  1468.         if (SIGN)
  1469.             PC = pop();
  1470.     when 249:        /* f9 LD SP,HL */
  1471.         SP = HL;
  1472.     when 250:        /* fa JP M,nn */
  1473.         if (SIGN)
  1474.         {
  1475.             TEMPL = ram[PC++];
  1476.             TEMPH = ram[PC++];
  1477.             PC = TEMP;
  1478.         }
  1479.         else PC += 2;
  1480.     when 251:        /* fb EI */
  1481.  
  1482.         /*
  1483.          * INTERRUPT: Enable
  1484.          */
  1485.         ;
  1486.     when 252:        /* fc CALL M,nn */
  1487.         if (SIGN)
  1488.         {
  1489.             TEMPL = ram[PC++];
  1490.             TEMPH = ram[PC++];
  1491.             push(PC);
  1492.             PC = TEMP;
  1493.         }
  1494.         else PC += 2;
  1495.     when 253:        /* FD instructions - use IY register */
  1496.         opcode = ram[PC++];
  1497.         switch (opcode)
  1498.         {
  1499.             case 0x09:        /* 09 ADD IY,BC */
  1500.                 s = BC;
  1501.                 a = (IY & 0xfff) + (s & 0xfff);
  1502.                 s += IY;
  1503.                 IY = s;
  1504.                 BCD = 0;
  1505.                 CARRY = s >> 16;
  1506.                 HALF_CARRY = a >> 12;
  1507.             when 0x19:        /* ADD IY, DE */
  1508.                 s = DE;
  1509.                 a = (IY & 0xfff) + (s & 0xfff);
  1510.                 s += IY;
  1511.                 IY = s;
  1512.                 BCD = 0;
  1513.                 CARRY = s >> 16;
  1514.                 HALF_CARRY = a >> 12;
  1515.             when 0x21:        /* LD IY, nn */
  1516.                 IYL = ram[PC++];
  1517.                 IYH = ram[PC++];
  1518.             when 0x22:        /* LD (nn), IY) */
  1519.                 TEMPL = ram[PC++];
  1520.                 TEMPH = ram[PC++];
  1521.                 ram[TEMP] = IYL;
  1522.                 ram[TEMP + 1] = IYH;
  1523.             when 0x23:        /* INC IY */
  1524.                 IY++;
  1525.             when 0x29:        /* ADD IY, IY */
  1526.                 s = IY;
  1527.                 a = (IY & 0xfff) + (s & 0xfff);
  1528.                 s += IY;
  1529.                 IY = s;
  1530.                 BCD = 0;
  1531.                 CARRY = s >> 16;
  1532.                 HALF_CARRY = a >> 12;
  1533.             when 0x2a:        /* LD IY, (nn) */
  1534.                 TEMPL = ram[PC++];
  1535.                 TEMPH = ram[PC++];
  1536.                 IYL = ram[TEMP];
  1537.                 IYH = ram[TEMP + 1];
  1538.             when 0x2b:        /* DEC IY */
  1539.                 IY--;
  1540.             when 0x34:        /* INC (IY + d) */
  1541.                 ptr = ram + IY + ram[PC++];
  1542.                 HALF_CARRY = lonyb(*ptr) == 0xf;
  1543.                 ++(*ptr);
  1544.                 SIGN = *ptr >> 7;
  1545.                 ZERO = *ptr == 0;
  1546.                 PARITY = *ptr == 0x80;
  1547.                 BCD = 0;
  1548.             when 0x35:        /* DEC (IY + d) */
  1549.                 ptr = ram + IY + ram[PC++];
  1550.                 HALF_CARRY = lonyb(*ptr) != 0;
  1551.                 --(*ptr);
  1552.                 SIGN = *ptr >> 7;
  1553.                 ZERO = *ptr == 0;
  1554.                 PARITY = *ptr == 0x7f;
  1555.                 BCD = 1;
  1556.             when 0x36:        /* LD (IY + d), n */
  1557.                 TEMP = IY + ram[PC++];
  1558.                 ram[TEMP] = ram[PC++];
  1559.             when 0x39:        /* ADD IY, SP */
  1560.                 s = SP;
  1561.                 a = (IY & 0xfff) + (s & 0xfff);
  1562.                 s += IY;
  1563.                 IY = s;
  1564.                 BCD = 0;
  1565.                 CARRY = s >> 16;
  1566.                 HALF_CARRY = a >> 12;
  1567.             when 0x46:        /* LD B, (IY + d) */
  1568.                 B = ram[IY + ram[PC++]];
  1569.             when 0x4e:        /* LD C, (IY + d) */
  1570.                 C = ram[IY + ram[PC++]];
  1571.             when 0x56:        /* LD D, (IY + d) */
  1572.                 D = ram[IY + ram[PC++]];
  1573.             when 0x5e:        /* LD E, (IY + d) */
  1574.                 E = ram[IY + ram[PC++]];
  1575.             when 0x66:        /* LD H, (IY + d) */
  1576.                 H = ram[IY + ram[PC++]];
  1577.             when 0x6e:        /* LD L, (IY + d) */
  1578.                 L = ram[IY + ram[PC++]];
  1579.             when 0x70:        /* LD (IY + d, B */
  1580.                 ram[IY + ram[PC++]] = B;
  1581.             when 0x71:        /* LD (IY + d, C */
  1582.                 ram[IY + ram[PC++]] = C;
  1583.             when 0x72:        /* LD (IY + d, D */
  1584.                 ram[IY + ram[PC++]] = D;
  1585.             when 0x73:        /* LD (IY + d, E */
  1586.                 ram[IY + ram[PC++]] = E;
  1587.             when 0x74:        /* LD (IY + d, H */
  1588.                 ram[IY + ram[PC++]] = H;
  1589.             when 0x75:        /* LD (IY + d, L */
  1590.                 ram[IY + ram[PC++]] = L;
  1591.             when 0x77:        /* LD (IY + d, A */
  1592.                 ram[IY + ram[PC++]] = A;
  1593.             when 0x7e:        /* LD A, (IY + d) */
  1594.                 A = ram[IY + ram[PC++]];
  1595.             when 0x86:        /* ADD A, (IY + d) */
  1596.                 s = ram[IY + ram[PC++]];
  1597.                 goto add;
  1598.             when 0x8e:        /* ADC A, (IY + d) */
  1599.                 s = ram[IY + ram[PC++]];
  1600.                 goto adc;
  1601.             when 0x96:        /* SUB A, (IY + d) */
  1602.                 s = ram[IY + ram[PC++]];
  1603.                 goto sub;
  1604.             when 0x9e:        /* SBC A, (IY + d) */
  1605.                 s = ram[IY + ram[PC++]];
  1606.                 goto sbc;
  1607.             when 0xa6:        /* AND A, (IY + d) */
  1608.                 s = ram[IY + ram[PC++]];
  1609.                 goto and;
  1610.             when 0xae:        /* XOR A, (IY + d) */
  1611.                 s = ram[IY + ram[PC++]];
  1612.                 goto xor;
  1613.             when 0xb6:        /* OR A, (IY + d) */
  1614.                 s = ram[IY + ram[PC++]];
  1615.                 goto or;
  1616.             when 0xbe:        /* CP A, (IY + d) */
  1617.                 s = ram[IY + ram[PC++]];
  1618.                 goto cp;
  1619.             when 0xcb:
  1620.                 ptr = ram + IY + ram[PC++];
  1621.                 goto cb_stuff;
  1622.             when 0xe1:        /* POP IY */
  1623.                 IY = pop();
  1624.             when 0xe3:        /* EX (SP), IY */
  1625.                 s = IY;
  1626.                 IY = pop();
  1627.                 push(s);
  1628.             when 0xe5:        /* PUSH IY */
  1629.                 push(IY);
  1630.             when 0xe9:        /* JP (IY) */
  1631.                 PC = IY;
  1632.             when 0xf9:        /* LD SP, IY */
  1633.                 SP = IY;
  1634.             break; default: return(-1);
  1635.         }
  1636.     when 254:        /* fe CP n */
  1637.         s = ram[PC++];
  1638.         goto cp;
  1639.     when 255:        /* ff RST 38 */
  1640.         push(PC);
  1641.         PC = 0x38;
  1642.     default: return(-1);
  1643.     }
  1644.  
  1645.     return(0);
  1646. }
  1647.