home *** CD-ROM | disk | FTP | other *** search
/ CBM Funet Archive / cbm-funet-archive-2003.iso / cbm / crossplatform / emulators / MacOS / mac64-04.hqx / MAC64-04.SEA / C64 / SOURCE / CpuC.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-02  |  17.1 KB  |  939 lines  |  [TEXT/KAHL]
  1. /*
  2.     cOMMODORE 64 eMULATOR V0.4      eARLE f. pHILHOWER iii 
  3.     cOPYRIGHT (c) 1993-4            (ST916W9R@DUNX1.OCS.DREXEL.EDU)
  4.  
  5.     tHIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
  6.     IT UNDER THE TERMS OF THE gnu gENERAL pUBLIC lICENSE AS PUBLISHED BY
  7.     THE fREE sOFTWARE fOUNDATION; EITHER VERSION 2 OF THE lICENSE, OR
  8.     (AT YOUR OPTION) ANY LATER VERSION.
  9.  
  10.     tHIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL,
  11.     BUT without any warranty; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12.     merchantability OR fitness for a particular purpose.  sEE THE
  13.     gnu gENERAL pUBLIC lICENSE FOR MORE DETAILS.
  14.  
  15.     yOU SHOULD HAVE RECEIVED A COPY OF THE gnu gENERAL pUBLIC lICENSE
  16.     ALONG WITH THIS PROGRAM; IF NOT, WRITE TO THE fREE sOFTWARE
  17.     fOUNDATION, iNC., 675 mASS aVE, cAMBRIDGE, ma 02139, usa.
  18. */
  19.  
  20. #INCLUDE "pROCESSOR.H"
  21. #INCLUDE "nEWiNSTRUCTIONS.H"
  22. #INCLUDE "sTACK.H"
  23. #INCLUDE "mODES.H"
  24. #INCLUDE "eRROR.H"
  25.  
  26. EXTERN BYTE BCD2DEC[], DEC2BCD[], CYCLETIME[], SCANcODE[];
  27.  
  28. /*
  29. tHIS IS MY iNSTRUCTIONS.C FILE CONDENSED INTO ONE SINGLE ROUTINE.
  30. */
  31. VOID iNTEGRATEDpROCESSOR(BYTE *gA, BYTE *gX, BYTE *gY, BYTE *gFLAGS, BYTE *gSP, WORD *gPC,
  32.  BYTE **gMEMORY, BYTE *gram)
  33. {$7b}
  34. /*
  35. fIRST WE MAKE LOCAL COPIES OF THE GLOBAL VARIABLES.  tHESE *SHOULD* BE STORED
  36. WITHIN A REGISTER VARIABLE, BUT WITH tc, WHO KNOWS!
  37. */
  38. REGISTER BYTE A, X, Y, FLAGS, SP;
  39. REGISTER WORD PC;
  40. REGISTER BYTE **MEMORY, **MEMORYP1, *ram;
  41.  
  42. REGISTER BYTE TBYTE;
  43. REGISTER WORD ADDR;
  44.  
  45. INT CYCLES, LINES;
  46. BYTE OLDmEMORYmAP;
  47.  
  48. A=*gA; X=*gX; Y=*gY; FLAGS=*gFLAGS; SP=*gSP; PC=*gPC;
  49. MEMORY=gMEMORY; MEMORYP1=MEMORY+1; ram=gram;
  50.  
  51. OLDmEMORYmAP=*ramP1;
  52.  
  53. LINES=0;
  54. WHILE (++LINES<350)
  55. {$7b}
  56. CYCLES=0;
  57. WHILE (CYCLES<35) 
  58. {$7b}
  59. TBYTE=iMMEDIATEbYTE(); PC++;
  60. CYCLES+=CYCLETIME[TBYTE];
  61. SWITCH (TBYTE)
  62. {$7b}
  63. CASE 0X00:
  64. pUSHwORD(PC);
  65. FLAGS {$7c}= bkc;
  66. pUSH(FLAGS{$7c}bkc);
  67. PC=wORDaT(iRQtO);
  68. BREAK;
  69. CASE 0X01:
  70. ora(iNDIRECTxaDDR); PC++;
  71. BREAK;
  72. CASE 0X02:
  73. crs();
  74. BREAK;
  75. CASE 0X03:
  76. lor(iNDIRECTxaDDR); PC++;
  77. BREAK;
  78. CASE 0X04:
  79. skp(1);
  80. BREAK;
  81. CASE 0X05:
  82. ora(zEROpAGEaDDR); PC++;
  83. BREAK;
  84. CASE 0X06:
  85. asl(zEROpAGEaDDR); PC++;
  86. BREAK;
  87. CASE 0X07:
  88. lor(zEROpAGEaDDR); PC++;
  89. BREAK;
  90. CASE 0X08:
  91. pUSH(FLAGS);
  92. BREAK;
  93. CASE 0X09:
  94. A {$7c}= iMMEDIATEbYTE(); fLAGSnz(A); PC++;
  95. BREAK;
  96. CASE 0X0A:
  97. IF (A&128) FLAGS {$7c}= car;
  98. ELSE FLAGS &= {$7e}car;
  99. A=A<<1;
  100. fLAGSnz(A);
  101. BREAK;
  102. CASE 0X0B:
  103. ana(); PC++;
  104. BREAK;
  105. CASE 0X0C:
  106. skp(2);
  107. BREAK;
  108. CASE 0X0D:
  109. ora(aBSOLUTEaDDR); PC+=2;
  110. BREAK;
  111. CASE 0X0E:
  112. asl(aBSOLUTEaDDR); PC+=2;
  113. BREAK;
  114. CASE 0X0F:
  115. lor(aBSOLUTEaDDR); PC+=2;
  116. BREAK;
  117. CASE 0X10:
  118. bcl(neg);
  119. BREAK;
  120. CASE 0X11:
  121. ora(iNDIRECTyaDDR); PC++;
  122. BREAK;
  123. CASE 0X12:
  124. crs();
  125. BREAK;
  126. CASE 0X13:
  127. lor(iNDIRECTyaDDR); PC++;
  128. BREAK;
  129. CASE 0X14:
  130. skp(1);
  131. BREAK;
  132. CASE 0X15:
  133. ora(zEROpAGExaDDR); PC++;
  134. BREAK;
  135. CASE 0X16:
  136. asl(zEROpAGExaDDR); PC++;
  137. BREAK;
  138. CASE 0X17:
  139. lor(zEROpAGExaDDR); PC++;
  140. BREAK;
  141. CASE 0X18:
  142. clr(car);
  143. BREAK;
  144. CASE 0X19:
  145. ora(aBSOLUTEyaDDR); PC+=2;
  146. BREAK;
  147. CASE 0X1A:
  148. PC++;
  149. BREAK;
  150. CASE 0X1B:
  151. lor(aBSOLUTEyaDDR); PC+=2;
  152. BREAK;
  153. CASE 0X1C:
  154. skp(2);
  155. BREAK;
  156. CASE 0X1D:
  157. ora(aBSOLUTExaDDR); PC+=2;
  158. BREAK;
  159. CASE 0X1E:
  160. asl(aBSOLUTExaDDR); PC+=2;
  161. BREAK;
  162. CASE 0X1F:
  163. lor(aBSOLUTExaDDR); PC+=2;
  164. BREAK;
  165. CASE 0X20:
  166. pUSHwORD(PC+1); PC=wORDaT(PC);
  167. BREAK;
  168. CASE 0X21:
  169. and(iNDIRECTxaDDR); PC++;
  170. BREAK;
  171. CASE 0X22:
  172. crs();
  173. BREAK;
  174. CASE 0X23:
  175. lan(iNDIRECTxaDDR); PC+=2;
  176. BREAK;
  177. CASE 0X24:
  178. bit(zEROpAGEaDDR); PC++;
  179. BREAK;
  180. CASE 0X25:
  181. and(zEROpAGEaDDR); PC++;
  182. BREAK;
  183. CASE 0X26:
  184. rol(zEROpAGEaDDR); PC++;
  185. BREAK;
  186. CASE 0X27:
  187. lan(zEROpAGEaDDR); PC++;
  188. BREAK;
  189. CASE 0X28:
  190. FLAGS = pOP();
  191. BREAK;
  192. CASE 0X29:
  193. A &= iMMEDIATEbYTE(); fLAGSnz(A); PC++;
  194. BREAK;
  195. CASE 0X2A:
  196. IF (FLAGS&car) {$7b}
  197. IF ((A&128)==0) FLAGS &={$7e}car;
  198. A=(A<<1){$7c}1; {$7d}
  199. ELSE {$7b}
  200. IF(A&128)FLAGS{$7c}=car;
  201. A=A<<1; {$7d}
  202. fLAGSnz(A);
  203. BREAK;
  204. CASE 0X2B:
  205. ana(); PC++;
  206. BREAK;
  207. CASE 0X2C:
  208. bit(aBSOLUTEaDDR); PC+=2;
  209. BREAK;
  210. CASE 0X2D:
  211. and(aBSOLUTEaDDR); PC+=2;
  212. BREAK;
  213. CASE 0X2E:
  214. rol(aBSOLUTEaDDR); PC+=2;
  215. BREAK;
  216. CASE 0X2F:
  217. lan(aBSOLUTEaDDR); PC+=2;
  218. BREAK;
  219. CASE 0X30:
  220. bst(neg);
  221. BREAK;
  222. CASE 0X31:
  223. and(iNDIRECTyaDDR); PC++;
  224. BREAK;
  225. CASE 0X32:
  226. crs();
  227. BREAK;
  228. CASE 0X33:
  229. lan(iNDIRECTyaDDR); PC+=2;
  230. BREAK;
  231. CASE 0X34:
  232. skp(1);
  233. BREAK;
  234. CASE 0X35:
  235. and(zEROpAGExaDDR); PC++;
  236. BREAK;
  237. CASE 0X36:
  238. rol(zEROpAGExaDDR); PC++;
  239. BREAK;
  240. CASE 0X37:
  241. lan(zEROpAGExaDDR); PC++;
  242. BREAK;
  243. CASE 0X38:
  244. set(car);
  245. BREAK;
  246. CASE 0X39:
  247. and(aBSOLUTEyaDDR); PC+=2;
  248. BREAK;
  249. CASE 0X3A:
  250. PC++;
  251. BREAK;
  252. CASE 0X3B:
  253. lan(aBSOLUTEyaDDR); PC+=2;
  254. BREAK;
  255. CASE 0X3C:
  256. skp(2);
  257. BREAK;
  258. CASE 0X3D:
  259. and(aBSOLUTExaDDR); PC+=2;
  260. BREAK;
  261. CASE 0X3E:
  262. rol(aBSOLUTExaDDR); PC+=2;
  263. BREAK;
  264. CASE 0X3F:
  265. lan(aBSOLUTExaDDR); PC+=2;
  266. BREAK;
  267. CASE 0X40:
  268. FLAGS=pOP(); pOPwORD(PC);
  269. BREAK;
  270. CASE 0X41:
  271. eor(iNDIRECTxaDDR); PC++;
  272. BREAK;
  273. CASE 0X42:
  274. crs();
  275. BREAK;
  276. CASE 0X43:
  277. reo(iNDIRECTxaDDR); PC+=2;
  278. BREAK;
  279. CASE 0X44:
  280. skp(1);
  281. BREAK;
  282. CASE 0X45:
  283. eor(zEROpAGEaDDR); PC++;
  284. BREAK;
  285. CASE 0X46:
  286. lsr(zEROpAGEaDDR); PC++;
  287. BREAK;
  288. CASE 0X47:
  289. reo(zEROpAGEaDDR); PC++;
  290. BREAK;
  291. CASE 0X48:
  292. pUSH(A);
  293. BREAK;
  294. CASE 0X49:
  295. A ^= iMMEDIATEbYTE(); fLAGSnz(A); PC++;
  296. BREAK;
  297. CASE 0X4A:
  298. FLAGS &={$7e}(car+neg+zer);
  299. IF (A&1) FLAGS {$7c}=car;
  300. IF (A=A>>1); ELSE FLAGS {$7c}=zer;
  301. BREAK;
  302. CASE 0X4B:
  303. rbm(); PC++;
  304. BREAK;
  305. CASE 0X4C:
  306. PC=wORDaT(PC);
  307. BREAK;
  308. CASE 0X4D:
  309. eor(aBSOLUTEaDDR); PC+=2;
  310. BREAK;
  311. CASE 0X4E:
  312. lsr(aBSOLUTEaDDR); PC+=2;
  313. BREAK;
  314. CASE 0X4F:
  315. reo(aBSOLUTEaDDR); PC+=2;
  316. BREAK;
  317. CASE 0X50:
  318. bcl(ovf);
  319. BREAK;
  320. CASE 0X51:
  321. eor(iNDIRECTyaDDR); PC++;
  322. BREAK;
  323. CASE 0X52:
  324. crs();
  325. BREAK;
  326. CASE 0X53:
  327. reo(iNDIRECTyaDDR); PC+=2;
  328. BREAK;
  329. CASE 0X54:
  330. skp(1);
  331. BREAK;
  332. CASE 0X55:
  333. eor(zEROpAGExaDDR); PC++;
  334. BREAK;
  335. CASE 0X56:
  336. lsr(zEROpAGExaDDR); PC++;
  337. BREAK;
  338. CASE 0X57:
  339. reo(zEROpAGExaDDR); PC++;
  340. BREAK;
  341. CASE 0X58:
  342. clr(int);
  343. BREAK;
  344. CASE 0X59:
  345. eor(aBSOLUTEyaDDR); PC+=2;
  346. BREAK;
  347. CASE 0X5A:
  348. PC++;
  349. BREAK;
  350. CASE 0X5B:
  351. reo(aBSOLUTEyaDDR); PC+=2;
  352. BREAK;
  353. CASE 0X5C:
  354. skp(2);
  355. BREAK;
  356. CASE 0X5D:
  357. eor(aBSOLUTExaDDR); PC+=2;
  358. BREAK;
  359. CASE 0X5E:
  360. lsr(aBSOLUTExaDDR); PC+=2;
  361. BREAK;
  362. CASE 0X5F:
  363. reo(aBSOLUTExaDDR); PC+=2;
  364. BREAK;
  365. CASE 0X60:
  366. pOPwORD(PC); PC++;
  367. BREAK;
  368. CASE 0X61:
  369. adc(iNDIRECTxaDDR); PC++;
  370. BREAK;
  371. CASE 0X62:
  372. crs();
  373. BREAK;
  374. CASE 0X63:
  375. rad(iNDIRECTxaDDR); PC++;
  376. BREAK;
  377. CASE 0X64:
  378. skp(1);
  379. BREAK;
  380. CASE 0X65:
  381. adc(zEROpAGEaDDR); PC++;
  382. BREAK;
  383. CASE 0X66:
  384. ror(zEROpAGEaDDR); PC++;
  385. BREAK;
  386. CASE 0X67:
  387. rad(zEROpAGEaDDR); PC++;
  388. BREAK;
  389. CASE 0X68:
  390. A=pOP(); fLAGSnz(A);
  391. BREAK;
  392. CASE 0X69:
  393. ADDR=iMMEDIATEbYTE();
  394. IF (FLAGS&dec) {$7b}
  395. ADDR = BCD2DEC[ADDR]+BCD2DEC[A]+((FLAGS&car)?1:0);
  396. FLAGS &= {$7e}(car+ovf+neg+zer);
  397. IF (ADDR>99) {$7b}
  398. FLAGS{$7c}=car+ovf;
  399. ADDR -=100; {$7d}
  400. IF (ADDR==0) FLAGS {$7c}= zer;
  401. ELSE FLAGS {$7c}= ADDR&128;
  402. A=DEC2BCD[ADDR];{$7d}
  403. ELSE {$7b}
  404. ADDR += A+((FLAGS&car)?1:0);
  405. FLAGS &= {$7e}(car+ovf+neg+zer);
  406. IF (ADDR>255) {$7b}
  407. FLAGS{$7c}=ovf+car;
  408. ADDR &=255; {$7d}
  409. IF (ADDR==0) FLAGS {$7c}= zer;
  410. ELSE FLAGS {$7c}= ADDR&128;
  411. A=ADDR; {$7d}
  412. PC++;
  413. BREAK;
  414. CASE 0X6A:
  415. IF (FLAGS&car) {$7b}
  416. IF ((A&1)==0) FLAGS &={$7e}car;
  417. A=(A>>1){$7c}128; {$7d}
  418. ELSE {$7b}
  419. IF(A&1) FLAGS{$7c}=car;
  420. A=A>>1; {$7d}
  421. fLAGSnz(A);
  422. BREAK;
  423. CASE 0X6B:
  424. rmam(); PC++;
  425. BREAK;
  426. CASE 0X6C:
  427. ADDR=wORDaT(PC); PC=wORDaT(ADDR);
  428. BREAK;
  429. CASE 0X6D:
  430. adc(aBSOLUTEaDDR); PC+=2;
  431. BREAK;
  432. CASE 0X6E:
  433. ror(aBSOLUTEaDDR); PC+=2;
  434. BREAK;
  435. CASE 0X6F:
  436. rad(aBSOLUTEaDDR); PC+=2;
  437. BREAK;
  438. CASE 0X70:
  439. bst(ovf);
  440. BREAK;
  441. CASE 0X71:
  442. adc(iNDIRECTyaDDR); PC++;
  443. BREAK;
  444. CASE 0X72:
  445. crs();
  446. BREAK;
  447. CASE 0X73:
  448. rad(iNDIRECTyaDDR); PC++;
  449. BREAK;
  450. CASE 0X74:
  451. skp(1);
  452. BREAK;
  453. CASE 0X75:
  454. adc(zEROpAGExaDDR); PC++;
  455. BREAK;
  456. CASE 0X76:
  457. ror(zEROpAGExaDDR); PC++;
  458. BREAK;
  459. CASE 0X77:
  460. rad(zEROpAGExaDDR); PC++;
  461. BREAK;
  462. CASE 0X78:
  463. set(int);
  464. BREAK;
  465. CASE 0X79:
  466. adc(aBSOLUTEyaDDR); PC+=2;
  467. BREAK;
  468. CASE 0X7A:
  469. PC++;
  470. BREAK;
  471. CASE 0X7B:
  472. rad(aBSOLUTEyaDDR); PC+=2;
  473. BREAK;
  474. CASE 0X7C:
  475. skp(2);
  476. BREAK;
  477. CASE 0X7D:
  478. adc(aBSOLUTExaDDR); PC+=2;
  479. BREAK;
  480. CASE 0X7E:
  481. ror(aBSOLUTExaDDR); PC+=2;
  482. BREAK;
  483. CASE 0X7F:
  484. rad(aBSOLUTExaDDR); PC+=2;
  485. BREAK;
  486. CASE 0X80:
  487. skp(1);
  488. BREAK;
  489. CASE 0X81:
  490. sta(iNDIRECTxaDDR); PC++;
  491. BREAK;
  492. CASE 0X82:
  493. skp(1);
  494. BREAK;
  495. CASE 0X83:
  496. aax(iNDIRECTxaDDR); PC++;
  497. BREAK;
  498. CASE 0X84:
  499. sty(zEROpAGEaDDR); PC++;
  500. BREAK;
  501. CASE 0X85:
  502. sta(zEROpAGEaDDR); PC++;
  503. BREAK;
  504. CASE 0X86:
  505. stx(zEROpAGEaDDR); PC++;
  506. BREAK;
  507. CASE 0X87:
  508. aax(zEROpAGEaDDR); PC+=1;
  509. BREAK;
  510. CASE 0X88:
  511. Y--; fLAGSnz(Y);
  512. BREAK;
  513. CASE 0X89:
  514. skp(1);
  515. BREAK;
  516. CASE 0X8A:
  517. A=X; fLAGSnz(A);
  518. BREAK;
  519. CASE 0X8B:
  520. xma(); PC++;
  521. BREAK;
  522. CASE 0X8C:
  523. sty(aBSOLUTEaDDR); PC+=2;
  524. BREAK;
  525. CASE 0X8D:
  526. sta(aBSOLUTEaDDR); PC+=2;
  527. BREAK;
  528. CASE 0X8E:
  529. stx(aBSOLUTEaDDR); PC+=2;
  530. BREAK;
  531. CASE 0X8F:
  532. aax(aBSOLUTEaDDR); PC+=2;
  533. BREAK;
  534. CASE 0X90:
  535. bcl(car);
  536. BREAK;
  537. CASE 0X91:
  538. sta(iNDIRECTyaDDR); PC++;
  539. BREAK;
  540. CASE 0X92:
  541. crs();
  542. BREAK;
  543. CASE 0X93:
  544. aax(iNDIRECTyaDDR); PC++;
  545. BREAK;
  546. CASE 0X94:
  547. sty(zEROpAGExaDDR); PC++;
  548. BREAK;
  549. CASE 0X95:
  550. sta(zEROpAGExaDDR); PC++;
  551. BREAK;
  552. CASE 0X96:
  553. stx(zEROpAGEyaDDR); PC++;
  554. BREAK;
  555. CASE 0X97:
  556. aax(zEROpAGEyaDDR); PC++;
  557. BREAK;
  558. CASE 0X98:
  559. A=Y; fLAGSnz(A);
  560. BREAK;
  561. CASE 0X99:
  562. sta(aBSOLUTEyaDDR); PC+=2;
  563. BREAK;
  564. CASE 0X9A:
  565. SP=X;
  566. BREAK;
  567. CASE 0X9B:
  568. axs(aBSOLUTEyaDDR); PC+=2;
  569. BREAK;
  570. CASE 0X9C:
  571. tey(aBSOLUTExaDDR); PC+=2;
  572. BREAK;
  573. CASE 0X9D:
  574. sta(aBSOLUTExaDDR); PC+=2;
  575. BREAK;
  576. CASE 0X9E:
  577. tex(aBSOLUTEyaDDR); PC+=2;
  578. BREAK;
  579. CASE 0X9F:
  580. tea(aBSOLUTEyaDDR); PC+=2;
  581. BREAK;
  582. CASE 0XA0:
  583. Y=iMMEDIATEbYTE(); fLAGSnz(Y); PC++;
  584. BREAK;
  585. CASE 0XA1:
  586. lda(iNDIRECTxaDDR); PC++;
  587. BREAK;
  588. CASE 0XA2:
  589. X=iMMEDIATEbYTE(); fLAGSnz(X); PC++;
  590. BREAK;
  591. CASE 0XA3:
  592. lax(iNDIRECTxaDDR); PC++;
  593. BREAK;
  594. CASE 0XA4:
  595. ldy(zEROpAGEaDDR); PC++;
  596. BREAK;
  597. CASE 0XA5:
  598. lda(zEROpAGEaDDR); PC++;
  599. BREAK;
  600. CASE 0XA6:
  601. ldx(zEROpAGEaDDR); PC++;
  602. BREAK;
  603. CASE 0XA7:
  604. lax(zEROpAGEaDDR); PC++;
  605. BREAK;
  606. CASE 0XA8:
  607. Y=A; fLAGSnz(Y);
  608. BREAK;
  609. CASE 0XA9:
  610. A=iMMEDIATEbYTE(); fLAGSnz(A); PC++;
  611. BREAK;
  612. CASE 0XAA:
  613. X=A; fLAGSnz(X);
  614. BREAK;
  615. CASE 0XAB:
  616. ama(); PC++;
  617. BREAK;
  618. CASE 0XAC:
  619. ldy(aBSOLUTEaDDR); PC+=2;
  620. BREAK;
  621. CASE 0XAD:
  622. lda(aBSOLUTEaDDR); PC+=2;
  623. BREAK;
  624. CASE 0XAE:
  625. ldx(aBSOLUTEaDDR); PC+=2;
  626. BREAK;
  627. CASE 0XAF:
  628. lax(aBSOLUTEaDDR); PC+=2;
  629. BREAK;
  630. CASE 0XB0:
  631. bst(car);
  632. BREAK;
  633. CASE 0XB1:
  634. lda(iNDIRECTyaDDR); PC++;
  635. BREAK;
  636. CASE 0XB2:
  637. crs();
  638. BREAK;
  639. CASE 0XB3:
  640. lax(iNDIRECTyaDDR); PC++;
  641. BREAK;
  642. CASE 0XB4:
  643. ldy(zEROpAGExaDDR); PC++;
  644. BREAK;
  645. CASE 0XB5:
  646. lda(zEROpAGExaDDR); PC++;
  647. BREAK;
  648. CASE 0XB6:
  649. ldx(zEROpAGEyaDDR); PC++;
  650. BREAK;
  651. CASE 0XB7:
  652. lax(zEROpAGEyaDDR); PC++;
  653. BREAK;
  654. CASE 0XB8:
  655. clr(ovf);
  656. BREAK;
  657. CASE 0XB9:
  658. lda(aBSOLUTEyaDDR); PC+=2;
  659. BREAK;
  660. CASE 0XBA:
  661. X=SP;
  662. BREAK;
  663. CASE 0XBB:
  664. las(aBSOLUTEyaDDR); PC+=2;
  665. BREAK;
  666. CASE 0XBC:
  667. ldy(aBSOLUTExaDDR); PC+=2;
  668. BREAK;
  669. CASE 0XBD:
  670. lda(aBSOLUTExaDDR); PC+=2;
  671. BREAK;
  672. CASE 0XBE:
  673. ldx(aBSOLUTEyaDDR); PC+=2;
  674. BREAK;
  675. CASE 0XBF:
  676. lax(aBSOLUTEyaDDR); PC+=2;
  677. BREAK;
  678. CASE 0XC0:
  679. TBYTE=iMMEDIATEbYTE();
  680. FLAGS &={$7e}(car+zer+neg);
  681. IF (Y==TBYTE) FLAGS {$7c}=car+zer;
  682. ELSE IF (Y>TBYTE) FLAGS {$7c}=car;
  683. ELSE FLAGS {$7c}=neg;
  684. PC++;
  685. BREAK;
  686. CASE 0XC1:
  687. cmp(iNDIRECTxaDDR); PC++;
  688. BREAK;
  689. CASE 0XC2:
  690. skp(1);
  691. BREAK;
  692. CASE 0XC3:
  693. dcp(iNDIRECTxaDDR); PC++;
  694. BREAK;
  695. CASE 0XC4:
  696. cpy(zEROpAGEaDDR); PC++;
  697. BREAK;
  698. CASE 0XC5:
  699. cmp(zEROpAGEaDDR); PC++;
  700. BREAK;
  701. CASE 0XC6:
  702. decr(zEROpAGEaDDR); PC++;
  703. BREAK;
  704. CASE 0XC7:
  705. dcp(zEROpAGEaDDR); PC++;
  706. BREAK;
  707. CASE 0XC8:
  708. Y++; fLAGSnz(Y);
  709. BREAK;
  710. CASE 0XC9:
  711. TBYTE=iMMEDIATEbYTE();
  712. FLAGS &={$7e}(car+zer+neg);
  713. IF (A==TBYTE) FLAGS {$7c}=car+zer;
  714. ELSE IF (A>TBYTE) FLAGS {$7c}=car;
  715. ELSE FLAGS {$7c}=neg;
  716. PC++;
  717. BREAK;
  718. CASE 0XCA:
  719. X--; fLAGSnz(X);
  720. BREAK;
  721. CASE 0XCB:
  722. axm(); PC++;
  723. BREAK;
  724. CASE 0XCC:
  725. cpy(aBSOLUTEaDDR); PC+=2;
  726. BREAK;
  727. CASE 0XCD:
  728. cmp(aBSOLUTEaDDR); PC+=2;
  729. BREAK;
  730. CASE 0XCE:
  731. decr(aBSOLUTEaDDR); PC+=2;
  732. BREAK;
  733. CASE 0XCF:
  734. dcp(aBSOLUTEaDDR); PC++;
  735. BREAK;
  736. CASE 0XD0:
  737. bcl(zer);
  738. BREAK;
  739. CASE 0XD1:
  740. cmp(iNDIRECTyaDDR); PC++;
  741. BREAK;
  742. CASE 0XD2:
  743. crs();
  744. BREAK;
  745. CASE 0XD3:
  746. dcp(iNDIRECTyaDDR); PC++;
  747. BREAK;
  748. CASE 0XD4:
  749. skp(1);
  750. BREAK;
  751. CASE 0XD5:
  752. cmp(zEROpAGExaDDR); PC++;
  753. BREAK;
  754. CASE 0XD6:
  755. decr(zEROpAGExaDDR); PC++;
  756. BREAK;
  757. CASE 0XD7:
  758. dcp(zEROpAGExaDDR); PC++;
  759. BREAK;
  760. CASE 0XD8:
  761. clr(dec);
  762. BREAK;
  763. CASE 0XD9:
  764. cmp(aBSOLUTEyaDDR); PC+=2;
  765. BREAK;
  766. CASE 0XDA:
  767. PC++;
  768. BREAK;
  769. CASE 0XDB:
  770. dcp(aBSOLUTEyaDDR); PC++;
  771. BREAK;
  772. CASE 0XDC:
  773. skp(2);
  774. BREAK;
  775. CASE 0XDD:
  776. cmp(aBSOLUTExaDDR); PC+=2;
  777. BREAK;
  778. CASE 0XDE:
  779. decr(aBSOLUTExaDDR); PC+=2;
  780. BREAK;
  781. CASE 0XDF:
  782. dcp(aBSOLUTExaDDR); PC++;
  783. BREAK;
  784. CASE 0XE0:
  785. TBYTE=iMMEDIATEbYTE();
  786. FLAGS &={$7e}(car+zer+neg);
  787. IF (X==TBYTE) FLAGS {$7c}=car+zer;
  788. ELSE IF (X>TBYTE) FLAGS {$7c}=car;
  789. ELSE FLAGS {$7c}=neg;
  790. PC++;
  791. BREAK;
  792. CASE 0XE1:
  793. sbc(iNDIRECTxaDDR); PC++;
  794. BREAK;
  795. CASE 0XE2:
  796. skp(1);
  797. BREAK;
  798. CASE 0XE3:
  799. isb(iNDIRECTxaDDR); PC++;
  800. BREAK;
  801. CASE 0XE4:
  802. cpx(zEROpAGEaDDR); PC++;
  803. BREAK;
  804. CASE 0XE5:
  805. sbc(zEROpAGEaDDR); PC++;
  806. BREAK;
  807. CASE 0XE6:
  808. incr(zEROpAGEaDDR); PC++;
  809. BREAK;
  810. CASE 0XE7:
  811. isb(zEROpAGEaDDR); PC++;
  812. BREAK;
  813. CASE 0XE8:
  814. X++; fLAGSnz(X);
  815. BREAK;
  816. CASE 0XE9:
  817. ADDR=iMMEDIATEbYTE();
  818. IF (FLAGS&dec) {$7b}
  819. ADDR = BCD2DEC[A]-BCD2DEC[ADDR]-((FLAGS&car)?0:1);
  820. FLAGS &= {$7e}(car+zer+neg+ovf);
  821. IF (ADDR==0) FLAGS {$7c}=zer+car;
  822. ELSE IF (((INT)ADDR)>0) FLAGS {$7c}=car;
  823. ELSE {$7b}
  824. FLAGS{$7c}=neg;
  825. ADDR +=100; {$7d}
  826. A=DEC2BCD[ADDR]; {$7d}
  827. ELSE {$7b}
  828. ADDR = A-ADDR-((FLAGS&car)?0:1);
  829. FLAGS &={$7e}(car+zer+ovf+neg);
  830. IF (ADDR==0) FLAGS {$7c}= zer+car;
  831. ELSE IF (((INT)ADDR)>0) FLAGS {$7c}= car;
  832. ELSE FLAGS{$7c}=ovf;
  833. ADDR &= 255;
  834. FLAGS {$7c}= ADDR&128;
  835. A=ADDR; {$7d}
  836. PC++; 
  837. BREAK;
  838. CASE 0XEA:
  839. BREAK;
  840. CASE 0XEB:
  841. ADDR=iMMEDIATEbYTE();
  842. IF (FLAGS&dec) {$7b}
  843. ADDR = BCD2DEC[A]-BCD2DEC[ADDR]-((FLAGS&car)?0:1);
  844. FLAGS &= {$7e}(car+zer+neg+ovf);
  845. IF (ADDR==0) FLAGS {$7c}=zer+car;
  846. ELSE IF (((INT)ADDR)>0) FLAGS {$7c}=car;
  847. ELSE {$7b}
  848. FLAGS{$7c}=neg;
  849. ADDR +=100; {$7d}
  850. A=DEC2BCD[ADDR]; {$7d}
  851. ELSE {$7b}
  852. ADDR = A-ADDR-((FLAGS&car)?0:1);
  853. FLAGS &={$7e}(car+zer+ovf+neg);
  854. IF (ADDR==0) FLAGS {$7c}= zer+car;
  855. ELSE IF (((INT)ADDR)>0) FLAGS {$7c}= car;
  856. ELSE FLAGS{$7c}=ovf;
  857. ADDR &= 255;
  858. FLAGS {$7c}= ADDR&128;
  859. A=ADDR; {$7d}
  860. PC++; 
  861. BREAK;
  862. CASE 0XEC:
  863. cpx(aBSOLUTEaDDR); PC+=2;
  864. BREAK;
  865. CASE 0XED:
  866. sbc(aBSOLUTEaDDR); PC+=2;
  867. BREAK;
  868. CASE 0XEE:
  869. incr(aBSOLUTEaDDR); PC+=2;
  870. BREAK;
  871. CASE 0XEF:
  872. isb(aBSOLUTEaDDR); PC+=2;
  873. BREAK;
  874. CASE 0XF0:
  875. bst(zer);
  876. BREAK;
  877. CASE 0XF1:
  878. sbc(iNDIRECTyaDDR); PC++;
  879. BREAK;
  880. CASE 0XF2:
  881. crs();
  882. BREAK;
  883. CASE 0XF3:
  884. isb(iNDIRECTyaDDR); PC++;
  885. BREAK;
  886. CASE 0XF4:
  887. skp(1);
  888. BREAK;
  889. CASE 0XF5:
  890. sbc(zEROpAGExaDDR); PC++;
  891. BREAK;
  892. CASE 0XF6:
  893. incr(zEROpAGExaDDR); PC++;
  894. BREAK;
  895. CASE 0XF7:
  896. isb(zEROpAGExaDDR); PC++;
  897. BREAK;
  898. CASE 0XF8:
  899. set(dec);
  900. BREAK;
  901. CASE 0XF9:
  902. sbc(aBSOLUTEyaDDR); PC+=2;
  903. BREAK;
  904. CASE 0XFA:
  905. PC++;
  906. BREAK;
  907. CASE 0XFB:
  908. isb(aBSOLUTEyaDDR); PC+=2;
  909. BREAK;
  910. CASE 0XFC:
  911. skp(2);
  912. BREAK;
  913. CASE 0XFD:
  914. sbc(aBSOLUTExaDDR); PC+=2;
  915. BREAK;
  916. CASE 0XFE:
  917. incr(aBSOLUTExaDDR); PC+=2;
  918. BREAK;
  919. CASE 0XFF:
  920.  
  921. /*
  922. tHIS IS OUT trap COMMAND FOR PATCHING THE romS.  fIRST MAKE SURE
  923. THE GLOBAL REGISTERS ARE SET PROPERLY
  924. */
  925. *gA=A; *gX=X; *gY=Y; *gFLAGS=FLAGS; *gSP=SP; *gPC=PC;
  926. tRAPeXECUTE();
  927. A=*gA; X=*gX; Y=*gY; FLAGS=*gFLAGS; SP=*gSP; PC=*gPC;
  928. BREAK;
  929. {$7d}
  930. /* sET UP THE KEYBOARD REGISTER ACCORDING TO PRECOMPUTED VALUES */
  931. ram[0XDC01]=SCANcODE[ram[0XDC00]];
  932. {$7d}
  933. IF (++ram[0XD012]==0) ram[0XD011] ^= 128;
  934. ram[0XD018] {$7c}=1;
  935. {$7d}
  936. *gA=A; *gX=X; *gY=Y; *gFLAGS=FLAGS; *gSP=SP; *gPC=PC;
  937. {$7d}
  938.  
  939.