emu51.cpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833
  1. #include <stdio.h>
  2. #include <stdint.h>
  3. #define USE_CONSOLE
  4. #include <allegro.h>
  5. #include <string.h>
  6. #include <stdlib.h>
  7. #include <code_51.h>
  8. #include <code_editor.h>
  9. #include <dis_asm.h>
  10. #include <flags.h>
  11. #include <gui.h>
  12. #include <ramv.h>
  13. #include <regs.h>
  14. #include <emu51.h>
  15. FONT *mainf;
  16. int white, red, lred, green, blue;
  17. uint8_t SFR[0x100]; // internal memory and sfr area 256 bytes
  18. uint8_t EXT_RAM[0x10000]; // external memory 64kB
  19. uint8_t EXT_PMEM[0x10000]; // external memory 64kB for program
  20. uint8_t *Acc = &SFR[0xe0]; // 8-bit accumlator
  21. uint16_t *DPTR = (uint16_t *) &SFR[0x82]; // 16-bit register
  22. uint8_t *DPH = &SFR[0x83]; // high byte of DPTR
  23. uint8_t *DPL = &SFR[0x82]; // low byte of DPTR
  24. uint8_t *B = &SFR[0xf0]; // B register
  25. uint8_t *SP = &SFR[0x81]; // Stack Pointer
  26. uint8_t *PSW = &SFR[0xd0]; // Program Status Word
  27. uint8_t *P0 = &SFR[0x80]; // 1st Port
  28. uint8_t *P1 = &SFR[0x90]; // 2nd Port
  29. uint8_t *P2 = &SFR[0xa0]; // 3rd Port
  30. uint8_t *P3 = &SFR[0xb0]; // 4th port
  31. uint8_t *SBUF = &SFR[0x99]; // Serial transmission Buffer
  32. uint8_t *IE = &SFR[0xa8]; // Int Enable
  33. uint8_t *SCON = &SFR[0x98]; // Serial Control
  34. uint8_t *TH1 = &SFR[0x8d]; // Timer1 High
  35. uint8_t *TH0 = &SFR[0x8c]; // Timer0 High
  36. uint8_t *TL1 = &SFR[0x8b]; // Timer1 Low
  37. uint8_t *TL0 = &SFR[0x8a]; // Timer0 Low
  38. uint8_t *TMOD = &SFR[0x89]; // Timer Mode
  39. uint8_t *TCON = &SFR[0x88]; // Timer Control
  40. uint8_t *PCON = &SFR[0x87]; // Power Control
  41. uint8_t *R = &SFR[0x00]; // Additional 8 Rx Registers
  42. uint16_t PC = 0x0000; // Progam Counter
  43. uint8_t *ram = EXT_RAM;
  44. uint8_t *prog = EXT_PMEM;
  45. // initialize the emulator
  46. void init_8051(void)
  47. {
  48. int i;
  49. c_time = 0; // cycles counter
  50. for ( i = 0 ; i < 256 ; i++ )
  51. {
  52. SFR[i] = 0xA5; // all regs in internal RAM & SFR
  53. }
  54. *P0 = 0xff; //
  55. *P1 = 0xff; //
  56. *P2 = 0xff; // Some SFR registers
  57. *P3 = 0xff; // and Program Counter
  58. PC = 0x0000; //
  59. *SP = 0x07; //
  60. }
  61. // 8051 assembler macros
  62. int get_length(uint8_t code)
  63. {
  64. if ( asm51[code].code == code )
  65. {
  66. return asm51[code].length;
  67. }
  68. else
  69. {
  70. return 1;
  71. }
  72. }
  73. /*bool vret (void)
  74. {
  75. if (inportb(0x3da) & 8) return true;
  76. else return false;
  77. }*/
  78. void wait_for_retrace(void)
  79. {
  80. /*while (!vret())
  81. {
  82. }*/
  83. //vsync();
  84. }
  85. int load_code_table(code_51 *tmp_tab)
  86. {
  87. FILE *strio = NULL;
  88. char _mnem[6];
  89. int _code;
  90. int _length;
  91. int _cycles;
  92. char _datas[12];
  93. strio = fopen("list51.txt", "r");
  94. if ( strio )
  95. {
  96. for ( int c = 0 ; c < 256 ; c++ )
  97. {
  98. fscanf(strio, "%x", &_code);
  99. fscanf(strio, "%s", _mnem);
  100. fscanf(strio, "%s", _datas);
  101. fscanf(strio, "%d", &_length);
  102. fscanf(strio, "%d", &_cycles);
  103. if ( _mnem[0] == 'E' && _mnem[1] == 'N' && _mnem[2] == 'D' )
  104. {
  105. break;
  106. }
  107. tmp_tab[_code].code = (uint8_t) _code;
  108. strcpy(tmp_tab[_code].mnem, _mnem);
  109. strcpy(tmp_tab[_code].datas, _datas);
  110. tmp_tab[_code].length = (uint8_t) _length;
  111. tmp_tab[_code].cycles = (uint8_t) _cycles;
  112. }
  113. fclose(strio);
  114. }
  115. else
  116. {
  117. ShowMessage("Can't load list51.txt file", screen, 100, 100, 200, 60, "Error!");
  118. }
  119. return 0;
  120. }
  121. int load_ram(char *filename, uint8_t *ram)
  122. {
  123. FILE *strin = NULL;
  124. if ( *filename != 0 )
  125. {
  126. strin = fopen(filename, "rb");
  127. }
  128. if ( strin == NULL )
  129. {
  130. ShowMessage("Can't open the file", screen, 250, 100, 200, 100, "Error!");
  131. }
  132. else
  133. {
  134. uint16_t c = 0;
  135. for ( c ; !feof(strin) ; c++ )
  136. {
  137. ram[c] = fgetc(strin);
  138. }
  139. fclose(strin);
  140. }
  141. return 0;
  142. }
  143. int load_hex(char *filename, uint8_t *ram)
  144. {
  145. FILE *strin;
  146. int Adr = 0;
  147. int Cnt;
  148. //int to_mem;
  149. int i;
  150. char line[50];
  151. char word[5];
  152. char byte[3];
  153. byte[2] = word[4] = 0;
  154. strin = NULL;
  155. if ( *filename != 0 )
  156. {
  157. strin = fopen(filename, "r");
  158. }
  159. if ( strin == NULL )
  160. {
  161. ShowMessage("Can't open the file", screen, 250, 100, 200, 100, "Error!");
  162. return -1;
  163. }
  164. else
  165. {
  166. while ( !feof(strin))
  167. {
  168. fscanf(strin, "%s", line);
  169. //fprintf (out,"%s\n", line);
  170. byte[0] = line[1];
  171. byte[1] = line[2];
  172. sscanf(byte, "%x", &Cnt);
  173. word[0] = line[3];
  174. word[1] = line[4];
  175. word[2] = line[5];
  176. word[3] = line[6];
  177. sscanf(word, "%x", &Adr);
  178. byte[0] = line[7];
  179. byte[1] = line[8];
  180. sscanf(byte, "%x", &i);
  181. if ( i == 1 )
  182. {
  183. break;
  184. }
  185. else
  186. {
  187. byte[2] = 0;
  188. for ( i = 9 ; i < 9 + Cnt * 2 ; i += 2 )
  189. {
  190. byte[0] = line[i];
  191. byte[1] = line[i + 1];
  192. sscanf(byte, "%x", ( ram + Adr ));
  193. Adr++;
  194. }
  195. }
  196. }
  197. fclose(strin);
  198. //fclose (out);
  199. }
  200. return 0;
  201. }
  202. void ChangeMonitedSFRRegister(regs *regwnd)
  203. {
  204. char lab[10];
  205. char ln[3];
  206. int line_num = 0;
  207. int reg_adr = 0;
  208. GetText(ln, screen, 50, 50, 300, 70, 3, "Enter line number (dec)");
  209. sscanf(ln, "%d", &line_num);
  210. if ( line_num < 1 || line_num > 25 )
  211. {
  212. return;
  213. }
  214. GetText(lab, screen, 50, 80, 300, 70, 10, "Enter reg. label (ascii)");
  215. GetText(ln, screen, 50, 100, 300, 70, 3, "Enter register number (hex)");
  216. sscanf(ln, "%x", &reg_adr);
  217. line_num--;
  218. strcpy(regwnd->reg_label[line_num], lab);
  219. regwnd->reg[line_num] = (uint8_t) reg_adr;
  220. return;
  221. }
  222. void reset51(void)
  223. {
  224. if ( QuestionBox("Are you sure want to reset 8051", screen, 250, 240, 300, 60, "Confirm!", makecol(255, 255, 255)))
  225. {
  226. init_8051();
  227. }
  228. return;
  229. }
  230. uint16_t ViewAt(void)
  231. {
  232. char hex4[6];
  233. int tmp_adr;
  234. GetText(hex4, screen, 50, 80, 300, 70, 5, "Enter new view point (hex)");
  235. if ( hex4[0] == 32 )
  236. {
  237. return 0;
  238. }
  239. sscanf(hex4, "%x", &tmp_adr);
  240. return (uint16_t) tmp_adr;
  241. }
  242. void ChangePC(void)
  243. {
  244. char hex4[5];
  245. int tmpPC = 0;
  246. GetText(hex4, screen, 50, 80, 300, 70, 5, "Enter new PC (hex)");
  247. if ( hex4[0] == 32 )
  248. {
  249. return;
  250. }
  251. sscanf(hex4, "%x", &tmpPC);
  252. PC = (uint16_t) tmpPC;
  253. return;
  254. }
  255. void ChangeRegValue_SFR(void)
  256. {
  257. char hex2[3];
  258. char hex2_a[3];
  259. int tmp_adr;
  260. int tmp_dat;
  261. GetText(hex2_a, screen, 50, 80, 300, 70, 3, "Enter adress from SFR (hex)");
  262. if ( hex2_a[0] == 32 )
  263. {
  264. return;
  265. }
  266. GetText(hex2, screen, 60, 90, 300, 70, 3, "Enter byte (hex)");
  267. sscanf(hex2_a, "%x", &tmp_adr);
  268. sscanf(hex2, "%x", &tmp_dat);
  269. SFR[(uint8_t) tmp_adr] = (uint8_t) tmp_dat;
  270. return;
  271. }
  272. void ChangeRegValue_RAM(void)
  273. {
  274. char hex2[3];
  275. char hex4_a[5];
  276. int tmp_adr;
  277. int tmp_dat;
  278. GetText(hex4_a, screen, 50, 80, 400, 70, 5, "Enter adress from External Memory (hex)");
  279. if ( hex4_a[0] == 32 )
  280. {
  281. return;
  282. }
  283. GetText(hex2, screen, 60, 90, 300, 70, 3, "Enter byte (hex)");
  284. sscanf(hex4_a, "%x", &tmp_adr);
  285. sscanf(hex2, "%x", &tmp_dat);
  286. prog[(uint16_t) tmp_adr] = (uint8_t) tmp_dat;
  287. return;
  288. }
  289. void LoadRAM(void)
  290. {
  291. char filename[40];
  292. GetText(filename, screen, 30, 80, 700, 70, 40, "Load *.bin file");
  293. for ( int c = 38 ; filename[c] == ' ' || filename[c] == '\r' ; c-- )
  294. {
  295. filename[c] = 0;
  296. }
  297. load_ram(filename, prog);
  298. return;
  299. }
  300. void LoadHEX(void)
  301. {
  302. char filename[40];
  303. GetText(filename, screen, 30, 80, 700, 70, 40, "Load *.hex file");
  304. for ( int c = 38 ; filename[c] == ' ' || filename[c] == '\r' ; c-- )
  305. {
  306. filename[c] = 0;
  307. }
  308. load_hex(filename, prog);
  309. return;
  310. }
  311. void LoadSrc(void)
  312. {
  313. char cmd[256];
  314. char filename[256];
  315. char comp_msg[512];
  316. FILE *msgin;
  317. int c = 0;
  318. GetText(filename, screen, 30, 80, 700, 70, 40, "Load and compile source file (*.*)");
  319. sprintf(cmd, "asm51.exe %s > out.tmp", filename);
  320. system(cmd);
  321. msgin = NULL;
  322. msgin = fopen("out.tmp", "rb");
  323. if ( msgin == NULL )
  324. {
  325. ShowMessage("Can't open the file: out.tmp", screen, 250, 100, 200, 100, "Error!");
  326. }
  327. else
  328. {
  329. for ( c ; c <= 0xffff ; c++ )
  330. {
  331. comp_msg[c] = fgetc(msgin);
  332. if ( feof(msgin))
  333. {
  334. break;
  335. }
  336. }
  337. fclose(msgin);
  338. }
  339. ShowMsgEx(comp_msg, screen, 100, 80, 600, 140, "Assembling status", makecol(255, 255, 255));
  340. for ( c = 512 ; c > 0 ; c-- )
  341. {
  342. if ( comp_msg[c] == ',' && comp_msg[c + 2] == '0' )
  343. {
  344. change_ext(filename);
  345. if ( load_hex(filename, prog) == 0 )
  346. {
  347. ShowMessage("Compiled file is loaded.", screen, 250, 100, 300, 80, "Message!");
  348. }
  349. break;
  350. }
  351. }
  352. return;
  353. }
  354. void EditSrc(void)
  355. {
  356. code_editor ed1;
  357. ed1.process();
  358. return;
  359. }
  360. void ChMaxI(int *maxi)
  361. {
  362. char dec6_a[7];
  363. GetText(dec6_a, screen, 50, 80, 400, 70, 7, "Enter number of instructions per frame");
  364. if ( dec6_a[0] == 32 )
  365. {
  366. return;
  367. }
  368. sscanf(dec6_a, "%d", maxi);
  369. return;
  370. }
  371. void ChMemMode(void)
  372. {
  373. if ( QuestionBox("Do you want to use memory in mixed mode?", screen, 100, 100, 400, 60, "Qusetion?", white))
  374. {
  375. ram = EXT_PMEM;
  376. }
  377. else
  378. {
  379. ram = EXT_RAM;
  380. }
  381. }
  382. void FillExt(void)
  383. {
  384. char h4beg[5], h4end[5], h2f[3];
  385. int from, to, i, ic = 1, fill;
  386. GetText(h4beg, screen, 50, 80, 400, 70, 5, "From adress... (16bit hex)");
  387. GetText(h4end, screen, 50, 80, 400, 70, 5, "...to adress (16bit hex)");
  388. GetText(h2f, screen, 50, 80, 400, 70, 3, "with byte (8bit hex)");
  389. sscanf(h4beg, "%x", &from);
  390. sscanf(h4end, "%x", &to);
  391. sscanf(h2f, "%x", &fill);
  392. if ( from > to )
  393. {
  394. ic = -1;
  395. }
  396. for ( i = from ; i != to ; i += ic )
  397. {
  398. ram[i] = fill;
  399. }
  400. ram[to] = fill;
  401. return;
  402. }
  403. void main_init(void)
  404. {
  405. load_code_table(asm51);
  406. //load_ram ("lekcja3.bin",ram);
  407. //load_ram ("avt.bin",ram);
  408. init_8051();
  409. allegro_init();
  410. install_timer();
  411. install_keyboard();
  412. //install_mouse();
  413. set_color_depth(8);
  414. set_gfx_mode(GFX_AUTODETECT_WINDOWED, 800, 600, 0, 0);
  415. //set_gfx_mode (GFX_AUTODETECT, 800, 600,0,0);
  416. set_palette(desktop_palette);
  417. //show_mouse (screen);
  418. RGB col;
  419. col.r = 0;
  420. col.g = 0;
  421. col.b = 0;
  422. set_color(0, &col);
  423. col.r = 63;
  424. col.g = 15;
  425. col.b = 0;
  426. set_color(1, &col);
  427. col.r = 20;
  428. col.g = 0;
  429. col.b = 0;
  430. set_color(2, &col);
  431. col.r = 255;
  432. col.g = 255;
  433. col.b = 255;
  434. set_color(255, &col);
  435. DATAFILE *dataf;
  436. dataf = load_datafile("data.dat");
  437. mainf = (FONT *) dataf[0].dat;
  438. }
  439. int main(void)
  440. {
  441. main_init();
  442. white = makecol(255, 255, 255);
  443. red = makecol(255, 0, 0);
  444. lred = makecol(255, 64, 0);
  445. green = makecol(0, 255, 0);
  446. blue = makecol(0, 0, 255);
  447. dis_asm disasm(prog, screen);
  448. regs SFRregs(SFR, screen);
  449. flags FlagWnd(screen);
  450. ramv RMon(screen);
  451. strcpy(SFRregs.reg_label[0], "Delay AVT");
  452. SFRregs.reg[0] = 0x75;
  453. strcpy(SFRregs.reg_label[1], "Key AVT ");
  454. SFRregs.reg[1] = 0x76;
  455. strcpy(SFRregs.reg_label[2], "DPH ");
  456. SFRregs.reg[2] = 0x83;
  457. strcpy(SFRregs.reg_label[3], "DPL ");
  458. SFRregs.reg[3] = 0x82;
  459. strcpy(SFRregs.reg_label[4], "PSW ");
  460. SFRregs.reg[4] = 0xd0;
  461. strcpy(SFRregs.reg_label[5], "P0 ");
  462. SFRregs.reg[5] = 0x80;
  463. strcpy(SFRregs.reg_label[6], "P1 ");
  464. SFRregs.reg[6] = 0x90;
  465. strcpy(SFRregs.reg_label[7], "P2 ");
  466. SFRregs.reg[7] = 0xa0;
  467. strcpy(SFRregs.reg_label[8], "P3 ");
  468. SFRregs.reg[8] = 0xb0;
  469. strcpy(SFRregs.reg_label[9], "TH1 ");
  470. SFRregs.reg[9] = 0x8d;
  471. strcpy(SFRregs.reg_label[10], "TL1 ");
  472. SFRregs.reg[10] = 0x8b;
  473. strcpy(SFRregs.reg_label[11], "TH0 ");
  474. SFRregs.reg[11] = 0x8c;
  475. strcpy(SFRregs.reg_label[12], "TL0 ");
  476. SFRregs.reg[12] = 0x8a;
  477. strcpy(SFRregs.reg_label[13], "IE ");
  478. SFRregs.reg[13] = 0xa8;
  479. strcpy(SFRregs.reg_label[14], "10 ");
  480. SFRregs.reg[14] = 0x12;
  481. strcpy(SFRregs.reg_label[15], "9 ");
  482. SFRregs.reg[15] = 0x11;
  483. strcpy(SFRregs.reg_label[16], "8 ");
  484. SFRregs.reg[16] = 0x10;
  485. strcpy(SFRregs.reg_label[17], "7 ");
  486. SFRregs.reg[17] = 0x0f;
  487. strcpy(SFRregs.reg_label[18], "6 ");
  488. SFRregs.reg[18] = 0x0e;
  489. strcpy(SFRregs.reg_label[19], "5 ");
  490. SFRregs.reg[19] = 0x0d;
  491. strcpy(SFRregs.reg_label[20], "4 ");
  492. SFRregs.reg[20] = 0x0c;
  493. strcpy(SFRregs.reg_label[21], "3 ");
  494. SFRregs.reg[21] = 0x0b;
  495. strcpy(SFRregs.reg_label[22], "2 ");
  496. SFRregs.reg[22] = 0x0a;
  497. strcpy(SFRregs.reg_label[23], "1 ");
  498. SFRregs.reg[23] = 0x09;
  499. strcpy(SFRregs.reg_label[24], "0 ");
  500. SFRregs.reg[24] = 0x08;
  501. PC = 0x0000;
  502. uint16_t aadr = 0x0000;
  503. uint16_t madr = 0x0000;
  504. bool manual_scrolling = true;
  505. bool step = true;
  506. bool into = false;
  507. bool over = false;
  508. unsigned long cnt = 0;
  509. int break_point = -1;
  510. char break_str[5];
  511. //load_ram("avt.bin",ram);
  512. int i = 0, maxi = 13000;
  513. while ( !( key[KEY_X] && key[KEY_ALT] ))
  514. {
  515. rect(screen, 2, 2, 798, 18, white);
  516. // key shortcuts disp
  517. rect(screen, 2, 521, 798, 598, white);
  518. textprintf(screen, mainf, 128, 528, white,
  519. "F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12");
  520. textprintf(screen, mainf, 128, 548, white,
  521. "Help ChSFR ManS Debug DView WrPC TInto SOver SrcEd FillE Speed Reset");
  522. textprintf(screen, mainf, 128, 568, white,
  523. "WrRAM WrSFR AutoS Run MView LdBIN LdHEX LdSrc BrkPt MemMod ");
  524. hline(screen, 2, 540, 798, white);
  525. textprintf(screen, mainf, 6, 548, white, "Function key :");
  526. hline(screen, 2, 560, 798, white);
  527. textprintf(screen, mainf, 6, 568, white, "Shift+key :");
  528. hline(screen, 2, 580, 798, white);
  529. textprintf(screen, mainf, 6, 587, white, "Alt+X: Exit ");
  530. textprintf(screen, mainf, 6, 7, white, "emu51 %s", VERSION);
  531. textout(screen, mainf, "AVT-2250 Segment display:", 490, 6, white);
  532. if ( ram == prog )
  533. {
  534. rect(screen, 680, 568, 680 + 6, 575, red);
  535. }
  536. cnt++;
  537. if ( manual_scrolling )
  538. {
  539. disasm.draw(aadr);
  540. }
  541. else
  542. {
  543. disasm.draw(PC);
  544. }
  545. disasm.blit_it(0, 20);
  546. RMon.draw(madr);
  547. RMon.blit_it(300, 320);
  548. SFRregs.draw();
  549. SFRregs.blit_it(400, 20);
  550. FlagWnd.draw();
  551. FlagWnd.blit_it(300, 20);
  552. if ( !step )
  553. {
  554. for ( i = 0 ; i < maxi ; i++ )
  555. {
  556. if ( PC == break_point )
  557. {
  558. step = true;
  559. break;
  560. }
  561. asm51[prog[PC]].process();
  562. }
  563. }
  564. else
  565. {
  566. if ( over )
  567. {
  568. asm51[prog[PC]].process();
  569. over = false;
  570. }
  571. if ( into )
  572. {
  573. asm51[prog[PC]].process();
  574. into = false;
  575. }
  576. }
  577. for ( i = 0 ; i <= 7 ; i++ )
  578. {
  579. // for compatibility with avt2250
  580. draw_SEG_digit(screen, 700 + 8 * i, 6, lred, 4, SFR[i + 0x78]);
  581. }
  582. if ( key[KEY_LCONTROL] )
  583. {
  584. if ( key[KEY_0_PAD] )
  585. {
  586. SFR[0x76] = 0x30;
  587. }
  588. if ( key[KEY_1_PAD] )
  589. {
  590. SFR[0x76] = 0x31;
  591. }
  592. if ( key[KEY_2_PAD] )
  593. {
  594. SFR[0x76] = 0x32;
  595. }
  596. if ( key[KEY_3_PAD] )
  597. {
  598. SFR[0x76] = 0x33;
  599. }
  600. if ( key[KEY_4_PAD] )
  601. {
  602. SFR[0x76] = 0x34;
  603. }
  604. if ( key[KEY_5_PAD] )
  605. {
  606. SFR[0x76] = 0x35;
  607. }
  608. if ( key[KEY_6_PAD] )
  609. {
  610. SFR[0x76] = 0x36;
  611. }
  612. if ( key[KEY_7_PAD] )
  613. {
  614. SFR[0x76] = 0x37;
  615. }
  616. if ( key[KEY_8_PAD] )
  617. {
  618. SFR[0x76] = 0x38;
  619. }
  620. if ( key[KEY_9_PAD] )
  621. {
  622. SFR[0x76] = 0x39;
  623. }
  624. if ( key[KEY_INSERT] )
  625. {
  626. SFR[0x76] = 0x41;
  627. }
  628. if ( key[KEY_HOME] )
  629. {
  630. SFR[0x76] = 0x42;
  631. }
  632. if ( key[KEY_PGUP] )
  633. {
  634. SFR[0x76] = 0x43;
  635. }
  636. if ( key[KEY_DEL] )
  637. {
  638. SFR[0x76] = 0x44;
  639. }
  640. if ( key[KEY_END] )
  641. {
  642. SFR[0x76] = 0x45;
  643. }
  644. if ( key[KEY_PGDN] )
  645. {
  646. SFR[0x76] = 0x46;
  647. }
  648. if ( key[KEY_ENTER_PAD] )
  649. {
  650. SFR[0x76] = 0x0d;
  651. }
  652. }
  653. else
  654. {
  655. if ( key[KEY_UP] )
  656. {
  657. aadr -= 3;
  658. }
  659. if ( key[KEY_DOWN] )
  660. {
  661. aadr += get_length(prog[aadr]);
  662. aadr += get_length(prog[aadr]);
  663. }
  664. if ( key[KEY_PGUP] && !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ))
  665. {
  666. madr -= 16;
  667. }
  668. if ( key[KEY_PGDN] && !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ))
  669. {
  670. madr += 16;
  671. }
  672. if ( key[KEY_PGUP] && ( key[KEY_LSHIFT] || key[KEY_RSHIFT] ))
  673. {
  674. madr -= 1;
  675. }
  676. if ( key[KEY_PGDN] && ( key[KEY_LSHIFT] || key[KEY_RSHIFT] ))
  677. {
  678. madr += 1;
  679. }
  680. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F2] )
  681. {
  682. ChangeMonitedSFRRegister(&SFRregs);
  683. }
  684. if (( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F2] )
  685. {
  686. ChangeRegValue_SFR();
  687. }
  688. if (( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F1] )
  689. {
  690. ChangeRegValue_RAM();
  691. }
  692. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F3] )
  693. {
  694. manual_scrolling = true;
  695. }
  696. if (( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F3] )
  697. {
  698. manual_scrolling = false;
  699. }
  700. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F4] )
  701. {
  702. step = true;
  703. }
  704. if (( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F4] )
  705. {
  706. step = false;
  707. }
  708. if ( step )
  709. {
  710. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F7] )
  711. {
  712. into = true;
  713. }
  714. while ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F7] )
  715. {
  716. }
  717. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F8] )
  718. {
  719. over = true;
  720. }
  721. while ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F8] )
  722. {
  723. }
  724. }
  725. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F5] )
  726. {
  727. aadr = ViewAt();
  728. }
  729. if (( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F5] )
  730. {
  731. madr = ViewAt();
  732. }
  733. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F6] )
  734. {
  735. ChangePC();
  736. }
  737. if (( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F7] )
  738. {
  739. LoadRAM();
  740. }
  741. if (( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F8] )
  742. {
  743. LoadHEX();
  744. }
  745. if (( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F9] )
  746. {
  747. LoadSrc();
  748. }
  749. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F9] )
  750. {
  751. EditSrc();
  752. }
  753. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F12] )
  754. {
  755. reset51();
  756. }
  757. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F11] )
  758. {
  759. ChMaxI(&maxi);
  760. }
  761. if (( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F11] )
  762. {
  763. ChMemMode();
  764. }
  765. if ( !( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F10] )
  766. {
  767. FillExt();
  768. }
  769. if (( key[KEY_LSHIFT] || key[KEY_RSHIFT] ) && key[KEY_F10] )
  770. {
  771. GetText(break_str, screen, 50, 80, 400, 70, 5, "Enter break piont adress");
  772. sscanf(break_str, "%x", &break_point);
  773. }
  774. }
  775. }
  776. return 0;
  777. }
  778. //END_OF_MAIN();