SHARE
TWEET

GTX1070

a guest Feb 18th, 2020 71 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. void Group_1(BYTE opcode){
  2.     BYTE LB = 0;
  3.     BYTE HB = 0;
  4.     WORD address = 0;
  5.     WORD data = 0;
  6.     WORD offset;
  7.     switch(opcode) {
  8.  
  9.         //////////////////////////////LD CASE//////////////////////////////
  10.  
  11.         case 0xB7:
  12.             data = fetch();
  13.             Registers[REGISTER_A] = data;
  14.             set_flag_n(Registers[REGISTER_A]);
  15.             set_flag_z(Registers[REGISTER_A]);
  16.             Flags = Flags & (0xFF - FLAG_C);
  17.             break;
  18.  
  19.         case 0xC7:
  20.             HB = fetch();
  21.             LB = fetch();
  22.             address += (WORD)((WORD)HB << 8) + LB;
  23.             if (address >= 0 && address < MEMORY_SIZE) {
  24.                 Registers[REGISTER_A] = Memory[address];
  25.             }
  26.             set_flag_n(Registers[REGISTER_A]);
  27.             set_flag_z(Registers[REGISTER_A]);
  28.             Flags = Flags & (0xFF - FLAG_C);
  29.  
  30.             break;
  31.  
  32.         case 0xD7:
  33.             address += IndexRegister;
  34.             HB = fetch();
  35.             LB = fetch();
  36.             address += (WORD)((WORD)HB << 8) + LB;
  37.             if (address >= 0 && address < MEMORY_SIZE) {
  38.                 Registers[REGISTER_A] = Memory[address];
  39.             }
  40.             set_flag_n(Registers[REGISTER_A]);
  41.             set_flag_z(Registers[REGISTER_A]);
  42.             Flags = Flags & (0xFF - FLAG_C);
  43.  
  44.             break;
  45.  
  46.         //////////////////////////////ST CASE//////////////////////////////
  47.  
  48.         case 0x10:
  49.             HB = fetch();
  50.             LB = fetch();
  51.             address += (WORD)((WORD)HB << 8) + LB;
  52.             if (address >= 0 && address < MEMORY_SIZE) {
  53.                 Memory[address] = Registers[REGISTER_A];
  54.             }
  55.             Flags = Flags & (0xFF - FLAG_C);
  56.             set_flag_n(Registers[REGISTER_A]);
  57.             set_flag_z(Registers[REGISTER_A]);
  58.  
  59.             break;
  60.  
  61.         case 0x20:
  62.             address += IndexRegister;
  63.             HB = fetch(); LB = fetch();
  64.             address += (WORD)((WORD)HB << 8) + LB;
  65.             if (address >= 0 && address < MEMORY_SIZE) {
  66.                 Memory[address] = Registers[REGISTER_A];
  67.             }
  68.             Flags = Flags & (0xFF - FLAG_C);
  69.             set_flag_n(Registers[REGISTER_A]);
  70.             set_flag_z(Registers[REGISTER_A]);
  71.  
  72.             break;
  73.  
  74.         //////////////////////////////MVI CASE//////////////////////////////
  75.         case 0x2A:
  76.             data = fetch();
  77.             Registers[REGISTER_B] = data;
  78.             set_flag_n(Registers[REGISTER_B]);
  79.             set_flag_z(Registers[REGISTER_B]);
  80.             Flags = Flags & (0xFF - FLAG_C);
  81.             break;
  82.  
  83.         case 0x2B:
  84.             data = fetch();
  85.             Registers[REGISTER_C] = data;
  86.             set_flag_n(Registers[REGISTER_C]);
  87.             set_flag_z(Registers[REGISTER_C]);
  88.             Flags = Flags & (0xFF - FLAG_C);
  89.             break;
  90.  
  91.         case 0x2C:
  92.             data = fetch();
  93.             Registers[REGISTER_D] = data;
  94.             set_flag_n(Registers[REGISTER_D]);
  95.             set_flag_z(Registers[REGISTER_D]);
  96.             Flags = Flags & (0xFF - FLAG_C);
  97.             break;
  98.  
  99.         case 0x2D:
  100.             data = fetch();
  101.             Registers[REGISTER_E] = data;
  102.             set_flag_n(Registers[REGISTER_E]);
  103.             set_flag_z(Registers[REGISTER_E]);
  104.             Flags = Flags & (0xFF - FLAG_C);
  105.             break;
  106.  
  107.         case 0x2E:
  108.             data = fetch();
  109.             Registers[REGISTER_L] = data;
  110.             set_flag_n(Registers[REGISTER_L]);
  111.             set_flag_z(Registers[REGISTER_L]);
  112.             Flags = Flags & (0xFF - FLAG_C);
  113.             break;
  114.  
  115.         case 0x2F:
  116.             data = fetch();
  117.             Registers[REGISTER_H] = data;
  118.             set_flag_n(Registers[REGISTER_H]);
  119.             set_flag_z(Registers[REGISTER_H]);
  120.             Flags = Flags & (0xFF - FLAG_C);
  121.             break;
  122.  
  123.         //////////////////////////////TSA CASE//////////////////////////////
  124.  
  125.         case 0x75:
  126.             Registers[REGISTER_A] = Flags;
  127.             break;
  128.  
  129.         //////////////////////////////TAS CASE//////////////////////////////
  130.  
  131.         case 0x74:
  132.             Flags = Registers[REGISTER_A];
  133.             break;
  134.  
  135.         //////////////////////////////LODS CASE//////////////////////////////
  136.            
  137.         case 0x4F:
  138.             data = fetch();
  139.             StackPointer = data << 8;
  140.             StackPointer += fetch();
  141.             set_flag_n(StackPointer);
  142.             set_flag_z(StackPointer);
  143.             Flags = Flags & (0xFF - FLAG_C);
  144.             break;
  145.  
  146.         case 0x5F:
  147.             HB = fetch();
  148.             LB = fetch();
  149.             address += (WORD)((WORD)HB << 8) + LB;
  150.             if (address >= 0 && address < MEMORY_SIZE - 1) {
  151.                 StackPointer = (WORD)Memory[address] << 8; StackPointer += Memory[address + 1];
  152.             }
  153.             set_flag_n(StackPointer);
  154.             set_flag_z(StackPointer);
  155.             Flags = Flags & (0xFF - FLAG_C);
  156.  
  157.             break;
  158.  
  159.         case 0x6F:
  160.             address += IndexRegister;
  161.             HB = fetch();
  162.             LB = fetch();
  163.             address += (WORD)((WORD)HB << 8) + LB;
  164.             if (address >= 0 && address < MEMORY_SIZE - 1) {
  165.                 StackPointer = (WORD)Memory[address] << 8;
  166.                 StackPointer += Memory[address + 1];
  167.             }
  168.             set_flag_n(StackPointer);
  169.             set_flag_z(StackPointer);
  170.             Flags = Flags & (0xFF - FLAG_C);
  171.  
  172.             break;
  173.  
  174.         //////////////////////////////STOX CASE//////////////////////////////
  175.         case 0x50:
  176.             address += IndexRegister;
  177.             HB = fetch();
  178.             LB = fetch();
  179.             address += (WORD)((WORD)HB << 8) + LB;
  180.             if (address >= 0 && address < MEMORY_SIZE) {
  181.                 Memory[address] = IndexRegister;
  182.             }
  183.             set_flag_n(IndexRegister);
  184.             set_flag_z(IndexRegister);
  185.             Flags = Flags & (0xFF - FLAG_C);
  186.             break;
  187.  
  188.         case 0x60:
  189.             address += IndexRegister;
  190.             HB = fetch();
  191.             LB = fetch();
  192.             address += (WORD)((WORD)HB << 8) + LB;
  193.             if (address >= 0 && address < MEMORY_SIZE) {
  194.                 Memory[address] = IndexRegister;
  195.             }
  196.             set_flag_n(IndexRegister);
  197.             set_flag_z(IndexRegister);
  198.             Flags = Flags & (0xFF - FLAG_C);
  199.             break;
  200.  
  201.         //////////////////////////////LDX CASE//////////////////////////////
  202.  
  203.         case 0x4E:
  204.             data = fetch();
  205.             IndexRegister = fetch();
  206.             set_flag_n(IndexRegister);
  207.             set_flag_z(IndexRegister);
  208.             Flags = Flags & (0xFF - FLAG_C);
  209.             break;
  210.  
  211.  
  212.         case 0x5E:
  213.             HB = fetch();
  214.             LB = fetch();
  215.             address += (WORD)((WORD)HB << 8) + LB;
  216.             if (address >= 0 && address < MEMORY_SIZE) {
  217.                 IndexRegister = Memory[address];
  218.             }
  219.             set_flag_n(IndexRegister);
  220.             set_flag_z(IndexRegister);
  221.             Flags = Flags & (0xFF - FLAG_C);
  222.             break;
  223.  
  224.         case 0x6E:
  225.             HB = fetch();
  226.             LB = fetch();
  227.             address += (WORD)((WORD)HB << 8) + LB;
  228.             if (address >= 0 && address < MEMORY_SIZE) {
  229.                 Registers[REGISTER_A] = Memory[address];
  230.             }
  231.             set_flag_n(IndexRegister);
  232.             set_flag_z(IndexRegister);
  233.             Flags = Flags & (0xFF - FLAG_C);
  234.             break;
  235.  
  236.         //////////////////////////////ADC FLAGS//////////////////////////////
  237.         case 0x90:
  238.             BYTE temp_word;
  239.             temp_word = (WORD)Registers[REGISTER_A] + (WORD)Registers[REGISTER_B];
  240.             if ((Flags & FLAG_C) != 0) {
  241.                 temp_word++;
  242.             }
  243.             if (temp_word >= 0x100) {
  244.                 Flags = Flags | FLAG_C; // Set carry Flag
  245.             }
  246.             else { Flags = Flags & (0xFF - FLAG_C); // Clear carryFlag
  247.             }
  248.             set_flag_n((BYTE)temp_word);
  249.             set_flag_z((BYTE)temp_word);
  250.             set_flag_v(REGISTER_A, REGISTER_B, (BYTE)temp_word);
  251.             Registers[REGISTER_A] = (BYTE)temp_word;
  252.             break;
  253.  
  254.         case 0xA0:
  255.            
  256.             temp_word = (WORD)Registers[REGISTER_A] + (WORD)Registers[REGISTER_C];
  257.             if ((Flags & FLAG_C) != 0) {
  258.                 temp_word++;
  259.             }
  260.             if (temp_word >= 0x100) {
  261.                 Flags = Flags | FLAG_C; // Set carry Flag
  262.             }
  263.             else {
  264.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  265.             }
  266.             set_flag_n((BYTE)temp_word);
  267.             set_flag_z((BYTE)temp_word);
  268.             set_flag_v(REGISTER_A, REGISTER_C, (BYTE)temp_word);
  269.             Registers[REGISTER_A] = (BYTE)temp_word;
  270.             break;
  271.  
  272.         case 0xB0:
  273.            
  274.             temp_word = (WORD)Registers[REGISTER_A] + (WORD)Registers[REGISTER_D];
  275.             if ((Flags & FLAG_C) != 0) {
  276.                 temp_word++;
  277.             }
  278.             if (temp_word >= 0x100) {
  279.                 Flags = Flags | FLAG_C; // Set carry Flag
  280.             }
  281.             else {
  282.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  283.             }
  284.             set_flag_n((BYTE)temp_word);
  285.             set_flag_z((BYTE)temp_word);
  286.             set_flag_v(REGISTER_A, REGISTER_D, (BYTE)temp_word);
  287.             Registers[REGISTER_A] = (BYTE)temp_word;
  288.             break;
  289.  
  290.         case 0xC0:
  291.            
  292.             temp_word = (WORD)Registers[REGISTER_A] + (WORD)Registers[REGISTER_E];
  293.             if ((Flags & FLAG_C) != 0) {
  294.                 temp_word++;
  295.             }
  296.             if (temp_word >= 0x100) {
  297.                 Flags = Flags | FLAG_C; // Set carry Flag
  298.             }
  299.             else {
  300.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  301.             }
  302.             set_flag_n((BYTE)temp_word);
  303.             set_flag_z((BYTE)temp_word);
  304.             set_flag_v(REGISTER_A, REGISTER_E, (BYTE)temp_word);
  305.             Registers[REGISTER_A] = (BYTE)temp_word;
  306.             break;
  307.  
  308.         case 0xD0:
  309.            
  310.             temp_word = (WORD)Registers[REGISTER_A] + (WORD)Registers[REGISTER_L];
  311.             if ((Flags & FLAG_C) != 0) {
  312.                 temp_word++;
  313.             }
  314.             if (temp_word >= 0x100) {
  315.                 Flags = Flags | FLAG_C; // Set carry Flag
  316.             }
  317.             else {
  318.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  319.             }
  320.             set_flag_n((BYTE)temp_word);
  321.             set_flag_z((BYTE)temp_word);
  322.             set_flag_v(REGISTER_A, REGISTER_L, (BYTE)temp_word);
  323.             Registers[REGISTER_A] = (BYTE)temp_word;
  324.             break;
  325.  
  326.         case 0xE0:
  327.            
  328.             temp_word = (WORD)Registers[REGISTER_A] + (WORD)Registers[REGISTER_H];
  329.             if ((Flags & FLAG_C) != 0) {
  330.                 temp_word++;
  331.             }
  332.             if (temp_word >= 0x100) {
  333.                 Flags = Flags | FLAG_C; // Set carry Flag
  334.             }
  335.             else {
  336.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  337.             }
  338.             set_flag_n((BYTE)temp_word);
  339.             set_flag_z((BYTE)temp_word);
  340.             set_flag_v(REGISTER_A, REGISTER_H, (BYTE)temp_word);
  341.             Registers[REGISTER_A] = (BYTE)temp_word;
  342.             break;
  343.  
  344.         case 0xF0:
  345.            
  346.             temp_word = (WORD)Registers[REGISTER_A] + (WORD)Registers[REGISTER_M];
  347.             if ((Flags & FLAG_C) != 0) {
  348.                 temp_word++;
  349.             }
  350.             if (temp_word >= 0x100) {
  351.                 Flags = Flags | FLAG_C; // Set carry Flag
  352.             }
  353.             else {
  354.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  355.             }
  356.             set_flag_n((BYTE)temp_word);
  357.             set_flag_z((BYTE)temp_word);
  358.             set_flag_v(REGISTER_A, REGISTER_M, (BYTE)temp_word);
  359.             Registers[REGISTER_A] = (BYTE)temp_word;
  360.             break;
  361.  
  362.         //////////////////////////////CMP FLAGS//////////////////////////////
  363.         case 0x92:
  364.        
  365.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_B];
  366.             if ((Flags & FLAG_C) != 0) {
  367.                 temp_word++;
  368.             }
  369.             if (temp_word >= 0x100) {
  370.                 Flags = Flags | FLAG_C; // Set carry Flag
  371.             }
  372.             else {
  373.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  374.             }
  375.             set_flag_n((BYTE)temp_word);
  376.             set_flag_z((BYTE)temp_word);
  377.             set_flag_v(Registers[REGISTER_A], -Registers[REGISTER_B], (BYTE)temp_word);
  378.             break;
  379.  
  380.         case 0xA2:
  381.    
  382.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_C];
  383.             if ((Flags & FLAG_C) != 0) {
  384.                 temp_word++;
  385.             }
  386.             if (temp_word >= 0x100) {
  387.                 Flags = Flags | FLAG_C; // Set carry Flag
  388.             }
  389.             else {
  390.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  391.             }
  392.             set_flag_n((BYTE)temp_word);
  393.             set_flag_z((BYTE)temp_word);
  394.             set_flag_v(Registers[REGISTER_A], -Registers[REGISTER_C], (BYTE)temp_word);
  395.             break;
  396.  
  397.         case 0xB2:
  398.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_D];
  399.             if ((Flags & FLAG_C) != 0) {
  400.                 temp_word++;
  401.             }
  402.             if (temp_word >= 0x100) {
  403.                 Flags = Flags | FLAG_C; // Set carry Flag
  404.             }
  405.             else {
  406.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  407.             }
  408.             set_flag_n((BYTE)temp_word);
  409.             set_flag_z((BYTE)temp_word);
  410.             set_flag_v(Registers[REGISTER_A], -Registers[REGISTER_D], (BYTE)temp_word);
  411.             break;
  412.  
  413.         case 0xC2:
  414.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_E];
  415.             if ((Flags & FLAG_C) != 0) {
  416.                 temp_word++;
  417.             }
  418.             if (temp_word >= 0x100) {
  419.                 Flags = Flags | FLAG_C; // Set carry Flag
  420.             }
  421.             else {
  422.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  423.             }
  424.             set_flag_n((BYTE)temp_word);
  425.             set_flag_z((BYTE)temp_word);
  426.             set_flag_v(Registers[REGISTER_A], -Registers[REGISTER_E], (BYTE)temp_word);
  427.             break;
  428.  
  429.         case 0xD2:
  430.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_L];
  431.             if ((Flags & FLAG_C) != 0) {
  432.                 temp_word++;
  433.             }
  434.             if (temp_word >= 0x100) {
  435.                 Flags = Flags | FLAG_C; // Set carry Flag
  436.             }
  437.             else {
  438.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  439.             }
  440.             set_flag_n((BYTE)temp_word);
  441.             set_flag_z((BYTE)temp_word);
  442.             set_flag_v(Registers[REGISTER_A], -Registers[REGISTER_L], (BYTE)temp_word);
  443.             break;
  444.  
  445.         case 0xE2:
  446.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_H];
  447.             if ((Flags & FLAG_C) != 0) {
  448.                 temp_word++;
  449.             }
  450.             if (temp_word >= 0x100) {
  451.                 Flags = Flags | FLAG_C; // Set carry Flag
  452.             }
  453.             else {
  454.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  455.             }
  456.             set_flag_n((BYTE)temp_word);
  457.             set_flag_z((BYTE)temp_word);
  458.             set_flag_v(Registers[REGISTER_A], -Registers[REGISTER_H], (BYTE)temp_word);
  459.             break;
  460.  
  461.         case 0xF2:
  462.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_M];
  463.             if ((Flags & FLAG_C) != 0) {
  464.                 temp_word++;
  465.             }
  466.             if (temp_word >= 0x100) {
  467.                 Flags = Flags | FLAG_C; // Set carry Flag
  468.             }
  469.             else {
  470.                 Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  471.             }
  472.             set_flag_n((BYTE)temp_word);
  473.             set_flag_z((BYTE)temp_word);
  474.             set_flag_v(Registers[REGISTER_A], -Registers[REGISTER_M], (BYTE)temp_word);
  475.             break;
  476.  
  477.         //////////////////////////////CLC FLAGS//////////////////////////////
  478.  
  479.         case 0x15:
  480.  
  481.             Flags = Flags & (0xFF - FLAG_C); // Clear carry ?ag
  482.             break;
  483.  
  484.         //////////////////////////////CLI FLAGS//////////////////////////////
  485.  
  486.         case 0x16:
  487.  
  488.             Flags = Flags & (0xFF - FLAG_I); // Clear carry ?ag
  489.             break;
  490.  
  491.         //////////////////////////////CLV FLAGS//////////////////////////////
  492.  
  493.         case 0x1A:
  494.             Flags = Flags | (0xFF - FLAG_V);
  495.             break;
  496.         //////////////////////////////SEC FLAGS//////////////////////////////
  497.  
  498.         case 0x17:
  499.  
  500.             Flags = Flags & (0xFF - FLAG_C); // Clear carry ?ag
  501.             break;
  502.  
  503.         //////////////////////////////STI FLAGS//////////////////////////////
  504.  
  505.         case 0x18:
  506.             Flags = Flags | (0xFF - FLAG_I);
  507.             break;
  508.         //////////////////////////////SEV FLAGS//////////////////////////////
  509.  
  510.         case 0x19:
  511.             Flags = Flags | (0xFF - FLAG_V);
  512.             break;
  513.  
  514.  
  515.         //////////////////////////////PSH STACKS//////////////////////////////
  516.  
  517.         case 0x11:
  518.             if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  519.                 Memory[StackPointer] = Registers[REGISTER_A];
  520.                 StackPointer--;
  521.             }
  522.             break;
  523.  
  524.         case 0x21:
  525.             if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  526.                 Memory[StackPointer] = Flags; //Registers[REGISTER_FL];
  527.                 StackPointer--;
  528.             }
  529.             break;
  530.  
  531.         case 0x31:
  532.             if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  533.                 Memory[StackPointer] = Registers[REGISTER_B];
  534.                 StackPointer--;
  535.             }
  536.             break;
  537.  
  538.         case 0x41:
  539.             if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  540.                 Memory[StackPointer] = Registers[REGISTER_C];
  541.                 StackPointer--;
  542.             }
  543.             break;
  544.  
  545.         case 0x51:
  546.             if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  547.                 Memory[StackPointer] = Registers[REGISTER_D];
  548.                 StackPointer--;
  549.             }
  550.             break;
  551.  
  552.         case 0x61:
  553.             if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  554.                 Memory[StackPointer] = Registers[REGISTER_E];
  555.                 StackPointer--;
  556.             }
  557.             break;
  558.  
  559.         case 0x71:
  560.             if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  561.                 Memory[StackPointer] = Registers[REGISTER_L];
  562.                 StackPointer--;
  563.             }
  564.             break;
  565.  
  566.         case 0x81:
  567.             if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  568.                 Memory[StackPointer] = Registers[REGISTER_H];
  569.                 StackPointer--;
  570.             }
  571.             break;
  572.  
  573.         //////////////////////////////POP STACKS//////////////////////////////
  574.  
  575.         case 0x12:
  576.             if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  577.                 StackPointer++;
  578.                 Registers[REGISTER_A] = Memory[StackPointer];
  579.             }
  580.             break;
  581.  
  582.         case 0x22:
  583.             if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  584.                 StackPointer++;
  585.                 Flags = Memory[StackPointer]; //Registers[REGISTER_FL] = Memory[StackPointer];
  586.             }
  587.             break;
  588.  
  589.         case 0x32:
  590.             if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  591.                 StackPointer++;
  592.                 Registers[REGISTER_B] = Memory[StackPointer];
  593.             }
  594.             break;
  595.  
  596.         case 0x42:
  597.             if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  598.                 StackPointer++;
  599.                 Registers[REGISTER_C] = Memory[StackPointer];
  600.             }
  601.             break;
  602.  
  603.         case 0x52:
  604.             if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  605.                 StackPointer++;
  606.                 Registers[REGISTER_D] = Memory[StackPointer];
  607.             }
  608.             break;
  609.  
  610.         case 0x62:
  611.             if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  612.                 StackPointer++;
  613.                 Registers[REGISTER_E] = Memory[StackPointer];
  614.             }
  615.             break;
  616.  
  617.         case 0x72:
  618.             if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  619.                 StackPointer++;
  620.                 Registers[REGISTER_L] = Memory[StackPointer];
  621.             }
  622.             break;
  623.  
  624.         case 0x82:
  625.             if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  626.                 StackPointer++;
  627.                 Registers[REGISTER_H] = Memory[StackPointer];
  628.             }
  629.             break;
  630.  
  631.         //////////////////////////////JMP STACKS//////////////////////////////
  632.         case 0xFA:
  633.             HB = fetch();
  634.             LB = fetch();
  635.             address = ((WORD)HB << 8) + (WORD)LB;
  636.             ProgramCounter = address;
  637.             break;
  638.  
  639.         //////////////////////////////JPR INSTRUCTION//////////////////////////////
  640.  
  641.         case 0x33:
  642.             HB = fetch();
  643.             LB = fetch();
  644.             address = ((WORD)HB << 8) + (WORD)LB;
  645.             if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE)) {
  646.                 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
  647.                 StackPointer--;
  648.                 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
  649.                 StackPointer--;
  650.             }
  651.             ProgramCounter = address;
  652.  
  653.             break;
  654.  
  655.         //////////////////////////////RTN OPCODE//////////////////////////////
  656.  
  657.         case 0x0E:
  658.             if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 2)) {
  659.                 StackPointer++;
  660.                 HB = Memory[StackPointer];
  661.                 StackPointer++;
  662.                 LB = Memory[StackPointer];
  663.  
  664.             }
  665.             ProgramCounter = ((WORD)HB << 8) + (WORD)LB;
  666.  
  667.             break;
  668.  
  669.         //////////////////////////////BRA OPCODE//////////////////////////////
  670.  
  671.         case 0x00:
  672.             LB = fetch();
  673.             offset = (WORD)LB;
  674.             if((offset & 0x80) != 0) {
  675.                 offset = offset + 0xFF00;
  676.             }
  677.             address = ProgramCounter + offset;
  678.  
  679.             ProgramCounter = address;
  680.             break;
  681.  
  682.         //////////////////////////////BCC OPCODE//////////////////////////////
  683.  
  684.         case 0x01:
  685.             if ((Flags & FLAG_C) == 0) {
  686.  
  687.                 LB = fetch();
  688.                 offset = (WORD)LB;
  689.                 if ((offset & 0x80) != 0) {
  690.                     offset = offset + 0xFF00;
  691.                 }
  692.                 address = ProgramCounter + offset;
  693.  
  694.             }
  695.             break;
  696.  
  697.         //////////////////////////////BCS OPCODE//////////////////////////////
  698.  
  699.         case 0x02:
  700.             LB = fetch();
  701.             if ((Flags & FLAG_C) == FLAG_C) {
  702.                 offset = (WORD)LB;
  703.                 if ((offset & 0x80) != 0) { // need to sign extend
  704.                     offset = offset + 0xFF00;
  705.                 } address = ProgramCounter + offset;
  706.  
  707.                 ProgramCounter = address;
  708.             }
  709.             break;
  710.  
  711.         //////////////////////////////BNE OPCODE//////////////////////////////
  712.  
  713.         case 0x03:
  714.             if ((Flags & FLAG_C) != 0) {
  715.  
  716.                 LB = fetch();
  717.                 offset = (WORD)LB;
  718.                 if ((offset & 0x80) != 0) {
  719.                     offset = offset + 0xFF00;
  720.                 }
  721.                 address = ProgramCounter + offset;
  722.  
  723.             }
  724.             break;
  725.  
  726.         //////////////////////////////BEQ OPCODE//////////////////////////////
  727.  
  728.         case 0x04:
  729.             if ((Flags & FLAG_C) != 0) {
  730.  
  731.                 LB = fetch();
  732.                 offset = (WORD)LB;
  733.                 if ((offset & 0x80) != 0) {
  734.                     offset = offset + 0xFF00;
  735.                 }
  736.                 address = ProgramCounter + offset;
  737.  
  738.             }
  739.             break;
  740.  
  741.         //////////////////////////////BVC OPCODE//////////////////////////////
  742.  
  743.         case 0x05:
  744.             if ((Flags & FLAG_C) == 0) {
  745.  
  746.                 LB = fetch();
  747.                 offset = (WORD)LB;
  748.                 if ((offset & 0x80) != 0) {
  749.                     offset = offset + 0xFF00;
  750.                 }
  751.                 address = ProgramCounter + offset;
  752.  
  753.             }
  754.            
  755.             break;
  756.  
  757.         //////////////////////////////BVS OPCODE//////////////////////////////
  758.  
  759.         case 0x06:
  760.             if (Flags & FLAG_V) {
  761.  
  762.                 LB = fetch();
  763.                 offset = (WORD)LB;
  764.                 if ((offset & 0x80) != 0) {
  765.                     offset = offset + 0xFF00;
  766.                 }
  767.                 address = ProgramCounter + offset;
  768.  
  769.             }
  770.            
  771.             break;
  772.  
  773.         //////////////////////////////BMI OPCODE//////////////////////////////
  774.  
  775.         case 0x07:
  776.             if ((Flags & FLAG_N) == 1) {
  777.  
  778.                 LB = fetch();
  779.                 offset = (WORD)LB;
  780.                 if ((offset & 0x80) != 0) {
  781.                     offset = offset + 0xFF00;
  782.                 }
  783.                 address = ProgramCounter + offset;
  784.  
  785.             }
  786.            
  787.             break;
  788.  
  789.         //////////////////////////////BPL OPCODE//////////////////////////////
  790.  
  791.         case 0x08:
  792.             if ((Flags & FLAG_N) == 0) {
  793.  
  794.                 LB = fetch();
  795.                 offset = (WORD)LB;
  796.                 if ((offset & 0x80) != 0) {
  797.                     offset = offset + 0xFF00;
  798.                 }
  799.                 address = ProgramCounter + offset;
  800.  
  801.             }
  802.            
  803.             break;
  804.  
  805.         //////////////////////////////BGE OPCODE//////////////////////////////
  806.  
  807.         case 0x09:
  808.             if ((Flags & FLAG_Z) <= 0) {
  809.  
  810.                 LB = fetch();
  811.                 offset = (WORD)LB;
  812.                 if ((offset & 0x80) != 0) {
  813.                     offset = offset + 0xFF00;
  814.                 }
  815.                 address = ProgramCounter + offset;
  816.  
  817.             }
  818.            
  819.             break;
  820.  
  821.         //////////////////////////////BLE OPCODE//////////////////////////////
  822.  
  823.         case 0x0A:
  824.             if ((Flags & FLAG_Z) >= 0) {
  825.  
  826.                 LB = fetch();
  827.                 offset = (WORD)LB;
  828.                 if ((offset & 0x80) != 0) {
  829.                     offset = offset + 0xFF00;
  830.                 }
  831.                 address = ProgramCounter + offset;
  832.  
  833.             }
  834.            
  835.             break;
  836.  
  837.         //////////////////////////////CVS OPCODE//////////////////////////////
  838.  
  839.         case 0x39: //CVS
  840.  
  841.             HB = fetch();
  842.             LB = fetch();
  843.             if ((Flags & FLAG_V) == FLAG_V) // Overflow flag set?
  844.             {
  845.                 address += (WORD)((WORD)HB << 8) + LB;
  846.                 if (address >= 0 && address < MEMORY_SIZE)
  847.                 {
  848.                     // Push return address onto the stack
  849.                     if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
  850.                     {
  851.                         Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
  852.                         StackPointer--;
  853.                         Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
  854.                         StackPointer--;
  855.                     }
  856.                     ProgramCounter = (WORD)address;
  857.                 }
  858.             }
  859.             break;
  860.  
  861.         /////////////////////////////INCA OPCODE//////////////////////////////
  862.  
  863.         case 0x64:
  864.             ++Registers[REGISTER_A];
  865.             set_flag_n(Registers[REGISTER_A]);
  866.             set_flag_z(Registers[REGISTER_A]);
  867.             break;
  868.  
  869.         //////////////////////////////INX OPCODE//////////////////////////////
  870.  
  871.         case 0x1C:
  872.             ++IndexRegister;
  873.             set_flag_z(IndexRegister);
  874.             break;
  875.  
  876.         //////////////////////////////AND OPCODE//////////////////////////////
  877.  
  878.         case 0x94:
  879.            
  880.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_B];       
  881.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  882.    
  883.             set_flag_n((BYTE)temp_word);
  884.             set_flag_z((BYTE)temp_word);
  885.             Flags = Flags & (0xFF - FLAG_V);
  886.             Registers[REGISTER_A] = (BYTE)temp_word;
  887.             break;
  888.  
  889.         case 0xA4:
  890.            
  891.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_C];
  892.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  893.  
  894.             set_flag_n((BYTE)temp_word);
  895.             set_flag_z((BYTE)temp_word);
  896.             Flags = Flags & (0xFF - FLAG_V);
  897.             Registers[REGISTER_A] = (BYTE)temp_word;
  898.             break;
  899.  
  900.         case 0xB4:
  901.            
  902.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_D];
  903.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  904.  
  905.             set_flag_n((BYTE)temp_word);
  906.             set_flag_z((BYTE)temp_word);
  907.             Flags = Flags & (0xFF - FLAG_V);
  908.             Registers[REGISTER_A] = (BYTE)temp_word;
  909.             break;
  910.  
  911.         case 0xC4:
  912.            
  913.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_E];
  914.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  915.  
  916.             set_flag_n((BYTE)temp_word);
  917.             set_flag_z((BYTE)temp_word);
  918.             Flags = Flags & (0xFF - FLAG_V);
  919.             Registers[REGISTER_A] = (BYTE)temp_word;
  920.             break;
  921.  
  922.         case 0xD4:
  923.            
  924.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_L];
  925.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  926.  
  927.             set_flag_n((BYTE)temp_word);
  928.             set_flag_z((BYTE)temp_word);
  929.             Flags = Flags & (0xFF - FLAG_V);
  930.             Registers[REGISTER_A] = (BYTE)temp_word;
  931.             break;
  932.  
  933.         case 0xE4:
  934.            
  935.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_H];
  936.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  937.  
  938.             set_flag_n((BYTE)temp_word);
  939.             set_flag_z((BYTE)temp_word);
  940.             Flags = Flags & (0xFF - FLAG_V);
  941.             Registers[REGISTER_A] = (BYTE)temp_word;
  942.             break;
  943.            
  944.         case 0xF4:
  945.            
  946.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_M];
  947.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  948.  
  949.             set_flag_n((BYTE)temp_word);
  950.             set_flag_z((BYTE)temp_word);
  951.             Flags = Flags & (0xFF - FLAG_V);
  952.             Registers[REGISTER_A] = (BYTE)temp_word;
  953.             break;
  954.         //////////////////////////////BT OPCODE//////////////////////////////
  955.  
  956.         case 0x96:
  957.            
  958.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_B];
  959.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  960.  
  961.             set_flag_n((BYTE)temp_word);
  962.             set_flag_z((BYTE)temp_word);
  963.             Flags = Flags & (0xFF - FLAG_V);
  964.             break;
  965.  
  966.         case 0xA6:
  967.            
  968.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_C];
  969.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  970.  
  971.             set_flag_n((BYTE)temp_word);
  972.             set_flag_z((BYTE)temp_word);
  973.             Flags = Flags & (0xFF - FLAG_V);
  974.             break;
  975.  
  976.         case 0xB6:
  977.            
  978.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_D];
  979.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  980.  
  981.             set_flag_n((BYTE)temp_word);
  982.             set_flag_z((BYTE)temp_word);
  983.             Flags = Flags & (0xFF - FLAG_V);
  984.             break;
  985.  
  986.         case 0xC6:
  987.            
  988.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_E];
  989.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  990.  
  991.             set_flag_n((BYTE)temp_word);
  992.             set_flag_z((BYTE)temp_word);
  993.             Flags = Flags & (0xFF - FLAG_V);
  994.             break;
  995.  
  996.         case 0xD6:
  997.            
  998.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_L];
  999.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1000.  
  1001.             set_flag_n((BYTE)temp_word);
  1002.             set_flag_z((BYTE)temp_word);
  1003.             Flags = Flags & (0xFF - FLAG_V);
  1004.             break;
  1005.  
  1006.         case 0xE6:
  1007.            
  1008.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_H];
  1009.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1010.  
  1011.             set_flag_n((BYTE)temp_word);
  1012.             set_flag_z((BYTE)temp_word);
  1013.             Flags = Flags & (0xFF - FLAG_V);
  1014.             break;
  1015.  
  1016.         case 0xF6:
  1017.            
  1018.             temp_word = (WORD)Registers[REGISTER_A] & (WORD)Registers[REGISTER_M];
  1019.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1020.  
  1021.             set_flag_n((BYTE)temp_word);
  1022.             set_flag_z((BYTE)temp_word);
  1023.             Flags = Flags & (0xFF - FLAG_V);
  1024.             break;
  1025.  
  1026.         //////////////////////////////INC OPCODE//////////////////////////////
  1027.  
  1028.         case 0x44:
  1029.             HB = fetch();
  1030.             LB = fetch();
  1031.             address += (WORD)((WORD)HB << 8) + LB;
  1032.             if (address >= 0 && address < MEMORY_SIZE) {
  1033.                 Registers[REGISTER_A] = Memory[address];
  1034.             }
  1035.             ++Registers[REGISTER_A];
  1036.             set_flag_n(Registers[REGISTER_A]);
  1037.             set_flag_z(Registers[REGISTER_A]);
  1038.             break;
  1039.  
  1040.         case 0x54:
  1041.             HB = fetch();
  1042.             LB = fetch();
  1043.             address += (WORD)((WORD)HB << 8) + LB;
  1044.             if (address >= 0 && address < MEMORY_SIZE - 1) {
  1045.                 StackPointer = (WORD)Memory[address] << 8;
  1046.                 StackPointer += Memory[address + 1];
  1047.             }
  1048.             ++Registers[REGISTER_A];
  1049.             set_flag_n(Registers[REGISTER_A]);
  1050.             set_flag_z(Registers[REGISTER_A]);
  1051.             break;
  1052.  
  1053.         //////////////////////////////DEX OPCODE//////////////////////////////
  1054.  
  1055.         case 0x1B:
  1056.             ++IndexRegister;
  1057.             set_flag_z(IndexRegister);
  1058.             break;
  1059.  
  1060.         //////////////////////////////SBC OPCODE//////////////////////////////
  1061.  
  1062.         case 0x91:
  1063.            
  1064.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_B];
  1065.             if ((Flags & FLAG_C) != 0) {
  1066.                 temp_word++;
  1067.             }
  1068.             if (temp_word >= 0x100) {
  1069.                 Flags = Flags | FLAG_C; // Set carry Flag
  1070.             }
  1071.             else {
  1072.                 Flags = Flags & (0xFF - FLAG_C); // Clear carryFlag
  1073.             }
  1074.             set_flag_n((BYTE)temp_word);
  1075.             set_flag_z((BYTE)temp_word);
  1076.             set_flag_v(REGISTER_A, REGISTER_B, (BYTE)temp_word);
  1077.             Registers[REGISTER_A] = (BYTE)temp_word;
  1078.             break;
  1079.  
  1080.         case 0xA1:
  1081.            
  1082.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_C];
  1083.             if ((Flags & FLAG_C) != 0) {
  1084.                 temp_word++;
  1085.             }
  1086.             if (temp_word >= 0x100) {
  1087.                 Flags = Flags | FLAG_C; // Set carry Flag
  1088.             }
  1089.             else {
  1090.                 Flags = Flags & (0xFF - FLAG_C); // Clear carryFlag
  1091.             }
  1092.             set_flag_n((BYTE)temp_word);
  1093.             set_flag_z((BYTE)temp_word);
  1094.             set_flag_v(REGISTER_A, REGISTER_C, (BYTE)temp_word);
  1095.             Registers[REGISTER_A] = (BYTE)temp_word;
  1096.             break;
  1097.  
  1098.         case 0xB1:
  1099.            
  1100.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_D];
  1101.             if ((Flags & FLAG_C) != 0) {
  1102.                 temp_word++;
  1103.             }
  1104.             if (temp_word >= 0x100) {
  1105.                 Flags = Flags | FLAG_C; // Set carry Flag
  1106.             }
  1107.             else {
  1108.                 Flags = Flags & (0xFF - FLAG_C); // Clear carryFlag
  1109.             }
  1110.             set_flag_n((BYTE)temp_word);
  1111.             set_flag_z((BYTE)temp_word);
  1112.             set_flag_v(REGISTER_A, REGISTER_D, (BYTE)temp_word);
  1113.             Registers[REGISTER_A] = (BYTE)temp_word;
  1114.             break;
  1115.  
  1116.         case 0xC1:
  1117.            
  1118.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_E];
  1119.             if ((Flags & FLAG_C) != 0) {
  1120.                 temp_word++;
  1121.             }
  1122.             if (temp_word >= 0x100) {
  1123.                 Flags = Flags | FLAG_C; // Set carry Flag
  1124.             }
  1125.             else {
  1126.                 Flags = Flags & (0xFF - FLAG_C); // Clear carryFlag
  1127.             }
  1128.             set_flag_n((BYTE)temp_word);
  1129.             set_flag_z((BYTE)temp_word);
  1130.             set_flag_v(REGISTER_A, REGISTER_E, (BYTE)temp_word);
  1131.             Registers[REGISTER_A] = (BYTE)temp_word;
  1132.             break;
  1133.  
  1134.         case 0xD1:
  1135.        
  1136.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_L];
  1137.             if ((Flags & FLAG_C) != 0) {
  1138.                 temp_word++;
  1139.             }
  1140.             if (temp_word >= 0x100) {
  1141.                 Flags = Flags | FLAG_C; // Set carry Flag
  1142.             }
  1143.             else {
  1144.                 Flags = Flags & (0xFF - FLAG_C); // Clear carryFlag
  1145.             }
  1146.             set_flag_n((BYTE)temp_word);
  1147.             set_flag_z((BYTE)temp_word);
  1148.             set_flag_v(REGISTER_A, REGISTER_L, (BYTE)temp_word);
  1149.             Registers[REGISTER_A] = (BYTE)temp_word;
  1150.             break;
  1151.  
  1152.         case 0xE1:
  1153.            
  1154.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_H];
  1155.             if ((Flags & FLAG_C) != 0) {
  1156.                 temp_word++;
  1157.             }
  1158.             if (temp_word >= 0x100) {
  1159.                 Flags = Flags | FLAG_C; // Set carry Flag
  1160.             }
  1161.             else {
  1162.                 Flags = Flags & (0xFF - FLAG_C); // Clear carryFlag
  1163.             }
  1164.             set_flag_n((BYTE)temp_word);
  1165.             set_flag_z((BYTE)temp_word);
  1166.             set_flag_v(REGISTER_A, REGISTER_H, (BYTE)temp_word);
  1167.             Registers[REGISTER_A] = (BYTE)temp_word;
  1168.             break;
  1169.  
  1170.         case 0xF1:
  1171.        
  1172.             temp_word = (WORD)Registers[REGISTER_A] - (WORD)Registers[REGISTER_M];
  1173.             if ((Flags & FLAG_C) != 0) {
  1174.                 temp_word++;
  1175.             }
  1176.             if (temp_word >= 0x100) {
  1177.                 Flags = Flags | FLAG_C; // Set carry Flag
  1178.             }
  1179.             else {
  1180.                 Flags = Flags & (0xFF - FLAG_C); // Clear carryFlag
  1181.             }
  1182.             set_flag_n((BYTE)temp_word);
  1183.             set_flag_z((BYTE)temp_word);
  1184.             set_flag_v(REGISTER_A, REGISTER_M, (BYTE)temp_word);
  1185.             Registers[REGISTER_A] = (BYTE)temp_word;
  1186.             break;
  1187.  
  1188.         //////////////////////////////IOR CASE//////////////////////////////
  1189.  
  1190.         case 0x93:
  1191.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_B];
  1192.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1193.  
  1194.             set_flag_n((BYTE)temp_word);
  1195.             set_flag_z((BYTE)temp_word);
  1196.             Flags = Flags & (0xFF - FLAG_V);
  1197.             Registers[REGISTER_A] = (BYTE)temp_word;
  1198.         break;
  1199.  
  1200.         case 0xA3:
  1201.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_C];
  1202.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1203.  
  1204.             set_flag_n((BYTE)temp_word);
  1205.             set_flag_z((BYTE)temp_word);
  1206.             Flags = Flags & (0xFF - FLAG_V);
  1207.             Registers[REGISTER_A] = (BYTE)temp_word;
  1208.             break;
  1209.  
  1210.         case 0xB3:
  1211.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_D];
  1212.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1213.  
  1214.             set_flag_n((BYTE)temp_word);
  1215.             set_flag_z((BYTE)temp_word);
  1216.             Flags = Flags & (0xFF - FLAG_V);
  1217.             Registers[REGISTER_A] = (BYTE)temp_word;
  1218.             break;
  1219.  
  1220.         case 0xC3:
  1221.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_E];
  1222.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1223.  
  1224.             set_flag_n((BYTE)temp_word);
  1225.             set_flag_z((BYTE)temp_word);
  1226.             Flags = Flags & (0xFF - FLAG_V);
  1227.             Registers[REGISTER_A] = (BYTE)temp_word;
  1228.             break;
  1229.  
  1230.         case 0xD3:
  1231.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_L];
  1232.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1233.  
  1234.             set_flag_n((BYTE)temp_word);
  1235.             set_flag_z((BYTE)temp_word);
  1236.             Flags = Flags & (0xFF - FLAG_V);
  1237.             Registers[REGISTER_A] = (BYTE)temp_word;
  1238.             break;
  1239.  
  1240.         case 0xE3:
  1241.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_H];
  1242.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1243.  
  1244.             set_flag_n((BYTE)temp_word);
  1245.             set_flag_z((BYTE)temp_word);
  1246.             Flags = Flags & (0xFF - FLAG_V);
  1247.             Registers[REGISTER_A] = (BYTE)temp_word;
  1248.             break;
  1249.  
  1250.         case 0xF3:
  1251.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_M];
  1252.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1253.  
  1254.             set_flag_n((BYTE)temp_word);
  1255.             set_flag_z((BYTE)temp_word);
  1256.             Flags = Flags & (0xFF - FLAG_V);
  1257.             Registers[REGISTER_A] = (BYTE)temp_word;
  1258.             break;
  1259.  
  1260.         //////////////////////////////NOTA CASE//////////////////////////////
  1261.  
  1262.         case 0x6A: // Need an XOR offset of OxFF
  1263.             break;
  1264.         //////////////////////////////XOR CASE//////////////////////////////
  1265.  
  1266.         case 0x95:
  1267.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_B];
  1268.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1269.  
  1270.             set_flag_n((BYTE)temp_word);
  1271.             set_flag_z((BYTE)temp_word);
  1272.             Flags = Flags & (0xFF - FLAG_V);
  1273.             Registers[REGISTER_A] = (BYTE)temp_word;
  1274.             break;
  1275.  
  1276.         case 0xA5:
  1277.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_C];
  1278.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1279.  
  1280.             set_flag_n((BYTE)temp_word);
  1281.             set_flag_z((BYTE)temp_word);
  1282.             Flags = Flags & (0xFF - FLAG_V);
  1283.             Registers[REGISTER_A] = (BYTE)temp_word;
  1284.             break;
  1285.  
  1286.         case 0xB5:
  1287.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_D];
  1288.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1289.  
  1290.             set_flag_n((BYTE)temp_word);
  1291.             set_flag_z((BYTE)temp_word);
  1292.             Flags = Flags & (0xFF - FLAG_V);
  1293.             Registers[REGISTER_A] = (BYTE)temp_word;
  1294.             break;
  1295.  
  1296.         case 0xC5:
  1297.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_E];
  1298.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1299.  
  1300.             set_flag_n((BYTE)temp_word);
  1301.             set_flag_z((BYTE)temp_word);
  1302.             Flags = Flags & (0xFF - FLAG_V);
  1303.             Registers[REGISTER_A] = (BYTE)temp_word;
  1304.             break;
  1305.  
  1306.         case 0xD5:
  1307.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_L];
  1308.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1309.  
  1310.             set_flag_n((BYTE)temp_word);
  1311.             set_flag_z((BYTE)temp_word);
  1312.             Flags = Flags & (0xFF - FLAG_V);
  1313.             Registers[REGISTER_A] = (BYTE)temp_word;
  1314.             break;
  1315.  
  1316.         case 0xE5:
  1317.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_H];
  1318.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1319.  
  1320.             set_flag_n((BYTE)temp_word);
  1321.             set_flag_z((BYTE)temp_word);
  1322.             Flags = Flags & (0xFF - FLAG_V);
  1323.             Registers[REGISTER_A] = (BYTE)temp_word;
  1324.             break;
  1325.  
  1326.         case 0xF5:
  1327.             temp_word = (WORD)Registers[REGISTER_A] | (WORD)Registers[REGISTER_M];
  1328.             Flags = Flags & (0xFF - FLAG_C); // Clear carry Flag
  1329.  
  1330.             set_flag_n((BYTE)temp_word);
  1331.             set_flag_z((BYTE)temp_word);
  1332.             Flags = Flags & (0xFF - FLAG_V);
  1333.             Registers[REGISTER_A] = (BYTE)temp_word;
  1334.             break;
  1335.  
  1336.         //////////////////////////////RCLA CASE//////////////////////////////
  1337.  
  1338.         case 0x67:
  1339.             BYTE saved_flags;
  1340.  
  1341.             saved_flags = Flags;
  1342.  
  1343.             if ((Registers[REGISTER_A] & 0x80) == 0x80) {
  1344.                 Flags = Flags | FLAG_C;
  1345.             }
  1346.             else {
  1347.                 Flags = Flags & (0xFF - FLAG_C);
  1348.             }
  1349.  
  1350.             Registers[REGISTER_A] = (Registers[REGISTER_A] << 1) & 0xFE;
  1351.  
  1352.             if ((saved_flags & FLAG_C) == FLAG_C) {
  1353.                 Registers[REGISTER_A] = Registers[REGISTER_A] | 0x01;
  1354.             }
  1355.             break;
  1356.  
  1357.     }
  1358. }
  1359.  
  1360. void Group_2_Move(BYTE opcode)
  1361. {
  1362.     int destination;
  1363.     int source;
  1364.  
  1365.     int destReg;
  1366.     int sourceReg;
  1367.  
  1368.     WORD address;
  1369.  
  1370.     destination = opcode & 0x0F;
  1371.  
  1372.     switch (destination)
  1373.     {
  1374.     case 0x08:
  1375.         destReg = REGISTER_A;
  1376.             break;
  1377.  
  1378.     case 0x09:
  1379.         destReg = REGISTER_B;
  1380.             break;
  1381.  
  1382.     case 0x0A:
  1383.         destReg = REGISTER_C;
  1384.             break;
  1385.  
  1386.     case 0x0B:
  1387.         destReg = REGISTER_D;
  1388.             break;
  1389.  
  1390.     case 0x0C:
  1391.         destReg = REGISTER_E;
  1392.             break;
  1393.  
  1394.     case 0x0D:
  1395.         destReg = REGISTER_L;
  1396.             break;
  1397.  
  1398.     case 0x0E:
  1399.         destReg = REGISTER_H;
  1400.             break;
  1401.  
  1402.     case 0x0F:
  1403.         destReg = REGISTER_M;
  1404.             break;
  1405.     }
  1406.  
  1407.     source = (opcode >> 4) & 0x0F;
  1408.  
  1409.     switch (source)
  1410.     {
  1411.     case 0x07:
  1412.         sourceReg = REGISTER_A;
  1413.         break;
  1414.  
  1415.     case 0x08:
  1416.         sourceReg = REGISTER_B;
  1417.         break;
  1418.  
  1419.     case 0x09:
  1420.         sourceReg = REGISTER_C;
  1421.         break;
  1422.  
  1423.     case 0x0A:
  1424.         sourceReg = REGISTER_D;
  1425.         break;
  1426.  
  1427.     case 0x0B:
  1428.         sourceReg = REGISTER_E;
  1429.         break;
  1430.  
  1431.     case 0x0C:
  1432.         sourceReg = REGISTER_L;
  1433.         break;
  1434.  
  1435.     case 0x0D:
  1436.         sourceReg = REGISTER_H;
  1437.         break;
  1438.  
  1439.     case 0x0E:
  1440.         sourceReg = REGISTER_M;
  1441.         break;
  1442.     }
  1443.  
  1444.     if (sourceReg == REGISTER_M)
  1445.     {
  1446.         address = (WORD)Registers[REGISTER_H] << 8 + (WORD)Registers[REGISTER_L];
  1447.         Registers[REGISTER_M] = Memory[address];
  1448.     }
  1449.  
  1450.     Registers[destReg] = Registers[sourceReg];
  1451.  
  1452.     if (destReg == REGISTER_M)
  1453.     {
  1454.         address = (WORD)Registers[REGISTER_H] << 8 + (WORD)Registers[REGISTER_L];
  1455.         Memory[address] = Registers[REGISTER_M];
  1456.     }
  1457. }
RAW Paste Data
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
Top