API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Aug 27th, 2010
169
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 4.28 KB | None | 0 0
raw download clone embed print report
  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
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!