API tools faq
paste
Advertisement
Guest User

GTX1070

a guest
Feb 18th, 2020
173
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 36.28 KB | None | 0 0
raw download clone embed print report
  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. }
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!