home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Misc / a2 / Source / a2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-21  |  23.0 KB  |  1,693 lines

  1. /*
  2.  *  a2, an Apple II emulator in C
  3.  *  (c) Copyright 1990 by Rich Skrenta
  4.  *
  5.  *  Command line interface written by Tom Markson
  6.  *
  7.  *  Distribution agreement:
  8.  *
  9.  *    You may freely copy or redistribute this software, so long
  10.  *    as there is no profit made from its use, sale, trade or
  11.  *    reproduction.  You may not change this copyright notice,
  12.  *    and it must be included prominently in any copy made.
  13.  *
  14.  *  Send emulator related mail to:  skrenta@blekko.commodore.com
  15.  *                    skrenta@blekko.uucp
  16.  */
  17.  
  18.  
  19. #include    <stdio.h>
  20. #include    "a2.h"
  21.  
  22. #define    BRANCH()    val = mem[Pc++]; if (val & 0x80) Pc += val - 256; else Pc += val;
  23.  
  24. #define    put_status(s) stmp = s; N = stmp & 0x80; V = stmp & 0x40; B = stmp & 0x10; D = stmp & 0x08; I = stmp & 0x04; NZ = !(stmp & 0x02); C = stmp & 0x01;
  25.  
  26.  
  27. extern long trace_lo, trace_hi;
  28. extern FILE *logging_fp;
  29. extern long phantom_location;
  30. extern long breakpoint;
  31.  
  32.  
  33. void run(void)
  34. {
  35.   register unsigned short ptr;
  36.   register unsigned short ptmp;
  37.   register unsigned int val;
  38.   register unsigned int tmp;
  39.   register unsigned int num;
  40.   unsigned char stmp;
  41.   int foo;
  42.   int show_flags = FALSE;
  43.   
  44.  
  45.   unsigned long mjhostet = 0;
  46.  
  47.  
  48.   do {                    /* while (tracing) */
  49.     if (tracing) {
  50.  
  51.       if (breakpoint == Pc) {
  52.     MoveCursor(term_lines, 0);
  53.     printf("Break at $%.4X\n", Pc);
  54.     return;
  55.       }
  56.       
  57.       if (phantom_location == (long) Pc)
  58.     phantom_location = -1;        /* start tracing now */
  59.       
  60.       if (phantom_location == -1
  61.       &&  trace_lo != -1
  62.       &&  (long) Pc >= trace_lo
  63.       &&  (long) Pc <= trace_hi) {
  64.     diss(Pc, logging_fp);
  65.     show_flags = TRUE;
  66.       } else
  67.     show_flags = FALSE;
  68.     }
  69.     
  70.     
  71.     do {                    /* while (running) */
  72.  
  73.  
  74.       /* MJHOSTET HACK */
  75. #if 1
  76.       if (!(mjhostet++ & 32767))
  77.     redraw_hgr_screen (mem + 0x2000);
  78. #endif
  79.  
  80.  
  81.       switch (mem[Pc++]) {
  82.       case 0x00:            /* BRK */
  83.     PCINC;
  84.     push(high(Pc));
  85.     push(low(Pc));
  86.     B = 1;                /* set I flag? */
  87.     push(get_status());
  88.     Pc = join(mem[0xFFFE], mem[0xFFFF]);
  89.     break;
  90.     
  91.       case 0x01:    /* ORA (indirect, X) */
  92.     INDX;
  93.     A |= REFptr;
  94.     SIGN(A);
  95.     ZERO(A);
  96.     break;
  97.     
  98.       case 0x02:
  99.     break;
  100.     
  101.       case 0x03:
  102.     break;
  103.     
  104.       case 0x04:    /* TSB zero page    65C02 */
  105.     break;
  106.     
  107.       case 0x05:    /* ORA zero page */
  108.     A |= rZEROP;
  109.     SIGN(A);
  110.     ZERO(A);
  111.     break;
  112.     
  113.       case 0x06:    /* ASL zero page */
  114.     ZEROP;
  115.     val = REFzero << 1;
  116.     CARRY(val);
  117.     val &= 0xFF;
  118.     SETzero(val);
  119.     SIGN(val);
  120.     ZERO(val);
  121.     break;
  122.     
  123.       case 0x07:
  124.     break;
  125.     
  126.       case 0x08:    /* PHP */
  127.     push(get_status());
  128.     break;
  129.     
  130.       case 0x09:    /* ORA immediate */
  131.     A |= REFimm;
  132.     SIGN(A);
  133.     ZERO(A);
  134.     break;
  135.     
  136.       case 0x0A:    /* ASL accumulator */
  137.     A = A << 1;
  138.     CARRY(A);
  139.     A &= 0xFF;
  140.     SIGN(A);
  141.     ZERO(A);
  142.     break;
  143.     
  144.       case 0x0B:
  145.     break;
  146.     
  147.       case 0x0C:    /* TSB absolute        65C02 */
  148.     break;
  149.     
  150.       case 0x0D:    /* ORA absolute */
  151.     ABSOL;
  152.     A |= REFptr;
  153.     SIGN(A);
  154.     ZERO(A);
  155.     break;
  156.     
  157.       case 0x0E:    /* ASL absolute */
  158.     ABSOL;
  159.     val = REFptr << 1;
  160.     CARRY(val);
  161.     val &= 0xFF;
  162.     SETptr(val);
  163.     SIGN(val);
  164.     ZERO(val);
  165.     break;
  166.     
  167.       case 0x0F:
  168.     break;
  169.     
  170.       case 0x10:    /* BPL */
  171.     if (N) {
  172.       PCINC;
  173.     } else {
  174.       BRANCH();
  175.     }
  176.     break;
  177.     
  178.       case 0x11:    /* ORA (indirect), Y */
  179.     INDY;
  180.     A |= REFptr;
  181.     SIGN(A);
  182.     ZERO(A);
  183.     break;
  184.     
  185.       case 0x12:    /* ORA (indz)        65C02 */
  186.     break;
  187.     
  188.       case 0x13:
  189.     break;
  190.     
  191.       case 0x14:    /* TRB zero page    65C02 */
  192.     break;
  193.     
  194.       case 0x15:    /* ORA zero page, X */
  195.     A |= rZEROX;
  196.     SIGN(A);
  197.     ZERO(A);
  198.     break;
  199.     
  200.       case 0x16:    /* ASL zero page, X */
  201.     ZEROX;
  202.     val = REFzero << 1;
  203.     CARRY(val);
  204.     val &= 0xFF;
  205.     SETzero(val);
  206.     SIGN(val);
  207.     ZERO(val);
  208.     break;
  209.     
  210.       case 0x17:
  211.     break;
  212.     
  213.       case 0x18:    /* CLC */
  214.     C = 0;
  215.     break;
  216.     
  217.       case 0x19:    /* ORA absolute, Y */
  218.     ABSY;
  219.     A |= REFptr;
  220.     SIGN(A);
  221.     ZERO(A);
  222.     break;
  223.     
  224.       case 0x1A:    /* INA            65C02 */
  225.     break;
  226.     
  227.       case 0x1C:    /* TRB absolute        65C02 */
  228.     break;
  229.     
  230.       case 0x1D:    /* ORA absolute, X */
  231.     ABSX;
  232.     A |= REFptr;
  233.     SIGN(A);
  234.     ZERO(A);
  235.     break;
  236.     
  237.       case 0x1E:    /* ASL absolute, X */
  238.     ABSX;
  239.     val = REFptr << 1;
  240.     CARRY(val);
  241.     val &= 0xFF;
  242.     SETptr(val);
  243.     SIGN(val);
  244.     ZERO(val);
  245.     break;
  246.     
  247.       case 0x1F:
  248.     break;
  249.     
  250.       case 0x20:    /* JSR */
  251.     ptmp = REFimm;
  252.     ptmp |= mem[Pc] << 8;
  253.     push(high(Pc));
  254.     push(low(Pc));
  255.     Pc = ptmp;
  256.     
  257.     if (jmp_tbl[Pc])
  258.       jump(jmp_tbl[Pc]);
  259.     break;
  260.     
  261.       case 0x21:    /* AND (indirect, X) */
  262.     INDX;
  263.     A &= REFptr;
  264.     SIGN(A);
  265.     ZERO(A);
  266.     break;
  267.     
  268.       case 0x22:
  269.     break;
  270.     
  271.       case 0x23:
  272.     break;
  273.     
  274.       case 0x24:    /* BIT zero page */
  275.     tmp = rZEROP;
  276.     ZERO(A & tmp);
  277.     N = tmp & 0x80;
  278.     V = tmp & 0x40;
  279.     break;
  280.     
  281.       case 0x25:    /* AND zero page */
  282.     A &= rZEROP;
  283.     SIGN(A);
  284.     ZERO(A);
  285.     break;
  286.     
  287.       case 0x26:    /* ROL zero page */
  288.     ZEROP;
  289.     val = REFzero;
  290.     tmp = C;
  291.     val = val << 1;
  292.     CARRY(val);
  293.     val = (val & 0xFF) | tmp;
  294.     SETzero(val);
  295.     SIGN(val);
  296.     ZERO(val);
  297.     break;
  298.     
  299.       case 0x27:
  300.     break;
  301.     
  302.       case 0x28:    /* PLP */
  303.     put_status(pop());
  304.     break;
  305.     
  306.       case 0x29:    /* AND immediate */
  307.     A &= REFimm;
  308.     SIGN(A);
  309.     ZERO(A);
  310.     break;
  311.     
  312.       case 0x2A:    /* ROL accumulator */
  313.     tmp = C;
  314.     A = A << 1;
  315.     CARRY(A);
  316.     A = (A & 0xFF) | tmp;
  317.     SIGN(A);
  318.     ZERO(A);
  319.     break;
  320.     
  321.       case 0x2B:
  322.     break;
  323.     
  324.       case 0x2C:    /* BIT absolute */
  325.     ABSOL;
  326.     tmp = REFptr;
  327.     ZERO(A & tmp);
  328.     N = tmp & 0x80;
  329.     V = tmp & 0x40;
  330.     break;
  331.     
  332.       case 0x2D:    /* AND absolute */
  333.     ABSOL;
  334.     A &= REFptr;
  335.     SIGN(A);
  336.     ZERO(A);
  337.     break;
  338.     
  339.       case 0x2E:    /* ROL absolute */
  340.     ABSOL;
  341.     val = REFptr;
  342.     tmp = C;
  343.     val = val << 1;
  344.     CARRY(val);
  345.     val = (val & 0xFF) | tmp;
  346.     SETptr(val);
  347.     SIGN(val);
  348.     ZERO(val);
  349.     break;
  350.     
  351.       case 0x2F:
  352.     break;
  353.     
  354.       case 0x30:    /* BMI */
  355.     if (N) {
  356.       BRANCH();
  357.     } else{
  358.       PCINC;
  359.     }
  360.     break;
  361.     
  362.       case 0x31:    /* AND (indirect), Y */
  363.     INDY;
  364.     A &= REFptr;
  365.     SIGN(A);
  366.     ZERO(A);
  367.     break;
  368.     
  369.       case 0x32:    /* AND (indz)        65C02 */
  370.     break;
  371.     
  372.       case 0x33:
  373.     break;
  374.     
  375.       case 0x34:    /* BIT zero page, X    65C02 */
  376.     break;
  377.     
  378.       case 0x35:    /* AND zero page, X */
  379.     A &= rZEROX;
  380.     SIGN(A);
  381.     ZERO(A);
  382.     break;
  383.     
  384.       case 0x36:    /* ROL zero page, X */
  385.     ZEROX;
  386.     val = REFzero;
  387.     tmp = C;
  388.     val = val << 1;
  389.     CARRY(val);
  390.     val = (val & 0xFF) | tmp;
  391.     SETzero(val);
  392.     SIGN(val);
  393.     ZERO(val);
  394.     break;
  395.     
  396.       case 0x37:
  397.     break;
  398.     
  399.       case 0x38:    /* SEC */
  400.     C = 1;
  401.     break;
  402.     
  403.       case 0x39:    /* AND absolute, Y */
  404.     ABSY;
  405.     A &= REFptr;
  406.     SIGN(A);
  407.     ZERO(A);
  408.     break;
  409.     
  410.       case 0x3A:    /* DEA            65C02 */
  411.     break;
  412.     
  413.       case 0x3B:
  414.     break;
  415.     
  416.       case 0x3C:    /* BIT absolute, X    65C02 */
  417.     break;
  418.     
  419.       case 0x3D:    /* AND absolute, X */
  420.     ABSX;
  421.     A &= REFptr;
  422.     SIGN(A);
  423.     ZERO(A);
  424.     break;
  425.     
  426.       case 0x3E:    /* ROL absolute, X */
  427.     ABSX;
  428.     val = REFptr;
  429.     tmp = C;
  430.     val = val << 1;
  431.     CARRY(val);
  432.     val = (val & 0xFF) | tmp;
  433.     SETptr(val);
  434.     SIGN(val);
  435.     ZERO(val);
  436.     break;
  437.     
  438.       case 0x3F:
  439.     break;
  440.     
  441.       case 0x40:    /* RTI */
  442.     put_status(pop());
  443.     Pc = pop();
  444.     Pc |= pop() << 8;
  445.     break;
  446.     
  447.       case 0x41:    /* EOR (indirect, X) */
  448.     INDX;
  449.     A ^= REFptr;
  450.     SIGN(A);
  451.     ZERO(A);
  452.     break;
  453.     
  454.       case 0x42:
  455.     break;
  456.     
  457.       case 0x43:
  458.     break;
  459.     
  460.       case 0x44:
  461.     break;
  462.     
  463.       case 0x45:    /* EOR zero page */
  464.     A ^= rZEROP;
  465.     SIGN(A);
  466.     ZERO(A);
  467.     break;
  468.     
  469.       case 0x46:    /* LSR zero page */
  470.     ZEROP;
  471.     tmp = REFzero;
  472.     C = (tmp & 0x01);
  473.     tmp = tmp >> 1;
  474.     SETzero(tmp);
  475.     N = 0;
  476.     ZERO(tmp);
  477.     break;
  478.     
  479.       case 0x47:
  480.     break;
  481.     
  482.       case 0x48:    /* PHA */
  483.     push(A);
  484.     break;
  485.     
  486.       case 0x49:    /* EOR immediate */
  487.     A ^= REFimm;
  488.     SIGN(A);
  489.     ZERO(A);
  490.     break;
  491.     
  492.       case 0x4A:    /* LSR accumulator */
  493.     C = (A & 0x01);
  494.     A = A >> 1;
  495.     N = 0;
  496.     ZERO(A);
  497.     break;
  498.     
  499.       case 0x4B:
  500.     break;
  501.     
  502.       case 0x4C:    /* JMP absolute */
  503.     ptmp = REFimm;
  504.     ptmp |= REFimm << 8;
  505.     Pc = ptmp;
  506.     
  507.     if (jmp_tbl[Pc])
  508.       jump(jmp_tbl[Pc]);
  509.     break;
  510.     
  511.       case 0x4D:    /* EOR absolute */
  512.     ABSOL;
  513.     A ^= REFptr;
  514.     SIGN(A);
  515.     ZERO(A);
  516.     break;
  517.     
  518.       case 0x4E:    /* LSR absolute */
  519.     ABSOL;
  520.     tmp = REFptr;
  521.     C = (tmp & 0x01);
  522.     tmp = tmp >> 1;
  523.     SETptr(tmp);
  524.     N = 0;
  525.     ZERO(tmp);
  526.     break;
  527.     
  528.       case 0x4F:
  529.     break;
  530.     
  531.       case 0x50:    /* BVC */
  532.     if (V) {
  533.       PCINC;
  534.     } else {
  535.       BRANCH();
  536.     }
  537.     break;
  538.     
  539.       case 0x51:    /* EOR (indirect), Y */
  540.     INDY;
  541.     A ^= REFptr;
  542.     SIGN(A);
  543.     ZERO(A);
  544.     break;
  545.     
  546.       case 0x52:    /* EOR (indz)        65C02 */
  547.     break;
  548.     
  549.       case 0x53:
  550.     break;
  551.     
  552.       case 0x54:
  553.     break;
  554.     
  555.       case 0x55:    /* EOR zero page, X */
  556.     A ^= rZEROX;
  557.     SIGN(A);
  558.     ZERO(A);
  559.     break;
  560.     
  561.       case 0x56:    /* LSR zero page, X */
  562.     ZEROX;
  563.     tmp = REFzero;
  564.     C = (tmp & 0x01);
  565.     tmp = tmp >> 1;
  566.     SETzero(tmp);
  567.     N = 0;
  568.     ZERO(tmp);
  569.     break;
  570.     
  571.       case 0x57:
  572.     break;
  573.     
  574.       case 0x58:    /* CLI */
  575.     I = 0;
  576.     break;
  577.     
  578.       case 0x59:    /* EOR absolute, Y */
  579.     ABSY;
  580.     A ^= REFptr;
  581.     SIGN(A);
  582.     ZERO(A);
  583.     break;
  584.     
  585.       case 0x5A:    /* PHY        65C02 */
  586.     break;
  587.     
  588.       case 0x5B:
  589.     break;
  590.     
  591.       case 0x5C:
  592.     break;
  593.     
  594.       case 0x5D:    /* EOR absolute, X */
  595.     ABSX;
  596.     A ^= REFptr;
  597.     SIGN(A);
  598.     ZERO(A);
  599.     break;
  600.     
  601.       case 0x5E:    /* LSR absolute, X */
  602.     ABSX;
  603.     tmp = REFptr;
  604.     C = (tmp & 0x01);
  605.     tmp = tmp >> 1;
  606.     SETptr(tmp);
  607.     N = 0;
  608.     ZERO(tmp);
  609.     break;
  610.     
  611.       case 0x5F:
  612.     break;
  613.     
  614.       case 0x60:    /* RTS */
  615.     DO_RTS;
  616.     break;
  617.     
  618.       case 0x61:    /* ADC (indirect, X) */
  619.     INDX;
  620.     val = REFptr;
  621.     tmp = A & 0x80;
  622.     stmp = val & 0x80;
  623.     if (D) {
  624.       num = tobinary(val);
  625.       val = tobinary(A);
  626.       
  627.       val += num + C;
  628.       dCARRY(val);
  629.       while (val >= 100)
  630.         val -= 100;
  631.       
  632.       A = tobcd(val);
  633.     } else {
  634.       A += val + C;
  635.       CARRY(A);
  636.       A &= 0xFF;
  637.     }
  638.     ZERO(A);
  639.     SIGN(A);
  640.     V = (tmp == stmp) && (tmp != N);
  641.     break;
  642.     
  643.       case 0x62:
  644.     break;
  645.     
  646.       case 0x63:
  647.     break;
  648.     
  649.       case 0x64:    /* STZ zero page    65C02 */
  650.     break;
  651.     
  652.       case 0x65:    /* ADC zero page */
  653.     val = rZEROP;
  654.     tmp = A & 0x80;
  655.     stmp = val & 0x80;
  656.     if (D) {
  657.       num = tobinary(val);
  658.       val = tobinary(A);
  659.       
  660.       val += num + C;
  661.       dCARRY(val);
  662.       while (val >= 100)
  663.         val -= 100;
  664.       
  665.       A = tobcd(val);
  666.     } else {
  667.       A += val + C;
  668.       CARRY(A);
  669.       A &= 0xFF;
  670.     }
  671.     ZERO(A);
  672.     SIGN(A);
  673.     V = (tmp == stmp) && (tmp != N);
  674.     break;
  675.     
  676.     
  677.       case 0x66:    /* ROR zero page */
  678.     ZEROP;
  679.     val = REFzero;
  680.     tmp = C;
  681.     C = val & 0x01;
  682.     val = val >> 1;
  683.     val |= tmp << 7;
  684.     SETzero(val);
  685.     SIGN(val);
  686.     ZERO(val);
  687.     break;
  688.     
  689.       case 0x67:
  690.     break;
  691.     
  692.       case 0x68:    /* PLA */
  693.     A = pop();
  694.     SIGN(A);
  695.     ZERO(A);
  696.     break;
  697.     
  698.       case 0x69:    /* ADC immediate */
  699.     val = REFimm;
  700.     tmp = A & 0x80;
  701.     stmp = val & 0x80;
  702.     if (D) {
  703.       num = tobinary(val);
  704.       val = tobinary(A);
  705.       
  706.       val += num + C;
  707.       dCARRY(val);
  708.       while (val >= 100)
  709.         val -= 100;
  710.       
  711.       A = tobcd(val);
  712.     } else {
  713.       A += val + C;
  714.       CARRY(A);
  715.       A &= 0xFF;
  716.     }
  717.     ZERO(A);
  718.     SIGN(A);
  719.     V = (tmp == stmp) && (tmp != N);
  720.     break;
  721.     
  722.       case 0x6A:    /* ROR accumulator */
  723.     tmp = C;
  724.     C = A & 0x01;
  725.     A = A >> 1;
  726.     A |= tmp << 7;
  727.     SIGN(A);
  728.     ZERO(A);
  729.     break;
  730.     
  731.       case 0x6B:
  732.     break;
  733.     
  734.       case 0x6C:    /* JMP indirect */
  735.     ptmp = REFimm;
  736.     ptmp |= REFimm << 8;
  737.     Pc = mem[ptmp++];
  738.     Pc |= mem[ptmp] << 8;
  739.     
  740.     if (jmp_tbl[Pc])
  741.       jump(jmp_tbl[Pc]);
  742.     break;
  743.     
  744.       case 0x6D:    /* ADC absolute */
  745.     ABSOL;
  746.     val = REFptr;
  747.     tmp = A & 0x80;
  748.     stmp = val & 0x80;
  749.     if (D) {
  750.       num = tobinary(val);
  751.       val = tobinary(A);
  752.       
  753.       val += num + C;
  754.       dCARRY(val);
  755.       while (val >= 100)
  756.         val -= 100;
  757.       
  758.       A = tobcd(val);
  759.     } else {
  760.       A += val + C;
  761.       CARRY(A);
  762.       A &= 0xFF;
  763.     }
  764.     ZERO(A);
  765.     SIGN(A);
  766.     V = (tmp == stmp) && (tmp != N);
  767.     break;
  768.     
  769.       case 0x6E:    /* ROR absolute */
  770.     ABSOL;
  771.     val = REFptr;
  772.     tmp = C;
  773.     C = val & 0x01;
  774.     val = val >> 1;
  775.     val |= tmp << 7;
  776.     SETptr(val);
  777.     SIGN(val);
  778.     ZERO(val);
  779.     break;
  780.     
  781.       case 0x6F:
  782.     break;
  783.     
  784.       case 0x70:    /* BVS */
  785.     if (V) {
  786.       BRANCH();
  787.     } else {
  788.       PCINC;
  789.     }
  790.     break;
  791.     
  792.       case 0x71:    /* ADC (indirect),Y */
  793.     INDY;
  794.     val = REFptr;
  795.     tmp = A & 0x80;
  796.     stmp = val & 0x80;
  797.     if (D) {
  798.       num = tobinary(val);
  799.       val = tobinary(A);
  800.       
  801.       val += num + C;
  802.       dCARRY(val);
  803.       while (val >= 100)
  804.         val -= 100;
  805.       
  806.       A = tobcd(val);
  807.     } else {
  808.       A += val + C;
  809.       CARRY(A);
  810.       A &= 0xFF;
  811.     }
  812.     ZERO(A);
  813.     SIGN(A);
  814.     V = (tmp == stmp) && (tmp != N);
  815.     break;
  816.     
  817.       case 0x72:    /* ADC (indz)        65C02 */
  818.     break;
  819.     
  820.       case 0x73:
  821.     break;
  822.     
  823.       case 0x74:    /* STZ zero page, X    65C02 */
  824.     break;
  825.     
  826.       case 0x75:    /* ADC zero page, X */
  827.     val = rZEROX;
  828.     tmp = A & 0x80;
  829.     stmp = val & 0x80;
  830.     if (D) {
  831.       num = tobinary(val);
  832.       val = tobinary(A);
  833.       
  834.       val += num + C;
  835.       dCARRY(val);
  836.       while (val >= 100)
  837.         val -= 100;
  838.       
  839.       A = tobcd(val);
  840.     } else {
  841.       A += val + C;
  842.       CARRY(A);
  843.       A &= 0xFF;
  844.     }
  845.     ZERO(A);
  846.     SIGN(A);
  847.     V = (tmp == stmp) && (tmp != N);
  848.     break;
  849.     
  850.       case 0x76:    /* ROR zero page, X */
  851.     ZEROX;
  852.     val = REFzero;
  853.     tmp = C;
  854.     C = val & 0x01;
  855.     val = val >> 1;
  856.     val |= tmp << 7;
  857.     SETzero(val);
  858.     SIGN(val);
  859.     ZERO(val);
  860.     break;
  861.     
  862.       case 0x77:
  863.     break;
  864.     
  865.       case 0x78:    /* SEI */
  866.     I = 1;
  867.     break;
  868.     
  869.       case 0x79:    /* ADC absolute, Y */
  870.     ABSY;
  871.     val = REFptr;
  872.     tmp = A & 0x80;
  873.     stmp = val & 0x80;
  874.     if (D) {
  875.       num = tobinary(val);
  876.       val = tobinary(A);
  877.       
  878.       val += num + C;
  879.       dCARRY(val);
  880.       while (val >= 100)
  881.         val -= 100;
  882.       
  883.       A = tobcd(val);
  884.     } else {
  885.       A += val + C;
  886.       CARRY(A);
  887.       A &= 0xFF;
  888.     }
  889.     ZERO(A);
  890.     SIGN(A);
  891.     V = (tmp == stmp) && (tmp != N);
  892.     break;
  893.     
  894.       case 0x7A:    /* PLY        65C02 */
  895.     break;
  896.     
  897.       case 0x7B:
  898.     break;
  899.     
  900.       case 0x7C:    /* JMP (abs indirect, X)    65C02 */
  901.     break;
  902.     
  903.       case 0x7D:    /* ADC absolute, X */
  904.     ABSX;
  905.     val = REFptr;
  906.     tmp = A & 0x80;
  907.     stmp = val & 0x80;
  908.     if (D) {
  909.       num = tobinary(val);
  910.       val = tobinary(A);
  911.       
  912.       val += num + C;
  913.       dCARRY(val);
  914.       while (val >= 100)
  915.         val -= 100;
  916.       
  917.       A = tobcd(val);
  918.     } else {
  919.       A += val + C;
  920.       CARRY(A);
  921.       A &= 0xFF;
  922.     }
  923.     ZERO(A);
  924.     SIGN(A);
  925.     V = (tmp == stmp) && (tmp != N);
  926.     break;
  927.     
  928.       case 0x7E:    /* ROR absolute, X */
  929.     ABSX;
  930.     val = REFptr;
  931.     tmp = C;
  932.     C = val & 0x01;
  933.     val = val >> 1;
  934.     val |= tmp << 7;
  935.     SETptr(val);
  936.     SIGN(val);
  937.     ZERO(val);
  938.     break;
  939.     
  940.       case 0x7F:
  941.     break;
  942.     
  943.       case 0x80:    /* BRA            65C02 */
  944.     break;
  945.     
  946.       case 0x81:    /* STA (indirect, X) */
  947.     INDX;
  948.     SETptr(A);
  949.     break;
  950.     
  951.       case 0x82:
  952.     break;
  953.     
  954.       case 0x83:
  955.     break;
  956.     
  957.       case 0x84:    /* STY zero page */
  958.     sZEROP(Y);
  959.     break;
  960.     
  961.       case 0x85:    /* STA zero page */
  962.     sZEROP(A);
  963.     break;
  964.     
  965.       case 0x86:    /* STX zero page */
  966.     sZEROP(X);
  967.     break;
  968.     
  969.       case 0x87:
  970.     break;
  971.     
  972.       case 0x88:    /* DEY */
  973.     Y--;
  974.     SIGN(Y);
  975.     ZERO(Y);
  976.     break;
  977.     
  978.       case 0x89:
  979.     break;
  980.     
  981.       case 0x8A:    /* TXA */
  982.     A = X;
  983.     SIGN(A);
  984.     ZERO(A);
  985.     break;
  986.     
  987.       case 0x8B:
  988.     break;
  989.     
  990.       case 0x8C:    /* STY absolute */
  991.     ABSOL;
  992.     SETptr(Y);
  993.     break;
  994.     
  995.       case 0x8D:    /* STA absolute */
  996.     ABSOL;
  997.     SETptr(A);
  998.     break;
  999.     
  1000.       case 0x8E:    /* STX absolute */
  1001.     ABSOL;
  1002.     SETptr(X);
  1003.     break;
  1004.     
  1005.       case 0x8F:
  1006.     break;
  1007.     
  1008.       case 0x90:    /* BCC */
  1009.     if (C) {
  1010.       PCINC;
  1011.     } else {
  1012.       BRANCH();
  1013.     }
  1014.     break;
  1015.     
  1016.       case 0x91:    /* STA (indirect), Y */
  1017.     INDY;
  1018.     SETptr(A);
  1019.     break;
  1020.     
  1021.       case 0x92:
  1022.     break;
  1023.     
  1024.       case 0x93:
  1025.     break;
  1026.     
  1027.       case 0x94:    /* STY zero page, X */
  1028.     sZEROX(Y);
  1029.     break;
  1030.     
  1031.       case 0x95:    /* STA zero page, X */
  1032.     sZEROX(A);
  1033.     break;
  1034.     
  1035.       case 0x96:    /* STX zero page, Y */
  1036.     sZEROY(X);
  1037.     break;
  1038.     
  1039.       case 0x97:
  1040.     break;
  1041.     
  1042.       case 0x98:    /* TYA */
  1043.     A = Y;
  1044.     SIGN(A);
  1045.     ZERO(A);
  1046.     break;
  1047.     
  1048.       case 0x99:    /* STA absolute, Y */
  1049.     ABSY;
  1050.     SETptr(A);
  1051.     break;
  1052.     
  1053.       case 0x9A:    /* TXS */
  1054.     Sp = X;
  1055.     break;
  1056.     
  1057.       case 0x9B:
  1058.     break;
  1059.     
  1060.       case 0x9C:    /* STZ absolute        65C02 */
  1061.     break;
  1062.     
  1063.       case 0x9D:    /* STA absolute, X */
  1064.     ABSX;
  1065.     SETptr(A);
  1066.     break;
  1067.     
  1068.       case 0x9E:    /* STZ absolute, X    65C02 */
  1069.     break;
  1070.     
  1071.       case 0x9F:
  1072.     break;
  1073.     
  1074.       case 0xA0:    /* LDY immediate */
  1075.     Y = REFimm;
  1076.     SIGN(Y);
  1077.     ZERO(Y);
  1078.     break;
  1079.     
  1080.       case 0xA1:    /* LDA (indirect, X) */
  1081.     INDX;
  1082.     A = REFptr;
  1083.     SIGN(A);
  1084.     ZERO(A);
  1085.     break;
  1086.     
  1087.       case 0xA2:    /* LDX immediate */
  1088.     X = REFimm;
  1089.     SIGN(X);
  1090.     ZERO(X);
  1091.     break;
  1092.     
  1093.       case 0xA3:
  1094.     break;
  1095.     
  1096.       case 0xA4:     /* LDY zero page */
  1097.     Y = rZEROP;
  1098.     SIGN(Y);
  1099.     ZERO(Y);
  1100.     break;
  1101.     
  1102.       case 0xA5:    /* LDA zero page */
  1103.     A = rZEROP;
  1104.     SIGN(A);
  1105.     ZERO(A);
  1106.     break;
  1107.     
  1108.       case 0xA6:    /* LDX zero page */
  1109.     X = rZEROP;
  1110.     SIGN(X);
  1111.     ZERO(X);
  1112.     break;
  1113.     
  1114.       case 0xA7:
  1115.     break;
  1116.     
  1117.       case 0xA8:    /* TAY */
  1118.     Y = A;
  1119.     SIGN(Y);
  1120.     ZERO(Y);
  1121.     break;
  1122.     
  1123.       case 0xA9:    /* LDA immediate */
  1124.     A = REFimm;
  1125.     SIGN(A);
  1126.     ZERO(A);
  1127.     break;
  1128.     
  1129.       case 0xAA:    /* TAX */
  1130.     X = A;
  1131.     SIGN(X);
  1132.     ZERO(X);
  1133.     break;
  1134.     
  1135.       case 0xAB:
  1136.     break;
  1137.     
  1138.       case 0xAC:    /* LDY absolute */
  1139.     ABSOL;
  1140.     Y = REFptr;
  1141.     SIGN(Y);
  1142.     ZERO(Y);
  1143.     break;
  1144.     
  1145.       case 0xAD:    /* LDA absolute */
  1146.     ABSOL;
  1147.     A = REFptr;
  1148.     SIGN(A);
  1149.     ZERO(A);
  1150.     break;
  1151.     
  1152.       case 0xAE:    /* LDX absolute */
  1153.     ABSOL;
  1154.     X = REFptr;
  1155.     SIGN(X);
  1156.     ZERO(X);
  1157.     break;
  1158.     
  1159.       case 0xAF:
  1160.     break;
  1161.     
  1162.       case 0xB0:    /* BCS */
  1163.     if (C) {
  1164.       BRANCH();
  1165.     } else {
  1166.       PCINC;
  1167.     }
  1168.     break;
  1169.     
  1170.       case 0xB1:    /* LDA (indirect), Y */
  1171.     INDY;
  1172.     A = REFptr;
  1173.     SIGN(A);
  1174.     ZERO(A);
  1175.     break;
  1176.     
  1177.       case 0xB2:    /* LDA (indz)        65C02 */
  1178.     break;
  1179.     
  1180.       case 0xB3:
  1181.     break;
  1182.     
  1183.       case 0xB4:    /* LDY zero page, X */
  1184.     Y = rZEROX;
  1185.     SIGN(Y);
  1186.     ZERO(Y);
  1187.     break;
  1188.     
  1189.       case 0xB5:    /* LDA zero page, X */
  1190.     A = rZEROX;
  1191.     SIGN(A);
  1192.     ZERO(A);
  1193.     break;
  1194.     
  1195.       case 0xB6:    /* LDX zero page, Y */
  1196.     X = rZEROY;
  1197.     SIGN(X);
  1198.     ZERO(X);
  1199.     break;
  1200.     
  1201.       case 0xB7:
  1202.     break;
  1203.     
  1204.       case 0xB8:    /* CLV */
  1205.     V = 0;
  1206.     break;
  1207.     
  1208.       case 0xB9:    /* LDA absolute, Y */
  1209.     ABSY;
  1210.     A = REFptr;
  1211.     SIGN(A);
  1212.     ZERO(A);
  1213.     break;
  1214.     
  1215.       case 0xBA:    /* TSX */
  1216.     X = Sp;
  1217.     SIGN(X);
  1218.     ZERO(X);
  1219.     break;
  1220.     
  1221.       case 0xBB:
  1222.     break;
  1223.     
  1224.       case 0xBC:    /* LDY absolute, X */
  1225.     ABSX;
  1226.     Y = REFptr;
  1227.     SIGN(Y);
  1228.     ZERO(Y);
  1229.     break;
  1230.     
  1231.       case 0xBD:    /* LDA absolute, X */
  1232.     ABSX;
  1233.     A = REFptr;
  1234.     SIGN(A);
  1235.     ZERO(A);
  1236.     break;
  1237.     
  1238.       case 0xBE:    /* LDX absolute, Y */
  1239.     ABSY;
  1240.     X = REFptr;
  1241.     SIGN(X);
  1242.     ZERO(X);
  1243.     break;
  1244.     
  1245.       case 0xBF:
  1246.     break;
  1247.     
  1248.       case 0xC0:    /* CPY immediate */
  1249.     tmp = REFimm;
  1250.     C = (Y >= tmp);
  1251.     tmp = (Y - tmp) & 0xFF;
  1252.     SIGN(tmp);
  1253.     ZERO(tmp);
  1254.     break;
  1255.     
  1256.       case 0xC1:    /* CMP (indirect, X) */
  1257.     INDX;
  1258.     tmp = REFptr;
  1259.     C = (A >= tmp);
  1260.     tmp = (A - tmp) & 0xFF;
  1261.     SIGN(tmp);
  1262.     ZERO(tmp);
  1263.     break;
  1264.     
  1265.       case 0xC2:
  1266.     break;
  1267.     
  1268.       case 0xC3:
  1269.     break;
  1270.     
  1271.       case 0xC4:    /* CPY zero page */
  1272.     tmp = rZEROP;
  1273.     C = (Y >= tmp);
  1274.     tmp = (Y - tmp) & 0xFF;
  1275.     SIGN(tmp);
  1276.     ZERO(tmp);
  1277.     break;
  1278.     
  1279.       case 0xC5:    /* CMP zero page */
  1280.     tmp = rZEROP;
  1281.     C = (A >= tmp);
  1282.     tmp = (A - tmp) & 0xFF;
  1283.     SIGN(tmp);
  1284.     ZERO(tmp);
  1285.     break;
  1286.     
  1287.       case 0xC6:    /* DEC zero page */
  1288.     ZEROP;
  1289.     stmp = REFzero - 1;
  1290.     SETzero(stmp);
  1291.     SIGN(stmp);
  1292.     ZERO(stmp);
  1293.     break;
  1294.     
  1295.       case 0xC7:
  1296.     break;
  1297.     
  1298.       case 0xC8:    /* INY */
  1299.     Y++;
  1300.     SIGN(Y);
  1301.     ZERO(Y);
  1302.     break;
  1303.     
  1304.       case 0xC9:    /* CMP immediate */
  1305.     tmp = REFimm;
  1306.     C = (A >= tmp);
  1307.     tmp = (A - tmp) & 0xFF;
  1308.     SIGN(tmp);
  1309.     ZERO(tmp);
  1310.     break;
  1311.     
  1312.       case 0xCA:    /* DEX */
  1313.     X--;
  1314.     SIGN(X);
  1315.     ZERO(X);
  1316.     break;
  1317.     
  1318.       case 0xCB:
  1319.     break;
  1320.     
  1321.       case 0xCC:    /* CPY absolute */
  1322.     ABSOL;
  1323.     tmp = REFptr;
  1324.     C = (Y >= tmp);
  1325.     tmp = (Y - tmp) & 0xFF;
  1326.     SIGN(tmp);
  1327.     ZERO(tmp);
  1328.     break;
  1329.     
  1330.       case 0xCD:    /* CMP absolute */
  1331.     ABSOL;
  1332.     tmp = REFptr;
  1333.     C = (A >= tmp);
  1334.     tmp = (A - tmp) & 0xFF;
  1335.     SIGN(tmp);
  1336.     ZERO(tmp);
  1337.     break;
  1338.     
  1339.       case 0xCE:    /* DEC absolute */
  1340.     ABSOL;
  1341.     stmp = REFptr - 1;
  1342.     SETptr(stmp);
  1343.     SIGN(stmp);
  1344.     ZERO(stmp);
  1345.     break;
  1346.     
  1347.       case 0xCF:
  1348.     break;
  1349.     
  1350.       case 0xD0:    /* BNE */
  1351.     if (NZ) {
  1352.       BRANCH();
  1353.     } else {
  1354.       PCINC;
  1355.     }
  1356.     break;
  1357.     
  1358.       case 0xD1:    /* CMP (indirect), Y */
  1359.     INDY;
  1360.     tmp = REFptr;
  1361.     C = (A >= tmp);
  1362.     tmp = (A - tmp) & 0xFF;
  1363.     SIGN(tmp);
  1364.     ZERO(tmp);
  1365.     break;
  1366.     
  1367.       case 0xD2:    /* CMP (indz)        65C02 */
  1368.     break;
  1369.     
  1370.       case 0xD3:
  1371.     break;
  1372.     
  1373.       case 0xD4:
  1374.     break;
  1375.     
  1376.       case 0xD5:    /* CMP zero page, X */
  1377.     tmp = rZEROX;
  1378.     C = (A >= tmp);
  1379.     tmp = (A - tmp) & 0xFF;
  1380.     SIGN(tmp);
  1381.     ZERO(tmp);
  1382.     break;
  1383.     
  1384.       case 0xD6:    /* DEC zero page, X */
  1385.     ZEROX;
  1386.     stmp = REFzero - 1;
  1387.     SETzero(stmp);
  1388.     SIGN(stmp);
  1389.     ZERO(stmp);
  1390.     break;
  1391.     
  1392.       case 0xD7:
  1393.     break;
  1394.     
  1395.       case 0xD8:    /* CLD */
  1396.     D = 0;
  1397.     break;
  1398.     
  1399.       case 0xD9:    /* CMP absolute, Y */
  1400.     ABSY;
  1401.     tmp = REFptr;
  1402.     C = (A >= tmp);
  1403.     tmp = (A - tmp) & 0xFF;
  1404.     SIGN(tmp);
  1405.     ZERO(tmp);
  1406.     break;
  1407.     
  1408.       case 0xDA:    /* PHX        65C02 */
  1409.     break;
  1410.     
  1411.       case 0xDB:
  1412.     break;
  1413.     
  1414.       case 0xDC:
  1415.     break;
  1416.     
  1417.       case 0xDD:    /* CMP absolute, X */
  1418.     ABSX;
  1419.     tmp = REFptr;
  1420.     C = (A >= tmp);
  1421.     tmp = (A - tmp) & 0xFF;
  1422.     SIGN(tmp);
  1423.     ZERO(tmp);
  1424.     break;
  1425.     
  1426.       case 0xDE:    /* DEC absolute, X */
  1427.     ABSX;
  1428.     stmp = REFptr - 1;
  1429.     SETptr(stmp);
  1430.     SIGN(stmp);
  1431.     ZERO(stmp);
  1432.     break;
  1433.     
  1434.       case 0xDF:
  1435.     break;
  1436.     
  1437.       case 0xE0:    /* CPX immediate */
  1438.     tmp = REFimm;
  1439.     C = (X >= tmp);
  1440.     tmp = (X - tmp) & 0xFF;
  1441.     SIGN(tmp);
  1442.     ZERO(tmp);
  1443.     break;
  1444.     
  1445.       case 0xE1:    /* SBC (indirect, X) */
  1446.     INDX;
  1447.     val = REFptr;
  1448.     tmp = A & 0x80;
  1449.     stmp = val & 0x80;
  1450.     if (D) {
  1451.       assert(FALSE);
  1452.     } else {
  1453.       foo = A - (val + !C);
  1454.       C = (foo >= 0);
  1455.       A = foo & 0xFF;
  1456.     }
  1457.     ZERO(A);
  1458.     SIGN(A);
  1459.     V = (tmp != stmp) && (tmp != N);
  1460.     break;
  1461.     
  1462.       case 0xE2:
  1463.     break;
  1464.     
  1465.       case 0xE3:
  1466.     break;
  1467.     
  1468.       case 0xE4:    /* CPX zero page */
  1469.     tmp = rZEROP;
  1470.     C = (X >= tmp);
  1471.     tmp = (X - tmp) & 0xFF;
  1472.     SIGN(tmp);
  1473.     ZERO(tmp);
  1474.     break;
  1475.     
  1476.       case 0xE5:    /* SBC zero page */
  1477.     val = rZEROP;
  1478.     tmp = A & 0x80;
  1479.     stmp = val & 0x80;
  1480.     if (D) {
  1481.       assert(FALSE);
  1482.     } else {
  1483.       foo = A - (val + !C);
  1484.       C = (foo >= 0);
  1485.       A = foo & 0xFF;
  1486.     }
  1487.     ZERO(A);
  1488.     SIGN(A);
  1489.     V = (tmp != stmp) && (tmp != N);
  1490.     break;
  1491.     
  1492.       case 0xE6:    /* INC zero page */
  1493.     ZEROP;
  1494.     stmp = REFzero + 1;
  1495.     SIGN(stmp);
  1496.     ZERO(stmp);
  1497.     SETzero(stmp);
  1498.     break;
  1499.     
  1500.       case 0xE7:
  1501.     break;
  1502.     
  1503.       case 0xE8:    /* INX */
  1504.     X++;
  1505.     SIGN(X);
  1506.     ZERO(X);
  1507.     break;
  1508.     
  1509.       case 0xE9:    /* SBC immediate */
  1510.     val = REFimm;
  1511.     tmp = A & 0x80;
  1512.     stmp = val & 0x80;
  1513.     if (D) {
  1514.       assert(FALSE);
  1515.     } else {
  1516.       foo = A - (val + !C);
  1517.       C = (foo >= 0);
  1518.       A = foo & 0xFF;
  1519.     }
  1520.     ZERO(A);
  1521.     SIGN(A);
  1522.     V = (tmp != stmp) && (tmp != N);
  1523.     break;
  1524.     
  1525.       case 0xEA:    /* NOP */
  1526.     break;
  1527.     
  1528.       case 0xEB:
  1529.     break;
  1530.     
  1531.       case 0xEC:    /* CPX absolute */
  1532.     ABSOL;
  1533.     tmp = REFptr;
  1534.     C = (X >= tmp);
  1535.     tmp = (X - tmp) & 0xFF;
  1536.     SIGN(tmp);
  1537.     ZERO(tmp);
  1538.     break;
  1539.     
  1540.       case 0xED:    /* SBC absolute */
  1541.     ABSOL;
  1542.     val = REFptr;
  1543.     tmp = A & 0x80;
  1544.     stmp = val & 0x80;
  1545.     if (D) {
  1546.       assert(FALSE);
  1547.     } else {
  1548.       foo = A - (val + !C);
  1549.       C = (foo >= 0);
  1550.       A = foo & 0xFF;
  1551.     }
  1552.     ZERO(A);
  1553.     SIGN(A);
  1554.     V = (tmp != stmp) && (tmp != N);
  1555.     break;
  1556.     
  1557.       case 0xEE:    /* INC absolute */
  1558.     ABSOL;
  1559.     stmp = REFptr + 1;
  1560.     SETptr(stmp);
  1561.     SIGN(stmp);
  1562.     ZERO(stmp);
  1563.     break;
  1564.     
  1565.       case 0xEF:
  1566.     break;
  1567.     
  1568.       case 0xF0:    /* BEQ */
  1569.     if (NZ) {
  1570.       PCINC;
  1571.     } else {
  1572.       BRANCH();
  1573.     }
  1574.     break;
  1575.     
  1576.       case 0xF1:    /* SBC (indirect), Y */
  1577.     INDY;
  1578.     val = REFptr;
  1579.     tmp = A & 0x80;
  1580.     stmp = val & 0x80;
  1581.     if (D) {
  1582.       assert(FALSE);
  1583.     } else {
  1584.       foo = A - (val + !C);
  1585.       C = (foo >= 0);
  1586.       A = foo & 0xFF;
  1587.     }
  1588.     ZERO(A);
  1589.     SIGN(A);
  1590.     V = (tmp != stmp) && (tmp != N);
  1591.     break;
  1592.     
  1593.       case 0xF2:    /* SBC (indz)        65C02 */
  1594.     break;
  1595.     
  1596.       case 0xF3:
  1597.     break;
  1598.     
  1599.       case 0xF4:
  1600.     break;
  1601.     
  1602.       case 0xF5:    /* SBC zero page, X */
  1603.     val = rZEROX;
  1604.     tmp = A & 0x80;
  1605.     stmp = val & 0x80;
  1606.     if (D) {
  1607.       assert(FALSE);
  1608.     } else {
  1609.       foo = A - (val + !C);
  1610.       C = (foo >= 0);
  1611.       A = foo & 0xFF;
  1612.     }
  1613.     ZERO(A);
  1614.     SIGN(A);
  1615.     V = (tmp != stmp) && (tmp != N);
  1616.     break;
  1617.     
  1618.       case 0xF6:    /* INC zero page, X */
  1619.     ZEROX;
  1620.     stmp = REFzero + 1;
  1621.     SETzero(stmp);
  1622.     SIGN(stmp);
  1623.     ZERO(stmp);
  1624.     break;
  1625.     
  1626.       case 0xF7:
  1627.     break;
  1628.     
  1629.       case 0xF8:    /* SED */
  1630.     D = 1;
  1631.     break;
  1632.     
  1633.       case 0xF9:    /* SBC absolute, Y */
  1634.     ABSY;
  1635.     val = REFptr;
  1636.     tmp = A & 0x80;
  1637.     stmp = val & 0x80;
  1638.     if (D) {
  1639.       assert(FALSE);
  1640.     } else {
  1641.       foo = A - (val + !C);
  1642.       C = (foo >= 0);
  1643.       A = foo & 0xFF;
  1644.     }
  1645.     ZERO(A);
  1646.     SIGN(A);
  1647.     V = (tmp != stmp) && (tmp != N);
  1648.     break;
  1649.     
  1650.       case 0xFA:    /* PLX        65C02 */
  1651.     break;
  1652.     
  1653.       case 0xFB:
  1654.     break;
  1655.     
  1656.       case 0xFC:
  1657.     break;
  1658.     
  1659.       case 0xFD:    /* SBC absolute, X */
  1660.     ABSX;
  1661.     val = REFptr;
  1662.     tmp = A & 0x80;
  1663.     stmp = val & 0x80;
  1664.     if (D) {
  1665.       assert(FALSE);
  1666.     } else {
  1667.       foo = A - (val + !C);
  1668.       C = (foo >= 0);
  1669.       A = foo & 0xFF;
  1670.     }
  1671.     ZERO(A);
  1672.     SIGN(A);
  1673.     V = (tmp != stmp) && (tmp != N);
  1674.     break;
  1675.     
  1676.       case 0xFE:    /* INC absolute, X */
  1677.     ABSX;
  1678.     stmp = REFptr + 1;
  1679.     SETptr(stmp);
  1680.     SIGN(stmp);
  1681.     ZERO(stmp);
  1682.     break;
  1683.     
  1684.       case 0xFF:
  1685.     break;
  1686.       }
  1687.     } while (running);
  1688.     
  1689.     if (show_flags)
  1690.       flags(logging_fp);
  1691.   } while (tracing);
  1692. }
  1693.