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