home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / compsrcs / apple2 / 25 < prev    next >
Encoding:
Internet Message Format  |  1990-11-26  |  36.3 KB
  1. Path: wuarchive!zaphod.mps.ohio-state.edu!mips!dimacs.rutgers.edu!aramis.rutgers.edu!paul.rutgers.edu!jac
  2. From: jac@paul.rutgers.edu (Jonathan A. Chandross)
  3. Newsgroups: comp.sources.apple2
  4. Subject: v001SRC005:  Apple ][ Simulator Part 2/3 (Koning Version)
  5. Message-ID: <Nov.18.20.59.16.1990.26190@paul.rutgers.edu>
  6. Date: 19 Nov 90 01:59:18 GMT
  7. Organization: Rutgers Univ., New Brunswick, N.J.
  8. Lines: 1708
  9. Approved: jac@paul.rutgers.edu
  10.  
  11.  
  12. Submitted-by: None
  13. Posting-number: Volume 1, Source:5
  14. Archive-name: unix/simulator/koning/part02
  15. Architecture: UNIX
  16. Version-number: 1.00
  17.  
  18.  
  19. =6502.c
  20. -
  21. -/*
  22. - *6502.c -- Mostek/Rockwell/Synertek/Siliconix 6502 for Apple II Emulator
  23. - *(C) 1989 Ben Koning [556498717 408/738-1763 ben@apple.com]
  24. - */
  25. -
  26. -#include "apple.h"
  27. -
  28. -
  29. -/*
  30. - * 6502 Globals:
  31. - */
  32. -
  33. -int A,X,Y,P,S;
  34. -ADDR PPC;
  35. -
  36. -void CPUReset (/*_  _*/);
  37. -void _push_ (/*_ BYTE _*/);
  38. -BYTE _pull_ (/*_ _*/);
  39. -BYTE _eaimm_ (/*_ _*/);
  40. -BYTE _eazp_ (/*_ _*/);
  41. -BYTE _eazpx_ (/*_ _*/);
  42. -BYTE _eazpy_ (/*_ _*/);
  43. -ADDR _eaabs_ (/*_ _*/);
  44. -ADDR _eaabsind_ (/*_ _*/);
  45. -ADDR _eaabsx_ (/*_ _*/);
  46. -ADDR _eaabsy_ (/*_ _*/);
  47. -ADDR _eaindx_ (/*_ _*/);
  48. -ADDR _eaindy_ (/*_ _*/);
  49. -
  50. -
  51. -void CPUReset ()
  52. -{
  53. -  /* Setup registers: */
  54. -  A = X = Y = P = 0;
  55. -  S = 0xff;
  56. -  
  57. -  /* Set PPC to pointer at $FFFC: */
  58. -  PPC = MegaGetMem (0xfffc) + MegaGetMem (0xfffd) * 0x0100;
  59. -  
  60. -  /* Should execute instructions forever after this */
  61. -} 
  62. -
  63. -/* This internal routine pushes a byte onto the stack */
  64. -void _push_ (byte)
  65. -BYTE byte;
  66. -{
  67. -  MegaPutMem ((ADDR)(0x100 + S--), byte);
  68. -  S &= 0xff;
  69. -}
  70. -
  71. -/* This internal routine pulls a byte from the stack */
  72. -BYTE _pull_ ()
  73. -{
  74. -  S++;
  75. -  S &= 0xff;
  76. -  return MegaGetMem (0x100 + S);
  77. -}
  78. -
  79. -/* This internal routine fetches an immediate operand value */
  80. -BYTE _eaimm_ ()
  81. -{
  82. -  register BYTE i;
  83. -
  84. -  i = MegaGetMem (PPC++);
  85. -  PPC &= 0xffff;
  86. -  return i;
  87. -}
  88. -
  89. -/* This internal routine fetches a zero-page operand address */
  90. -BYTE _eazp_ ()
  91. -{
  92. -  register BYTE a;
  93. -
  94. -  a = MegaGetMem (PPC++);
  95. -  PPC &= 0xffff;
  96. -
  97. -  return a;
  98. -}
  99. -
  100. -/* This internal routine fetches a zpage,X operand address */
  101. -BYTE _eazpx_ ()
  102. -{
  103. -  register BYTE a;
  104. -
  105. -  a = MegaGetMem (PPC++);
  106. -  PPC &= 0xffff;
  107. -  a += X;
  108. -  a &= 0xff;
  109. -
  110. -  return a;
  111. -}
  112. -
  113. -/* This internal routine fetches a zpage,Y operand address */
  114. -BYTE _eazpy_ ()
  115. -{
  116. -  register BYTE a;
  117. -
  118. -  a = MegaGetMem (PPC++);
  119. -  PPC &= 0xffff;
  120. -  a += Y;
  121. -  a &= 0xff;
  122. -
  123. -  return a;
  124. -}
  125. -
  126. -/* This internal routine fetches an absolute operand address */
  127. -ADDR _eaabs_ ()
  128. -{
  129. -  register BYTE lo, hi;
  130. -
  131. -  lo = MegaGetMem (PPC++);
  132. -  PPC &= 0xffff;
  133. -  hi = MegaGetMem (PPC++);
  134. -  PPC &= 0xffff;
  135. -
  136. -  return lo + hi * 0x0100;
  137. -}
  138. -
  139. -/* This internal routine fetches an indirect absolute operand address */
  140. -ADDR _eaabsind_ ()
  141. -{
  142. -  register int a, lo, hi;
  143. -
  144. -  a = _eaabs_();
  145. -  lo = MegaGetMem ((ADDR)a++);
  146. -  a &= 0xffff;
  147. -  hi = MegaGetMem ((ADDR)a);
  148. -
  149. -  return lo + hi * 0x0100;
  150. -}
  151. -
  152. -/* This internal routine fetches an absolute,X operand address */
  153. -ADDR _eaabsx_ ()
  154. -{
  155. -  register int a;
  156. -
  157. -  a = _eaabs_() + X;
  158. -
  159. -  return (a & 0xffff); /* Not entirely correct */
  160. -}
  161. -
  162. -/* This internal routine fetches an absolute,Y operand address */
  163. -ADDR _eaabsy_ ()
  164. -{
  165. -  register int a;
  166. -
  167. -  a = _eaabs_() + Y;
  168. -
  169. -  return (a & 0xffff); /* Not entirely correct */
  170. -}
  171. -
  172. -/* This internal routine fetches a (zpage,X) operand address */
  173. -ADDR _eaindx_ ()
  174. -{
  175. -  register int a, lo, hi;
  176. -
  177. -  a = _eazpx_();
  178. -  lo = MegaGetMem ((ADDR)a++);
  179. -  a &= 0xff;
  180. -  hi = MegaGetMem ((ADDR)a);
  181. -
  182. -  return lo + hi * 0x0100;
  183. -}
  184. -
  185. -/* This internal routine fetches a (zpage),Y operand address */
  186. -ADDR _eaindy_ ()
  187. -{
  188. -  register int a, lo, hi;
  189. -
  190. -  a = _eazp_();
  191. -  lo = MegaGetMem ((ADDR)a++);
  192. -  a &= 0xff;
  193. -  hi = MegaGetMem ((ADDR)a);
  194. -
  195. -  return ( (Y + lo + hi * 0x0100) & 0xffff ); /* Not entirely correct */
  196. -}
  197. -#ifdef NEVER
  198. -/* Macros to set the P flags: */
  199. -#define _setN_(b)    if ((b)!=0) P |= 0x80;   else P &= ~0x80
  200. -#define _setV_(b)    if ((b)!=0) P |= 0x40;   else P &= ~0x40
  201. -/* This bit not implemented */
  202. -#define _setB_(b)    if ((b)!=0) P |= 0x10;   else P &= ~0x10
  203. -#define _setD_(b)    if ((b)!=0) P |= 0x08;   else P &= ~0x08
  204. -#define _setI_(b)    if ((b)!=0) P |= 0x04;   else P &= ~0x04
  205. -#define _setZ_(b)    if ((b)!=0) P |= 0x02;   else P &= ~0x02
  206. -#define _setC_(b)    if ((b)!=0) P |= 0x01;   else P &= ~0x01
  207. -#endif
  208. -/* Macros to set the P flags: */
  209. -void _setN_(b){    if ((b)!=0) P |= 0x80;   else P &= ~0x80;}
  210. -void _setV_(b){    if ((b)!=0) P |= 0x40;   else P &= ~0x40;}
  211. -/* This bit not implemented */
  212. -void _setB_(b){    if ((b)!=0) P |= 0x10;   else P &= ~0x10;}
  213. -void _setD_(b){    if ((b)!=0) P |= 0x08;   else P &= ~0x08;}
  214. -void _setI_(b){    if ((b)!=0) P |= 0x04;   else P &= ~0x04;}
  215. -void _setZ_(b){    if ((b)!=0) P |= 0x02;   else P &= ~0x02;}
  216. -void _setC_(b){    if ((b)!=0) P |= 0x01;   else P &= ~0x01;}
  217. -  
  218. -  /* Macros to read the P flags: */
  219. -#define _getN_  ((P & 0x80) ? 1 : 0)
  220. -#define _getV_  ((P & 0x40) ? 1 : 0)
  221. -/* This bit not implemented */
  222. -#define _getB_  ((P & 0x10) ? 1 : 0)
  223. -#define _getD_  ((P & 0x08) ? 1 : 0)
  224. -#define _getI_  ((P & 0x04) ? 1 : 0)
  225. -#define _getZ_  ((P & 0x02) ? 1 : 0)
  226. -#define _getC_  ((P & 0x01) ? 1 : 0)
  227. -
  228. -/* This routine executes a single instruction. */
  229. -void CPUExecute ()
  230. -{
  231. -  register int opcode;      /* Scratch: Opcode fetched */
  232. -  register int d;           /* Scratch: Data byte fetched */
  233. -  register int lo;          /* Scratch: Lo8 for building ptr */
  234. -  register int hi;          /* Scratch: Hi8 for building ptr */
  235. -  register int al;          /* Scratch: Accumulator lo nibble */
  236. -  register int ah;          /* Scratch: Accumulator hi nibble */
  237. -  register int ol;          /* Scratch: Operand lo nibble */
  238. -  register int oh;          /* Scratch: Operand hi nibble */
  239. -
  240. -  if (PPC == 0xc780)
  241. -    prodos();
  242. -  opcode = MegaGetMem (PPC++);
  243. -  PPC &= 0xffff;
  244. -  
  245. -  switch (opcode)
  246. -  {
  247. -  case 0x69:    /* ADC #dd */
  248. -    d = _eaimm_();
  249. -    if (!_getD_) {
  250. -      A = A + d + _getC_;
  251. -      _setC_ (A > 0xff);
  252. -    } else {
  253. -      ah = A / 16;   al = A % 16;
  254. -      oh = d / 16;   ol = d % 16;
  255. -      al = al + _getC_ + ol;
  256. -      if (al >= 10) { al -= 10; ah++; }
  257. -      ah += oh;
  258. -      _setC_ (ah >= 10);
  259. -      if (ah >= 10) ah -= 10;
  260. -      A = al + (ah * 16);
  261. -    }
  262. -    _setV_ ((A < -0x80) || (A > 0x7f));
  263. -    A %= 0x0100;
  264. -    _setZ_ (A == 0);
  265. -    _setN_ (A >= 0x80);
  266. -    break;
  267. -    
  268. -  case 0x65:    /* ADC aa */
  269. -    d = MegaGetMem ((ADDR)_eazp_ ());
  270. -    if (!_getD_) {
  271. -      A = A + d + _getC_;
  272. -      _setC_ (A > 0xff);
  273. -    } else {
  274. -      ah = A / 16;   al = A % 16;
  275. -      oh = d / 16;   ol = d % 16;
  276. -      al = al + _getC_ + ol;
  277. -      if (al >= 10) { al -= 10; ah++; }
  278. -      ah += oh;
  279. -      _setC_ (ah >= 10);
  280. -      if (ah >= 10) ah -= 10;
  281. -      A = al + (ah*16);
  282. -    }
  283. -    _setV_ ((A < -0x80) || (A > 0x7f));
  284. -    A %= 0x0100;
  285. -    _setZ_ (A == 0);
  286. -    _setN_ (A >= 0x80);
  287. -    break;
  288. -    
  289. -  case 0x75:    /* ADC aa,X */
  290. -    d = MegaGetMem ((ADDR)_eazpx_ ());
  291. -    if (!_getD_) {
  292. -      A = A + d + _getC_;
  293. -      _setC_ (A > 0xff);
  294. -    } else {
  295. -      ah = A / 16;   al = A % 16;
  296. -      oh = d / 16;   ol = d % 16;
  297. -      al = al + _getC_ + ol;
  298. -      if (al >= 10) { al -= 10; ah++; }
  299. -      ah += oh;
  300. -      _setC_ (ah >= 10);
  301. -      if (ah >= 10) ah -= 10;
  302. -      A = al + (ah*16);
  303. -    }
  304. -    _setV_ ((A < -0x80) || (A > 0x7f));
  305. -    A %= 0x0100;
  306. -    _setZ_ (A == 0);
  307. -    _setN_ (A >= 0x80);
  308. -    break;
  309. -    
  310. -  case 0x6d:    /* ADC aaaa */
  311. -    d = MegaGetMem (_eaabs_ ());
  312. -    if (!_getD_) {
  313. -      A = A + d + _getC_;
  314. -      _setC_ (A > 0xff);
  315. -    } else {
  316. -      ah = A / 16;   al = A % 16;
  317. -      oh = d / 16;   ol = d % 16;
  318. -      al = al + _getC_ + ol;
  319. -      if (al >= 10) { al -= 10; ah++; }
  320. -      ah += oh;
  321. -      _setC_ (ah >= 10);
  322. -      if (ah >= 10) ah -= 10;
  323. -      A = al + (ah*16);
  324. -    }
  325. -    _setV_ ((A < -0x80) || (A > 0x7f));
  326. -    A %= 0x0100;
  327. -    _setZ_ (A == 0);
  328. -    _setN_ (A >= 0x80);
  329. -    break;
  330. -    
  331. -  case 0x7d:    /* ADC aaaa,X */
  332. -    d = MegaGetMem (_eaabsx_ ());
  333. -    if (!_getD_) {
  334. -      A = A + d + _getC_;
  335. -      _setC_ (A > 0xff);
  336. -    } else {
  337. -      ah = A / 16;   al = A % 16;
  338. -      oh = d / 16;   ol = d % 16;
  339. -      al = al + _getC_ + ol;
  340. -      if (al >= 10) { al -= 10; ah++; }
  341. -      ah += oh;
  342. -      _setC_ (ah >= 10);
  343. -      if (ah >= 10) ah -= 10;
  344. -      A = al + (ah * 16);
  345. -    }
  346. -    _setV_ ((A < -0x80) || (A > 0x7f));
  347. -    A %= 0x0100;
  348. -    _setZ_ (A == 0);
  349. -    _setN_ (A >= 0x80);
  350. -    break;
  351. -    
  352. -  case 0x79:    /* ADC aaaa,Y */
  353. -    d = MegaGetMem (_eaabsy_ ());
  354. -    if (!_getD_) {
  355. -      A = A + d + _getC_;
  356. -      _setC_ (A > 0xff);
  357. -    } else {
  358. -      ah = A / 16;   al = A % 16;
  359. -      oh = d / 16;   ol = d % 16;
  360. -      al = al + _getC_ + ol;
  361. -      if (al >= 10) { al -= 10; ah++; }
  362. -      ah += oh;
  363. -      _setC_ (ah >= 10);
  364. -      if (ah >= 10) ah -= 10;
  365. -      A = al + (ah * 16);
  366. -    }
  367. -    _setV_ ((A < -0x80) || (A > 0x7f));
  368. -    A %= 0x0100;
  369. -    _setZ_ (A == 0);
  370. -    _setN_ (A >= 0x80);
  371. -    break;
  372. -    
  373. -  case 0x61:    /* ADC (aa,X) */
  374. -    d = MegaGetMem (_eaindx_ ());
  375. -    if (!_getD_) {
  376. -      A = A + d + _getC_;
  377. -      _setC_ (A > 0xff);
  378. -    } else {
  379. -      ah = A / 16;   al = A % 16;
  380. -      oh = d / 16;   ol = d % 16;
  381. -      al = al + _getC_ + ol;
  382. -      if (al >= 10) { al -= 10; ah++; }
  383. -      ah += oh;
  384. -      _setC_ (ah >= 10);
  385. -      if (ah >= 10) ah -= 10;
  386. -      A = al + (ah * 16);
  387. -    }
  388. -    _setV_ ((A < -0x80) || (A > 0x7f));
  389. -    A %= 0x0100;
  390. -    _setZ_ (A == 0);
  391. -    _setN_ (A >= 0x80);
  392. -    break;
  393. -    
  394. -  case 0x71:    /* ADC (aa),Y */
  395. -    d = MegaGetMem (_eaindy_ ());
  396. -    if (!_getD_) {
  397. -      A = A + d + _getC_;
  398. -      _setC_ (A > 0xff);
  399. -    } else {
  400. -      ah = A / 16;   al = A % 16;
  401. -      oh = d / 16;   ol = d % 16;
  402. -      al = al + _getC_ + ol;
  403. -      if (al >= 10) { al -= 10; ah++; }
  404. -      ah += oh;
  405. -      _setC_ (ah >= 10);
  406. -      if (ah >= 10) ah -= 10;
  407. -      A = al + (ah * 16);
  408. -    }
  409. -    _setV_ ((A < -0x80) || (A > 0x7f));
  410. -    A %= 0x0100;
  411. -    _setZ_ (A == 0);
  412. -    _setN_ (A >= 0x80);
  413. -    break;
  414. -    
  415. -    
  416. -    
  417. -  case 0x29:    /* AND #dd */
  418. -    A &= _eaimm_ ();
  419. -    _setN_ (A >= 0x80);
  420. -    _setZ_ (A == 0);
  421. -    break;
  422. -    
  423. -  case 0x25:    /* AND aa */
  424. -    A &= MegaGetMem ((ADDR)_eazp_ ());
  425. -    _setN_ (A >= 0x80);
  426. -    _setZ_ (A == 0);
  427. -    break;
  428. -    
  429. -  case 0x35:    /* AND aa,X */
  430. -    A &= MegaGetMem ((ADDR)_eazpx_ ());
  431. -    _setN_ (A >= 0x80);
  432. -    _setZ_ (A == 0);
  433. -    break;
  434. -    
  435. -  case 0x2d:    /* AND aaaa */
  436. -    A &= MegaGetMem (_eaabs_ ());
  437. -    _setN_ (A >= 0x80);
  438. -    _setZ_ (A == 0);
  439. -    break;
  440. -    
  441. -  case 0x3d:    /* AND aaaa,X */
  442. -    A &= MegaGetMem (_eaabsx_ ());
  443. -    _setN_ (A >= 0x80);
  444. -    _setZ_ (A == 0);
  445. -    break;
  446. -    
  447. -  case 0x39:    /* AND aaaa,Y */
  448. -    A &= MegaGetMem (_eaabsy_ ());
  449. -    _setN_ (A >= 0x80);
  450. -    _setZ_ (A == 0);
  451. -    break;
  452. -    
  453. -  case 0x21:    /* AND (aa,X) */
  454. -    A &= MegaGetMem (_eaindx_ ());
  455. -    _setN_ (A >= 0x80);
  456. -    _setZ_ (A == 0);
  457. -    break;
  458. -    
  459. -  case 0x31:    /* AND (aa),Y */
  460. -    A &= MegaGetMem (_eaindy_ ());
  461. -    _setN_ (A >= 0x80);
  462. -    _setZ_ (A == 0);
  463. -    break;
  464. -    
  465. -    
  466. -    
  467. -  case 0x0a:    /* ASL A */
  468. -    _setC_ (A >= 0x80);
  469. -    A = (A << 1) & 0xff;
  470. -    _setN_ (A >= 0x80);
  471. -    _setZ_ (A == 0);
  472. -    break;
  473. -    
  474. -  case 0x06:    /* ASL aa */
  475. -    hi = _eazp_();
  476. -    d = MegaGetMem ((ADDR)hi);
  477. -    _setC_ (d >= 0x80);
  478. -    d = (d << 1) & 0xff;
  479. -    _setN_ (d >= 0x80);
  480. -    _setZ_ (d == 0);
  481. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  482. -    break;
  483. -    
  484. -  case 0x16:    /* ASL aa,X */
  485. -    hi = _eazpx_();
  486. -    d = MegaGetMem ((ADDR)hi);
  487. -    _setC_ (d >= 0x80);
  488. -    d = (d << 1) & 0xff;
  489. -    _setN_ (d >= 0x80);
  490. -    _setZ_ (d == 0);
  491. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  492. -    break;
  493. -    
  494. -  case 0x0e:    /* ASL aaaa */
  495. -    hi = _eaabs_();
  496. -    d = MegaGetMem ((ADDR)hi);
  497. -    _setC_ (d >= 0x80);
  498. -    d = (d << 1) & 0xff;
  499. -    _setN_ (d >= 0x80);
  500. -    _setZ_ (d == 0);
  501. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  502. -    break;
  503. -    
  504. -  case 0x1e:    /* ASL aaaa,X */
  505. -    hi = _eaabsx_();
  506. -    d = MegaGetMem ((ADDR)hi);
  507. -    _setC_ (d >= 0x80);
  508. -    d = (d << 1) & 0xff;
  509. -    _setN_ (d >= 0x80);
  510. -    _setZ_ (d == 0);
  511. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  512. -    break;
  513. -    
  514. -    
  515. -    
  516. -  case 0x90:    /* BCC rr */
  517. -    lo = _eaimm_ ();
  518. -    if (lo >= 0x80) lo -= 0x0100;
  519. -    if (!_getC_) PPC += lo;
  520. -    break;
  521. -    
  522. -    
  523. -    
  524. -  case 0xb0:    /* BCS rr */
  525. -    lo = _eaimm_ ();
  526. -    if (lo >= 0x80) lo -= 0x0100;
  527. -    if (_getC_) PPC += lo;
  528. -    break;
  529. -    
  530. -    
  531. -    
  532. -  case 0xf0:    /* BEQ rr */
  533. -    lo = _eaimm_ ();
  534. -    if (lo >= 0x80) lo -= 0x0100;
  535. -    if (_getZ_) PPC += lo;
  536. -    break;
  537. -    
  538. -    
  539. -    
  540. -  case 0x24:    /* BIT aa */
  541. -    d = MegaGetMem ((ADDR)_eazp_ ());
  542. -    _setN_ (d >= 0x80);
  543. -    _setV_ ((d & 64) != 0);
  544. -    _setZ_ ((d & A) == 0);
  545. -    break;
  546. -    
  547. -  case 0x2c:    /* BIT aaaa */
  548. -    d = MegaGetMem (_eaabs_ ());
  549. -    _setN_ (d >= 0x80);
  550. -    _setV_ ((d & 64) != 0);
  551. -    _setZ_ ((d & A) == 0);
  552. -    break;
  553. -    
  554. -    
  555. -    
  556. -  case 0x30:    /* BMI rr */
  557. -    lo = _eaimm_ ();
  558. -    if (lo >= 0x80) lo -= 0x0100;
  559. -    if (_getN_) PPC += lo;
  560. -    break;
  561. -    
  562. -    
  563. -    
  564. -  case 0xd0:    /* BNE rr */
  565. -    lo = _eaimm_ ();
  566. -    if (lo >= 0x80) lo -= 0x0100;
  567. -    if (!_getZ_) PPC += lo;
  568. -    break;
  569. -    
  570. -    
  571. -    
  572. -  case 0x10:    /* BPL rr */
  573. -    lo = _eaimm_ ();
  574. -    if (lo >= 0x80) lo -= 0x0100;
  575. -    if (!_getN_) PPC += lo;
  576. -    break;
  577. -    
  578. -    
  579. -    
  580. -  case 0x00:     /* BRK */
  581. -    lo = (PPC+1) & 65535;
  582. -    _push_ ((BYTE)(lo / 0x0100));
  583. -    _push_ ((BYTE)(lo % 0x0100));
  584. -    _push_ ((BYTE)P);
  585. -    _setB_ (1);
  586. -    lo = MegaGetMem (0xfffe);
  587. -    hi = MegaGetMem (0xffff);
  588. -    PPC = lo + (hi*0x0100);
  589. -    break;
  590. -    
  591. -    
  592. -    
  593. -  case 0x50:    /* BVC rr */
  594. -    lo = _eaimm_ ();
  595. -    if (lo >= 0x80) lo -= 0x0100;
  596. -    if (!_getV_) PPC += lo;
  597. -    break;
  598. -    
  599. -    
  600. -    
  601. -  case 0x70:    /* BVS rr */
  602. -    lo = _eaimm_ ();
  603. -    if (lo >= 0x80) lo -= 0x0100;
  604. -    if (_getV_) PPC += lo;
  605. -    break;
  606. -    
  607. -    
  608. -    
  609. -  case 0x18:    /* CLC */
  610. -    _setC_ (0);
  611. -    break;
  612. -    
  613. -    
  614. -    
  615. -  case 0xd8:    /* CLD */
  616. -    _setD_ (0);
  617. -    break;
  618. -    
  619. -    
  620. -    
  621. -  case 0x58:    /* CLI */
  622. -    _setI_ (0);
  623. -    break;
  624. -    
  625. -    
  626. -    
  627. -  case 0xb8:    /* CLV */
  628. -    _setV_ (0);
  629. -    break;
  630. -    
  631. -    
  632. -    
  633. -  case 0xc9:    /* CMP #dd */
  634. -    d = _eaimm_();
  635. -    _setZ_ (A == d);
  636. -    _setC_ (A >= d);
  637. -    if (d >= 0x80) d -= 0x0100;
  638. -    lo = A;
  639. -    if (lo >= 0x80) lo -= 0x0100;
  640. -    hi = lo - d;
  641. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  642. -    if (hi < -0x80) _setN_(0);
  643. -    break;
  644. -    
  645. -  case 0xc5:    /* CMP aa */
  646. -    d = MegaGetMem ((ADDR)_eazp_());
  647. -    _setZ_ (A == d);
  648. -    _setC_ (A >= d);
  649. -    if (d >= 0x80) d -= 0x0100;
  650. -    lo = A;
  651. -    if (lo >= 0x80) lo -= 0x0100;
  652. -    hi = lo - d;
  653. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  654. -    if (hi < -0x80) _setN_(0);
  655. -    break;
  656. -    
  657. -  case 0xd5:    /* CMP aa,X */
  658. -    d = MegaGetMem ((ADDR)_eazpx_());
  659. -    _setZ_ (A == d);
  660. -    _setC_ (A >= d);
  661. -    if (d >= 0x80) d -= 0x0100;
  662. -    lo = A;
  663. -    if (lo >= 0x80) lo -= 0x0100;
  664. -    hi = lo - d;
  665. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  666. -    if (hi < -0x80) _setN_(0);
  667. -    break;
  668. -    
  669. -  case 0xcd:    /* CMP aaaa */
  670. -    d = MegaGetMem (_eaabs_());
  671. -    _setZ_ (A == d);
  672. -    _setC_ (A >= d);
  673. -    if (d >= 0x80) d -= 0x0100;
  674. -    lo = A;
  675. -    if (lo >= 0x80) lo -= 0x0100;
  676. -    hi = lo - d;
  677. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  678. -    if (hi < -0x80) _setN_(0);
  679. -    break;
  680. -    
  681. -  case 0xdd:    /* CMP aaaa,X */
  682. -    d = MegaGetMem (_eaabsx_());
  683. -    _setZ_ (A == d);
  684. -    _setC_ (A >= d);
  685. -    if (d >= 0x80) d -= 0x0100;
  686. -    lo = A;
  687. -    if (lo >= 0x80) lo -= 0x0100;
  688. -    hi = lo - d;
  689. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  690. -    if (hi < -0x80) _setN_(0);
  691. -    break;
  692. -    
  693. -  case 0xd9:    /* CMP aaaa,Y */
  694. -    d = MegaGetMem (_eaabsy_());
  695. -    _setZ_ (A == d);
  696. -    _setC_ (A >= d);
  697. -    if (d >= 0x80) d -= 0x0100;
  698. -    lo = A;
  699. -    if (lo >= 0x80) lo -= 0x0100;
  700. -    hi = lo - d;
  701. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  702. -    if (hi < -0x80) _setN_(0);
  703. -    break;
  704. -    
  705. -  case 0xc1:    /* CMP (aa,X) */
  706. -    d = MegaGetMem (_eaindx_());
  707. -    _setZ_ (A == d);
  708. -    _setC_ (A >= d);
  709. -    if (d >= 0x80) d -= 0x0100;
  710. -    lo = A;
  711. -    if (lo >= 0x80) lo -= 0x0100;
  712. -    hi = lo - d;
  713. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  714. -    if (hi < -0x80) _setN_(0);
  715. -    break;
  716. -    
  717. -  case 0xd1:    /* CMP (aa),y */
  718. -    d = MegaGetMem (_eaindy_());
  719. -    _setZ_ (A == d);
  720. -    _setC_ (A >= d);
  721. -    if (d >= 0x80) d -= 0x0100;
  722. -    lo = A;
  723. -    if (lo >= 0x80) lo -= 0x0100;
  724. -    hi = lo - d;
  725. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  726. -    if (hi < -0x80) _setN_(0);
  727. -    break;
  728. -    
  729. -    
  730. -    
  731. -  case 0xe0:    /* CPX #dd */
  732. -    d = _eaimm_();
  733. -    _setZ_ (X == d);
  734. -    _setC_ (X >= d);
  735. -    if (d >= 0x80) d -= 0x0100;
  736. -    lo = X;
  737. -    if (lo >= 0x80) lo -= 0x0100;
  738. -    hi = lo - d;
  739. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  740. -    if (hi < -0x80) _setN_(0);
  741. -    break;
  742. -    
  743. -  case 0xe4:    /* CPX aa */
  744. -    d = MegaGetMem ((ADDR)_eazp_());
  745. -    _setZ_ (X == d);
  746. -    _setC_ (X >= d);
  747. -    if (d >= 0x80) d -= 0x0100;
  748. -    lo = X;
  749. -    if (lo >= 0x80) lo -= 0x0100;
  750. -    hi = lo - d;
  751. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  752. -    if (hi < -0x80) _setN_(0);
  753. -    break;
  754. -    
  755. -  case 0xec:    /* CPX aaaa */
  756. -    d = MegaGetMem (_eaabs_());
  757. -    _setZ_ (X == d);
  758. -    _setC_ (X >= d);
  759. -    if (d >= 0x80) d -= 0x0100;
  760. -    lo = X;
  761. -    if (lo >= 0x80) lo -= 0x0100;
  762. -    hi = lo - d;
  763. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  764. -    if (hi < -0x80) _setN_(0);
  765. -    break;
  766. -    
  767. -    
  768. -    
  769. -  case 0xc0:    /* CPY #dd */
  770. -    d = _eaimm_();
  771. -    _setZ_ (Y == d);
  772. -    _setC_ (Y >= d);
  773. -    if (d >= 0x80) d -= 0x0100;
  774. -    lo = Y;
  775. -    if (lo >= 0x80) lo -= 0x0100;
  776. -    hi = lo - d;
  777. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  778. -    if (hi < -0x80) _setN_(0);
  779. -    break;
  780. -    
  781. -  case 0xc4:    /* CPY aa */
  782. -    d = MegaGetMem ((ADDR)_eazp_());
  783. -    _setZ_ (Y == d);
  784. -    _setC_ (Y >= d);
  785. -    if (d >= 0x80) d -= 0x0100;
  786. -    lo = Y;
  787. -    if (lo >= 0x80) lo -= 0x0100;
  788. -    hi = lo - d;
  789. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  790. -    if (hi < -0x80) _setN_(0);
  791. -    break;
  792. -    
  793. -  case 0xcc:    /* CPY aaaa */
  794. -    d = MegaGetMem (_eaabs_());
  795. -    _setZ_ (Y == d);
  796. -    _setC_ (Y >= d);
  797. -    if (d >= 0x80) d -= 0x0100;
  798. -    lo = Y;
  799. -    if (lo >= 0x80) lo -= 0x0100;
  800. -    hi = lo - d;
  801. -    _setN_ ( (hi >= 0x80) || (hi < 0) );
  802. -    if (hi < -0x80) _setN_(0);
  803. -    break;
  804. -    
  805. -    
  806. -    
  807. -  case 0xc6:    /* DEC aa */
  808. -    hi = _eazp_();
  809. -    d = MegaGetMem ((ADDR)hi) - 1;
  810. -    if (d < 0) d += 0x0100;
  811. -    _setN_ (d >= 0x80);
  812. -    _setZ_ (d == 0);
  813. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  814. -    break;
  815. -    
  816. -  case 0xd6:    /* DEC aa,X */
  817. -    hi = _eazpx_();
  818. -    d = MegaGetMem ((ADDR)hi) - 1;
  819. -    if (d < 0) d += 0x0100;
  820. -    _setN_ (d >= 0x80);
  821. -    _setZ_ (d == 0);
  822. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  823. -    break;
  824. -    
  825. -  case 0xce:    /* DEC aaaa */
  826. -    hi = _eaabs_();
  827. -    d = MegaGetMem ((ADDR)hi) - 1;
  828. -    if (d < 0) d += 0x0100;
  829. -    _setN_ (d >= 0x80);
  830. -    _setZ_ (d == 0);
  831. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  832. -    break;
  833. -    
  834. -  case 0xde:    /* DEC aaaa,X */
  835. -    hi = _eaabs_();
  836. -    d = MegaGetMem ((ADDR)hi) - 1;
  837. -    if (d < 0) d += 0x0100;
  838. -    _setN_ (d >= 0x80);
  839. -    _setZ_ (d == 0);
  840. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  841. -    break;
  842. -    
  843. -    
  844. -    
  845. -  case 0xca:    /* DEX */
  846. -    X--;
  847. -    if (X < 0) X += 0x0100;
  848. -    _setN_ (X >= 0x80);
  849. -    _setZ_ (X == 0);
  850. -    break;
  851. -    
  852. -    
  853. -    
  854. -  case 0x88:    /* DEY */
  855. -    Y--;
  856. -    if (Y < 0) Y += 0x0100;
  857. -    _setN_ (Y >= 0x80);
  858. -    _setZ_ (Y == 0);
  859. -    break;
  860. -    
  861. -    
  862. -    
  863. -  case 0x49:    /* EOR #dd */
  864. -    d = _eaimm_();
  865. -    A ^= d;   A &= 0xff;
  866. -    _setN_ (A >= 0x80);
  867. -    _setZ_ (A == 0);
  868. -    break;
  869. -    
  870. -  case 0x45:    /* EOR aa */
  871. -    d = MegaGetMem ((ADDR)_eazp_());
  872. -    A ^= d;   A &= 0xff;
  873. -    _setN_ (A >= 0x80);
  874. -    _setZ_ (A == 0);
  875. -    break;
  876. -    
  877. -  case 0x55:    /* EOR aa,X */
  878. -    d = MegaGetMem ((ADDR)_eazpx_());
  879. -    A ^= d;   A &= 0xff;
  880. -    _setN_ (A >= 0x80);
  881. -    _setZ_ (A == 0);
  882. -    break;
  883. -    
  884. -  case 0x4d:    /* EOR aaaa */
  885. -    d = MegaGetMem (_eaabs_());
  886. -    A ^= d;   A &= 0xff;
  887. -    _setN_ (A >= 0x80);
  888. -    _setZ_ (A == 0);
  889. -    break;
  890. -    
  891. -  case 0x5d:    /* EOR aaaa,X */
  892. -    d = MegaGetMem (_eaabsx_());
  893. -    A ^= d;   A &= 0xff;
  894. -    _setN_ (A >= 0x80);
  895. -    _setZ_ (A == 0);
  896. -    break;
  897. -    
  898. -  case 0x59:    /* EOR aaaa,Y */
  899. -    d = MegaGetMem (_eaabsy_());
  900. -    A ^= d;   A &= 0xff;
  901. -    _setN_ (A >= 0x80);
  902. -    _setZ_ (A == 0);
  903. -    break;
  904. -    
  905. -  case 0x41:    /* EOR (aa,X) */
  906. -    d = MegaGetMem (_eaindx_());
  907. -    A ^= d;   A &= 0xff;
  908. -    _setN_ (A >= 0x80);
  909. -    _setZ_ (A == 0);
  910. -    break;
  911. -    
  912. -  case 0x51:    /* EOR (aa),Y */
  913. -    d = MegaGetMem (_eaindy_());
  914. -    A ^= d;   A &= 0xff;
  915. -    _setN_ (A >= 0x80);
  916. -    _setZ_ (A == 0);
  917. -    break;
  918. -    
  919. -    
  920. -    
  921. -  case 0xe6:    /* INC aa */
  922. -    hi = _eazp_();
  923. -    d = MegaGetMem ((ADDR)hi) + 1;
  924. -    d &= 0xff;
  925. -    _setN_ (d >= 0x80);
  926. -    _setZ_ (d == 0);
  927. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  928. -    break;
  929. -    
  930. -  case 0xf6:    /* INC aa,X */
  931. -    hi = _eazpx_();
  932. -    d = MegaGetMem ((ADDR)hi) + 1;
  933. -    d &= 0xff;
  934. -    _setN_ (d >= 0x80);
  935. -    _setZ_ (d == 0);
  936. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  937. -    break;
  938. -    
  939. -  case 0xee:    /* INC aaaa */
  940. -    hi = _eaabs_();
  941. -    d = MegaGetMem ((ADDR)hi) + 1;
  942. -    d &= 0xff;
  943. -    _setN_ (d >= 0x80);
  944. -    _setZ_ (d == 0);
  945. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  946. -    break;
  947. -    
  948. -  case 0xfe:    /* INC aaaa,X */
  949. -    hi = _eaabsx_();
  950. -    d = MegaGetMem ((ADDR)hi) + 1;
  951. -    d &= 0xff;
  952. -    _setN_ (d >= 0x80);
  953. -    _setZ_ (d == 0);
  954. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  955. -    break;
  956. -    
  957. -    
  958. -    
  959. -  case 0xe8:    /* INX */
  960. -    X++;
  961. -    X &= 0xff;
  962. -    _setN_ (X >= 0x80);
  963. -    _setZ_ (X == 0);
  964. -    break;
  965. -    
  966. -    
  967. -    
  968. -  case 0xc8:    /* INY */
  969. -    Y++;
  970. -    Y &= 0xff;
  971. -    _setN_ (Y >= 0x80);
  972. -    _setZ_ (Y == 0);
  973. -    break;
  974. -    
  975. -    
  976. -    
  977. -  case 0x4c:    /* JMP aaaa */
  978. -    PPC = _eaabs_();
  979. -    break;
  980. -    
  981. -  case 0x6c:    /* JMP (aaaa) */
  982. -    PPC = _eaabsind_();
  983. -    break;
  984. -    
  985. -    
  986. -    
  987. -  case 0x20:    /* JSR aaaa */
  988. -    /* Push address of 3rd byte of jsr: */
  989. -    lo = (PPC+1) & 65535;
  990. -    _push_ ((BYTE)(lo / 0x0100));
  991. -    _push_ ((BYTE)(lo % 0x0100));
  992. -    PPC = _eaabs_();
  993. -    break;
  994. -    
  995. -    
  996. -    
  997. -  case 0xa9:    /* LDA #dd */
  998. -    A = _eaimm_();
  999. -    _setN_ (A >= 0x80);
  1000. -    _setZ_ (A == 0); 
  1001. -    break;
  1002. -    
  1003. -  case 0xa5:    /* LDA aa */
  1004. -    A = MegaGetMem ((ADDR)_eazp_());
  1005. -    _setN_ (A >= 0x80);
  1006. -    _setZ_ (A == 0); 
  1007. -    break;
  1008. -    
  1009. -  case 0xb5:    /* LDA aa,X */
  1010. -    A = MegaGetMem ((ADDR)_eazpx_());
  1011. -    _setN_ (A >= 0x80);
  1012. -    _setZ_ (A == 0); 
  1013. -    break;
  1014. -    
  1015. -  case 0xad:    /* LDA aaaa */
  1016. -    A = MegaGetMem (_eaabs_());
  1017. -    _setN_ (A >= 0x80);
  1018. -    _setZ_ (A == 0); 
  1019. -    break;
  1020. -    
  1021. -  case 0xbd:    /* LDA aaaa,X */
  1022. -    A = MegaGetMem (_eaabsx_());
  1023. -    _setN_ (A >= 0x80);
  1024. -    _setZ_ (A == 0); 
  1025. -    break;
  1026. -    
  1027. -  case 0xb9:    /* LDA aaaa,Y */
  1028. -    A = MegaGetMem (_eaabsy_());
  1029. -    _setN_ (A >= 0x80);
  1030. -    _setZ_ (A == 0); 
  1031. -    break;
  1032. -    
  1033. -  case 0xa1:    /* LDA (aa,X) */
  1034. -    A = MegaGetMem (_eaindx_());
  1035. -    _setN_ (A >= 0x80);
  1036. -    _setZ_ (A == 0); 
  1037. -    break;
  1038. -    
  1039. -  case 0xb1:    /* LDA (aa),Y */
  1040. -    A = MegaGetMem (_eaindy_());
  1041. -    _setN_ (A >= 0x80);
  1042. -    _setZ_ (A == 0); 
  1043. -    break;
  1044. -    
  1045. -    
  1046. -    
  1047. -  case 0xa2:    /* LDX #dd */
  1048. -    X = _eaimm_();
  1049. -    _setN_ (X >= 0x80);
  1050. -    _setZ_ (X == 0); 
  1051. -    break;
  1052. -    
  1053. -  case 0xa6:    /* LDX aa */
  1054. -    X = MegaGetMem ((ADDR)_eazp_());
  1055. -    _setN_ (X >= 0x80);
  1056. -    _setZ_ (X == 0); 
  1057. -    break;
  1058. -    
  1059. -  case 0xb6:    /* LDX aa,Y */
  1060. -    X = MegaGetMem ((ADDR)_eazpy_());
  1061. -    _setN_ (X >= 0x80);
  1062. -    _setZ_ (X == 0); 
  1063. -    break;
  1064. -    
  1065. -  case 0xae:    /* LDX aaaa */
  1066. -    X = MegaGetMem (_eaabs_());
  1067. -    _setN_ (X >= 0x80);
  1068. -    _setZ_ (X == 0); 
  1069. -    break;
  1070. -    
  1071. -  case 0xbe:    /* LDX aaaa,Y */
  1072. -    X = MegaGetMem (_eaabsy_());
  1073. -    _setN_ (X >= 0x80);
  1074. -    _setZ_ (X == 0); 
  1075. -    break;
  1076. -    
  1077. -    
  1078. -    
  1079. -  case 0xa0:    /* LDY #dd */
  1080. -    Y = _eaimm_();
  1081. -    _setN_ (Y >= 0x80);
  1082. -    _setZ_ (Y == 0); 
  1083. -    break;
  1084. -    
  1085. -  case 0xa4:    /* LDY aa */
  1086. -    Y = MegaGetMem ((ADDR)_eazp_());
  1087. -    _setN_ (Y >= 0x80);
  1088. -    _setZ_ (Y == 0); 
  1089. -    break;
  1090. -    
  1091. -  case 0xb4:    /* LDY aa,X */
  1092. -    Y = MegaGetMem ((ADDR)_eazpx_());
  1093. -    _setN_ (Y >= 0x80);
  1094. -    _setZ_ (Y == 0); 
  1095. -    break;
  1096. -    
  1097. -  case 0xac:    /* LDY aaaa */
  1098. -    Y = MegaGetMem (_eaabs_());
  1099. -    _setN_ (Y >= 0x80);
  1100. -    _setZ_ (Y == 0); 
  1101. -    break;
  1102. -    
  1103. -  case 0xbc:    /* LDY aaaa,X */
  1104. -    Y = MegaGetMem (_eaabsx_());
  1105. -    _setN_ (Y >= 0x80);
  1106. -    _setZ_ (Y == 0); 
  1107. -    break;
  1108. -    
  1109. -    
  1110. -    
  1111. -  case 0x4a:    /* LSR A */
  1112. -    _setC_ (A & 1);
  1113. -    A = A >> 1;
  1114. -    _setN_ (0);
  1115. -    _setZ_ (A == 0);
  1116. -    break;
  1117. -    
  1118. -  case 0x46:    /* LSR aa */
  1119. -    hi = _eazp_();
  1120. -    d = MegaGetMem ((ADDR)hi);
  1121. -    _setC_ (d & 1);
  1122. -    d = d >> 1;
  1123. -    _setN_ (0);
  1124. -    _setZ_ (d == 0);
  1125. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1126. -    break;
  1127. -    
  1128. -  case 0x56:    /* LSR aa,X */
  1129. -    hi = _eazpx_();
  1130. -    d = MegaGetMem ((ADDR)hi);
  1131. -    _setC_ (d & 1);
  1132. -    d = d >> 1;
  1133. -    _setN_ (0);
  1134. -    _setZ_ (d == 0);
  1135. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1136. -    break;
  1137. -    
  1138. -  case 0x4e:    /* LSR aaaa */
  1139. -    hi = _eaabs_();
  1140. -    d = MegaGetMem ((ADDR)hi);
  1141. -    _setC_ (d & 1);
  1142. -    d = d >> 1;
  1143. -    _setN_ (0);
  1144. -    _setZ_ (d == 0);
  1145. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1146. -    break;
  1147. -    
  1148. -  case 0x5e:    /* LSR aaaa,X */
  1149. -    hi = _eaabsx_();
  1150. -    d = MegaGetMem ((ADDR)hi);
  1151. -    _setC_ (d & 1);
  1152. -    d = d >> 1;
  1153. -    _setN_ (0);
  1154. -    _setZ_ (d == 0);
  1155. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1156. -    break;
  1157. -    
  1158. -    
  1159. -    
  1160. -  case 0xea:    /* NOP */
  1161. -nop:
  1162. -    break;
  1163. -    
  1164. -    
  1165. -    
  1166. -  case 0x09:    /* ORA #dd */
  1167. -    A |= _eaimm_();
  1168. -    _setN_ (A >= 0x80);
  1169. -    _setZ_ (A == 0);
  1170. -    break;
  1171. -    
  1172. -  case 0x05:    /* ORA aa */
  1173. -    A |= MegaGetMem ((ADDR)_eazp_());
  1174. -    _setN_ (A >= 0x80);
  1175. -    _setZ_ (A == 0);
  1176. -    break;
  1177. -    
  1178. -  case 0x15:    /* ORA aa,X */
  1179. -    A |= MegaGetMem ((ADDR)_eazpx_());
  1180. -    _setN_ (A >= 0x80);
  1181. -    _setZ_ (A == 0);
  1182. -    break;
  1183. -    
  1184. -  case 0x0d:    /* ORA aaaa */
  1185. -    A |= MegaGetMem (_eaabs_());
  1186. -    _setN_ (A >= 0x80);
  1187. -    _setZ_ (A == 0);
  1188. -    break;
  1189. -    
  1190. -  case 0x1d:    /* ORA aaaa,X */
  1191. -    A |= MegaGetMem (_eaabsx_());
  1192. -    _setN_ (A >= 0x80);
  1193. -    _setZ_ (A == 0);
  1194. -    break;
  1195. -    
  1196. -  case 0x19:    /* ORA aaaa,Y */
  1197. -    A |= MegaGetMem (_eaabsy_());
  1198. -    _setN_ (A >= 0x80);
  1199. -    _setZ_ (A == 0);
  1200. -    break;
  1201. -    
  1202. -  case 0x01:    /* ORA (aa,X) */
  1203. -    A |= MegaGetMem (_eaindx_());
  1204. -    _setN_ (A >= 0x80);
  1205. -    _setZ_ (A == 0);
  1206. -    break;
  1207. -    
  1208. -  case 0x11:    /* ORA (aa),Y */
  1209. -    A |= MegaGetMem (_eaindy_());
  1210. -    _setN_ (A >= 0x80);
  1211. -    _setZ_ (A == 0);
  1212. -    break;
  1213. -    
  1214. -    
  1215. -    
  1216. -  case 0x48:    /* PHA */
  1217. -    _push_ ((BYTE)A);
  1218. -    break;
  1219. -    
  1220. -    
  1221. -    
  1222. -  case 0x08:    /* PHP */
  1223. -    _push_ ((BYTE)P);
  1224. -    break;
  1225. -    
  1226. -    
  1227. -    
  1228. -  case 0x68:    /* PLA */
  1229. -    A = _pull_();
  1230. -    _setN_ (A >= 0x80);
  1231. -    _setZ_ (A == 0);
  1232. -    break;
  1233. -    
  1234. -    
  1235. -    
  1236. -  case 0x28:    /* PLP */
  1237. -    P = _pull_();
  1238. -    break;
  1239. -    
  1240. -    
  1241. -    
  1242. -  case 0x2a:    /* ROL A */
  1243. -    al = _getC_;
  1244. -    _setC_ (A >= 0x80);
  1245. -    A = (A << 1) & 0xff;
  1246. -    A |= al;
  1247. -    _setN_ (A >= 0x80);
  1248. -    _setZ_ (A == 0);
  1249. -    break;
  1250. -    
  1251. -  case 0x26:    /* ROL aa */
  1252. -    hi = _eazp_();
  1253. -    d = MegaGetMem ((ADDR)hi);
  1254. -    al = _getC_;
  1255. -    _setC_ (d >= 0x80);
  1256. -    d = (d << 1) & 0xff;
  1257. -    d |= al;
  1258. -    _setN_ (d >= 0x80);
  1259. -    _setZ_ (d == 0);
  1260. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1261. -    break;
  1262. -    
  1263. -  case 0x36:    /* ROL aa,X */
  1264. -    hi = _eazpx_();
  1265. -    d = MegaGetMem ((ADDR)hi);
  1266. -    al = _getC_;
  1267. -    _setC_ (d >= 0x80);
  1268. -    d = (d << 1) & 0xff;
  1269. -    d |= al;
  1270. -    _setN_ (d >= 0x80);
  1271. -    _setZ_ (d == 0);
  1272. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1273. -    break;
  1274. -    
  1275. -  case 0x2e:    /* ROL aaaa */
  1276. -    hi = _eaabs_();
  1277. -    d = MegaGetMem ((ADDR)hi);
  1278. -    al = _getC_;
  1279. -    _setC_ (d >= 0x80);
  1280. -    d = (d << 1) & 0xff;
  1281. -    d |= al;
  1282. -    _setN_ (d >= 0x80);
  1283. -    _setZ_ (d == 0);
  1284. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1285. -    break;
  1286. -    
  1287. -  case 0x3e:    /* ROL aaaa,X */
  1288. -    hi = _eaabsx_();
  1289. -    d = MegaGetMem ((ADDR)hi);
  1290. -    al = _getC_;
  1291. -    _setC_ (d >= 0x80);
  1292. -    d = (d << 1) & 0xff;
  1293. -    d |= al;
  1294. -    _setN_ (d >= 0x80);
  1295. -    _setZ_ (d == 0);
  1296. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1297. -    break;
  1298. -    
  1299. -    
  1300. -    
  1301. -  case 0x6a:    /* ROR A */
  1302. -    al = _getC_;
  1303. -    _setC_ (A & 1);
  1304. -    A = A >> 1;
  1305. -    A |= (al*0x80);
  1306. -    _setN_ (A >= 0x80);
  1307. -    _setZ_ (A == 0);
  1308. -    break;
  1309. -    
  1310. -  case 0x66:    /* ROR aa */
  1311. -    hi = _eazp_();
  1312. -    d = MegaGetMem ((ADDR)hi);
  1313. -    al = _getC_;
  1314. -    _setC_ (d & 1);
  1315. -    d = d >> 1;
  1316. -    d |= (al*0x80);
  1317. -    _setN_ (d >= 0x80);
  1318. -    _setZ_ (d == 0);
  1319. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1320. -    break;
  1321. -    
  1322. -  case 0x76:    /* ROR aa,X */
  1323. -    hi = _eazpx_();
  1324. -    d = MegaGetMem ((ADDR)hi);
  1325. -    al = _getC_;
  1326. -    _setC_ (d & 1);
  1327. -    d = d >> 1;
  1328. -    d |= (al*0x80);
  1329. -    _setN_ (d >= 0x80);
  1330. -    _setZ_ (d == 0);
  1331. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1332. -    break;
  1333. -    
  1334. -  case 0x6e:    /* ROR aaaa */
  1335. -    hi = _eaabs_();
  1336. -    d = MegaGetMem ((ADDR)hi);
  1337. -    al = _getC_;
  1338. -    _setC_ (d & 1);
  1339. -    d = d >> 1;
  1340. -    d |= (al*0x80);
  1341. -    _setN_ (d >= 0x80);
  1342. -    _setZ_ (d == 0);
  1343. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1344. -    break;
  1345. -    
  1346. -  case 0x7e:    /* ROR aaaa,X */
  1347. -    hi = _eaabsx_();
  1348. -    d = MegaGetMem ((ADDR)hi);
  1349. -    al = _getC_;
  1350. -    _setC_ (d & 1);
  1351. -    d = d >> 1;
  1352. -    d |= (al*0x80);
  1353. -    _setN_ (d >= 0x80);
  1354. -    _setZ_ (d == 0);
  1355. -    MegaPutMem ((ADDR)hi,(BYTE)d);
  1356. -    break;
  1357. -    
  1358. -    
  1359. -    
  1360. -  case 0x40:    /* RTI */
  1361. -    P = _pull_();
  1362. -    lo = _pull_();
  1363. -    hi = _pull_();
  1364. -    PPC = lo + (hi*0x0100);
  1365. -    break;
  1366. -    
  1367. -    
  1368. -    
  1369. -    
  1370. -  case 0x60:    /* RTS */
  1371. -    lo = _pull_();
  1372. -    hi = _pull_();
  1373. -    PPC = 1 + lo + (hi*0x0100);
  1374. -    break;
  1375. -    
  1376. -    
  1377. -    
  1378. -  case 0xe9:    /* SBC #dd */
  1379. -    d = _eaimm_ ();
  1380. -    if (!_getD_) {
  1381. -      A -= d;   A -= !_getC_;
  1382. -      _setC_ (! (A < 0));
  1383. -    } else {
  1384. -      ah = A / 16;   al = A % 16;
  1385. -      oh = d / 16;   ol = d % 16;
  1386. -      al -= !_getC_;   al -= ol;
  1387. -      if (al < 0) { al += 10; ah--; }
  1388. -      ah -= oh;
  1389. -      _setC_ (! (ah < 0));
  1390. -      if (ah < 0) ah += 10;
  1391. -      A = al + (ah*16);
  1392. -    }
  1393. -    _setV_ ((A < -0x80) || (A > 0x7f));
  1394. -    if (A < 0) A += 0x0100;
  1395. -    A %= 0x0100;
  1396. -    _setZ_ (A == 0);
  1397. -    _setN_ (A >= 0x80);
  1398. -    break;
  1399. -    
  1400. -  case 0xe5:    /* SBC aa */
  1401. -    d = MegaGetMem ((ADDR)_eazp_ ());
  1402. -    if (!_getD_) {
  1403. -      A -= d;   A -= !_getC_;
  1404. -      _setC_ (! (A < 0));
  1405. -    } else {
  1406. -      ah = A / 16;   al = A % 16;
  1407. -      oh = d / 16;   ol = d % 16;
  1408. -      al -= !_getC_;   al -= ol;
  1409. -      if (al < 0) { al += 10; ah--; }
  1410. -      ah -= oh;
  1411. -      _setC_ (! (ah < 0));
  1412. -      if (ah < 0) ah += 10;
  1413. -      A = al + (ah*16);
  1414. -    }
  1415. -    _setV_ ((A < -0x80) || (A > 0x7f));
  1416. -    if (A < 0) A += 0x0100;
  1417. -    A %= 0x0100;
  1418. -    _setZ_ (A == 0);
  1419. -    _setN_ (A >= 0x80);
  1420. -    break;
  1421. -    
  1422. -  case 0xf5:    /* SBC aa,x */
  1423. -    d = MegaGetMem ((ADDR)_eazpx_ ());
  1424. -    if (!_getD_) {
  1425. -      A -= d;   A -= !_getC_;
  1426. -      _setC_ (! (A < 0));
  1427. -    } else {
  1428. -      ah = A / 16;   al = A % 16;
  1429. -      oh = d / 16;   ol = d % 16;
  1430. -      al -= !_getC_;   al -= ol;
  1431. -      if (al < 0) { al += 10; ah--; }
  1432. -      ah -= oh;
  1433. -      _setC_ (! (ah < 0));
  1434. -      if (ah < 0) ah += 10;
  1435. -      A = al + (ah*16);
  1436. -    }
  1437. -    _setV_ ((A < -0x80) || (A > 0x7f));
  1438. -    if (A < 0) A += 0x0100;
  1439. -    A %= 0x0100;
  1440. -    _setZ_ (A == 0);
  1441. -    _setN_ (A >= 0x80);
  1442. -    break;
  1443. -    
  1444. -  case 0xed:    /* SBC aaaa */
  1445. -    d = MegaGetMem (_eaabs_ ());
  1446. -    if (!_getD_) {
  1447. -      A -= d;   A -= !_getC_;
  1448. -      _setC_ (! (A < 0));
  1449. -    } else {
  1450. -      ah = A / 16;   al = A % 16;
  1451. -      oh = d / 16;   ol = d % 16;
  1452. -      al -= !_getC_;   al -= ol;
  1453. -      if (al < 0) { al += 10; ah--; }
  1454. -      ah -= oh;
  1455. -      _setC_ (! (ah < 0));
  1456. -      if (ah < 0) ah += 10;
  1457. -      A = al + (ah*16);
  1458. -    }
  1459. -    _setV_ ((A < -0x80) || (A > 0x7f));
  1460. -    if (A < 0) A += 0x0100;
  1461. -    A %= 0x0100;
  1462. -    _setZ_ (A == 0);
  1463. -    _setN_ (A >= 0x80);
  1464. -    break;
  1465. -    
  1466. -  case 0xfd:    /* SBC aaaa,X */
  1467. -    d = MegaGetMem (_eaabsx_ ());
  1468. -    if (!_getD_) {
  1469. -      A -= d;   A -= !_getC_;
  1470. -      _setC_ (! (A < 0));
  1471. -    } else {
  1472. -      ah = A / 16;   al = A % 16;
  1473. -      oh = d / 16;   ol = d % 16;
  1474. -      al -= !_getC_;   al -= ol;
  1475. -      if (al < 0) { al += 10; ah--; }
  1476. -      ah -= oh;
  1477. -      _setC_ (! (ah < 0));
  1478. -      if (ah < 0) ah += 10;
  1479. -      A = al + (ah*16);
  1480. -    }
  1481. -    _setV_ ((A < -0x80) || (A > 0x7f));
  1482. -    if (A < 0) A += 0x0100;
  1483. -    A %= 0x0100;
  1484. -    _setZ_ (A == 0);
  1485. -    _setN_ (A >= 0x80);
  1486. -    break;
  1487. -    
  1488. -  case 0xf9:    /* SBC aaaa,Y */
  1489. -    d = MegaGetMem (_eaabsy_ ());
  1490. -    if (!_getD_) {
  1491. -      A -= d;   A -= !_getC_;
  1492. -      _setC_ (! (A < 0));
  1493. -    } else {
  1494. -      ah = A / 16;   al = A % 16;
  1495. -      oh = d / 16;   ol = d % 16;
  1496. -      al -= !_getC_;   al -= ol;
  1497. -      if (al < 0) { al += 10; ah--; }
  1498. -      ah -= oh;
  1499. -      _setC_ (! (ah < 0));
  1500. -      if (ah < 0) ah += 10;
  1501. -      A = al + (ah*16);
  1502. -    }
  1503. -    _setV_ ((A < -0x80) || (A > 0x7f));
  1504. -    if (A < 0) A += 0x0100;
  1505. -    A %= 0x0100;
  1506. -    _setZ_ (A == 0);
  1507. -    _setN_ (A >= 0x80);
  1508. -    break;
  1509. -    
  1510. -  case 0xe1:    /* SBC (aa,X) */
  1511. -    d = MegaGetMem (_eaindx_ ());
  1512. -    if (!_getD_) {
  1513. -      A -= d;   A -= !_getC_;
  1514. -      _setC_ (! (A < 0));
  1515. -    } else {
  1516. -      ah = A / 16;   al = A % 16;
  1517. -      oh = d / 16;   ol = d % 16;
  1518. -      al -= !_getC_;   al -= ol;
  1519. -      if (al < 0) { al += 10; ah--; }
  1520. -      ah -= oh;
  1521. -      _setC_ (! (ah < 0));
  1522. -      if (ah < 0) ah += 10;
  1523. -      A = al + (ah*16);
  1524. -    }
  1525. -    _setV_ ((A < -0x80) || (A > 0x7f));
  1526. -    if (A < 0) A += 0x0100;
  1527. -    A %= 0x0100;
  1528. -    _setZ_ (A == 0);
  1529. -    _setN_ (A >= 0x80);
  1530. -    break;
  1531. -    
  1532. -  case 0xf1:    /* SBC (aa),Y */
  1533. -    d = MegaGetMem (_eaindy_ ());
  1534. -    if (!_getD_) {
  1535. -      A -= d;   A -= !_getC_;
  1536. -      _setC_ (! (A < 0));
  1537. -    } else {
  1538. -      ah = A / 16;   al = A % 16;
  1539. -      oh = d / 16;   ol = d % 16;
  1540. -      al -= !_getC_;   al -= ol;
  1541. -      if (al < 0) { al += 10; ah--; }
  1542. -      ah -= oh;
  1543. -      _setC_ (! (ah < 0));
  1544. -      if (ah < 0) ah += 10;
  1545. -      A = al + (ah*16);
  1546. -    }
  1547. -    _setV_ ((A < -0x80) || (A > 0x7f));
  1548. -    if (A < 0) A += 0x0100;
  1549. -    A %= 0x0100;
  1550. -    _setZ_ (A == 0);
  1551. -    _setN_ (A >= 0x80);
  1552. -    break;
  1553. -    
  1554. -    
  1555. -    
  1556. -  case 0x38:     /* SEC */
  1557. -    _setC_ (1);
  1558. -    break;
  1559. -    
  1560. -    
  1561. -    
  1562. -  case 0xf8:     /* SED */
  1563. -    _setD_ (1);
  1564. -    break;
  1565. -    
  1566. -    
  1567. -    
  1568. -  case 0x78:     /* SEI */
  1569. -    _setI_ (1);
  1570. -    break;
  1571. -    
  1572. -    
  1573. -    
  1574. -  case 0x85:     /* STA aa */
  1575. -    hi = _eazp_();
  1576. -    MegaPutMem ((ADDR)hi,(BYTE)A);
  1577. -    break;
  1578. -    
  1579. -    
  1580. -    
  1581. -  case 0x95:     /* STA aa,X */
  1582. -    hi = _eazpx_();
  1583. -    MegaPutMem ((ADDR)hi,(BYTE)A);
  1584. -    break;
  1585. -    
  1586. -    
  1587. -    
  1588. -  case 0x8d:     /* STA aaaa */
  1589. -    hi = _eaabs_();
  1590. -    MegaPutMem ((ADDR)hi,(BYTE)A);
  1591. -    break;
  1592. -    
  1593. -    
  1594. -    
  1595. -  case 0x9d:     /* STA aaaa,X */
  1596. -    hi = _eaabsx_();
  1597. -    MegaPutMem ((ADDR)hi,(BYTE)A);
  1598. -    break;
  1599. -    
  1600. -    
  1601. -    
  1602. -  case 0x99:     /* STA aaaa,Y */
  1603. -    hi = _eaabsy_();
  1604. -    MegaPutMem ((ADDR)hi,(BYTE)A);
  1605. -    break;
  1606. -    
  1607. -    
  1608. -    
  1609. -  case 0x81:     /* STA (aa,X) */
  1610. -    hi = _eaindx_();
  1611. -    MegaPutMem ((ADDR)hi,(BYTE)A);
  1612. -    break;
  1613. -    
  1614. -    
  1615. -    
  1616. -  case 0x91:     /* STA (aa),Y */
  1617. -    hi = _eaindy_();
  1618. -    MegaPutMem ((ADDR)hi,(BYTE)A);
  1619. -    break;
  1620. -    
  1621. -    
  1622. -    
  1623. -  case 0x86:     /* STX aa */
  1624. -    hi = _eazp_();
  1625. -    MegaPutMem ((ADDR)hi,(BYTE)X);
  1626. -    break;
  1627. -    
  1628. -    
  1629. -    
  1630. -  case 0x96:     /* STX aa,Y */
  1631. -    hi = _eazpy_();
  1632. -    MegaPutMem ((ADDR)hi,(BYTE)X);
  1633. -    break;
  1634. -    
  1635. -    
  1636. -    
  1637. -  case 0x8e:     /* STX aaaa */
  1638. -    hi = _eaabs_();
  1639. -    MegaPutMem ((ADDR)hi,(BYTE)X);
  1640. -    break;
  1641. -    
  1642. -    
  1643. -    
  1644. -  case 0x84:     /* STY aa */
  1645. -    hi = _eazp_();
  1646. -    MegaPutMem ((ADDR)hi,(BYTE)Y);
  1647. -    break;
  1648. -    
  1649. -    
  1650. -    
  1651. -  case 0x94:     /* STY aa,X */
  1652. -    hi = _eazpx_();
  1653. -    MegaPutMem ((ADDR)hi,(BYTE)Y);
  1654. -    break;
  1655. -    
  1656. -    
  1657. -    
  1658. -  case 0x8c:     /* STY aaaa */
  1659. -    hi = _eaabs_();
  1660. -    MegaPutMem ((ADDR)hi,(BYTE)Y);
  1661. -    break;
  1662. -    
  1663. -    
  1664. -    
  1665. -  case 0xaa:     /* TAX */
  1666. -    X = A;
  1667. -    _setN_ (X >= 0x80);
  1668. -    _setZ_ (X == 0);
  1669. -    break;
  1670. -    
  1671. -    
  1672. -    
  1673. -  case 0xa8:     /* TAY */
  1674. -    Y = A;
  1675. -    _setN_ (Y >= 0x80);
  1676. -    _setZ_ (Y == 0);
  1677. -    break;
  1678. -    
  1679. -    
  1680. -    
  1681. -  case 0xba:     /* TSX */
  1682. -    X = S;
  1683. -    _setN_ (X >= 0x80);
  1684. -    _setZ_ (X == 0);
  1685. -    break;
  1686. -    
  1687. -    
  1688. -    
  1689. -  case 0x8a:     /* TXA */
  1690. -    A = X;
  1691. -    _setN_ (A >= 0x80);
  1692. -    _setZ_ (A == 0);
  1693. -    break;
  1694. -    
  1695. -    
  1696. -    
  1697. -  case 0x9a:     /* TXS */
  1698. -    S = X;
  1699. -    break;
  1700. -    
  1701. -    
  1702. -    
  1703. -  case 0x98:     /* TYA */
  1704. -    A = Y;
  1705. -    _setN_ (A >= 0x80);
  1706. -    _setZ_ (A == 0);
  1707. -    break;
  1708. -    
  1709. -    
  1710. -    
  1711. -    default:     /* Undefined opcode */
  1712. -    goto nop;
  1713. -    break;
  1714. -  }
  1715. -}
  1716. -
  1717. -
  1718. + END OF ARCHIVE
  1719.