Guest User

Untitled

a guest
Aug 27th, 2010
97
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.           }case 40:{
  2.  
  3.                 // *******
  4.                 // * ROR *
  5.                 // *******
  6.  
  7.                 // Rotate one bit right
  8.                 if(addrMode == 4){ // ADDR_ACC = 4
  9.  
  10.             readout("Rotate the value in Accumulator right one bit");
  11.  
  12.                 }else{
  13.             readout("Rotate the value at " + addr + " right one bit");
  14.                 }
  15.                 break;
  16.  
  17.             }case 41:{
  18.  
  19.                 // *******
  20.                 // * RTI *
  21.                 // *******
  22.  
  23.                 // Return from interrupt. Pull status and PC from stack.
  24.            
  25.             readout("Return from interrupt; read CPU status regs and program counter address from the stack");
  26.                 break;
  27.  
  28.             }case 42:{
  29.  
  30.                 // *******
  31.                 // * RTS *
  32.                 // *******
  33.  
  34.                 // Return from subroutine. Pull PC from stack.
  35.               readout("Return from subroutine; read program counter address off the stack");
  36.                 break;
  37.  
  38.             }case 43:{
  39.  
  40.                 // *******
  41.                 // * SBC *
  42.                 // *******
  43.             readout("Subtract value at address " + addr + " from Accumulator");
  44.                 break;
  45.  
  46.             }case 44:{
  47.  
  48.                 // *******
  49.                 // * SEC *
  50.                 // *******
  51.  
  52.                 // Set carry flag
  53.             readout("Set carry bit to 1");
  54.                 break;
  55.  
  56.             }case 45:{
  57.  
  58.                 // *******
  59.                 // * SED *
  60.                 // *******
  61.  
  62.                 // Set decimal mode
  63.             readout("Set decimal mode bit to 1");
  64.                 break;
  65.  
  66.             }case 46:{
  67.  
  68.                 // *******
  69.                 // * SEI *
  70.                 // *******
  71.  
  72.                 // Set interrupt disable status
  73.             readout("Disable interrupts");
  74.                 break;
  75.  
  76.             }case 47:{
  77.  
  78.                 // *******
  79.                 // * STA *
  80.                 // *******
  81.  
  82.                 // Store accumulator in memory
  83.             readout("Move Accumulator to address " + addr);
  84.                 break;
  85.  
  86.             }case 48:{
  87.  
  88.                 // *******
  89.                 // * STX *
  90.                 // *******
  91.  
  92.                 // Store index X in memory
  93.             readout("Move X-index to address " + addr);
  94.                 break;
  95.  
  96.             }case 49:{
  97.  
  98.                 // *******
  99.                 // * STY *
  100.                 // *******
  101.  
  102.                 // Store index Y in memory:
  103.             readout("Move Y-index to address " + addr);
  104.                 break;
  105.  
  106.             }case 50:{
  107.  
  108.                 // *******
  109.                 // * TAX *
  110.                 // *******
  111.  
  112.                 // Transfer accumulator to index X:
  113.             readout("Move Accumulator to X-index");
  114.                 break;
  115.  
  116.             }case 51:{
  117.  
  118.                 // *******
  119.                 // * TAY *
  120.                 // *******
  121.  
  122.                 // Transfer accumulator to index Y:
  123.             readout("Move Accumulator to Y-index");
  124.                 break;
  125.  
  126.             }case 52:{
  127.  
  128.                 // *******
  129.                 // * TSX *
  130.                 // *******
  131.  
  132.                 // Transfer stack pointer to index X:
  133.             readout("Move stack pointer address to X-index");
  134.                 break;
  135.  
  136.             }case 53:{
  137.  
  138.                 // *******
  139.                 // * TXA *
  140.                 // *******
  141.  
  142.                 // Transfer index X to accumulator:
  143.             readout("Move X-index to Accumulator");
  144.                 break;
  145.  
  146.             }case 54:{
  147.  
  148.                 // *******
  149.                 // * TXS *
  150.                 // *******
  151.  
  152.                 // Transfer index X to stack pointer:
  153.             readout("Set stack pointer address to Index-X");
  154.                 break;
  155.  
  156.             }case 55:{
  157.  
  158.                 // *******
  159.                 // * TYA *
  160.                 // *******
  161.  
  162.                 // Transfer index Y to accumulator:
  163.             readout("Move Y-index to Accumulator");
  164.                 break;
  165.  
  166.             }default:{
  167.  
  168.                 // *******
  169.                 // * ??? *
  170.                 // *******
  171.             readout("* NOT A 6502 INSTRUCTION *");
  172.                 break;
  173.  
  174.             }
  175.  
  176.         }// end of switch
RAW Paste Data