Advertisement
Guest User

Untitled

a guest
Feb 18th, 2020
113
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 36.81 KB | None | 0 0
  1. #include "stdafx.h"
  2. #include <winsock2.h>
  3.  
  4. #pragma comment(lib, "wsock32.lib")
  5.  
  6.  
  7. #define STUDENT_NUMBER "18007506"
  8.  
  9. #define IP_ADDRESS_SERVER "127.0.0.1"
  10.  
  11. #define PORT_SERVER 0x1984 // We define a port that we are going to use.
  12. #define PORT_CLIENT 0x1985 // We define a port that we are going to use.
  13.  
  14. #define WORD unsigned short
  15. #define DWORD unsigned long
  16. #define BYTE unsigned char
  17.  
  18. #define MAX_FILENAME_SIZE 500
  19. #define MAX_BUFFER_SIZE 500
  20.  
  21. SOCKADDR_IN server_addr;
  22. SOCKADDR_IN client_addr;
  23.  
  24. SOCKET sock; // This is our socket, it is the handle to the IO address to read/write packets
  25.  
  26. WSADATA data;
  27.  
  28. char InputBuffer[MAX_BUFFER_SIZE];
  29.  
  30. char hex_file[MAX_BUFFER_SIZE];
  31. char trc_file[MAX_BUFFER_SIZE];
  32.  
  33. //////////////////////////
  34. // Registers //
  35. //////////////////////////
  36.  
  37. #define FLAG_I 0x80
  38. #define FLAG_N 0x20
  39. #define FLAG_V 0x10
  40. #define FLAG_Z 0x08
  41. #define FLAG_C 0x01
  42.  
  43. #define REGISTER_M 7
  44. #define REGISTER_A 6
  45. #define REGISTER_H 5
  46. #define REGISTER_L 4
  47. #define REGISTER_E 3
  48. #define REGISTER_D 2
  49. #define REGISTER_C 1
  50. #define REGISTER_B 0
  51. WORD IndexRegister;
  52.  
  53. BYTE Registers[8];
  54. BYTE Flags;
  55. WORD ProgramCounter;
  56. WORD StackPointer;
  57.  
  58.  
  59. ////////////
  60. // Memory //
  61. ////////////
  62.  
  63. #define MEMORY_SIZE 65536
  64.  
  65. BYTE Memory[MEMORY_SIZE];
  66.  
  67. #define TEST_ADDRESS_1 0x01FA
  68. #define TEST_ADDRESS_2 0x01FB
  69. #define TEST_ADDRESS_3 0x01FC
  70. #define TEST_ADDRESS_4 0x01FD
  71. #define TEST_ADDRESS_5 0x01FE
  72. #define TEST_ADDRESS_6 0x01FF
  73. #define TEST_ADDRESS_7 0x0200
  74. #define TEST_ADDRESS_8 0x0201
  75. #define TEST_ADDRESS_9 0x0202
  76. #define TEST_ADDRESS_10 0x0203
  77. #define TEST_ADDRESS_11 0x0204
  78. #define TEST_ADDRESS_12 0x0205
  79.  
  80.  
  81. ///////////////////////
  82. // Control variables //
  83. ///////////////////////
  84.  
  85. bool memory_in_range = true;
  86. bool halt = false;
  87.  
  88.  
  89. ///////////////////////
  90. // Disassembly table //
  91. ///////////////////////
  92.  
  93. char opcode_mneumonics[][14] =
  94. {
  95. "BRA rel ",
  96. "BCC rel ",
  97. "BCS rel ",
  98. "BNE rel ",
  99. "BEQ rel ",
  100. "BVC rel ",
  101. "BVS rel ",
  102. "BMI rel ",
  103. "BPL rel ",
  104. "BGE rel ",
  105. "BLE rel ",
  106. "BLS rel ",
  107. "BHI rel ",
  108. "ILLEGAL ",
  109. "RTN impl ",
  110. "ILLEGAL ",
  111.  
  112. "ST abs ",
  113. "PSH ,A ",
  114. "POP A, ",
  115. "ILLEGAL ",
  116. "ILLEGAL ",
  117. "CLC impl ",
  118. "SEC impl ",
  119. "CLI impl ",
  120. "STI impl ",
  121. "SEV impl ",
  122. "CLV impl ",
  123. "DEX impl ",
  124. "INX impl ",
  125. "NOP impl ",
  126. "WAI impl ",
  127. "ILLEGAL ",
  128.  
  129. "ST abs,X ",
  130. "PSH ,s ",
  131. "POP s, ",
  132. "ILLEGAL ",
  133. "ILLEGAL ",
  134. "ADI # ",
  135. "SBI # ",
  136. "CPI # ",
  137. "ANI # ",
  138. "XRI # ",
  139. "MVI #,B ",
  140. "MVI #,C ",
  141. "MVI #,D ",
  142. "MVI #,E ",
  143. "MVI #,L ",
  144. "MVI #,H ",
  145.  
  146. "ILLEGAL ",
  147. "PSH ,B ",
  148. "POP B, ",
  149. "JPR abs ",
  150. "CCC abs ",
  151. "CCS abs ",
  152. "CNE abs ",
  153. "CEQ abs ",
  154. "CVC abs ",
  155. "CVS abs ",
  156. "CMI abs ",
  157. "CPL abs ",
  158. "CHI abs ",
  159. "CLE abs ",
  160. "ILLEGAL ",
  161. "ILLEGAL ",
  162.  
  163. "ILLEGAL ",
  164. "PSH ,C ",
  165. "POP C, ",
  166. "TST abs ",
  167. "INC abs ",
  168. "DEC abs ",
  169. "RCR abs ",
  170. "RCL abs ",
  171. "SAL abs ",
  172. "ASR abs ",
  173. "NOT abs ",
  174. "ROL abs ",
  175. "ROR abs ",
  176. "ILLEGAL ",
  177. "LDX # ",
  178. "LODS # ",
  179.  
  180. "STOX abs ",
  181. "PSH ,D ",
  182. "POP D, ",
  183. "TST abs,X ",
  184. "INC abs,X ",
  185. "DEC abs,X ",
  186. "RCR abs,X ",
  187. "RCL abs,X ",
  188. "SAL abs,X ",
  189. "ASR abs,X ",
  190. "NOT abs,X ",
  191. "ROL abs,X ",
  192. "ROR abs,X ",
  193. "ILLEGAL ",
  194. "LDX abs ",
  195. "LODS abs ",
  196.  
  197. "STOX abs,X ",
  198. "PSH ,E ",
  199. "POP E, ",
  200. "TSTA A,A ",
  201. "INCA A,A ",
  202. "DECA A,A ",
  203. "RCRA A,A ",
  204. "RCLA A,A ",
  205. "SALA A,A ",
  206. "ASRA A,A ",
  207. "NOTA A,A ",
  208. "ROLA A,A ",
  209. "RORA A,A ",
  210. "ILLEGAL ",
  211. "LDX abs,X ",
  212. "LODS abs,X ",
  213.  
  214. "ILLEGAL ",
  215. "PSH ,L ",
  216. "POP L, ",
  217. "ILLEGAL ",
  218. "TAS impl ",
  219. "TSA impl ",
  220. "ILLEGAL ",
  221. "ILLEGAL ",
  222. "MOVE A,A ",
  223. "MOVE B,A ",
  224. "MOVE C,A ",
  225. "MOVE D,A ",
  226. "MOVE E,A ",
  227. "MOVE L,A ",
  228. "MOVE H,A ",
  229. "MOVE M,A ",
  230.  
  231. "ILLEGAL ",
  232. "PSH ,H ",
  233. "POP H, ",
  234. "ILLEGAL ",
  235. "ILLEGAL ",
  236. "SWI impl ",
  237. "RTI impl ",
  238. "ILLEGAL ",
  239. "MOVE A,B ",
  240. "MOVE B,B ",
  241. "MOVE C,B ",
  242. "MOVE D,B ",
  243. "MOVE E,B ",
  244. "MOVE L,B ",
  245. "MOVE H,B ",
  246. "MOVE M,B ",
  247.  
  248. "ADC A,B ",
  249. "SBC A,B ",
  250. "CMP A,B ",
  251. "IOR A,B ",
  252. "AND A,B ",
  253. "XOR A,B ",
  254. "BT A,B ",
  255. "ILLEGAL ",
  256. "MOVE A,C ",
  257. "MOVE B,C ",
  258. "MOVE C,C ",
  259. "MOVE D,C ",
  260. "MOVE E,C ",
  261. "MOVE L,C ",
  262. "MOVE H,C ",
  263. "MOVE M,C ",
  264.  
  265. "ADC A,C ",
  266. "SBC A,C ",
  267. "CMP A,C ",
  268. "IOR A,C ",
  269. "AND A,C ",
  270. "XOR A,C ",
  271. "BT A,C ",
  272. "ILLEGAL ",
  273. "MOVE A,D ",
  274. "MOVE B,D ",
  275. "MOVE C,D ",
  276. "MOVE D,D ",
  277. "MOVE E,D ",
  278. "MOVE L,D ",
  279. "MOVE H,D ",
  280. "MOVE M,D ",
  281.  
  282. "ADC A,D ",
  283. "SBC A,D ",
  284. "CMP A,D ",
  285. "IOR A,D ",
  286. "AND A,D ",
  287. "XOR A,D ",
  288. "BT A,D ",
  289. "LD # ",
  290. "MOVE A,E ",
  291. "MOVE B,E ",
  292. "MOVE C,E ",
  293. "MOVE D,E ",
  294. "MOVE E,E ",
  295. "MOVE L,E ",
  296. "MOVE H,E ",
  297. "MOVE M,E ",
  298.  
  299. "ADC A,E ",
  300. "SBC A,E ",
  301. "CMP A,E ",
  302. "IOR A,E ",
  303. "AND A,E ",
  304. "XOR A,E ",
  305. "BT A,E ",
  306. "LD abs ",
  307. "MOVE A,L ",
  308. "MOVE B,L ",
  309. "MOVE C,L ",
  310. "MOVE D,L ",
  311. "MOVE E,L ",
  312. "MOVE L,L ",
  313. "MOVE H,L ",
  314. "MOVE M,L ",
  315.  
  316. "ADC A,L ",
  317. "SBC A,L ",
  318. "CMP A,L ",
  319. "IOR A,L ",
  320. "AND A,L ",
  321. "XOR A,L ",
  322. "BT A,L ",
  323. "LD abs,X ",
  324. "MOVE A,H ",
  325. "MOVE B,H ",
  326. "MOVE C,H ",
  327. "MOVE D,H ",
  328. "MOVE E,H ",
  329. "MOVE L,H ",
  330. "MOVE H,H ",
  331. "MOVE M,H ",
  332.  
  333. "ADC A,H ",
  334. "SBC A,H ",
  335. "CMP A,H ",
  336. "IOR A,H ",
  337. "AND A,H ",
  338. "XOR A,H ",
  339. "BT A,H ",
  340. "ILLEGAL ",
  341. "MOVE A,M ",
  342. "MOVE B,M ",
  343. "MOVE C,M ",
  344. "MOVE D,M ",
  345. "MOVE E,M ",
  346. "MOVE L,M ",
  347. "MOVE H,M ",
  348. "MOVE -,- ",
  349.  
  350. "ADC A,M ",
  351. "SBC A,M ",
  352. "CMP A,M ",
  353. "IOR A,M ",
  354. "AND A,M ",
  355. "XOR A,M ",
  356. "BT A,M ",
  357. "ILLEGAL ",
  358. "ILLEGAL ",
  359. "ILLEGAL ",
  360. "JMP abs ",
  361. "ILLEGAL ",
  362. "ILLEGAL ",
  363. "ILLEGAL ",
  364. "ILLEGAL ",
  365. "ILLEGAL ",
  366.  
  367. };
  368.  
  369. ////////////////////////////////////////////////////////////////////////////////
  370. // Simulator/Emulator (Start) //
  371. ////////////////////////////////////////////////////////////////////////////////
  372. BYTE fetch()
  373. {
  374. BYTE byte = 0;
  375.  
  376. if ((ProgramCounter >= 0) && (ProgramCounter <= MEMORY_SIZE))
  377. {
  378. memory_in_range = true;
  379. byte = Memory[ProgramCounter];
  380. ProgramCounter++;
  381. }
  382. else
  383. {
  384. memory_in_range = false;
  385. }
  386. return byte;
  387. }
  388.  
  389. void set_flag_n(BYTE inReg) {
  390. BYTE reg;
  391. reg = inReg;
  392. if ((reg & 0x80) != 0) // msbit set
  393. {
  394. Flags = Flags | FLAG_N;
  395. }
  396. else
  397. {
  398. Flags = Flags & (0xFF - FLAG_N);
  399. }
  400. }
  401.  
  402.  
  403. void set_flag_v(BYTE in1, BYTE in2, BYTE out1)
  404. {
  405. BYTE reg1in;
  406. BYTE reg2in;
  407. BYTE regOut;
  408.  
  409. reg1in = in1;
  410. reg2in = in2;
  411. regOut = out1;
  412.  
  413. if ((((reg1in & 0x80) == 0x80) && ((reg2in & 0x80) == 0x80) && ((regOut & 0x80) != 0x80)) //overflow
  414. || (((reg1in & 0x80) != 0x80) && ((reg2in & 0x80) != 0x80) && ((regOut & 0x80) == 0x80))) //overflow
  415. {
  416. Flags = Flags | FLAG_V;
  417. }
  418.  
  419. else
  420. {
  421. Flags = Flags & (0xFF - FLAG_V);
  422. }
  423. }
  424.  
  425.  
  426. void set_flag_z(BYTE inReg) {
  427. BYTE reg;
  428. reg = inReg;
  429. if (reg == 0) // zero set
  430. {
  431. Flags = Flags | FLAG_Z;
  432. }
  433. else
  434. {
  435. Flags = Flags & (0xFF - FLAG_Z);
  436. }
  437. }
  438.  
  439.  
  440. void Group_1(BYTE opcode) {
  441. BYTE LB = 0;
  442. BYTE HB = 0;
  443.  
  444. WORD address = 0;
  445. WORD data = 0;
  446. WORD param1;
  447. WORD param2;
  448. WORD temp_word;
  449. WORD offset;
  450.  
  451. switch (opcode) {
  452. case 0xB7: //LD Immidiate
  453. data = fetch();
  454. Registers[REGISTER_A] = data;
  455. set_flag_n(Registers[REGISTER_A]);
  456. set_flag_z(Registers[REGISTER_A]);
  457. Flags = Flags & (0xFF - FLAG_C);
  458. break;
  459.  
  460. case 0xC7:
  461. HB = fetch();
  462. LB = fetch();
  463. address += (WORD)((WORD)HB << 8) + LB;
  464. if (address >= 0 && address < MEMORY_SIZE) {
  465. Registers[REGISTER_A] = Memory[address];
  466. }
  467. set_flag_n(Registers[REGISTER_A]);
  468. set_flag_z(Registers[REGISTER_A]);
  469. Flags = Flags & (0xFF - FLAG_C);
  470. break;
  471.  
  472. case 0xD7:
  473. address += IndexRegister;
  474. HB = fetch(); LB = fetch();
  475. address += (WORD)((WORD)HB << 8) + LB;
  476. if (address >= 0 && address < MEMORY_SIZE) {
  477. Registers[REGISTER_A] = Memory[address];
  478. }
  479. set_flag_n(Registers[REGISTER_A]);
  480. set_flag_z(Registers[REGISTER_A]);
  481. Flags = Flags & (0xFF - FLAG_C);
  482. break;
  483.  
  484. ///-------------ST------------///
  485.  
  486. case 0x10:
  487. HB = fetch();
  488. LB = fetch(); address += (WORD)((WORD)HB << 8) + LB;
  489. if (address >= 0 && address < MEMORY_SIZE) {
  490. Memory[address] = Registers[REGISTER_A];
  491. }
  492. set_flag_n(Registers[REGISTER_A]);
  493. set_flag_z(Registers[REGISTER_A]);
  494. Flags = Flags & (0xFF - FLAG_C);
  495. break;
  496.  
  497. case 0x20:
  498. address += IndexRegister;
  499. HB = fetch();
  500. LB = fetch();
  501. address += (WORD)((WORD)HB << 8) + LB
  502. ; if (address >= 0 && address < MEMORY_SIZE) {
  503. Memory[address] = Registers[REGISTER_A];
  504. }
  505. set_flag_n(Registers[REGISTER_A]);
  506. set_flag_z(Registers[REGISTER_A]);
  507. Flags = Flags & (0xFF - FLAG_C);
  508. break;
  509.  
  510. ////------MVI------///
  511.  
  512. case 0x2A:
  513. data = fetch();
  514. Registers[REGISTER_B] = data;
  515. set_flag_n(Registers[REGISTER_A]);
  516. set_flag_z(Registers[REGISTER_A]);
  517. Flags = Flags & (0xFF - FLAG_C);
  518. break;
  519.  
  520. case 0x2B:
  521. data = fetch();
  522. Registers[REGISTER_C] = data;
  523. set_flag_n(Registers[REGISTER_A]);
  524. set_flag_z(Registers[REGISTER_A]);
  525. Flags = Flags & (0xFF - FLAG_C);
  526. break;
  527.  
  528. case 0x2C:
  529. data = fetch();
  530. Registers[REGISTER_D] = data;
  531. set_flag_n(Registers[REGISTER_A]);
  532. set_flag_z(Registers[REGISTER_A]);
  533. Flags = Flags & (0xFF - FLAG_C);
  534. break;
  535.  
  536. case 0x2D:
  537. data = fetch();
  538. Registers[REGISTER_E] = data;
  539. set_flag_n(Registers[REGISTER_A]);
  540. set_flag_z(Registers[REGISTER_A]);
  541. Flags = Flags & (0xFF - FLAG_C);
  542. break;
  543.  
  544. case 0x2E:
  545. data = fetch();
  546. Registers[REGISTER_L] = data;
  547. set_flag_n(Registers[REGISTER_A]);
  548. set_flag_z(Registers[REGISTER_A]);
  549. Flags = Flags & (0xFF - FLAG_C);
  550. break;
  551.  
  552. case 0x2F:
  553. data = fetch();
  554. Registers[REGISTER_H] = data;
  555. set_flag_n(Registers[REGISTER_A]);
  556. set_flag_z(Registers[REGISTER_A]);
  557. Flags = Flags & (0xFF - FLAG_C);
  558. break;
  559. ////----LODS-----///
  560. case 0x4F:
  561. data = fetch();
  562. StackPointer = data << 8;
  563. StackPointer += fetch();
  564. break;
  565.  
  566. case 0x5f:
  567. HB = fetch();
  568. LB = fetch();
  569. address += (WORD)((WORD)HB << 8) + LB;
  570. if (address >= 0 && address < MEMORY_SIZE - 1) {
  571. StackPointer = (WORD)Memory[address] << 8;
  572. StackPointer += Memory[address + 1];
  573. }
  574. break;
  575.  
  576. case 0x6f:
  577. address += IndexRegister;
  578. HB = fetch();
  579. LB = fetch();
  580. address += (WORD)((WORD)HB << 8) + LB;
  581. if (address >= 0 && address < MEMORY_SIZE - 1) {
  582. StackPointer = (WORD)Memory[address] << 8;
  583. StackPointer += Memory[address + 1];
  584. }
  585. break;
  586.  
  587. /*
  588. * Opcode: LDX
  589. * Description: Loads Memory into register X
  590. * Flags: - - T - T - - 0
  591. * Notes: None
  592. */
  593. case 0x4E: //LDX IMMEDIATE ADDRESSING (#)
  594. data = fetch();
  595. Registers[IndexRegister] = data;
  596.  
  597. set_flag_n(Registers[IndexRegister]);
  598. set_flag_z(Registers[IndexRegister]);
  599. Flags = Flags & (0xFF - FLAG_C);
  600. break;
  601.  
  602. case 0x5E: //LDX ABSOLUTE ADDRESSING (abs)
  603. HB = fetch();
  604. LB = fetch();
  605. address += (WORD)((WORD)HB << 8) + LB;
  606. if (address >= 0 && address < MEMORY_SIZE) {
  607. Registers[IndexRegister] = Memory[address];
  608. }
  609.  
  610. set_flag_n(Registers[IndexRegister]);
  611. set_flag_z(Registers[IndexRegister]);
  612. Flags = Flags & (0xFF - FLAG_C);
  613. break;
  614.  
  615. case 0x6E: //LDX INDEXED ABSOLUTE ADDRESSING (abs,X)
  616. address += IndexRegister;
  617. HB = fetch();
  618. LB = fetch();
  619. address += (WORD)((WORD)HB << 8) + LB;
  620. if (address >= 0 && address < MEMORY_SIZE) {
  621. Registers[IndexRegister] = Memory[address];
  622. }
  623.  
  624. set_flag_n(Registers[IndexRegister]);
  625. set_flag_z(Registers[IndexRegister]);
  626. Flags = Flags & (0xFF - FLAG_C);
  627. break;
  628.  
  629. /*
  630. * Opcode: STOX
  631. * Description: Stores register X into Memory
  632. * Flags: - - T - T - - 0
  633. * Notes: None
  634. */
  635. case 0x50: //STOX ABSOLUTE ADDRESSING (abs)
  636. address += IndexRegister;
  637. HB = fetch();
  638. LB = fetch();
  639. address += (WORD)((WORD)HB << 8) + LB;
  640. if (address >= 0 && address < MEMORY_SIZE) {
  641. Memory[address] = Registers[IndexRegister];
  642. }
  643.  
  644. set_flag_n(Registers[IndexRegister]);
  645. set_flag_z(Registers[IndexRegister]);
  646. Flags = Flags & (0xFF - FLAG_C);
  647. break;
  648.  
  649. case 0x60: //STOX INDEXED ABSOLUTE ADDRESSING (abs, X)
  650. address += IndexRegister;
  651. HB = fetch();
  652. LB = fetch();
  653. address += (WORD)((WORD)HB << 8) + LB;
  654. if (address >= 0 && address < MEMORY_SIZE) {
  655. Memory[address] = Registers[IndexRegister];
  656. }
  657.  
  658. set_flag_n(Registers[IndexRegister]);
  659. set_flag_z(Registers[IndexRegister]);
  660. Flags = Flags & (0xFF - FLAG_C);
  661. break;
  662.  
  663.  
  664. /////-----ADC-----/////
  665.  
  666. case 0x90:
  667. param1 = Registers[REGISTER_A];
  668. param2 = Registers[REGISTER_B];
  669. temp_word = (WORD)param1 + (WORD)param2;
  670. if ((Flags & FLAG_C) != 0) {
  671. temp_word++;
  672. }
  673. if (temp_word >= 0x100) {
  674. Flags = Flags | FLAG_C; // Set carry flag
  675. }
  676. else {
  677. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  678. }
  679. set_flag_n((BYTE)temp_word);
  680. set_flag_z((BYTE)temp_word);
  681. set_flag_v(param1, param2, (BYTE)temp_word);
  682. Registers[REGISTER_A] = (BYTE)temp_word;
  683. break;
  684.  
  685. case 0xA0:
  686. param1 = Registers[REGISTER_A];
  687. param2 = Registers[REGISTER_C];
  688. temp_word = (WORD)param1 + (WORD)param2;
  689. if ((Flags & FLAG_C) != 0) {
  690. temp_word++;
  691. }
  692. if (temp_word >= 0x100) {
  693. Flags = Flags | FLAG_C; // Set carry flag
  694. }
  695. else {
  696. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  697. }
  698. set_flag_n((BYTE)temp_word);
  699. set_flag_z((BYTE)temp_word);
  700. set_flag_v(param1, param2, (BYTE)temp_word);
  701. Registers[REGISTER_A] = (BYTE)temp_word;
  702. break;
  703.  
  704. case 0xB0:
  705. param1 = Registers[REGISTER_A];
  706. param2 = Registers[REGISTER_D];
  707. temp_word = (WORD)param1 + (WORD)param2;
  708. if ((Flags & FLAG_C) != 0) {
  709. temp_word++;
  710. }
  711. if (temp_word >= 0x100) {
  712. Flags = Flags | FLAG_C; // Set carry flag
  713. }
  714. else {
  715. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  716. }
  717. set_flag_n((BYTE)temp_word);
  718. set_flag_z((BYTE)temp_word);
  719. set_flag_v(param1, param2, (BYTE)temp_word);
  720. Registers[REGISTER_A] = (BYTE)temp_word;
  721. break;
  722.  
  723. case 0xC0:
  724. param1 = Registers[REGISTER_A];
  725. param2 = Registers[REGISTER_E];
  726. temp_word = (WORD)param1 + (WORD)param2;
  727. if ((Flags & FLAG_C) != 0) {
  728. temp_word++;
  729. }
  730. if (temp_word >= 0x100) {
  731. Flags = Flags | FLAG_C; // Set carry flag
  732. }
  733. else {
  734. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  735. }
  736. set_flag_n((BYTE)temp_word);
  737. set_flag_z((BYTE)temp_word);
  738. set_flag_v(param1, param2, (BYTE)temp_word);
  739. Registers[REGISTER_A] = (BYTE)temp_word;
  740. break;
  741.  
  742. case 0xD0:
  743. param1 = Registers[REGISTER_A];
  744. param2 = Registers[REGISTER_L];
  745. temp_word = (WORD)param1 + (WORD)param2;
  746. if ((Flags & FLAG_C) != 0) {
  747. temp_word++;
  748. }
  749. if (temp_word >= 0x100) {
  750. Flags = Flags | FLAG_C; // Set carry flag
  751. }
  752. else {
  753. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  754. }
  755. set_flag_n((BYTE)temp_word);
  756. set_flag_z((BYTE)temp_word);
  757. set_flag_v(param1, param2, (BYTE)temp_word);
  758. Registers[REGISTER_A] = (BYTE)temp_word;
  759. break;
  760.  
  761. case 0xE0:
  762. param1 = Registers[REGISTER_A];
  763. param2 = Registers[REGISTER_H];
  764. temp_word = (WORD)param1 + (WORD)param2;
  765. if ((Flags & FLAG_C) != 0) {
  766. temp_word++;
  767. }
  768. if (temp_word >= 0x100) {
  769. Flags = Flags | FLAG_C; // Set carry flag
  770. }
  771. else {
  772. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  773. }
  774. set_flag_n((BYTE)temp_word);
  775. set_flag_z((BYTE)temp_word);
  776. set_flag_v(param1, param2, (BYTE)temp_word);
  777. Registers[REGISTER_A] = (BYTE)temp_word;
  778. break;
  779.  
  780. case 0xF0:
  781. param1 = Registers[REGISTER_A];
  782. param2 = Registers[REGISTER_M];
  783. temp_word = (WORD)param1 + (WORD)param2;
  784. if ((Flags & FLAG_C) != 0) {
  785. temp_word++;
  786. }
  787. if (temp_word >= 0x100) {
  788. Flags = Flags | FLAG_C; // Set carry flag
  789. }
  790. else {
  791. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  792. }
  793. set_flag_n((BYTE)temp_word);
  794. set_flag_z((BYTE)temp_word);
  795. set_flag_v(param1, param2, (BYTE)temp_word);
  796. Registers[REGISTER_A] = (BYTE)temp_word;
  797. break;
  798.  
  799. /////-------CMP--------/////
  800.  
  801. case 0x92:
  802. param1 = Registers[REGISTER_A];
  803. param2 = Registers[REGISTER_B];
  804. temp_word = (WORD)param1 - (WORD)param2;
  805. if (temp_word >= 0x100) {
  806. Flags = Flags | FLAG_C; // Set carry flag
  807. }
  808. else {
  809. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  810. }
  811. set_flag_n((BYTE)temp_word);
  812. set_flag_z((BYTE)temp_word);
  813. set_flag_v(param1, param2, (BYTE)temp_word);
  814. break;
  815.  
  816. case 0xA2:
  817. param1 = Registers[REGISTER_A];
  818. param2 = Registers[REGISTER_C];
  819. temp_word = (WORD)param1 - (WORD)param2;
  820. if (temp_word >= 0x100) {
  821. Flags = Flags | FLAG_C; // Set carry flag
  822. }
  823. else {
  824. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  825. }
  826. set_flag_n((BYTE)temp_word);
  827. set_flag_z((BYTE)temp_word);
  828. set_flag_v(param1, param2, (BYTE)temp_word);
  829. break;
  830.  
  831. case 0xB2:
  832. param1 = Registers[REGISTER_A];
  833. param2 = Registers[REGISTER_D];
  834. temp_word = (WORD)param1 - (WORD)param2;
  835. if (temp_word >= 0x100) {
  836. Flags = Flags | FLAG_C; // Set carry flag
  837. }
  838. else {
  839. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  840. }
  841. set_flag_n((BYTE)temp_word);
  842. set_flag_z((BYTE)temp_word);
  843. set_flag_v(param1, param2, (BYTE)temp_word);
  844. break;
  845.  
  846. case 0xC2:
  847. param1 = Registers[REGISTER_A];
  848. param2 = Registers[REGISTER_E];
  849. temp_word = (WORD)param1 - (WORD)param2;
  850. if (temp_word >= 0x100) {
  851. Flags = Flags | FLAG_C; // Set carry flag
  852. }
  853. else {
  854. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  855. }
  856. set_flag_n((BYTE)temp_word);
  857. set_flag_z((BYTE)temp_word);
  858. set_flag_v(param1, param2, (BYTE)temp_word);
  859. break;
  860.  
  861. case 0xD2:
  862. param1 = Registers[REGISTER_A];
  863. param2 = Registers[REGISTER_L];
  864. temp_word = (WORD)param1 - (WORD)param2;
  865. if (temp_word >= 0x100) {
  866. Flags = Flags | FLAG_C; // Set carry flag
  867. }
  868. else {
  869. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  870. }
  871. set_flag_n((BYTE)temp_word);
  872. set_flag_z((BYTE)temp_word);
  873. set_flag_v(param1, param2, (BYTE)temp_word);
  874. break;
  875.  
  876. case 0xE2:
  877. param1 = Registers[REGISTER_A];
  878. param2 = Registers[REGISTER_H];
  879. temp_word = (WORD)param1 - (WORD)param2;
  880. if (temp_word >= 0x100) {
  881. Flags = Flags | FLAG_C; // Set carry flag
  882. }
  883. else {
  884. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  885. }
  886. set_flag_n((BYTE)temp_word);
  887. set_flag_z((BYTE)temp_word);
  888. set_flag_v(param1, param2, (BYTE)temp_word);
  889. break;
  890.  
  891. case 0xF2:
  892. param1 = Registers[REGISTER_A];
  893. param2 = Registers[REGISTER_M];
  894. temp_word = (WORD)param1 - (WORD)param2;
  895. if (temp_word >= 0x100) {
  896. Flags = Flags | FLAG_C; // Set carry flag
  897. }
  898. else {
  899. Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
  900. }
  901. set_flag_n((BYTE)temp_word);
  902. set_flag_z((BYTE)temp_word);
  903. set_flag_v(param1, param2, (BYTE)temp_word);
  904. break;
  905.  
  906.  
  907. //////-----------TSA-------------//////
  908.  
  909. case 0x75:
  910. Registers[REGISTER_A] = Flags;
  911. break;
  912.  
  913.  
  914. //////-----------TAS-------------//////
  915.  
  916. case 0x74:
  917. Flags = Registers[REGISTER_A];
  918. break;
  919.  
  920. //////-----------SEC-------------//////
  921. case 0x16:
  922. Flags = Flags | FLAG_C;
  923. break;
  924.  
  925. /////-----------CLC----------/////
  926.  
  927. case 0x15:
  928. Flags = Flags & (0xFF - FLAG_C);
  929. break;
  930.  
  931. /////----------CLI------------/////
  932. case 0x17:
  933. Flags = Flags & (0xFF - FLAG_I);
  934. break;
  935. /////----------STI------------/////
  936. case 0x18:
  937. Flags = Flags | FLAG_I;
  938. break;
  939.  
  940. /////----------SEV------------/////
  941. Flags = Flags | FLAG_V;
  942.  
  943. /////----------CLV------------/////
  944. Flags = Flags & (0xFF - FLAG_V);
  945.  
  946. /////-----------PSH-----------/////
  947. case 0x11:
  948. if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  949. Memory[StackPointer] = Registers[REGISTER_A];
  950. StackPointer--;
  951. }
  952. break;
  953.  
  954. case 0x21:
  955. Memory[StackPointer] = Flags;
  956. StackPointer--;
  957. break;
  958.  
  959. case 0x31:
  960. if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  961. Memory[StackPointer] = Registers[REGISTER_B];
  962. StackPointer--;
  963. }
  964. break;
  965.  
  966. case 0x41:
  967. if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  968. Memory[StackPointer] = Registers[REGISTER_C];
  969. StackPointer--;
  970. }
  971. break;
  972.  
  973. case 0x51:
  974. if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  975. Memory[StackPointer] = Registers[REGISTER_D];
  976. StackPointer--;
  977. }
  978. break;
  979.  
  980. case 0x61:
  981. if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  982. Memory[StackPointer] = Registers[REGISTER_E];
  983. StackPointer--;
  984. }
  985. break;
  986.  
  987. case 0x71:
  988. if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  989. Memory[StackPointer] = Registers[REGISTER_L];
  990. StackPointer--;
  991. }
  992. break;
  993.  
  994. case 0x81:
  995. if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
  996. Memory[StackPointer] = Registers[REGISTER_H];
  997. StackPointer--;
  998. }
  999. break;
  1000.  
  1001. /////-----------POP------------////
  1002.  
  1003. case 0x12:
  1004. if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  1005. StackPointer++;
  1006. Registers[REGISTER_A] = Memory[StackPointer];
  1007. }
  1008. break;
  1009.  
  1010. case 0x22:
  1011. StackPointer++;
  1012. Flags = Memory[StackPointer];
  1013. break;
  1014.  
  1015. case 0x32:
  1016. if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  1017. StackPointer++;
  1018. Registers[REGISTER_B] = Memory[StackPointer];
  1019. }
  1020. break;
  1021.  
  1022. case 0x42:
  1023. if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  1024. StackPointer++;
  1025. Registers[REGISTER_C] = Memory[StackPointer];
  1026. }
  1027. break;
  1028.  
  1029. case 0x52:
  1030. if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  1031. StackPointer++;
  1032. Registers[REGISTER_D] = Memory[StackPointer];
  1033. }
  1034. break;
  1035.  
  1036. case 0x62:
  1037. if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  1038. StackPointer++;
  1039. Registers[REGISTER_E] = Memory[StackPointer];
  1040. }
  1041. break;
  1042.  
  1043. case 0x72:
  1044. if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  1045. StackPointer++;
  1046. Registers[REGISTER_L] = Memory[StackPointer];
  1047. }
  1048. break;
  1049.  
  1050. case 0x82:
  1051. if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
  1052. StackPointer++;
  1053. Registers[REGISTER_H] = Memory[StackPointer];
  1054. }
  1055. break;
  1056.  
  1057. //////------JMP------//////
  1058. case 0xFA:
  1059. HB = fetch();
  1060. LB = fetch();
  1061. address = ((WORD)HB << 8) + (WORD)LB;
  1062. ProgramCounter = address;
  1063. break;
  1064.  
  1065. //////-----JPR-----------////
  1066. case 0x33:
  1067. HB = fetch();
  1068. LB = fetch();
  1069. address = ((WORD)HB << 8) + (WORD)LB;
  1070. ProgramCounter = address;
  1071. break;
  1072.  
  1073. /////------RTN---------/////
  1074. case 0x0E:
  1075. HB = fetch();
  1076. LB = fetch();
  1077. address = ((WORD)HB << 8) + (WORD)LB;
  1078. if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 2)) {
  1079. StackPointer++;
  1080. HB = Memory[StackPointer];
  1081. StackPointer++;
  1082. LB = Memory[StackPointer];
  1083. }
  1084. ProgramCounter = ((WORD)HB << 8) + (WORD)LB;
  1085. break;
  1086.  
  1087. /////------BRA-------/////
  1088. case 0x00:
  1089. LB = fetch();
  1090. offset = (WORD)LB;
  1091. if ((offset & 0x80) != 0) {
  1092. offset = offset + 0xFF00;
  1093. }
  1094. address = ProgramCounter + offset;
  1095. break;
  1096.  
  1097. /////------BCC-------/////
  1098. case 0x01:
  1099. LB = fetch();
  1100. if ((Flags & FLAG_C) == 0) {
  1101. offset = (WORD)LB;
  1102. if ((offset & 0x80) != 0) {
  1103. offset = offset + 0xFF00;
  1104. }
  1105. address = ProgramCounter + offset;
  1106. ProgramCounter = address;
  1107. }
  1108.  
  1109. break;
  1110. }
  1111. }
  1112.  
  1113. void Group_2_Move(BYTE opcode) {
  1114. WORD address = 0;
  1115.  
  1116. BYTE source = opcode >> 4;
  1117. BYTE dest = opcode & 0x0F;
  1118. int destReg = 0;
  1119. int sourceReg = 0;
  1120. /*---------------------------------MOVE DEST---------------------------------*/
  1121. switch (dest) {
  1122. case 0x08:
  1123. destReg = REGISTER_A;
  1124. break;
  1125.  
  1126. case 0x09:
  1127. destReg = REGISTER_B;
  1128. break;
  1129.  
  1130. case 0x0A:
  1131. destReg = REGISTER_C;
  1132. break;
  1133.  
  1134. case 0x0B:
  1135. destReg = REGISTER_D;
  1136. break;
  1137.  
  1138. case 0x0C:
  1139. destReg = REGISTER_E;
  1140. break;
  1141.  
  1142. case 0x0D:
  1143. destReg = REGISTER_L;
  1144. break;
  1145.  
  1146. case 0x0E:
  1147. destReg = REGISTER_H;
  1148. break;
  1149.  
  1150. case 0x0F:
  1151. destReg = REGISTER_M;
  1152. break;
  1153. }
  1154.  
  1155. /*--------------------------------MOVE SOURCE--------------------------------*/
  1156. switch (source) {
  1157. case 0x07:
  1158. sourceReg = REGISTER_A;
  1159. break;
  1160.  
  1161. case 0x08:
  1162. sourceReg = REGISTER_B;
  1163. break;
  1164.  
  1165. case 0x09:
  1166. sourceReg = REGISTER_C;
  1167. break;
  1168.  
  1169. case 0x0A:
  1170. sourceReg = REGISTER_D;
  1171. break;
  1172.  
  1173. case 0x0B:
  1174. sourceReg = REGISTER_E;
  1175. break;
  1176.  
  1177. case 0x0C:
  1178. sourceReg = REGISTER_L;
  1179. break;
  1180.  
  1181. case 0x0D:
  1182. sourceReg = REGISTER_H;
  1183. break;
  1184.  
  1185. case 0x0E:
  1186. sourceReg = REGISTER_M;
  1187. break;
  1188. }
  1189.  
  1190. if (sourceReg == REGISTER_M) {
  1191. address = Registers[REGISTER_L];
  1192. address += (WORD)Registers[REGISTER_H] << 8;
  1193. Registers[destReg] = Memory[address];
  1194. }
  1195. Registers[destReg] = Registers[sourceReg];
  1196.  
  1197. if (destReg == REGISTER_M) {
  1198. address = Registers[REGISTER_L];
  1199. address += (WORD)Registers[REGISTER_H] << 8;
  1200. Memory[address] = Registers[REGISTER_M];
  1201. }
  1202. }
  1203.  
  1204.  
  1205.  
  1206. void execute(BYTE opcode)
  1207. {
  1208. if (((opcode >= 0x78) && (opcode <= 0x7F))
  1209. || ((opcode >= 0x88) && (opcode <= 0x8F))
  1210. || ((opcode >= 0x98) && (opcode <= 0x9F))
  1211. || ((opcode >= 0xA8) && (opcode <= 0xAF))
  1212. || ((opcode >= 0xB8) && (opcode <= 0xBF))
  1213. || ((opcode >= 0xC8) && (opcode <= 0xCF))
  1214. || ((opcode >= 0xD8) && (opcode <= 0xDF))
  1215. || ((opcode >= 0xE8) && (opcode <= 0xEF)))
  1216. {
  1217. Group_2_Move(opcode);
  1218. }
  1219. else
  1220. {
  1221. Group_1(opcode);
  1222. }
  1223. }
  1224.  
  1225. void emulate()
  1226. {
  1227. BYTE opcode;
  1228. int sanity;
  1229. ProgramCounter = 0;
  1230. halt = false;
  1231. memory_in_range = true;
  1232. sanity = 0;
  1233.  
  1234. printf(" A B C D E L H X SP\n");
  1235. while ((!halt) && (memory_in_range)) {
  1236. sanity++;
  1237. if (sanity > 500) halt = true;
  1238. printf("%04X ", ProgramCounter); // Print current address
  1239. opcode = fetch();
  1240. execute(opcode);
  1241.  
  1242. printf("%s ", opcode_mneumonics[opcode]); // Print current opcode
  1243.  
  1244. printf("%02X ", Registers[REGISTER_A]);
  1245. printf("%02X ", Registers[REGISTER_B]);
  1246. printf("%02X ", Registers[REGISTER_C]);
  1247. printf("%02X ", Registers[REGISTER_D]);
  1248. printf("%02X ", Registers[REGISTER_E]);
  1249. printf("%02X ", Registers[REGISTER_L]);
  1250. printf("%02X ", Registers[REGISTER_H]);
  1251. printf("%04X ", IndexRegister);
  1252. printf("%04X ", StackPointer); // Print Stack Pointer
  1253.  
  1254. if ((Flags & FLAG_I) == FLAG_I)
  1255. {
  1256. printf("I=1 ");
  1257. }
  1258. else
  1259. {
  1260. printf("I=0 ");
  1261. }
  1262. if ((Flags & FLAG_N) == FLAG_N)
  1263. {
  1264. printf("N=1 ");
  1265. }
  1266. else
  1267. {
  1268. printf("N=0 ");
  1269. }
  1270. if ((Flags & FLAG_V) == FLAG_V)
  1271. {
  1272. printf("V=1 ");
  1273. }
  1274. else
  1275. {
  1276. printf("V=0 ");
  1277. }
  1278. if ((Flags & FLAG_Z) == FLAG_Z)
  1279. {
  1280. printf("Z=1 ");
  1281. }
  1282. else
  1283. {
  1284. printf("Z=0 ");
  1285. }
  1286. if ((Flags & FLAG_C) == FLAG_C)
  1287. {
  1288. printf("C=1 ");
  1289. }
  1290. else
  1291. {
  1292. printf("C=0 ");
  1293. }
  1294.  
  1295. printf("\n"); // New line
  1296. }
  1297.  
  1298. printf("\n"); // New line
  1299. }
  1300.  
  1301.  
  1302. ////////////////////////////////////////////////////////////////////////////////
  1303. // Simulator/Emulator (End) //
  1304. ////////////////////////////////////////////////////////////////////////////////
  1305.  
  1306.  
  1307. void initialise_filenames() {
  1308. int i;
  1309.  
  1310. for (i = 0; i < MAX_FILENAME_SIZE; i++) {
  1311. hex_file[i] = '\0';
  1312. trc_file[i] = '\0';
  1313. }
  1314. }
  1315.  
  1316.  
  1317.  
  1318.  
  1319. int find_dot_position(char* filename) {
  1320. int dot_position;
  1321. int i;
  1322. char chr;
  1323.  
  1324. dot_position = 0;
  1325. i = 0;
  1326. chr = filename[i];
  1327.  
  1328. while (chr != '\0') {
  1329. if (chr == '.') {
  1330. dot_position = i;
  1331. }
  1332. i++;
  1333. chr = filename[i];
  1334. }
  1335.  
  1336. return (dot_position);
  1337. }
  1338.  
  1339.  
  1340. int find_end_position(char* filename) {
  1341. int end_position;
  1342. int i;
  1343. char chr;
  1344.  
  1345. end_position = 0;
  1346. i = 0;
  1347. chr = filename[i];
  1348.  
  1349. while (chr != '\0') {
  1350. end_position = i;
  1351. i++;
  1352. chr = filename[i];
  1353. }
  1354.  
  1355. return (end_position);
  1356. }
  1357.  
  1358.  
  1359. bool file_exists(char* filename) {
  1360. bool exists;
  1361. FILE* ifp;
  1362.  
  1363. exists = false;
  1364.  
  1365. if ((ifp = fopen(filename, "r")) != NULL) {
  1366. exists = true;
  1367.  
  1368. fclose(ifp);
  1369. }
  1370.  
  1371. return (exists);
  1372. }
  1373.  
  1374.  
  1375.  
  1376. void create_file(char* filename) {
  1377. FILE* ofp;
  1378.  
  1379. if ((ofp = fopen(filename, "w")) != NULL) {
  1380. fclose(ofp);
  1381. }
  1382. }
  1383.  
  1384.  
  1385.  
  1386. bool getline(FILE* fp, char* buffer) {
  1387. bool rc;
  1388. bool collect;
  1389. char c;
  1390. int i;
  1391.  
  1392. rc = false;
  1393. collect = true;
  1394.  
  1395. i = 0;
  1396. while (collect) {
  1397. c = getc(fp);
  1398.  
  1399. switch (c) {
  1400. case EOF:
  1401. if (i > 0) {
  1402. rc = true;
  1403. }
  1404. collect = false;
  1405. break;
  1406.  
  1407. case '\n':
  1408. if (i > 0) {
  1409. rc = true;
  1410. collect = false;
  1411. buffer[i] = '\0';
  1412. }
  1413. break;
  1414.  
  1415. default:
  1416. buffer[i] = c;
  1417. i++;
  1418. break;
  1419. }
  1420. }
  1421.  
  1422. return (rc);
  1423. }
  1424.  
  1425.  
  1426.  
  1427.  
  1428.  
  1429.  
  1430. void load_and_run(int args, _TCHAR** argv) {
  1431. char chr;
  1432. int ln;
  1433. int dot_position;
  1434. int end_position;
  1435. long i;
  1436. FILE* ifp;
  1437. long address;
  1438. long load_at;
  1439. int code;
  1440.  
  1441. // Prompt for the .hex file
  1442.  
  1443. printf("\n");
  1444. printf("Enter the hex filename (.hex): ");
  1445.  
  1446. if (args == 2) {
  1447. ln = 0;
  1448. chr = argv[1][ln];
  1449. while (chr != '\0')
  1450. {
  1451. if (ln < MAX_FILENAME_SIZE)
  1452. {
  1453. hex_file[ln] = chr;
  1454. trc_file[ln] = chr;
  1455. ln++;
  1456. }
  1457. chr = argv[1][ln];
  1458. }
  1459. }
  1460. else {
  1461. ln = 0;
  1462. chr = '\0';
  1463. while (chr != '\n') {
  1464. chr = getchar();
  1465.  
  1466. switch (chr) {
  1467. case '\n':
  1468. break;
  1469. default:
  1470. if (ln < MAX_FILENAME_SIZE) {
  1471. hex_file[ln] = chr;
  1472. trc_file[ln] = chr;
  1473. ln++;
  1474. }
  1475. break;
  1476. }
  1477. }
  1478.  
  1479. }
  1480. // Tidy up the file names
  1481.  
  1482. dot_position = find_dot_position(hex_file);
  1483. if (dot_position == 0) {
  1484. end_position = find_end_position(hex_file);
  1485.  
  1486. hex_file[end_position + 1] = '.';
  1487. hex_file[end_position + 2] = 'h';
  1488. hex_file[end_position + 3] = 'e';
  1489. hex_file[end_position + 4] = 'x';
  1490. hex_file[end_position + 5] = '\0';
  1491. }
  1492. else {
  1493. hex_file[dot_position + 0] = '.';
  1494. hex_file[dot_position + 1] = 'h';
  1495. hex_file[dot_position + 2] = 'e';
  1496. hex_file[dot_position + 3] = 'x';
  1497. hex_file[dot_position + 4] = '\0';
  1498. }
  1499.  
  1500. dot_position = find_dot_position(trc_file);
  1501. if (dot_position == 0) {
  1502. end_position = find_end_position(trc_file);
  1503.  
  1504. trc_file[end_position + 1] = '.';
  1505. trc_file[end_position + 2] = 't';
  1506. trc_file[end_position + 3] = 'r';
  1507. trc_file[end_position + 4] = 'c';
  1508. trc_file[end_position + 5] = '\0';
  1509. }
  1510. else {
  1511. trc_file[dot_position + 0] = '.';
  1512. trc_file[dot_position + 1] = 't';
  1513. trc_file[dot_position + 2] = 'r';
  1514. trc_file[dot_position + 3] = 'c';
  1515. trc_file[dot_position + 4] = '\0';
  1516. }
  1517.  
  1518. if (file_exists(hex_file)) {
  1519. // Clear Registers and Memory
  1520.  
  1521. Registers[REGISTER_A] = 0;
  1522. Registers[REGISTER_B] = 0;
  1523. Registers[REGISTER_C] = 0;
  1524. Registers[REGISTER_D] = 0;
  1525. Registers[REGISTER_E] = 0;
  1526. Registers[REGISTER_L] = 0;
  1527. Registers[REGISTER_H] = 0;
  1528. IndexRegister = 0;
  1529. Flags = 0;
  1530. ProgramCounter = 0;
  1531. StackPointer = 0;
  1532.  
  1533. for (i = 0; i < MEMORY_SIZE; i++) {
  1534. Memory[i] = 0x00;
  1535. }
  1536.  
  1537. // Load hex file
  1538.  
  1539. if ((ifp = fopen(hex_file, "r")) != NULL) {
  1540. printf("Loading file...\n\n");
  1541.  
  1542. load_at = 0;
  1543.  
  1544. while (getline(ifp, InputBuffer)) {
  1545. if (sscanf(InputBuffer, "L=%x", &address) == 1) {
  1546. load_at = address;
  1547. }
  1548. else if (sscanf(InputBuffer, "%x", &code) == 1) {
  1549. if ((load_at >= 0) && (load_at <= MEMORY_SIZE)) {
  1550. Memory[load_at] = (BYTE)code;
  1551. }
  1552. load_at++;
  1553. }
  1554. else {
  1555. printf("ERROR> Failed to load instruction: %s \n", InputBuffer);
  1556. }
  1557. }
  1558.  
  1559. fclose(ifp);
  1560. }
  1561.  
  1562. // Emulate
  1563.  
  1564. emulate();
  1565. }
  1566. else {
  1567. printf("\n");
  1568. printf("ERROR> Input file %s does not exist!\n", hex_file);
  1569. printf("\n");
  1570. }
  1571. }
  1572.  
  1573. void building(int args, _TCHAR** argv) {
  1574. char buffer[1024];
  1575. load_and_run(args, argv);
  1576. sprintf(buffer, "0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X,0x%02X",
  1577. Memory[TEST_ADDRESS_1],
  1578. Memory[TEST_ADDRESS_2],
  1579. Memory[TEST_ADDRESS_3],
  1580. Memory[TEST_ADDRESS_4],
  1581. Memory[TEST_ADDRESS_5],
  1582. Memory[TEST_ADDRESS_6],
  1583. Memory[TEST_ADDRESS_7],
  1584. Memory[TEST_ADDRESS_8],
  1585. Memory[TEST_ADDRESS_9],
  1586. Memory[TEST_ADDRESS_10],
  1587. Memory[TEST_ADDRESS_11],
  1588. Memory[TEST_ADDRESS_12]
  1589. );
  1590. sendto(sock, buffer, strlen(buffer), 0, (SOCKADDR*)&server_addr, sizeof(SOCKADDR));
  1591. }
  1592.  
  1593.  
  1594.  
  1595. void test_and_mark() {
  1596. char buffer[1024];
  1597. bool testing_complete;
  1598. int len = sizeof(SOCKADDR);
  1599. char chr;
  1600. int i;
  1601. int j;
  1602. bool end_of_program;
  1603. long address;
  1604. long load_at;
  1605. int code;
  1606. int mark;
  1607. int passed;
  1608.  
  1609. printf("\n");
  1610. printf("Automatic Testing and Marking\n");
  1611. printf("\n");
  1612.  
  1613. testing_complete = false;
  1614.  
  1615. sprintf(buffer, "Test Student %s", STUDENT_NUMBER);
  1616. sendto(sock, buffer, strlen(buffer), 0, (SOCKADDR*)&server_addr, sizeof(SOCKADDR));
  1617.  
  1618. while (!testing_complete) {
  1619. memset(buffer, '\0', sizeof(buffer));
  1620.  
  1621. if (recvfrom(sock, buffer, sizeof(buffer) - 1, 0, (SOCKADDR*)&client_addr, &len) != SOCKET_ERROR) {
  1622. printf("Incoming Data: %s \n", buffer);
  1623.  
  1624. //if (strcmp(buffer, "Testing complete") == 1)
  1625. if (sscanf(buffer, "Testing complete %d", &mark) == 1) {
  1626. testing_complete = true;
  1627. printf("Current mark = %d\n", mark);
  1628.  
  1629. }
  1630. else if (sscanf(buffer, "Tests passed %d", &passed) == 1) {
  1631. //testing_complete = true;
  1632. printf("Passed = %d\n", passed);
  1633.  
  1634. }
  1635. else if (strcmp(buffer, "Error") == 0) {
  1636. printf("ERROR> Testing abnormally terminated\n");
  1637. testing_complete = true;
  1638. }
  1639. else {
  1640. // Clear Registers and Memory
  1641.  
  1642. Registers[REGISTER_A] = 0;
  1643. Registers[REGISTER_B] = 0;
  1644. Registers[REGISTER_C] = 0;
  1645. Registers[REGISTER_D] = 0;
  1646. Registers[REGISTER_E] = 0;
  1647. Registers[REGISTER_L] = 0;
  1648. Registers[REGISTER_H] = 0;
  1649. IndexRegister = 0;
  1650. Flags = 0;
  1651. ProgramCounter = 0;
  1652. StackPointer = 0;
  1653. for (i = 0; i < MEMORY_SIZE; i++) {
  1654. Memory[i] = 0;
  1655. }
  1656.  
  1657. // Load hex file
  1658.  
  1659. i = 0;
  1660. j = 0;
  1661. load_at = 0;
  1662. end_of_program = false;
  1663. FILE* ofp;
  1664. fopen_s(&ofp, "branch.txt", "a");
  1665.  
  1666. while (!end_of_program) {
  1667. chr = buffer[i];
  1668. switch (chr) {
  1669. case '\0':
  1670. end_of_program = true;
  1671.  
  1672. case ',':
  1673. if (sscanf(InputBuffer, "L=%x", &address) == 1) {
  1674. load_at = address;
  1675. }
  1676. else if (sscanf(InputBuffer, "%x", &code) == 1) {
  1677. if ((load_at >= 0) && (load_at <= MEMORY_SIZE)) {
  1678. Memory[load_at] = (BYTE)code;
  1679. fprintf(ofp, "%02X\n", (BYTE)code);
  1680. }
  1681. load_at++;
  1682. }
  1683. else {
  1684. printf("ERROR> Failed to load instruction: %s \n", InputBuffer);
  1685. }
  1686. j = 0;
  1687. break;
  1688.  
  1689. default:
  1690. InputBuffer[j] = chr;
  1691. j++;
  1692. break;
  1693. }
  1694. i++;
  1695. }
  1696. fclose(ofp);
  1697. // Emulate
  1698.  
  1699. if (load_at > 1) {
  1700. emulate();
  1701. // Send and store results
  1702. sprintf(buffer, "%02X%02X %02X%02X %02X%02X %02X%02X %02X%02X %02X%02X",
  1703. Memory[TEST_ADDRESS_1],
  1704. Memory[TEST_ADDRESS_2],
  1705. Memory[TEST_ADDRESS_3],
  1706. Memory[TEST_ADDRESS_4],
  1707. Memory[TEST_ADDRESS_5],
  1708. Memory[TEST_ADDRESS_6],
  1709. Memory[TEST_ADDRESS_7],
  1710. Memory[TEST_ADDRESS_8],
  1711. Memory[TEST_ADDRESS_9],
  1712. Memory[TEST_ADDRESS_10],
  1713. Memory[TEST_ADDRESS_11],
  1714. Memory[TEST_ADDRESS_12]
  1715. );
  1716. sendto(sock, buffer, strlen(buffer), 0, (SOCKADDR*)&server_addr, sizeof(SOCKADDR));
  1717. }
  1718. }
  1719. }
  1720. }
  1721. }
  1722.  
  1723.  
  1724.  
  1725. int _tmain(int argc, _TCHAR* argv[])
  1726. {
  1727. char chr;
  1728. char dummy;
  1729.  
  1730. printf("\n");
  1731. printf("Microprocessor Emulator\n");
  1732. printf("UWE Computer and Network Systems Assignment 1\n");
  1733. printf("\n");
  1734.  
  1735. initialise_filenames();
  1736.  
  1737. if (WSAStartup(MAKEWORD(2, 2), &data) != 0) return(0);
  1738.  
  1739. sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); // Here we create our socket, which will be a UDP socket (SOCK_DGRAM).
  1740. if (!sock) {
  1741. // Creation failed!
  1742. }
  1743.  
  1744. memset(&server_addr, 0, sizeof(SOCKADDR_IN));
  1745. server_addr.sin_family = AF_INET;
  1746. server_addr.sin_addr.s_addr = inet_addr(IP_ADDRESS_SERVER);
  1747. server_addr.sin_port = htons(PORT_SERVER);
  1748.  
  1749. memset(&client_addr, 0, sizeof(SOCKADDR_IN));
  1750. client_addr.sin_family = AF_INET;
  1751. client_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  1752. client_addr.sin_port = htons(PORT_CLIENT);
  1753.  
  1754. chr = '\0';
  1755. while ((chr != 'e') && (chr != 'E'))
  1756. {
  1757. printf("\n");
  1758. printf("Please select option\n");
  1759. printf("L - Load and run a hex file\n");
  1760. printf("T - Have the server test and mark your emulator\n");
  1761. printf("E - Exit\n");
  1762. if (argc == 2) { building(argc, argv); exit(0); }
  1763. printf("Enter option: ");
  1764. chr = getchar();
  1765. if (chr != 0x0A)
  1766. {
  1767. dummy = getchar(); // read in the <CR>
  1768. }
  1769. printf("\n");
  1770.  
  1771. switch (chr)
  1772. {
  1773. case 'L':
  1774. case 'l':
  1775. load_and_run(argc, argv);
  1776. break;
  1777.  
  1778. case 'T':
  1779. case 't':
  1780. test_and_mark();
  1781. break;
  1782.  
  1783. default:
  1784. break;
  1785. }
  1786. }
  1787.  
  1788. closesocket(sock);
  1789. WSACleanup();
  1790.  
  1791.  
  1792. return 0;
  1793. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement