code_51.cpp 42 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050
  1. /*******************************************************************************
  2. * Emu51
  3. * code_51.cpp:
  4. * Created by mlt on 22/03/23.
  5. ******************************************************************************/
  6. #include <emu51.h>
  7. #include <code_51.h>
  8. #include <stdio.h>
  9. unsigned long c_time = 0;
  10. code_51 asm51[256];
  11. // 1 or 0
  12. uint8_t check_C(void)
  13. {
  14. if ( *PSW & bit7 )
  15. {
  16. return 1;
  17. }
  18. else
  19. {
  20. return 0;
  21. }
  22. }
  23. // 1 or 0
  24. uint8_t check_AC(void)
  25. {
  26. if ( *PSW & bit6 )
  27. {
  28. return 1;
  29. }
  30. else
  31. {
  32. return 0;
  33. }
  34. }
  35. // 1 or 0
  36. uint8_t check_OV(void)
  37. {
  38. if ( *PSW & bit2 )
  39. {
  40. return 1;
  41. }
  42. else
  43. {
  44. return 0;
  45. }
  46. }
  47. // C <- 1
  48. void set_C(void)
  49. {
  50. *PSW = *PSW | bit7;
  51. }
  52. // AC <- 1
  53. void set_AC(void)
  54. {
  55. *PSW = *PSW | bit6;
  56. }
  57. // OV <- 1
  58. void set_OV(void)
  59. {
  60. *PSW = *PSW | bit2;
  61. }
  62. // C <- 0
  63. void clr_C(void)
  64. {
  65. *PSW = *PSW & 0x7f;
  66. }
  67. // AC <- 0
  68. void clr_AC(void)
  69. {
  70. *PSW = *PSW & 0xbf;
  71. }
  72. // OV <- 0
  73. void clr_OV(void)
  74. {
  75. *PSW = *PSW & 0xfb;
  76. }
  77. // 1 or 0
  78. uint8_t check_P(void)
  79. {
  80. if ( *PSW & bit0 )
  81. {
  82. return 1;
  83. }
  84. else
  85. {
  86. return 0;
  87. }
  88. }
  89. // P <- 1
  90. void set_P(void)
  91. {
  92. *PSW = *PSW | bit0;
  93. }
  94. // P <- 0
  95. void clr_P(void)
  96. {
  97. *PSW = *PSW & 0xfe;
  98. }
  99. // (bit) <- 1
  100. void set_Bit(uint8_t bit)
  101. {
  102. uint8_t tmpB;
  103. uint8_t tmpbit;
  104. tmpbit = bit & 0x07;
  105. tmpB = bit & 0xf8;
  106. if ( bit >= 128 )
  107. {
  108. // bit set in SFR area
  109. SFR[tmpB] = SFR[tmpB] | ( 1 << tmpbit );
  110. }
  111. else
  112. {
  113. // bit set in int. RAM
  114. tmpB = ( tmpB >> 3 ) + 32;
  115. SFR[tmpB] = SFR[tmpB] | ( 1 << tmpbit );
  116. }
  117. }
  118. // (bit) <- 0
  119. void clr_Bit(uint8_t bit)
  120. {
  121. uint8_t tmpB;
  122. uint8_t tmpbit;
  123. tmpbit = bit & 0x07;
  124. tmpB = bit & 0xf8;
  125. if ( bit >= 128 )
  126. {
  127. // bit clear in SFR area
  128. SFR[tmpB] = SFR[tmpB] & ~( 1 << tmpbit );
  129. }
  130. else
  131. {
  132. // bit clear in int. RAM
  133. tmpB = ( tmpB >> 3 ) + 32;
  134. SFR[tmpB] = SFR[tmpB] & ~( 1 << tmpbit );
  135. }
  136. }
  137. // returns (bit) 1 or 0
  138. uint8_t check_Bit(uint8_t bit)
  139. {
  140. uint8_t tmpB;
  141. uint8_t tmpbit;
  142. tmpbit = bit & 0x07;
  143. tmpB = bit & 0xf8;
  144. if ( bit >= 128 )
  145. {
  146. // bit check in SFR area
  147. if ( SFR[tmpB] & 1 << tmpbit )
  148. {
  149. return 1;
  150. }
  151. else
  152. {
  153. return 0;
  154. }
  155. }
  156. else
  157. {
  158. // bit check in int. RAM
  159. tmpB = ( tmpB >> 3 ) + 32;
  160. if ( SFR[tmpB] & 1 << tmpbit )
  161. {
  162. return 1;
  163. }
  164. else
  165. {
  166. return 0;
  167. }
  168. }
  169. }
  170. uint8_t check_RS0(void)
  171. {
  172. if ( *PSW & bit3 )
  173. {
  174. return 1;
  175. }
  176. else
  177. {
  178. return 0;
  179. }
  180. }
  181. void set_RS0(void)
  182. {
  183. *PSW = *PSW | bit3;
  184. }
  185. void clr_RS0(void)
  186. {
  187. *PSW = *PSW & 0xf7;
  188. }
  189. uint8_t check_RS1(void)
  190. {
  191. if ( *PSW & bit4 )
  192. {
  193. return 1;
  194. }
  195. else
  196. {
  197. return 0;
  198. }
  199. }
  200. void set_RS1(void)
  201. {
  202. *PSW = *PSW | bit4;
  203. }
  204. void clr_RS1(void)
  205. {
  206. *PSW = *PSW & 0xef;
  207. }
  208. void _add(uint8_t &a, uint8_t &b)
  209. {
  210. int tmp1, tmp2;
  211. (( 0xf & a ) + ( 0xf & b )) > 0xf ? set_AC() : clr_AC();
  212. tmp1 = (( 0x7f & a ) + ( 0x7f & b )) > 0x7f ? 1 : 0;
  213. ( tmp2 = a + b ) > 0xff ? ( set_C(), tmp1 ? clr_OV() : set_OV()) : ( clr_C(), tmp1 ? set_OV() : clr_OV());
  214. a = (uint8_t) tmp2 & 0xff;
  215. }
  216. void _addc(uint8_t &a, uint8_t &b)
  217. {
  218. int tmp1, tmp2, c;
  219. c = check_C();
  220. (( 0xf & a ) + ( 0xf & b + c )) > 0xf ? set_AC() : clr_AC();
  221. tmp1 = (( 0x7f & a ) + ( 0x7f & b ) + c ) > 0x7f ? 1 : 0;
  222. ( tmp2 = a + b + c ) > 0xff ? ( set_C(), tmp1 ? clr_OV() : set_OV()) : ( clr_C(), tmp1 ? set_OV() : clr_OV());
  223. a = (uint8_t) tmp2 & 0xff;
  224. }
  225. void _subb(uint8_t &a, uint8_t &b)
  226. {
  227. int tmp1, tmp2, c;
  228. c = check_C();
  229. ((char) ( 0xf & a ) - (char) ( 0xf & b ) - c ) < 0 ? set_AC() : clr_AC();
  230. tmp1 = ((char) ( 0x7f & a ) - (char) ( 0x7f & b ) - c ) < 0 ? 1 : 0;
  231. (char) ( tmp2 = a - b - c ) < 0 ? ( set_C(), tmp1 ? clr_OV() : set_OV()) : ( clr_C(), tmp1 ? set_OV() : clr_OV());
  232. a = (uint8_t) tmp2 & 0xff;
  233. }
  234. void code_51::make_ds(uint16_t ram_pl)
  235. {
  236. int c, i;
  237. char tmp[3], tmpW[5];
  238. display_string[0] = mnem[0];
  239. display_string[1] = mnem[1];
  240. display_string[2] = ( mnem[2] >= 0x61 && mnem[2] <= 0x7a ) ? mnem[2] : (char) 32;
  241. display_string[3] = ( mnem[3] >= 0x61 && mnem[3] <= 0x7a ) ? mnem[3] : (char) 32;
  242. display_string[4] = ( mnem[4] >= 0x61 && mnem[4] <= 0x7a ) ? mnem[4] : (char) 32;
  243. display_string[5] = (char) 32;
  244. for ( c = 0 ; c <= 10 ; c++ )
  245. {
  246. if ( datas[c] != '%' )
  247. {
  248. if ( datas[c] == 'O' && datas[c + 1] == '%' )
  249. {
  250. if ( datas[c + 2] == '1' )
  251. {
  252. sprintf(tmpW, "%4x", (signed char) prog[ram_pl + 1] + ram_pl + 2);
  253. for ( i = 0 ; i < 4 ; i++ )
  254. {
  255. display_string[c + 6 + i] = ( tmpW[i] == ' ' ) ? '0' : tmpW[i];
  256. }
  257. }
  258. if ( datas[c + 2] == '2' )
  259. {
  260. sprintf(tmpW, "%4x", (signed char) prog[ram_pl + 2] + ram_pl + 3);
  261. for ( i = 0 ; i < 4 ; i++ )
  262. {
  263. display_string[c + 6 + i] = ( tmpW[i] == ' ' ) ? '0' : tmpW[i];
  264. }
  265. }
  266. c += 3;
  267. }
  268. else
  269. {
  270. display_string[c + 6] = datas[c];
  271. }
  272. }
  273. else
  274. {
  275. if ( datas[c + 1] == '1' )
  276. {
  277. sprintf(tmp, "%2x", prog[ram_pl + 1]);
  278. for ( i = 0 ; i < 2 ; i++ )
  279. {
  280. display_string[c + 6 + i] = tmp[i] == ' ' ? '0' : tmp[i];
  281. }
  282. }
  283. if ( datas[c + 1] == '2' )
  284. {
  285. sprintf(tmp, "%2x", prog[ram_pl + 2]);
  286. for ( i = 0 ; i < 2 ; i++ )
  287. {
  288. display_string[c + 6 + i] = tmp[i] == ' ' ? '0' : tmp[i];
  289. }
  290. }
  291. c++;
  292. }
  293. }
  294. }
  295. void code_51::process(void)
  296. {
  297. uint8_t tmpB;
  298. uint16_t tmpW;
  299. switch ( code )
  300. {
  301. case 0x00: //nop 00
  302. PC++;
  303. break;
  304. case 0x74: // mov a,#(byte) 74 xx
  305. PC++;
  306. *Acc = prog[PC];
  307. PC++;
  308. break;
  309. case 0x75: // mov (adress),#(byte) 75 xx yy
  310. PC++;
  311. SFR[prog[PC]] = prog[PC + 1];
  312. PC += 2;
  313. break;
  314. case 0x02: // ljmp 16bit_adres 02 xx yy
  315. PC++;
  316. PC = (uint16_t) prog[PC] << 8 | prog[PC + 1];
  317. break;
  318. case 0x80: // sjmp offset 80 oo
  319. PC++;
  320. PC += (signed char) prog[PC] + 1;
  321. break;
  322. case 0x85: // mov (adress1),(ardess2) 85 yy xx
  323. PC++;
  324. SFR[prog[PC + 1]] = SFR[prog[PC]];
  325. PC += 2;
  326. break;
  327. case 0xe5: // mov A,(adress)
  328. PC++;
  329. *Acc = SFR[prog[PC]];
  330. PC++;
  331. break;
  332. case 0x92: // mov (bit),C
  333. PC++;
  334. if ( check_C())
  335. {
  336. set_Bit(prog[PC]);
  337. }
  338. else
  339. {
  340. clr_Bit(prog[PC]);
  341. }
  342. PC++;
  343. break;
  344. case 0x04: // inc a
  345. ( *Acc )++;
  346. PC++;
  347. break;
  348. case 0x05: // inc (adress)
  349. PC++;
  350. SFR[prog[PC]]++;
  351. PC++;
  352. break;
  353. case 0xa3: // inc DPTR
  354. *DPTR = *DPTR + 1;
  355. PC++;
  356. break;
  357. case 0x06: //inc @R0
  358. SFR[R[0]]++;
  359. PC++;
  360. break;
  361. case 0x07: //inc @R1
  362. SFR[R[1]]++;
  363. PC++;
  364. break;
  365. case 0x08: //inc R0
  366. R[0]++;
  367. PC++;
  368. break;
  369. case 0x09: //inc R1
  370. R[1]++;
  371. PC++;
  372. break;
  373. case 0x0a: //inc R2
  374. R[2]++;
  375. PC++;
  376. break;
  377. case 0x0b: //inc R3
  378. R[3]++;
  379. PC++;
  380. break;
  381. case 0x0c: //inc R4
  382. R[4]++;
  383. PC++;
  384. break;
  385. case 0x0d: //inc R5
  386. R[5]++;
  387. PC++;
  388. break;
  389. case 0x0e: //inc R6
  390. R[6]++;
  391. PC++;
  392. break;
  393. case 0x0f: //inc R7
  394. R[7]++;
  395. PC++;
  396. break;
  397. case 0x14: //dec A
  398. *Acc = *Acc - 1;
  399. PC++;
  400. break;
  401. case 0x15: //dec (adress)
  402. PC++;
  403. SFR[prog[PC]]--;
  404. PC++;
  405. break;
  406. case 0x16: //dec @R0
  407. SFR[R[0]]--;
  408. PC++;
  409. break;
  410. case 0x17: //dec @R1
  411. SFR[R[1]]--;
  412. PC++;
  413. break;
  414. case 0x18: // dec R0
  415. R[0]--;
  416. PC++;
  417. break;
  418. case 0x19: // dec R1
  419. R[1]--;
  420. PC++;
  421. break;
  422. case 0x1a: // dec R2
  423. R[2]--;
  424. PC++;
  425. break;
  426. case 0x1b: // dec R3
  427. R[3]--;
  428. PC++;
  429. break;
  430. case 0x1c: // dec R4
  431. R[4]--;
  432. PC++;
  433. break;
  434. case 0x1d: // dec R5
  435. R[5]--;
  436. PC++;
  437. break;
  438. case 0x1e: // dec R6
  439. R[6]--;
  440. PC++;
  441. break;
  442. case 0x1f: // dec R7
  443. R[7]--;
  444. PC++;
  445. break;
  446. case 0x84: // div AB
  447. clr_C();
  448. if ( *B != 0 )
  449. {
  450. tmpB = *Acc;
  451. *Acc = tmpB / *B;
  452. *B = tmpB % *B;
  453. }
  454. else
  455. {
  456. set_OV();
  457. }
  458. PC++;
  459. break;
  460. case 0xa4: // mul AB
  461. tmpW = (uint16_t) *Acc * (uint16_t) *B;
  462. if ( tmpW > 255 )
  463. {
  464. set_OV();
  465. }
  466. else
  467. {
  468. clr_OV();
  469. }
  470. *B = (uint8_t) tmpW >> 8;
  471. *Acc = (uint8_t) ( tmpW & 0xff );
  472. PC++;
  473. break;
  474. case 0x23: // rl A
  475. tmpB = *Acc;
  476. *Acc = tmpB << 1 | tmpB >> 7;
  477. PC++;
  478. break;
  479. case 0x03: // rr A
  480. tmpB = *Acc;
  481. *Acc = tmpB >> 1 | tmpB << 7;
  482. PC++;
  483. break;
  484. case 0x33: // rlc A
  485. tmpB = *Acc;
  486. *Acc = tmpB << 1 | check_C();
  487. if ( tmpB & 0x80 )
  488. {
  489. set_C();
  490. }
  491. else
  492. {
  493. clr_C();
  494. }
  495. PC++;
  496. break;
  497. case 0x13: // rrc A
  498. tmpB = *Acc;
  499. *Acc = tmpB >> 1 | check_C() << 7;
  500. if ( tmpB & 0x01 )
  501. {
  502. set_C();
  503. }
  504. else
  505. {
  506. clr_C();
  507. }
  508. PC++;
  509. break;
  510. case 0x90: // mov DPTR,#(16-bit data)
  511. PC++;
  512. *DPH = prog[PC];
  513. PC++;
  514. *DPL = prog[PC];
  515. PC++;
  516. break;
  517. case 0xf5: // mov (adress),A
  518. PC++;
  519. SFR[prog[PC]] = *Acc;
  520. PC++;
  521. break;
  522. // ADD (full functional)
  523. case 0x24: // add A,#(data)
  524. PC++;
  525. _add(*Acc, prog[PC]);
  526. PC++;
  527. break;
  528. case 0x25: // add A,(adres)
  529. PC++;
  530. _add(*Acc, SFR[prog[PC]]);
  531. PC++;
  532. break;
  533. case 0x26: // add A,@R0
  534. _add(*Acc, SFR[R[0]]);
  535. PC++;
  536. break;
  537. case 0x27: // add A,@R1
  538. _add(*Acc, SFR[R[1]]);
  539. PC++;
  540. break;
  541. case 0x28: //add A,R0
  542. _add(*Acc, R[0]);
  543. PC++;
  544. break;
  545. case 0x29: //add A,R1
  546. _add(*Acc, R[1]);
  547. PC++;
  548. break;
  549. case 0x2a: //add A,R2
  550. _add(*Acc, R[2]);
  551. PC++;
  552. break;
  553. case 0x2b: //add A,R3
  554. _add(*Acc, R[3]);
  555. PC++;
  556. break;
  557. case 0x2c: //add A,R4
  558. _add(*Acc, R[4]);
  559. PC++;
  560. break;
  561. case 0x2d: //add A,R5
  562. _add(*Acc, R[5]);
  563. PC++;
  564. break;
  565. case 0x2e: //add A,R6
  566. _add(*Acc, R[6]);
  567. PC++;
  568. break;
  569. case 0x2f: //add A,R7
  570. _add(*Acc, R[7]);
  571. PC++;
  572. break;
  573. // ADDC
  574. case 0x34: // addc A,#(data)
  575. PC++;
  576. _addc(*Acc, prog[PC]);
  577. PC++;
  578. break;
  579. case 0x35: // addc A,(adres)
  580. PC++;
  581. _addc(*Acc, SFR[prog[PC]]);
  582. PC++;
  583. break;
  584. case 0x36: // addc A,@R0
  585. _addc(*Acc, SFR[R[0]]);
  586. PC++;
  587. break;
  588. case 0x37: // addc A,@R1
  589. _addc(*Acc, SFR[R[1]]);
  590. PC++;
  591. break;
  592. case 0x38: //addc A,R0
  593. _addc(*Acc, R[0]);
  594. PC++;
  595. break;
  596. case 0x39: //addc A,R1
  597. _addc(*Acc, R[1]);
  598. PC++;
  599. break;
  600. case 0x3a: //addc A,R2
  601. _addc(*Acc, R[2]);
  602. PC++;
  603. break;
  604. case 0x3b: //addc A,R3
  605. _addc(*Acc, R[3]);
  606. PC++;
  607. break;
  608. case 0x3c: //addc A,R4
  609. _addc(*Acc, R[4]);
  610. PC++;
  611. break;
  612. case 0x3d: //addc A,R5
  613. _addc(*Acc, R[5]);
  614. PC++;
  615. break;
  616. case 0x3e: //addc A,R6
  617. _addc(*Acc, R[6]);
  618. PC++;
  619. break;
  620. case 0x3f: //addc A,R7
  621. _addc(*Acc, R[7]);
  622. PC++;
  623. break;
  624. case 0xe0: // movx A,@DPTR
  625. *Acc = ram[*DPTR];
  626. PC++;
  627. break;
  628. case 0xf0: // movx @DPTR,A
  629. ram[*DPTR] = *Acc;
  630. PC++;
  631. break;
  632. case 0xc0: // push (adress)
  633. *SP = *SP + 1;
  634. PC++;
  635. SFR[*SP] = SFR[prog[PC]];
  636. PC++;
  637. break;
  638. case 0xd0: // pop (adress)
  639. PC++;
  640. SFR[prog[PC]] = SFR[*SP];
  641. *SP = *SP - 1;
  642. PC++;
  643. break;
  644. case 0xc3: // clr C
  645. clr_C();
  646. PC++;
  647. break;
  648. case 0xd3: // setb C
  649. set_C();
  650. PC++;
  651. break;
  652. case 0xd2: // setb (bit)
  653. PC++;
  654. set_Bit(prog[PC]);
  655. PC++;
  656. break;
  657. case 0xc2: // clr (bit)
  658. PC++;
  659. clr_Bit(prog[PC]);
  660. PC++;
  661. break;
  662. case 0x62: // xrl (adress),A
  663. PC++;
  664. SFR[prog[PC]] = SFR[prog[PC]] ^ ( *Acc );
  665. PC++;
  666. break;
  667. case 0x63: // xrl (adress),#(data)
  668. PC++;
  669. SFR[prog[PC]] ^= prog[PC + 1];
  670. PC += 2;
  671. break;
  672. case 0x64: // xrl A,#(data)
  673. PC++;
  674. *Acc = *Acc ^ prog[PC];
  675. PC++;
  676. break;
  677. case 0x65: // xrl A,(adress)
  678. PC++;
  679. *Acc = *Acc ^ SFR[prog[PC]];
  680. PC++;
  681. break;
  682. case 0x66: // xrl A,@R0
  683. *Acc = *Acc ^ SFR[R[0]];
  684. PC++;
  685. break;
  686. case 0x67: // xrl A,@R1
  687. *Acc = *Acc ^ SFR[R[1]];
  688. PC++;
  689. break;
  690. case 0x68: // xrl A,R0
  691. *Acc = ( *Acc ) ^ R[0];
  692. PC++;
  693. break;
  694. case 0x69: // xrl A,R1
  695. *Acc = ( *Acc ) ^ R[1];
  696. PC++;
  697. break;
  698. case 0x6a: // xrl A,R2
  699. *Acc = ( *Acc ) ^ R[2];
  700. PC++;
  701. break;
  702. case 0x6b: // xrl A,R3
  703. *Acc = ( *Acc ) ^ R[3];
  704. PC++;
  705. break;
  706. case 0x6c: // xrl A,R4
  707. *Acc = ( *Acc ) ^ R[4];
  708. PC++;
  709. break;
  710. case 0x6d: // xrl A,R5
  711. *Acc = ( *Acc ) ^ R[5];
  712. PC++;
  713. break;
  714. case 0x6e: // xrl A,R6
  715. *Acc = ( *Acc ) ^ R[6];
  716. PC++;
  717. break;
  718. case 0x6f: // xrl A,R7
  719. *Acc = ( *Acc ) ^ R[7];
  720. PC++;
  721. break;
  722. case 0xc5: // xch A,(adress)
  723. PC++;
  724. tmpB = *Acc;
  725. *Acc = SFR[prog[PC]];
  726. SFR[prog[PC]] = tmpB;
  727. PC++;
  728. break;
  729. case 0xc6: // xch A,@R0
  730. tmpB = *Acc;
  731. *Acc = SFR[R[0]];
  732. SFR[R[0]] = tmpB;
  733. PC++;
  734. break;
  735. case 0xc7: // xch A,@R1
  736. tmpB = *Acc;
  737. *Acc = SFR[R[1]];
  738. SFR[R[1]] = tmpB;
  739. PC++;
  740. break;
  741. case 0xc8: // xch A,R0
  742. tmpB = *Acc;
  743. *Acc = R[0];
  744. R[0] = tmpB;
  745. PC++;
  746. break;
  747. case 0xc9: // xch A,R1
  748. tmpB = *Acc;
  749. *Acc = R[1];
  750. R[1] = tmpB;
  751. PC++;
  752. break;
  753. case 0xca: // xch A,R2
  754. tmpB = *Acc;
  755. *Acc = R[2];
  756. R[2] = tmpB;
  757. PC++;
  758. break;
  759. case 0xcb: // xch A,R3
  760. tmpB = *Acc;
  761. *Acc = R[3];
  762. R[3] = tmpB;
  763. PC++;
  764. break;
  765. case 0xcc: // xch A,R4
  766. tmpB = *Acc;
  767. *Acc = R[4];
  768. R[4] = tmpB;
  769. PC++;
  770. break;
  771. case 0xcd: // xch A,R5
  772. tmpB = *Acc;
  773. *Acc = R[5];
  774. R[5] = tmpB;
  775. PC++;
  776. break;
  777. case 0xce: // xch A,R6
  778. tmpB = *Acc;
  779. *Acc = R[6];
  780. R[6] = tmpB;
  781. PC++;
  782. break;
  783. case 0xcf: // xch A,R7
  784. tmpB = *Acc;
  785. *Acc = R[7];
  786. R[7] = tmpB;
  787. PC++;
  788. break;
  789. case 0x12: // lcall 16bit_adres 02 xx yy
  790. tmpW = PC + 3;
  791. PC++;
  792. PC = (uint16_t) prog[PC] << 8 | prog[PC + 1];
  793. *SP = *SP + 1;
  794. SFR[*SP] = (uint8_t) ( tmpW & 0x00ff );
  795. *SP = *SP + 1;
  796. SFR[*SP] = (uint8_t) ( tmpW >> 8 );
  797. break;
  798. case 0x22: // ret
  799. PC = (uint16_t) SFR[*SP] << 8 | (uint16_t) SFR[*SP - 1];
  800. *SP = *SP - 2;
  801. break;
  802. case 0x70: // jnz (offset)
  803. PC++;
  804. if ( *Acc != 0 )
  805. {
  806. PC += (signed char) prog[PC] + 1;
  807. }
  808. else
  809. {
  810. PC++;
  811. }
  812. break;
  813. case 0x60: // jz (offset)
  814. PC++;
  815. if ( *Acc == 0 )
  816. {
  817. PC += (signed char) prog[PC] + 1;
  818. }
  819. else
  820. {
  821. PC++;
  822. }
  823. break;
  824. case 0x40: // jc (offset)
  825. PC++;
  826. if ( check_C())
  827. {
  828. PC += (signed char) prog[PC] + 1;
  829. }
  830. else
  831. {
  832. PC++;
  833. }
  834. break;
  835. case 0x50: // jnc (offset)
  836. PC++;
  837. if ( !check_C())
  838. {
  839. PC += (signed char) prog[PC] + 1;
  840. }
  841. else
  842. {
  843. PC++;
  844. }
  845. break;
  846. case 0xc4: // swap A
  847. tmpB = *Acc;
  848. tmpB = ( tmpB << 4 ) & 0xf0;
  849. *Acc = ( *Acc >> 4 ) & 0x0f;
  850. *Acc = *Acc | tmpB;
  851. PC++;
  852. break;
  853. case 0x93: // movc A,@DPTR+A
  854. *Acc = ram[*Acc + *DPTR];
  855. PC++;
  856. break;
  857. case 0x83: // movc A,@PC+A
  858. *Acc = ram[*Acc + PC];
  859. PC++;
  860. break;
  861. case 0xe6: // mov A,@R0
  862. *Acc = SFR[R[0]];
  863. PC++;
  864. break;
  865. case 0xe7: // mov A,@R1
  866. *Acc = SFR[R[1]];
  867. PC++;
  868. break;
  869. case 0xf6: // mov @R0,A
  870. SFR[R[0]] = *Acc;
  871. PC++;
  872. break;
  873. case 0xf7: // mov @R1,a
  874. SFR[R[1]] = *Acc;
  875. PC++;
  876. break;
  877. case 0x78: // mov R0,#(data)
  878. PC++;
  879. R[0] = prog[PC];
  880. PC++;
  881. break;
  882. case 0x79: // mov R1,#(data)
  883. PC++;
  884. R[1] = prog[PC];
  885. PC++;
  886. break;
  887. case 0x7a: // mov R2,#(data)
  888. PC++;
  889. R[2] = prog[PC];
  890. PC++;
  891. break;
  892. case 0x7b: // mov R3,#(data)
  893. PC++;
  894. R[3] = prog[PC];
  895. PC++;
  896. break;
  897. case 0x7c: // mov R4,#(data)
  898. PC++;
  899. R[4] = prog[PC];
  900. PC++;
  901. break;
  902. case 0x7d: // mov R5,#(data)
  903. PC++;
  904. R[5] = prog[PC];
  905. PC++;
  906. break;
  907. case 0x7e: // mov R6,#(data)
  908. PC++;
  909. R[6] = prog[PC];
  910. PC++;
  911. break;
  912. case 0x7f: // mov R7,#(data)
  913. PC++;
  914. R[7] = prog[PC];
  915. PC++;
  916. break;
  917. case 0xa8: // mov R0,(adress)
  918. PC++;
  919. R[0] = SFR[prog[PC]];
  920. PC++;
  921. break;
  922. case 0xa9: // mov R1,(adress)
  923. PC++;
  924. R[1] = SFR[prog[PC]];
  925. PC++;
  926. break;
  927. case 0xaa: // mov R2,(adress)
  928. PC++;
  929. R[2] = SFR[prog[PC]];
  930. PC++;
  931. break;
  932. case 0xab: // mov R3,(adress)
  933. PC++;
  934. R[3] = SFR[prog[PC]];
  935. PC++;
  936. break;
  937. case 0xac: // mov R4,(adress)
  938. PC++;
  939. R[4] = SFR[prog[PC]];
  940. PC++;
  941. break;
  942. case 0xad: // mov R5,(adress)
  943. PC++;
  944. R[5] = SFR[prog[PC]];
  945. PC++;
  946. break;
  947. case 0xae: // mov R6,(adress)
  948. PC++;
  949. R[6] = SFR[prog[PC]];
  950. PC++;
  951. break;
  952. case 0xaf: // mov R7,(adress)
  953. PC++;
  954. R[7] = SFR[prog[PC]];
  955. PC++;
  956. break;
  957. case 0x88: // mov (adress),R0
  958. PC++;
  959. SFR[prog[PC]] = R[0];
  960. PC++;
  961. break;
  962. case 0x89: // mov (adress),R1
  963. PC++;
  964. SFR[prog[PC]] = R[1];
  965. PC++;
  966. break;
  967. case 0x8a: // mov (adress),R2
  968. PC++;
  969. SFR[prog[PC]] = R[2];
  970. PC++;
  971. break;
  972. case 0x8b: // mov (adress),R3
  973. PC++;
  974. SFR[prog[PC]] = R[3];
  975. PC++;
  976. break;
  977. case 0x8c: // mov (adress),R4
  978. PC++;
  979. SFR[prog[PC]] = R[4];
  980. PC++;
  981. break;
  982. case 0x8d: // mov (adress),R5
  983. PC++;
  984. SFR[prog[PC]] = R[5];
  985. PC++;
  986. break;
  987. case 0x8e: // mov (adress),R6
  988. PC++;
  989. SFR[prog[PC]] = R[6];
  990. PC++;
  991. break;
  992. case 0x8f: // mov (adress),R7
  993. PC++;
  994. SFR[prog[PC]] = R[7];
  995. PC++;
  996. break;
  997. case 0xf8: // mov R0,A
  998. PC++;
  999. R[0] = *Acc;
  1000. break;
  1001. case 0xf9: // mov R1,A
  1002. PC++;
  1003. R[1] = *Acc;
  1004. break;
  1005. case 0xfa: // mov R2,A
  1006. PC++;
  1007. R[2] = *Acc;
  1008. break;
  1009. case 0xfb: // mov R3,A
  1010. PC++;
  1011. R[3] = *Acc;
  1012. break;
  1013. case 0xfc: // mov R4,A
  1014. PC++;
  1015. R[4] = *Acc;
  1016. break;
  1017. case 0xfd: // mov R5,A
  1018. PC++;
  1019. R[5] = *Acc;
  1020. break;
  1021. case 0xfe: // mov R6,A
  1022. PC++;
  1023. R[6] = *Acc;
  1024. break;
  1025. case 0xff: // mov R7,A
  1026. PC++;
  1027. R[7] = *Acc;
  1028. break;
  1029. case 0xe8: // mov A,R0
  1030. PC++;
  1031. *Acc = R[0];
  1032. break;
  1033. case 0xe9: // mov A,R1
  1034. PC++;
  1035. *Acc = R[1];
  1036. break;
  1037. case 0xea: // mov A,R2
  1038. PC++;
  1039. *Acc = R[2];
  1040. break;
  1041. case 0xeb: // mov A,R3
  1042. PC++;
  1043. *Acc = R[3];
  1044. break;
  1045. case 0xec: // mov A,R4
  1046. PC++;
  1047. *Acc = R[4];
  1048. break;
  1049. case 0xed: // mov A,R5
  1050. PC++;
  1051. *Acc = R[5];
  1052. break;
  1053. case 0xee: // mov A,R6
  1054. PC++;
  1055. *Acc = R[6];
  1056. break;
  1057. case 0xef: // mov A,R7
  1058. PC++;
  1059. *Acc = R[7];
  1060. break;
  1061. case 0xe4: //clr A
  1062. PC++;
  1063. *Acc = 0;
  1064. break;
  1065. case 0x01: // ajmp 00xx
  1066. PC++;
  1067. PC = (uint16_t) prog[PC];
  1068. break;
  1069. case 0x21: // ajmp 01xx
  1070. PC++;
  1071. PC = 0x0100 | (uint16_t) prog[PC];
  1072. break;
  1073. case 0x41: // ajmp 02xx
  1074. PC++;
  1075. PC = 0x0200 | (uint16_t) prog[PC];
  1076. break;
  1077. case 0x61: // ajmp 03xx
  1078. PC++;
  1079. PC = 0x0300 | (uint16_t) prog[PC];
  1080. break;
  1081. case 0x81: // ajmp 04xx
  1082. PC++;
  1083. PC = 0x0400 | (uint16_t) prog[PC];
  1084. break;
  1085. case 0xa1: // ajmp 05xx
  1086. PC++;
  1087. PC = 0x0500 | (uint16_t) prog[PC];
  1088. break;
  1089. case 0xc1: // ajmp 06xx
  1090. PC++;
  1091. PC = 0x0600 | (uint16_t) prog[PC];
  1092. break;
  1093. case 0xe1: // ajmp 07xx
  1094. PC++;
  1095. PC = 0x0700 | (uint16_t) prog[PC];
  1096. break;
  1097. case 0x11: // acall 00xx
  1098. tmpW = PC + 2;
  1099. PC++;
  1100. PC = (uint16_t) prog[PC];
  1101. *SP = *SP + 1;
  1102. SFR[*SP] = (uint8_t) ( tmpW & 0x00ff );
  1103. *SP = *SP + 1;
  1104. SFR[*SP] = (uint8_t) ( tmpW >> 8 );
  1105. break;
  1106. case 0x31: // acall 01xx
  1107. tmpW = PC + 2;
  1108. PC++;
  1109. PC = 0x0100 | prog[PC];
  1110. *SP = *SP + 1;
  1111. SFR[*SP] = (uint8_t) ( tmpW & 0x00ff );
  1112. *SP = *SP + 1;
  1113. SFR[*SP] = (uint8_t) ( tmpW >> 8 );
  1114. break;
  1115. case 0x51: // acall 02xx
  1116. tmpW = PC + 2;
  1117. PC++;
  1118. PC = 0x0200 | prog[PC];
  1119. *SP = *SP + 1;
  1120. SFR[*SP] = (uint8_t) ( tmpW & 0x00ff );
  1121. *SP = *SP + 1;
  1122. SFR[*SP] = (uint8_t) ( tmpW >> 8 );
  1123. break;
  1124. case 0x71: // acall 03xx
  1125. tmpW = PC + 2;
  1126. PC++;
  1127. PC = 0x0300 | prog[PC];
  1128. *SP = *SP + 1;
  1129. SFR[*SP] = (uint8_t) ( tmpW & 0x00ff );
  1130. *SP = *SP + 1;
  1131. SFR[*SP] = (uint8_t) ( tmpW >> 8 );
  1132. break;
  1133. case 0x91: // acall 04xx
  1134. tmpW = PC + 2;
  1135. PC++;
  1136. PC = 0x0400 | prog[PC];
  1137. *SP = *SP + 1;
  1138. SFR[*SP] = (uint8_t) ( tmpW & 0x00ff );
  1139. *SP = *SP + 1;
  1140. SFR[*SP] = (uint8_t) ( tmpW >> 8 );
  1141. break;
  1142. case 0xb1: // acall 05xx
  1143. tmpW = PC + 2;
  1144. PC++;
  1145. PC = 0x0500 | prog[PC];
  1146. *SP = *SP + 1;
  1147. SFR[*SP] = (uint8_t) ( tmpW & 0x00ff );
  1148. *SP = *SP + 1;
  1149. SFR[*SP] = (uint8_t) ( tmpW >> 8 );
  1150. break;
  1151. case 0xd1: // acall 06xx
  1152. tmpW = PC + 2;
  1153. PC++;
  1154. PC = 0x0600 | prog[PC];
  1155. *SP = *SP + 1;
  1156. SFR[*SP] = (uint8_t) ( tmpW & 0x00ff );
  1157. *SP = *SP + 1;
  1158. SFR[*SP] = (uint8_t) ( tmpW >> 8 );
  1159. break;
  1160. case 0xf1: // acall 07xx
  1161. tmpW = PC + 2;
  1162. PC++;
  1163. PC = 0x0700 | prog[PC];
  1164. *SP = *SP + 1;
  1165. SFR[*SP] = (uint8_t) ( tmpW & 0x00ff );
  1166. *SP = *SP + 1;
  1167. SFR[*SP] = (uint8_t) ( tmpW >> 8 );
  1168. break;
  1169. case 0xd8: // djnz R0,(offset)
  1170. PC++;
  1171. R[0]--;
  1172. if ( R[0] != 0 )
  1173. {
  1174. PC += (signed char) prog[PC];
  1175. }
  1176. PC++;
  1177. break;
  1178. case 0xd9: // djnz R1,(offset)
  1179. PC++;
  1180. R[1]--;
  1181. if ( R[1] != 0 )
  1182. {
  1183. PC += (signed char) prog[PC];
  1184. }
  1185. PC++;
  1186. break;
  1187. case 0xda: // djnz R2,(offset)
  1188. PC++;
  1189. R[2]--;
  1190. if ( R[2] != 0 )
  1191. {
  1192. PC += (signed char) prog[PC];
  1193. }
  1194. PC++;
  1195. break;
  1196. case 0xdb: // djnz R3,(offset)
  1197. PC++;
  1198. R[3]--;
  1199. if ( R[3] != 0 )
  1200. {
  1201. PC += (signed char) prog[PC];
  1202. }
  1203. PC++;
  1204. break;
  1205. case 0xdc: // djnz R4,(offset)
  1206. PC++;
  1207. R[4]--;
  1208. if ( R[4] != 0 )
  1209. {
  1210. PC += (signed char) prog[PC];
  1211. }
  1212. PC++;
  1213. break;
  1214. case 0xdd: // djnz R5,(offset)
  1215. PC++;
  1216. R[5]--;
  1217. if ( R[5] != 0 )
  1218. {
  1219. PC += (signed char) prog[PC];
  1220. }
  1221. PC++;
  1222. break;
  1223. case 0xde: // djnz R6,(offset)
  1224. PC++;
  1225. R[6]--;
  1226. if ( R[6] != 0 )
  1227. {
  1228. PC += (signed char) prog[PC];
  1229. }
  1230. PC++;
  1231. break;
  1232. case 0xdf: // djnz R7,(offset)
  1233. PC++;
  1234. R[7]--;
  1235. if ( R[7] != 0 )
  1236. {
  1237. PC += (signed char) prog[PC];
  1238. }
  1239. PC++;
  1240. break;
  1241. case 0xd5: // djnz (adress),(offset)
  1242. PC++;
  1243. tmpB = prog[PC];
  1244. PC++;
  1245. SFR[tmpB]--;
  1246. if ( SFR[tmpB] != 0 )
  1247. {
  1248. PC += (signed char) prog[PC];
  1249. }
  1250. PC++;
  1251. break;
  1252. case 0x43: // orl (adress),#(data)
  1253. PC++;
  1254. SFR[prog[PC]] = SFR[prog[PC]] | prog[PC + 1];
  1255. PC += 2;
  1256. break;
  1257. case 0x44: // orl A,#(data)
  1258. PC++;
  1259. *Acc = prog[PC] | *Acc;
  1260. PC++;
  1261. break;
  1262. case 0x45: // orl A,(adress)
  1263. PC++;
  1264. *Acc = SFR[prog[PC]] | *Acc;
  1265. PC++;
  1266. break;
  1267. case 0x42: // orl (adress),A
  1268. PC++;
  1269. SFR[prog[PC]] = SFR[prog[PC]] | *Acc;
  1270. PC++;
  1271. break;
  1272. case 0x48: // orl A,R0
  1273. *Acc = *Acc | R[0];
  1274. PC++;
  1275. break;
  1276. case 0x49: // orl A,R1
  1277. *Acc = *Acc | R[1];
  1278. PC++;
  1279. break;
  1280. case 0x4a: // orl A,R2
  1281. *Acc = *Acc | R[2];
  1282. PC++;
  1283. break;
  1284. case 0x4b: // orl A,R3
  1285. *Acc = *Acc | R[3];
  1286. PC++;
  1287. break;
  1288. case 0x4c: // orl A,R4
  1289. *Acc = *Acc | R[4];
  1290. PC++;
  1291. break;
  1292. case 0x4d: // orl A,R5
  1293. *Acc = *Acc | R[5];
  1294. PC++;
  1295. break;
  1296. case 0x4e: // orl A,R6
  1297. *Acc = *Acc | R[6];
  1298. PC++;
  1299. break;
  1300. case 0x4f: // orl A,R7
  1301. *Acc = *Acc | R[7];
  1302. PC++;
  1303. break;
  1304. case 0x46: // orl A,@R0
  1305. *Acc = *Acc | SFR[R[0]];
  1306. PC++;
  1307. break;
  1308. case 0x47: // orl A,@R1
  1309. *Acc = *Acc | SFR[R[1]];
  1310. PC++;
  1311. break;
  1312. case 0x54: // anl A,#(data)
  1313. PC++;
  1314. *Acc = *Acc & prog[PC];
  1315. PC++;
  1316. break;
  1317. case 0x55: // anl A,(adress)
  1318. PC++;
  1319. *Acc = SFR[prog[PC]] & *Acc;
  1320. PC++;
  1321. break;
  1322. case 0x52: // anl (adress),A
  1323. PC++;
  1324. SFR[prog[PC]] = SFR[prog[PC]] & *Acc;
  1325. PC++;
  1326. break;
  1327. case 0x53: // anl (adress),#(data)
  1328. PC++;
  1329. SFR[prog[PC]] = SFR[prog[PC]] & prog[PC + 1];
  1330. PC++;
  1331. break;
  1332. case 0x58: // anl A,R0
  1333. *Acc = *Acc & R[0];
  1334. PC++;
  1335. break;
  1336. case 0x59: // anl A,R1
  1337. *Acc = *Acc & R[1];
  1338. PC++;
  1339. break;
  1340. case 0x5a: // anl A,R2
  1341. *Acc = *Acc & R[2];
  1342. PC++;
  1343. break;
  1344. case 0x5b: // anl A,R3
  1345. *Acc = *Acc & R[3];
  1346. PC++;
  1347. break;
  1348. case 0x5c: // anl A,R4
  1349. *Acc = *Acc & R[4];
  1350. PC++;
  1351. break;
  1352. case 0x5d: // anl A,R5
  1353. *Acc = *Acc & R[5];
  1354. PC++;
  1355. break;
  1356. case 0x5e: // anl A,R6
  1357. *Acc = *Acc & R[6];
  1358. PC++;
  1359. break;
  1360. case 0x5f: // anl A,R7
  1361. *Acc = *Acc & R[7];
  1362. PC++;
  1363. break;
  1364. case 0x56: // anl A,@R0
  1365. *Acc = *Acc & SFR[R[0]];
  1366. PC++;
  1367. break;
  1368. case 0x57: // anl A,@R1
  1369. *Acc = *Acc & SFR[R[1]];
  1370. PC++;
  1371. break;
  1372. case 0xa2: // mov C,(bit)
  1373. PC++;
  1374. if ( check_Bit(prog[PC]))
  1375. {
  1376. set_C();
  1377. }
  1378. else
  1379. {
  1380. clr_C();
  1381. }
  1382. PC++;
  1383. break;
  1384. case 0xb2: // cpl (bit)
  1385. PC++;
  1386. if ( check_Bit(prog[PC]))
  1387. {
  1388. clr_Bit(prog[PC]);
  1389. }
  1390. else
  1391. {
  1392. set_Bit(prog[PC]);
  1393. }
  1394. PC++;
  1395. break;
  1396. case 0xb3: // cpl C
  1397. PC++;
  1398. if ( check_C())
  1399. {
  1400. clr_C();
  1401. }
  1402. else
  1403. {
  1404. set_C();
  1405. }
  1406. break;
  1407. case 0x72: // orl C,(bit)
  1408. PC++;
  1409. if ( check_C() || check_Bit(prog[PC]))
  1410. {
  1411. set_C();
  1412. }
  1413. else
  1414. {
  1415. clr_C();
  1416. }
  1417. PC++;
  1418. break;
  1419. case 0xa0: // orl C,/(bit)
  1420. PC++;
  1421. if ( check_C() || !check_Bit(prog[PC]))
  1422. {
  1423. set_C();
  1424. }
  1425. else
  1426. {
  1427. clr_C();
  1428. }
  1429. PC++;
  1430. break;
  1431. case 0x82: // anl C,(bit)
  1432. PC++;
  1433. if ( check_C() && check_Bit(prog[PC]))
  1434. {
  1435. set_C();
  1436. }
  1437. else
  1438. {
  1439. clr_C();
  1440. }
  1441. PC++;
  1442. break;
  1443. case 0xb0: // anl C,/(bit)
  1444. PC++;
  1445. if ( check_C() && !check_Bit(prog[PC]))
  1446. {
  1447. set_C();
  1448. }
  1449. else
  1450. {
  1451. clr_C();
  1452. }
  1453. PC++;
  1454. break;
  1455. case 0xf4: // cpl A
  1456. *Acc = *Acc ^ 0xff;
  1457. PC++;
  1458. break;
  1459. case 0xa6: // mov @R0,(adress)
  1460. PC++;
  1461. SFR[R[0]] = SFR[prog[PC]];
  1462. PC++;
  1463. break;
  1464. case 0xa7: // mov @R1,(adress)
  1465. PC++;
  1466. SFR[R[1]] = SFR[prog[PC]];
  1467. PC++;
  1468. break;
  1469. case 0x76: // mov @R0,#(data)
  1470. PC++;
  1471. SFR[R[0]] = prog[PC];
  1472. PC++;
  1473. break;
  1474. case 0x77: // mov @R1,#(data)
  1475. PC++;
  1476. SFR[R[1]] = prog[PC];
  1477. PC++;
  1478. break;
  1479. case 0x86: // mov (adress),@R0
  1480. PC++;
  1481. SFR[prog[PC]] = SFR[R[0]];
  1482. PC++;
  1483. break;
  1484. case 0x87: // mov (adress),@R1
  1485. PC++;
  1486. SFR[prog[PC]] = SFR[R[1]];
  1487. PC++;
  1488. break;
  1489. case 0x73: // jmp @A+DPTR
  1490. PC = (uint16_t) ( *Acc + *DPTR );
  1491. break;
  1492. case 0xb4: // cjne A,#(byte),offset
  1493. PC++;
  1494. if ( *Acc < prog[PC] )
  1495. {
  1496. set_C();
  1497. }
  1498. else
  1499. {
  1500. clr_C();
  1501. }
  1502. if ( *Acc != prog[PC] )
  1503. {
  1504. PC++;
  1505. PC += (signed char) prog[PC] + 1;
  1506. }
  1507. else
  1508. {
  1509. PC += 2;
  1510. }
  1511. break;
  1512. case 0xb5: // cjne A,(adress),offset
  1513. PC++;
  1514. if ( *Acc < SFR[prog[PC]] )
  1515. {
  1516. set_C();
  1517. }
  1518. else
  1519. {
  1520. clr_C();
  1521. }
  1522. if ( *Acc != SFR[prog[PC]] )
  1523. {
  1524. PC++;
  1525. PC += (signed char) prog[PC] + 1;
  1526. }
  1527. else
  1528. {
  1529. PC += 2;
  1530. }
  1531. break;
  1532. case 0xb6: // cjne @R0,#(byte),offset
  1533. PC++;
  1534. if ( SFR[R[0]] < prog[PC] )
  1535. {
  1536. set_C();
  1537. }
  1538. else
  1539. {
  1540. clr_C();
  1541. }
  1542. if ( SFR[R[0]] != prog[PC] )
  1543. {
  1544. PC++;
  1545. PC += (signed char) prog[PC] + 1;
  1546. }
  1547. else
  1548. {
  1549. PC += 2;
  1550. }
  1551. break;
  1552. case 0xb7: // cjne @R1,#(byte),offset
  1553. PC++;
  1554. if ( SFR[R[1]] < prog[PC] )
  1555. {
  1556. set_C();
  1557. }
  1558. else
  1559. {
  1560. clr_C();
  1561. }
  1562. if ( SFR[R[1]] != prog[PC] )
  1563. {
  1564. PC++;
  1565. PC += (signed char) prog[PC] + 1;
  1566. }
  1567. else
  1568. {
  1569. PC += 2;
  1570. }
  1571. break;
  1572. case 0xb8: // cjne R0,#(byte),offset
  1573. PC++;
  1574. if ( R[0] < prog[PC] )
  1575. {
  1576. set_C();
  1577. }
  1578. else
  1579. {
  1580. clr_C();
  1581. }
  1582. if ( R[0] != prog[PC] )
  1583. {
  1584. PC++;
  1585. PC += (signed char) prog[PC] + 1;
  1586. }
  1587. else
  1588. {
  1589. PC += 2;
  1590. }
  1591. break;
  1592. case 0xb9: // cjne R1,#(byte),offset
  1593. PC++;
  1594. if ( R[1] < prog[PC] )
  1595. {
  1596. set_C();
  1597. }
  1598. else
  1599. {
  1600. clr_C();
  1601. }
  1602. if ( R[1] != prog[PC] )
  1603. {
  1604. PC++;
  1605. PC += (signed char) prog[PC] + 1;
  1606. }
  1607. else
  1608. {
  1609. PC += 2;
  1610. }
  1611. break;
  1612. case 0xba: // cjne R2,#(byte),offset
  1613. PC++;
  1614. if ( R[2] < prog[PC] )
  1615. {
  1616. set_C();
  1617. }
  1618. else
  1619. {
  1620. clr_C();
  1621. }
  1622. if ( R[2] != prog[PC] )
  1623. {
  1624. PC++;
  1625. PC += (signed char) prog[PC] + 1;
  1626. }
  1627. else
  1628. {
  1629. PC += 2;
  1630. }
  1631. break;
  1632. case 0xbb: // cjne R3,#(byte),offset
  1633. PC++;
  1634. if ( R[3] < prog[PC] )
  1635. {
  1636. set_C();
  1637. }
  1638. else
  1639. {
  1640. clr_C();
  1641. }
  1642. if ( R[3] != prog[PC] )
  1643. {
  1644. PC++;
  1645. PC += (signed char) prog[PC] + 1;
  1646. }
  1647. else
  1648. {
  1649. PC += 2;
  1650. }
  1651. break;
  1652. case 0xbc: // cjne R4,#(byte),offset
  1653. PC++;
  1654. if ( R[4] < prog[PC] )
  1655. {
  1656. set_C();
  1657. }
  1658. else
  1659. {
  1660. clr_C();
  1661. }
  1662. if ( R[4] != prog[PC] )
  1663. {
  1664. PC++;
  1665. PC += (signed char) prog[PC] + 1;
  1666. }
  1667. else
  1668. {
  1669. PC += 2;
  1670. }
  1671. break;
  1672. case 0xbd: // cjne R5,#(byte),offset
  1673. PC++;
  1674. if ( R[5] < prog[PC] )
  1675. {
  1676. set_C();
  1677. }
  1678. else
  1679. {
  1680. clr_C();
  1681. }
  1682. if ( R[5] != prog[PC] )
  1683. {
  1684. PC++;
  1685. PC += (signed char) prog[PC] + 1;
  1686. }
  1687. else
  1688. {
  1689. PC += 2;
  1690. }
  1691. break;
  1692. case 0xbe: // cjne R6,#(byte),offset
  1693. PC++;
  1694. if ( R[6] < prog[PC] )
  1695. {
  1696. set_C();
  1697. }
  1698. else
  1699. {
  1700. clr_C();
  1701. }
  1702. if ( R[6] != prog[PC] )
  1703. {
  1704. PC++;
  1705. PC += (signed char) prog[PC] + 1;
  1706. }
  1707. else
  1708. {
  1709. PC += 2;
  1710. }
  1711. break;
  1712. case 0xbf: // cjne R7,#(byte),offset
  1713. PC++;
  1714. if ( R[7] < prog[PC] )
  1715. {
  1716. set_C();
  1717. }
  1718. else
  1719. {
  1720. clr_C();
  1721. }
  1722. if ( R[7] != prog[PC] )
  1723. {
  1724. PC++;
  1725. PC += (signed char) prog[PC] + 1;
  1726. }
  1727. else
  1728. {
  1729. PC += 2;
  1730. }
  1731. break;
  1732. case 0x32: // reti
  1733. PC = (uint16_t) SFR[*SP] << 8 | (uint16_t) SFR[*SP - 1];
  1734. *SP = *SP - 2;
  1735. break;
  1736. case 0x30: //jnb (bit),(offset)
  1737. PC++;
  1738. if ( !check_Bit(prog[PC]))
  1739. {
  1740. PC++;
  1741. PC += (signed char) prog[PC] + 1;
  1742. }
  1743. else
  1744. {
  1745. PC += 2;
  1746. }
  1747. break;
  1748. case 0x20: //jb (bit),(offset)
  1749. PC++;
  1750. if ( check_Bit(prog[PC]))
  1751. {
  1752. PC++;
  1753. PC += (signed char) prog[PC] + 1;
  1754. }
  1755. else
  1756. {
  1757. PC += 2;
  1758. }
  1759. break;
  1760. case 0x10: //jbc (bit),(offset)
  1761. PC++;
  1762. if ( check_Bit(prog[PC]))
  1763. {
  1764. clr_Bit(prog[PC]);
  1765. PC++;
  1766. PC += (signed char) prog[PC] + 1;
  1767. }
  1768. else
  1769. {
  1770. PC += 2;
  1771. }
  1772. break;
  1773. case 0x94: // subb A,#(data)
  1774. PC++;
  1775. _subb(*Acc, prog[PC]); //*Acc=*Acc-prog[PC];
  1776. PC++;
  1777. break;
  1778. case 0x95: // subb A,(adress)
  1779. PC++;
  1780. _subb(*Acc, SFR[prog[PC]]); //*Acc=*Acc-SFR[prog[PC]];
  1781. PC++;
  1782. break;
  1783. case 0x96: // subb A,@R0
  1784. PC++;
  1785. _subb(*Acc, SFR[R[0]]); //*Acc=*Acc-SFR[R[0]];
  1786. PC++;
  1787. break;
  1788. case 0x97: // subb A,@R1
  1789. PC++;
  1790. _subb(*Acc, SFR[R[1]]); //*Acc=*Acc-SFR[R[1]];
  1791. PC++;
  1792. break;
  1793. case 0x98: // subb A,R0
  1794. PC++;
  1795. _subb(*Acc, R[0]); //*Acc=*Acc-R[0];
  1796. PC++;
  1797. break;
  1798. case 0x99: // subb A,R1
  1799. PC++;
  1800. _subb(*Acc, R[1]); //*Acc=*Acc-R[1];
  1801. PC++;
  1802. break;
  1803. case 0x9a: // subb A,R2
  1804. PC++;
  1805. _subb(*Acc, R[2]); //*Acc=*Acc-R[2];
  1806. PC++;
  1807. break;
  1808. case 0x9b: // subb A,R3
  1809. PC++;
  1810. _subb(*Acc, R[3]); //*Acc=*Acc-R[3];
  1811. PC++;
  1812. break;
  1813. case 0x9c: // subb A,R4
  1814. PC++;
  1815. _subb(*Acc, R[4]); //*Acc=*Acc-R[4];
  1816. PC++;
  1817. break;
  1818. case 0x9d: // subb A,R5
  1819. PC++;
  1820. _subb(*Acc, R[5]); //*Acc=*Acc-R[5];
  1821. PC++;
  1822. break;
  1823. case 0x9e: // subb A,R6
  1824. PC++;
  1825. _subb(*Acc, R[6]); //*Acc=*Acc-R[6];
  1826. PC++;
  1827. break;
  1828. case 0x9f: // subb A,R7
  1829. PC++;
  1830. _subb(*Acc, R[7]); //*Acc=*Acc-R[7];
  1831. PC++;
  1832. break;
  1833. case 0xd4: // da A
  1834. PC++;
  1835. tmpB = *Acc;
  1836. *Acc &= 0xf;
  1837. tmpB >>= 4;
  1838. if (( *Acc > 9 ) || check_AC())
  1839. {
  1840. *Acc += 9;
  1841. }
  1842. if (( tmpB > 9 ) || check_C())
  1843. {
  1844. tmpB += 9;
  1845. }
  1846. *Acc |= tmpB << 4;
  1847. break;
  1848. case 0xd6: // xchd A,@R0
  1849. PC++;
  1850. tmpB = SFR[R[0]] & 0xf;
  1851. SFR[R[0]] &= 0xf;
  1852. SFR[R[0]] |= ( *Acc ) & 0xf;
  1853. ( *Acc ) &= 0xf;
  1854. ( *Acc ) |= tmpB;
  1855. break;
  1856. case 0xd7: // xchd A,@R1
  1857. PC++;
  1858. tmpB = SFR[R[1]] & 0xf;
  1859. SFR[R[1]] &= 0xf;
  1860. SFR[R[1]] |= ( *Acc ) & 0xf;
  1861. ( *Acc ) &= 0xf;
  1862. ( *Acc ) |= tmpB;
  1863. break;
  1864. case 0xe2: // movx A,@R0
  1865. *Acc = ram[R[0]];
  1866. PC++;
  1867. break;
  1868. case 0xe3: // movx A,@R1
  1869. *Acc = ram[R[1]];
  1870. PC++;
  1871. break;
  1872. case 0xf2: // movx @R0,A
  1873. ram[R[0]] = *Acc;
  1874. PC++;
  1875. break;
  1876. case 0xf3: // movx @R1,A
  1877. ram[R[1]] = *Acc;
  1878. PC++;
  1879. break;
  1880. }
  1881. uint8_t cnt = 0;
  1882. // count cycles
  1883. c_time += cycles;
  1884. // count bits in Acc
  1885. for ( uint8_t c = 0 ; c <= 7 ; c++ )
  1886. {
  1887. if (( 1 << c ) & *Acc )
  1888. {
  1889. cnt++;
  1890. }
  1891. }
  1892. // parrity check
  1893. if ( cnt % 2 ) // if cnt parity isn't true
  1894. {
  1895. clr_P();
  1896. }
  1897. else
  1898. {
  1899. // if cnt parity is true
  1900. set_P();
  1901. }
  1902. // setup Rx bank
  1903. tmpB = check_RS1() << 1 | check_RS0();
  1904. R = &SFR[tmpB << 3];
  1905. uint8_t modeT0, modeT1;
  1906. // timers & interrupts
  1907. modeT0 = *TMOD & 0x03;
  1908. modeT1 = ( *TMOD & 0x30 ) >> 4;
  1909. // Timer 0
  1910. clr_Bit(0x8d); // clr bit TF0 - T0 overflow
  1911. if ( check_Bit(0x8c)) // if TR0
  1912. {
  1913. switch ( modeT0 )
  1914. {
  1915. case 0:
  1916. break;
  1917. case 1:
  1918. if ((int) ( *TL0 ) + (int) cycles <= 0xff )
  1919. {
  1920. *TL0 += cycles;
  1921. }
  1922. else
  1923. {
  1924. *TL0 = (uint8_t) ((int) *TL0 - (int) 0x100 + cycles );
  1925. if ((int) ( *TH0 ) < 0xff )
  1926. {
  1927. *TH0 += 1;
  1928. }
  1929. else
  1930. {
  1931. *TH0 = 0;
  1932. set_Bit(0x8d); // set bit TF0 - T0 overflow
  1933. }
  1934. }
  1935. break;
  1936. case 2:
  1937. if ((int) ( *TL0 ) + (int) cycles <= 0xff )
  1938. {
  1939. *TL0 += cycles;
  1940. }
  1941. else
  1942. {
  1943. *TL0 = *TH0;
  1944. set_Bit(0x8d); // set bit TF0 - T0 overflow
  1945. }
  1946. break;
  1947. case 3:
  1948. break;
  1949. }
  1950. }
  1951. clr_Bit(0x8f); // clr bit TF1 - T1 overflow
  1952. if ( check_Bit(0x8e)) // if TR1
  1953. {
  1954. switch ( modeT1 )
  1955. {
  1956. case 0:
  1957. break;
  1958. case 1:
  1959. if ((int) ( *TL1 ) + (int) cycles <= 0xff )
  1960. {
  1961. *TL1 += cycles;
  1962. }
  1963. else
  1964. {
  1965. *TL1 = (uint8_t) ((int) *TL1 - (int) 0x100 + cycles );
  1966. if ((int) ( *TH1 ) < 0xff )
  1967. {
  1968. *TH1 += 1;
  1969. }
  1970. else
  1971. {
  1972. *TH1 = 0;
  1973. set_Bit(0x8f); // set bit TF0 - T0 overflow
  1974. }
  1975. }
  1976. break;
  1977. case 2:
  1978. if ((int) ( *TL1 ) + (int) cycles <= 0xff )
  1979. {
  1980. *TL1 += cycles;
  1981. }
  1982. else
  1983. {
  1984. *TL1 = *TH1;
  1985. set_Bit(0x8f); // set bit TF0 - T0 overflow
  1986. }
  1987. break;
  1988. case 3:
  1989. break;
  1990. }
  1991. }
  1992. // Interrupts
  1993. if ( check_Bit(0xaf)) //if EA is 1
  1994. {
  1995. // T0 int
  1996. if ( check_Bit(0x8d) && check_Bit(0xa9)) // if TF0 and ET0
  1997. {
  1998. *SP = *SP + 1;
  1999. SFR[*SP] = (uint8_t) ( PC & 0x00ff );
  2000. *SP = *SP + 1;
  2001. SFR[*SP] = (uint8_t) ( PC >> 8 );
  2002. PC = 0x0000b;
  2003. }
  2004. // T1 int
  2005. if ( check_Bit(0x8f) && check_Bit(0xab)) // if TF1 and ET1
  2006. {
  2007. *SP = *SP + 1;
  2008. SFR[*SP] = (uint8_t) ( PC & 0x00ff );
  2009. *SP = *SP + 1;
  2010. SFR[*SP] = (uint8_t) ( PC >> 8 );
  2011. PC = 0x001b;
  2012. }
  2013. }
  2014. }