· 5 years ago · Feb 24, 2020, 11:14 PM
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
21SOCKADDR_IN server_addr;
22SOCKADDR_IN client_addr;
23
24SOCKET sock; // This is our socket, it is the handle to the IO address to read/write packets
25
26WSADATA data;
27
28char InputBuffer[MAX_BUFFER_SIZE];
29
30char hex_file[MAX_BUFFER_SIZE];
31char 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
51WORD IndexRegister;
52
53BYTE Registers[8];
54BYTE Flags;
55WORD ProgramCounter;
56WORD StackPointer;
57
58
59////////////
60// Memory //
61////////////
62
63#define MEMORY_SIZE 65536
64
65BYTE 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
85bool memory_in_range = true;
86bool halt = false;
87
88
89///////////////////////
90// Disassembly table //
91///////////////////////
92
93char 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////////////////////////////////////////////////////////////////////////////////
372BYTE 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
389void 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
403void 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
426void 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
440void 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
452 BYTE CF;
453 if ((Flags & FLAG_C) == FLAG_C) {
454 CF = 1;
455 }
456 else {
457 CF = 0;
458 }
459
460 BYTE NF;
461 if ((Flags & FLAG_N) == FLAG_N) {
462 NF = 1;
463 }
464 else {
465 NF = 0;
466 }
467
468 BYTE ZF;
469 if ((Flags & FLAG_Z) == FLAG_Z) {
470 ZF = 1;
471 }
472 else {
473 ZF = 0;
474 }
475
476 BYTE VF;
477 if ((Flags & FLAG_V) == FLAG_V) {
478 VF = 1;
479 }
480 else {
481 VF = 0;
482 }
483
484 switch (opcode) {
485 case 0xB7: //LD Immidiate
486 data = fetch();
487 Registers[REGISTER_A] = data;
488 set_flag_n(Registers[REGISTER_A]);
489 set_flag_z(Registers[REGISTER_A]);
490 Flags = Flags & (0xFF - FLAG_C);
491 break;
492
493 case 0xC7:
494 HB = fetch();
495 LB = fetch();
496 address += (WORD)((WORD)HB << 8) + LB;
497 if (address >= 0 && address < MEMORY_SIZE) {
498 Registers[REGISTER_A] = Memory[address];
499 }
500 set_flag_n(Registers[REGISTER_A]);
501 set_flag_z(Registers[REGISTER_A]);
502 Flags = Flags & (0xFF - FLAG_C);
503 break;
504
505 case 0xD7:
506 address += IndexRegister;
507 HB = fetch(); LB = fetch();
508 address += (WORD)((WORD)HB << 8) + LB;
509 if (address >= 0 && address < MEMORY_SIZE) {
510 Registers[REGISTER_A] = Memory[address];
511 }
512 set_flag_n(Registers[REGISTER_A]);
513 set_flag_z(Registers[REGISTER_A]);
514 Flags = Flags & (0xFF - FLAG_C);
515 break;
516
517 ///-------------ST------------///
518
519 case 0x10:
520 HB = fetch();
521 LB = fetch(); address += (WORD)((WORD)HB << 8) + LB;
522 if (address >= 0 && address < MEMORY_SIZE) {
523 Memory[address] = Registers[REGISTER_A];
524 }
525 set_flag_n(Registers[REGISTER_A]);
526 set_flag_z(Registers[REGISTER_A]);
527 Flags = Flags & (0xFF - FLAG_C);
528 break;
529
530 case 0x20:
531 address += IndexRegister;
532 HB = fetch();
533 LB = fetch();
534 address += (WORD)((WORD)HB << 8) + LB
535 ; if (address >= 0 && address < MEMORY_SIZE) {
536 Memory[address] = Registers[REGISTER_A];
537 }
538 set_flag_n(Registers[REGISTER_A]);
539 set_flag_z(Registers[REGISTER_A]);
540 Flags = Flags & (0xFF - FLAG_C);
541 break;
542
543 ////------MVI------///
544
545 case 0x2A:
546 data = fetch();
547 Registers[REGISTER_B] = data;
548 set_flag_n(Registers[REGISTER_A]);
549 set_flag_z(Registers[REGISTER_A]);
550 Flags = Flags & (0xFF - FLAG_C);
551 break;
552
553 case 0x2B:
554 data = fetch();
555 Registers[REGISTER_C] = data;
556 set_flag_n(Registers[REGISTER_A]);
557 set_flag_z(Registers[REGISTER_A]);
558 Flags = Flags & (0xFF - FLAG_C);
559 break;
560
561 case 0x2C:
562 data = fetch();
563 Registers[REGISTER_D] = data;
564 set_flag_n(Registers[REGISTER_A]);
565 set_flag_z(Registers[REGISTER_A]);
566 Flags = Flags & (0xFF - FLAG_C);
567 break;
568
569 case 0x2D:
570 data = fetch();
571 Registers[REGISTER_E] = data;
572 set_flag_n(Registers[REGISTER_A]);
573 set_flag_z(Registers[REGISTER_A]);
574 Flags = Flags & (0xFF - FLAG_C);
575 break;
576
577 case 0x2E:
578 data = fetch();
579 Registers[REGISTER_L] = data;
580 set_flag_n(Registers[REGISTER_A]);
581 set_flag_z(Registers[REGISTER_A]);
582 Flags = Flags & (0xFF - FLAG_C);
583 break;
584
585 case 0x2F:
586 data = fetch();
587 Registers[REGISTER_H] = data;
588 set_flag_n(Registers[REGISTER_A]);
589 set_flag_z(Registers[REGISTER_A]);
590 Flags = Flags & (0xFF - FLAG_C);
591 break;
592 ////----LODS-----///
593 case 0x4F:
594 data = fetch();
595 StackPointer = data << 8;
596 StackPointer += fetch();
597 break;
598
599 case 0x5f:
600 HB = fetch();
601 LB = fetch();
602 address += (WORD)((WORD)HB << 8) + LB;
603 if (address >= 0 && address < MEMORY_SIZE - 1) {
604 StackPointer = (WORD)Memory[address] << 8;
605 StackPointer += Memory[address + 1];
606 }
607 break;
608
609 case 0x6f:
610 address += IndexRegister;
611 HB = fetch();
612 LB = fetch();
613 address += (WORD)((WORD)HB << 8) + LB;
614 if (address >= 0 && address < MEMORY_SIZE - 1) {
615 StackPointer = (WORD)Memory[address] << 8;
616 StackPointer += Memory[address + 1];
617 }
618 break;
619
620 /*
621 * Opcode: LDX
622 * Description: Loads Memory into register X
623 * Flags: - - T - T - - 0
624 * Notes: None
625 */
626 case 0x4E: //LDX IMMEDIATE ADDRESSING (#)
627 data = fetch();
628 Registers[IndexRegister] = data;
629
630 set_flag_n(Registers[IndexRegister]);
631 set_flag_z(Registers[IndexRegister]);
632 Flags = Flags & (0xFF - FLAG_C);
633 break;
634
635 case 0x5E: //LDX ABSOLUTE ADDRESSING (abs)
636 HB = fetch();
637 LB = fetch();
638 address += (WORD)((WORD)HB << 8) + LB;
639 if (address >= 0 && address < MEMORY_SIZE) {
640 Registers[IndexRegister] = Memory[address];
641 }
642
643 set_flag_n(Registers[IndexRegister]);
644 set_flag_z(Registers[IndexRegister]);
645 Flags = Flags & (0xFF - FLAG_C);
646 break;
647
648 case 0x6E: //LDX INDEXED ABSOLUTE ADDRESSING (abs,X)
649 address += IndexRegister;
650 HB = fetch();
651 LB = fetch();
652 address += (WORD)((WORD)HB << 8) + LB;
653 if (address >= 0 && address < MEMORY_SIZE) {
654 Registers[IndexRegister] = Memory[address];
655 }
656
657 set_flag_n(Registers[IndexRegister]);
658 set_flag_z(Registers[IndexRegister]);
659 Flags = Flags & (0xFF - FLAG_C);
660 break;
661
662 /*
663 * Opcode: STOX
664 * Description: Stores register X into Memory
665 * Flags: - - T - T - - 0
666 * Notes: None
667 */
668 case 0x50: //STOX ABSOLUTE ADDRESSING (abs)
669 address += IndexRegister;
670 HB = fetch();
671 LB = fetch();
672 address += (WORD)((WORD)HB << 8) + LB;
673 if (address >= 0 && address < MEMORY_SIZE) {
674 Memory[address] = Registers[IndexRegister];
675 }
676
677 set_flag_n(Registers[IndexRegister]);
678 set_flag_z(Registers[IndexRegister]);
679 Flags = Flags & (0xFF - FLAG_C);
680 break;
681
682 case 0x60: //STOX INDEXED ABSOLUTE ADDRESSING (abs, X)
683 address += IndexRegister;
684 HB = fetch();
685 LB = fetch();
686 address += (WORD)((WORD)HB << 8) + LB;
687 if (address >= 0 && address < MEMORY_SIZE) {
688 Memory[address] = Registers[IndexRegister];
689 }
690
691 set_flag_n(Registers[IndexRegister]);
692 set_flag_z(Registers[IndexRegister]);
693 Flags = Flags & (0xFF - FLAG_C);
694 break;
695
696
697 /////-----ADC-----/////
698
699 case 0x90:
700 param1 = Registers[REGISTER_A];
701 param2 = Registers[REGISTER_B];
702 temp_word = (WORD)param1 + (WORD)param2;
703 if ((Flags & FLAG_C) != 0) {
704 temp_word++;
705 }
706 if (temp_word >= 0x100) {
707 Flags = Flags | FLAG_C; // Set carry flag
708 }
709 else {
710 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
711 }
712 set_flag_n((BYTE)temp_word);
713 set_flag_z((BYTE)temp_word);
714 set_flag_v(param1, param2, (BYTE)temp_word);
715 Registers[REGISTER_A] = (BYTE)temp_word;
716 break;
717
718 case 0xA0:
719 param1 = Registers[REGISTER_A];
720 param2 = Registers[REGISTER_C];
721 temp_word = (WORD)param1 + (WORD)param2;
722 if ((Flags & FLAG_C) != 0) {
723 temp_word++;
724 }
725 if (temp_word >= 0x100) {
726 Flags = Flags | FLAG_C; // Set carry flag
727 }
728 else {
729 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
730 }
731 set_flag_n((BYTE)temp_word);
732 set_flag_z((BYTE)temp_word);
733 set_flag_v(param1, param2, (BYTE)temp_word);
734 Registers[REGISTER_A] = (BYTE)temp_word;
735 break;
736
737 case 0xB0:
738 param1 = Registers[REGISTER_A];
739 param2 = Registers[REGISTER_D];
740 temp_word = (WORD)param1 + (WORD)param2;
741 if ((Flags & FLAG_C) != 0) {
742 temp_word++;
743 }
744 if (temp_word >= 0x100) {
745 Flags = Flags | FLAG_C; // Set carry flag
746 }
747 else {
748 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
749 }
750 set_flag_n((BYTE)temp_word);
751 set_flag_z((BYTE)temp_word);
752 set_flag_v(param1, param2, (BYTE)temp_word);
753 Registers[REGISTER_A] = (BYTE)temp_word;
754 break;
755
756 case 0xC0:
757 param1 = Registers[REGISTER_A];
758 param2 = Registers[REGISTER_E];
759 temp_word = (WORD)param1 + (WORD)param2;
760 if ((Flags & FLAG_C) != 0) {
761 temp_word++;
762 }
763 if (temp_word >= 0x100) {
764 Flags = Flags | FLAG_C; // Set carry flag
765 }
766 else {
767 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
768 }
769 set_flag_n((BYTE)temp_word);
770 set_flag_z((BYTE)temp_word);
771 set_flag_v(param1, param2, (BYTE)temp_word);
772 Registers[REGISTER_A] = (BYTE)temp_word;
773 break;
774
775 case 0xD0:
776 param1 = Registers[REGISTER_A];
777 param2 = Registers[REGISTER_L];
778 temp_word = (WORD)param1 + (WORD)param2;
779 if ((Flags & FLAG_C) != 0) {
780 temp_word++;
781 }
782 if (temp_word >= 0x100) {
783 Flags = Flags | FLAG_C; // Set carry flag
784 }
785 else {
786 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
787 }
788 set_flag_n((BYTE)temp_word);
789 set_flag_z((BYTE)temp_word);
790 set_flag_v(param1, param2, (BYTE)temp_word);
791 Registers[REGISTER_A] = (BYTE)temp_word;
792 break;
793
794 case 0xE0:
795 param1 = Registers[REGISTER_A];
796 param2 = Registers[REGISTER_H];
797 temp_word = (WORD)param1 + (WORD)param2;
798 if ((Flags & FLAG_C) != 0) {
799 temp_word++;
800 }
801 if (temp_word >= 0x100) {
802 Flags = Flags | FLAG_C; // Set carry flag
803 }
804 else {
805 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
806 }
807 set_flag_n((BYTE)temp_word);
808 set_flag_z((BYTE)temp_word);
809 set_flag_v(param1, param2, (BYTE)temp_word);
810 Registers[REGISTER_A] = (BYTE)temp_word;
811 break;
812
813 case 0xF0:
814 param1 = Registers[REGISTER_A];
815 param2 = Registers[REGISTER_M];
816 temp_word = (WORD)param1 + (WORD)param2;
817 if ((Flags & FLAG_C) != 0) {
818 temp_word++;
819 }
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 Registers[REGISTER_A] = (BYTE)temp_word;
830 break;
831
832 /////-------CMP--------/////
833
834 case 0x92:
835 param1 = Registers[REGISTER_A];
836 param2 = Registers[REGISTER_B];
837 temp_word = (WORD)param1 - (WORD)param2;
838 if (temp_word >= 0x100) {
839 Flags = Flags | FLAG_C; // Set carry flag
840 }
841 else {
842 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
843 }
844 set_flag_n((BYTE)temp_word);
845 set_flag_z((BYTE)temp_word);
846 set_flag_v(param1, param2, (BYTE)temp_word);
847 break;
848
849 case 0xA2:
850 param1 = Registers[REGISTER_A];
851 param2 = Registers[REGISTER_C];
852 temp_word = (WORD)param1 - (WORD)param2;
853 if (temp_word >= 0x100) {
854 Flags = Flags | FLAG_C; // Set carry flag
855 }
856 else {
857 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
858 }
859 set_flag_n((BYTE)temp_word);
860 set_flag_z((BYTE)temp_word);
861 set_flag_v(param1, param2, (BYTE)temp_word);
862 break;
863
864 case 0xB2:
865 param1 = Registers[REGISTER_A];
866 param2 = Registers[REGISTER_D];
867 temp_word = (WORD)param1 - (WORD)param2;
868 if (temp_word >= 0x100) {
869 Flags = Flags | FLAG_C; // Set carry flag
870 }
871 else {
872 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
873 }
874 set_flag_n((BYTE)temp_word);
875 set_flag_z((BYTE)temp_word);
876 set_flag_v(param1, param2, (BYTE)temp_word);
877 break;
878
879 case 0xC2:
880 param1 = Registers[REGISTER_A];
881 param2 = Registers[REGISTER_E];
882 temp_word = (WORD)param1 - (WORD)param2;
883 if (temp_word >= 0x100) {
884 Flags = Flags | FLAG_C; // Set carry flag
885 }
886 else {
887 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
888 }
889 set_flag_n((BYTE)temp_word);
890 set_flag_z((BYTE)temp_word);
891 set_flag_v(param1, param2, (BYTE)temp_word);
892 break;
893
894 case 0xD2:
895 param1 = Registers[REGISTER_A];
896 param2 = Registers[REGISTER_L];
897 temp_word = (WORD)param1 - (WORD)param2;
898 if (temp_word >= 0x100) {
899 Flags = Flags | FLAG_C; // Set carry flag
900 }
901 else {
902 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
903 }
904 set_flag_n((BYTE)temp_word);
905 set_flag_z((BYTE)temp_word);
906 set_flag_v(param1, param2, (BYTE)temp_word);
907 break;
908
909 case 0xE2:
910 param1 = Registers[REGISTER_A];
911 param2 = Registers[REGISTER_H];
912 temp_word = (WORD)param1 - (WORD)param2;
913 if (temp_word >= 0x100) {
914 Flags = Flags | FLAG_C; // Set carry flag
915 }
916 else {
917 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
918 }
919 set_flag_n((BYTE)temp_word);
920 set_flag_z((BYTE)temp_word);
921 set_flag_v(param1, param2, (BYTE)temp_word);
922 break;
923
924 case 0xF2:
925 param1 = Registers[REGISTER_A];
926 param2 = Registers[REGISTER_M];
927 temp_word = (WORD)param1 - (WORD)param2;
928 if (temp_word >= 0x100) {
929 Flags = Flags | FLAG_C; // Set carry flag
930 }
931 else {
932 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
933 }
934 set_flag_n((BYTE)temp_word);
935 set_flag_z((BYTE)temp_word);
936 set_flag_v(param1, param2, (BYTE)temp_word);
937 break;
938
939
940 //////-----------TSA-------------//////
941
942 case 0x75:
943 Registers[REGISTER_A] = Flags;
944 break;
945
946
947 //////-----------TAS-------------//////
948
949 case 0x74:
950 Flags = Registers[REGISTER_A];
951 break;
952
953 //////-----------SEC-------------//////
954 case 0x16:
955 Flags = Flags | FLAG_C;
956 break;
957
958 /////-----------CLC----------/////
959
960 case 0x15:
961 Flags = Flags & (0xFF - FLAG_C);
962 break;
963
964 /////----------CLI------------/////
965 case 0x17:
966 Flags = Flags & (0xFF - FLAG_I);
967 break;
968 /////----------STI------------/////
969 case 0x18:
970 Flags = Flags | FLAG_I;
971 break;
972
973 /////----------SEV------------/////
974 Flags = Flags | FLAG_V;
975
976 /////----------CLV------------/////
977 Flags = Flags & (0xFF - FLAG_V);
978
979 /////-----------PSH-----------/////
980 case 0x11:
981 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
982 Memory[StackPointer] = Registers[REGISTER_A];
983 StackPointer--;
984 }
985 break;
986
987 case 0x21:
988 Memory[StackPointer] = Flags;
989 StackPointer--;
990 break;
991
992 case 0x31:
993 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
994 Memory[StackPointer] = Registers[REGISTER_B];
995 StackPointer--;
996 }
997 break;
998
999 case 0x41:
1000 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
1001 Memory[StackPointer] = Registers[REGISTER_C];
1002 StackPointer--;
1003 }
1004 break;
1005
1006 case 0x51:
1007 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
1008 Memory[StackPointer] = Registers[REGISTER_D];
1009 StackPointer--;
1010 }
1011 break;
1012
1013 case 0x61:
1014 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
1015 Memory[StackPointer] = Registers[REGISTER_E];
1016 StackPointer--;
1017 }
1018 break;
1019
1020 case 0x71:
1021 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
1022 Memory[StackPointer] = Registers[REGISTER_L];
1023 StackPointer--;
1024 }
1025 break;
1026
1027 case 0x81:
1028 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
1029 Memory[StackPointer] = Registers[REGISTER_H];
1030 StackPointer--;
1031 }
1032 break;
1033
1034 /////-----------POP------------////
1035
1036 case 0x12:
1037 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
1038 StackPointer++;
1039 Registers[REGISTER_A] = Memory[StackPointer];
1040 }
1041 break;
1042
1043 case 0x22:
1044 StackPointer++;
1045 Flags = Memory[StackPointer];
1046 break;
1047
1048 case 0x32:
1049 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
1050 StackPointer++;
1051 Registers[REGISTER_B] = Memory[StackPointer];
1052 }
1053 break;
1054
1055 case 0x42:
1056 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
1057 StackPointer++;
1058 Registers[REGISTER_C] = Memory[StackPointer];
1059 }
1060 break;
1061
1062 case 0x52:
1063 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
1064 StackPointer++;
1065 Registers[REGISTER_D] = Memory[StackPointer];
1066 }
1067 break;
1068
1069 case 0x62:
1070 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
1071 StackPointer++;
1072 Registers[REGISTER_E] = Memory[StackPointer];
1073 }
1074 break;
1075
1076 case 0x72:
1077 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
1078 StackPointer++;
1079 Registers[REGISTER_L] = Memory[StackPointer];
1080 }
1081 break;
1082
1083 case 0x82:
1084 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
1085 StackPointer++;
1086 Registers[REGISTER_H] = Memory[StackPointer];
1087 }
1088 break;
1089
1090 //////------JMP------//////
1091 case 0xFA:
1092 HB = fetch();
1093 LB = fetch();
1094 address = ((WORD)HB << 8) + (WORD)LB;
1095 ProgramCounter = address;
1096 break;
1097
1098 //////-----JPR-----------////
1099 case 0x33:
1100 HB = fetch();
1101 LB = fetch();
1102 address = ((WORD)HB << 8) + (WORD)LB;
1103 ProgramCounter = address;
1104 break;
1105
1106 /////------RTN---------/////
1107 case 0x0E:
1108 HB = fetch();
1109 LB = fetch();
1110 address = ((WORD)HB << 8) + (WORD)LB;
1111 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 2)) {
1112 StackPointer++;
1113 HB = Memory[StackPointer];
1114 StackPointer++;
1115 LB = Memory[StackPointer];
1116 }
1117 ProgramCounter = ((WORD)HB << 8) + (WORD)LB;
1118 break;
1119
1120 /////------BRA-------/////
1121 case 0x00:
1122 LB = fetch();
1123 offset = (WORD)LB;
1124 if ((offset & 0x80) != 0) {
1125 offset = offset + 0xFF00;
1126 }
1127 address = ProgramCounter + offset;
1128 break;
1129
1130 /////------BCC-------/////
1131 case 0x01:
1132 LB = fetch();
1133 if (CF == 0) {
1134 offset = (WORD)LB;
1135 if ((offset & 0x80) != 0) {
1136 offset = offset + 0xFF00;
1137 } address = ProgramCounter + offset;
1138 ProgramCounter = address;
1139 }
1140
1141 break;
1142 /////------BCS-------/////
1143 case 0x02:
1144 LB = fetch();
1145 if (CF == 1){
1146 offset = (WORD)LB;
1147 if ((offset & 0x80) != 0) {
1148 offset = offset + 0xFF00;
1149 } address = ProgramCounter + offset;
1150 ProgramCounter = address;
1151 }
1152 break;
1153 /////------BNE-------/////
1154 case 0x03:
1155 LB = fetch();
1156 if (ZF == 0) {
1157 offset = (WORD)LB;
1158 if ((offset & 0x80) != 0) {
1159 offset = offset + 0xFF00;
1160 } address = ProgramCounter + offset;
1161 ProgramCounter = address;
1162 }
1163 break;
1164
1165 /////------BEQ-------/////
1166 case 0x04:
1167 LB = fetch();
1168 if (ZF == 1) {
1169 offset = (WORD)LB;
1170 if ((offset & 0x80) != 0) {
1171 offset = offset + 0xFF00;
1172 } address = ProgramCounter + offset;
1173 ProgramCounter = address;
1174 }
1175 break;
1176 /////------BVC-------/////
1177 case 0x05:
1178 LB = fetch();
1179 if (VF == 0) {
1180 offset = (WORD)LB;
1181 if ((offset & 0x80) != 0) {
1182 offset = offset + 0xFF00;
1183 } address = ProgramCounter + offset;
1184 ProgramCounter = address;
1185 }
1186 break;
1187 /////------BVS-------/////
1188 case 0x06:
1189 LB = fetch();
1190 if (VF == 1) {
1191 offset = (WORD)LB;
1192 if ((offset & 0x80) != 0) {
1193 offset = offset + 0xFF00;
1194 } address = ProgramCounter + offset;
1195 ProgramCounter = address;
1196 }
1197 break;
1198
1199 /////------BMI-------/////
1200 case 0x07:
1201 LB = fetch();
1202 if (NF == 1) {
1203 offset = (WORD)LB;
1204 if ((offset & 0x80) != 0) {
1205 offset = offset + 0xFF00;
1206 } address = ProgramCounter + offset;
1207 ProgramCounter = address;
1208 }
1209 break;
1210
1211 /////------BPL-------/////
1212 case 0x08:
1213 LB = fetch();
1214 if (NF == 0) {
1215 offset = (WORD)LB;
1216 if ((offset & 0x80) != 0) {
1217 offset = offset + 0xFF00;
1218 } address = ProgramCounter + offset;
1219 ProgramCounter = address;
1220 }
1221 break;
1222 /////------BGE-------/////
1223 case 0x09:
1224 LB = fetch();
1225 if ((NF ^ VF) == 0) {
1226 offset = (WORD)LB;
1227 if ((offset & 0x80) != 0) {
1228 offset = offset + 0xFF00;
1229 } address = ProgramCounter + offset;
1230 ProgramCounter = address;
1231 }
1232 break;
1233 /////------BLE -------/////
1234 case 0x0A:
1235 LB = fetch();
1236 if ((ZF| NF ^ VF) == 0) {
1237 offset = (WORD)LB;
1238 if ((offset & 0x80) != 0) {
1239 offset = offset + 0xFF00;
1240 } address = ProgramCounter + offset;
1241 ProgramCounter = address;
1242 }
1243 break;
1244 /////------BLS------/////
1245 LB = fetch();
1246 if ((CF | ZF) == 1) {
1247 offset = (WORD)LB;
1248 if ((offset & 0x80) != 0) {
1249 offset = offset + 0xFF00;
1250 } address = ProgramCounter + offset;
1251 ProgramCounter = address;
1252 }
1253 /////------BHI------/////
1254 case 0x0C:
1255 LB = fetch();
1256 if ((CF | ZF) == 0) {
1257 offset = (WORD)LB;
1258 if ((offset & 0x80) != 0) {
1259 offset = offset + 0xFF00;
1260 } address = ProgramCounter + offset;
1261 ProgramCounter = address;
1262 }
1263 break;
1264 /////------CCC------/////
1265 case 0x34:
1266 HB = fetch();
1267 LB = fetch();
1268 if (CF == 0)
1269 {
1270 address += (WORD)((WORD)HB << 8) + LB;
1271 if (address >= 0 && address < MEMORY_SIZE)
1272 {
1273
1274 if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
1275 {
1276 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
1277 StackPointer--;
1278 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
1279 StackPointer--;
1280 }
1281 ProgramCounter = (WORD)address;
1282 }
1283 }
1284 break;
1285 /////------CCS------/////
1286 case 0x35:
1287 HB = fetch();
1288 LB = fetch();
1289 if (CF == 1)
1290 {
1291 address += (WORD)((WORD)HB << 8) + LB;
1292 if (address >= 0 && address < MEMORY_SIZE)
1293 {
1294
1295 if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
1296 {
1297 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
1298 StackPointer--;
1299 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
1300 StackPointer--;
1301 }
1302 ProgramCounter = (WORD)address;
1303 }
1304 }
1305 break;
1306
1307 /////------CNE------/////
1308 case 0x36:
1309 HB = fetch();
1310 LB = fetch();
1311 if (ZF == 0)
1312 {
1313 address += (WORD)((WORD)HB << 8) + LB;
1314 if (address >= 0 && address < MEMORY_SIZE)
1315 {
1316
1317 if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
1318 {
1319 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
1320 StackPointer--;
1321 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
1322 StackPointer--;
1323 }
1324 ProgramCounter = (WORD)address;
1325 }
1326 }
1327 break;
1328
1329 /////------CEQ------/////
1330 case 0x37:
1331 HB = fetch();
1332 LB = fetch();
1333 if (ZF == 1)
1334 {
1335 address += (WORD)((WORD)HB << 8) + LB;
1336 if (address >= 0 && address < MEMORY_SIZE)
1337 {
1338
1339 if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
1340 {
1341 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
1342 StackPointer--;
1343 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
1344 StackPointer--;
1345 }
1346 ProgramCounter = (WORD)address;
1347 }
1348 }
1349 break;
1350
1351 /////------CVC------/////
1352 case 0x38:
1353 HB = fetch();
1354 LB = fetch();
1355 if (VF == 0)
1356 {
1357 address += (WORD)((WORD)HB << 8) + LB;
1358 if (address >= 0 && address < MEMORY_SIZE)
1359 {
1360
1361 if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
1362 {
1363 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
1364 StackPointer--;
1365 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
1366 StackPointer--;
1367 }
1368 ProgramCounter = (WORD)address;
1369 }
1370 }
1371 break;
1372
1373
1374 /////------CVS------/////
1375 case 0x39:
1376 HB = fetch();
1377 LB = fetch();
1378 if (VF == 1)
1379 {
1380 address += (WORD)((WORD)HB << 8) + LB;
1381 if (address >= 0 && address < MEMORY_SIZE)
1382 {
1383
1384 if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
1385 {
1386 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
1387 StackPointer--;
1388 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
1389 StackPointer--;
1390 }
1391 ProgramCounter = (WORD)address;
1392 }
1393 }
1394 break;
1395
1396
1397 /////------CMI------/////
1398 case 0x3A:
1399 HB = fetch();
1400 LB = fetch();
1401 if (NF == 1)
1402 {
1403 address += (WORD)((WORD)HB << 8) + LB;
1404 if (address >= 0 && address < MEMORY_SIZE)
1405 {
1406
1407 if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
1408 {
1409 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
1410 StackPointer--;
1411 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
1412 StackPointer--;
1413 }
1414 ProgramCounter = (WORD)address;
1415 }
1416 }
1417 break;
1418
1419
1420 /////------CPL------/////
1421 case 0x3B:
1422 HB = fetch();
1423 LB = fetch();
1424 if (NF == 0)
1425 {
1426 address += (WORD)((WORD)HB << 8) + LB;
1427 if (address >= 0 && address < MEMORY_SIZE)
1428 {
1429
1430 if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
1431 {
1432 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
1433 StackPointer--;
1434 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
1435 StackPointer--;
1436 }
1437 ProgramCounter = (WORD)address;
1438 }
1439 }
1440 break;
1441
1442
1443 /////------CHI------/////
1444 case 0x3C:
1445 HB = fetch();
1446 LB = fetch();
1447 if ((CF | ZF) == 1)
1448 {
1449 address += (WORD)((WORD)HB << 8) + LB;
1450 if (address >= 0 && address < MEMORY_SIZE)
1451 {
1452
1453 if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
1454 {
1455 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
1456 StackPointer--;
1457 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
1458 StackPointer--;
1459 }
1460 ProgramCounter = (WORD)address;
1461 }
1462 }
1463 break;
1464
1465
1466 /////------CLE------/////
1467 case 0x3D:
1468 HB = fetch();
1469 LB = fetch();
1470 if ((CF | ZF) == 0)
1471 {
1472 address += (WORD)((WORD)HB << 8) + LB;
1473 if (address >= 0 && address < MEMORY_SIZE)
1474 {
1475
1476 if ((StackPointer >= 2) && (StackPointer < MEMORY_SIZE))
1477 {
1478 Memory[StackPointer] = (BYTE)(ProgramCounter & 0xFF);
1479 StackPointer--;
1480 Memory[StackPointer] = (BYTE)((ProgramCounter >> 8) & 0xFF);
1481 StackPointer--;
1482 }
1483 ProgramCounter = (WORD)address;
1484 }
1485 }
1486 break;
1487
1488 /////------INC-------/////
1489 case 0x44:
1490 ++Registers[REGISTER_A];
1491 set_flag_n(Registers[REGISTER_A]);
1492 set_flag_z(Registers[REGISTER_A]);
1493 break;
1494
1495 case 0x54:
1496 ++Registers[REGISTER_A];
1497 set_flag_n(Registers[REGISTER_A]);
1498 set_flag_z(Registers[REGISTER_A]);
1499 break;
1500 /////------DEX------/////
1501 case 0x1B:
1502 --IndexRegister;
1503 set_flag_z(IndexRegister);
1504 break;
1505
1506 /////------INCA------/////
1507 case 0x64:
1508 ++Registers[REGISTER_A];
1509 set_flag_n(Registers[REGISTER_A]);
1510 set_flag_z(Registers[REGISTER_A]);
1511
1512
1513 ////-------INX---------////
1514 case 0x1C:
1515 ++IndexRegister;
1516 set_flag_z(IndexRegister);
1517 break;
1518
1519 /////------AND------/////
1520 case 0x94:
1521 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_B];
1522 set_flag_n(Registers[REGISTER_A]);
1523 set_flag_z(Registers[REGISTER_A]);
1524 break;
1525
1526 case 0xA4:
1527 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_C];
1528 set_flag_n(Registers[REGISTER_A]);
1529 set_flag_z(Registers[REGISTER_A]);
1530 break;
1531
1532 case 0xB4:
1533 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_D];
1534 set_flag_n(Registers[REGISTER_A]);
1535 set_flag_z(Registers[REGISTER_A]);
1536 break;
1537
1538 case 0xC4:
1539 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_E];
1540 set_flag_n(Registers[REGISTER_A]);
1541 set_flag_z(Registers[REGISTER_A]);
1542 break;
1543
1544 case 0xD4:
1545 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_L];
1546 set_flag_n(Registers[REGISTER_A]);
1547 set_flag_z(Registers[REGISTER_A]);
1548 break;
1549
1550 case 0xE4:
1551 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_H];
1552 set_flag_n(Registers[REGISTER_A]);
1553 set_flag_z(Registers[REGISTER_A]);
1554 break;
1555
1556 case 0xF4:
1557 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_M];
1558 set_flag_n(Registers[REGISTER_A]);
1559 set_flag_z(Registers[REGISTER_A]);
1560 break;
1561 /////-----BT----/////
1562 case 0x96:
1563 data = Registers[REGISTER_A] & Registers[REGISTER_B];
1564 set_flag_n(data);
1565 set_flag_z(data);
1566 break;
1567
1568 case 0xA6:
1569 data = Registers[REGISTER_A] & Registers[REGISTER_C];
1570 set_flag_n(data);
1571 set_flag_z(data);
1572 break;
1573
1574 case 0xB6:
1575 data = Registers[REGISTER_A] & Registers[REGISTER_D];
1576 set_flag_n(data);
1577 set_flag_z(data);
1578 break;
1579
1580 case 0xC6:
1581 data = Registers[REGISTER_A] & Registers[REGISTER_E];
1582 set_flag_n(data);
1583 set_flag_z(data);
1584 break;
1585
1586 case 0xD6:
1587 data = Registers[REGISTER_A] & Registers[REGISTER_L];
1588 set_flag_n(data);
1589 set_flag_z(data);
1590 break;
1591
1592 case 0xE6:
1593 data = Registers[REGISTER_A] & Registers[REGISTER_H];
1594 set_flag_n(data);
1595 set_flag_z(data);
1596 break;
1597
1598 case 0xF6:
1599 data = Registers[REGISTER_A] & Registers[REGISTER_M];
1600 set_flag_n(data);
1601 set_flag_z(data);
1602 break;
1603 /////--------SBC-------/////
1604 case 0x91:
1605 param1 = Registers[REGISTER_A];
1606 param2 = Registers[REGISTER_B];
1607 temp_word = (WORD)param1 - (WORD)param2;
1608 if ((Flags & FLAG_C) != 0) {
1609 temp_word++;
1610 }
1611 if (temp_word >= 0x100) {
1612 Flags = Flags | FLAG_C; // Set carry flag
1613 }
1614 else {
1615 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
1616 }
1617 set_flag_n((BYTE)temp_word);
1618 set_flag_z((BYTE)temp_word);
1619 set_flag_v(param1, param2, (BYTE)temp_word);
1620 Registers[REGISTER_A] = (BYTE)temp_word;
1621
1622 break;
1623 case 0xA1:
1624 param1 = Registers[REGISTER_A];
1625 param2 = Registers[REGISTER_C];
1626 temp_word = (WORD)param1 - (WORD)param2;
1627 if ((Flags & FLAG_C) != 0) {
1628 temp_word++;
1629 }
1630 if (temp_word >= 0x100) {
1631 Flags = Flags | FLAG_C; // Set carry flag
1632 }
1633 else {
1634 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
1635 }
1636 set_flag_n((BYTE)temp_word);
1637 set_flag_z((BYTE)temp_word);
1638 set_flag_v(param1, param2, (BYTE)temp_word);
1639 Registers[REGISTER_A] = (BYTE)temp_word;
1640 break;
1641 case 0xB1:
1642 param1 = Registers[REGISTER_A];
1643 param2 = Registers[REGISTER_D];
1644 temp_word = (WORD)param1 - (WORD)param2;
1645 if ((Flags & FLAG_C) != 0) {
1646 temp_word++;
1647 }
1648 if (temp_word >= 0x100) {
1649 Flags = Flags | FLAG_C; // Set carry flag
1650 }
1651 else {
1652 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
1653 }
1654 set_flag_n((BYTE)temp_word);
1655 set_flag_z((BYTE)temp_word);
1656 set_flag_v(param1, param2, (BYTE)temp_word);
1657 Registers[REGISTER_A] = (BYTE)temp_word;
1658 break;
1659 case 0xC1:
1660 param1 = Registers[REGISTER_A];
1661 param2 = Registers[REGISTER_E];
1662 temp_word = (WORD)param1 - (WORD)param2;
1663 if ((Flags & FLAG_C) != 0) {
1664 temp_word++;
1665 }
1666 if (temp_word >= 0x100) {
1667 Flags = Flags | FLAG_C; // Set carry flag
1668 }
1669 else {
1670 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
1671 }
1672 set_flag_n((BYTE)temp_word);
1673 set_flag_z((BYTE)temp_word);
1674 set_flag_v(param1, param2, (BYTE)temp_word);
1675 Registers[REGISTER_A] = (BYTE)temp_word;
1676 break;
1677 case 0xD1:
1678 param1 = Registers[REGISTER_A];
1679 param2 = Registers[REGISTER_L];
1680 temp_word = (WORD)param1 - (WORD)param2;
1681 if ((Flags & FLAG_C) != 0) {
1682 temp_word++;
1683 }
1684 if (temp_word >= 0x100) {
1685 Flags = Flags | FLAG_C; // Set carry flag
1686 }
1687 else {
1688 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
1689 }
1690 set_flag_n((BYTE)temp_word);
1691 set_flag_z((BYTE)temp_word);
1692 set_flag_v(param1, param2, (BYTE)temp_word);
1693 Registers[REGISTER_A] = (BYTE)temp_word;
1694 break;
1695 case 0xE1:
1696 param1 = Registers[REGISTER_A];
1697 param2 = Registers[REGISTER_H];
1698 temp_word = (WORD)param1 - (WORD)param2;
1699 if ((Flags & FLAG_C) != 0) {
1700 temp_word++;
1701 }
1702 if (temp_word >= 0x100) {
1703 Flags = Flags | FLAG_C; // Set carry flag
1704 }
1705 else {
1706 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
1707 }
1708 set_flag_n((BYTE)temp_word);
1709 set_flag_z((BYTE)temp_word);
1710 set_flag_v(param1, param2, (BYTE)temp_word);
1711 Registers[REGISTER_A] = (BYTE)temp_word;
1712 break;
1713 case 0xF1:
1714 param1 = Registers[REGISTER_A];
1715 param2 = Registers[REGISTER_M];
1716 temp_word = (WORD)param1 - (WORD)param2;
1717 if ((Flags & FLAG_C) != 0) {
1718 temp_word++;
1719 }
1720 if (temp_word >= 0x100) {
1721 Flags = Flags | FLAG_C; // Set carry flag
1722 }
1723 else {
1724 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
1725 }
1726 set_flag_n((BYTE)temp_word);
1727 set_flag_z((BYTE)temp_word);
1728 set_flag_v(param1, param2, (BYTE)temp_word);
1729 Registers[REGISTER_A] = (BYTE)temp_word;
1730 break;
1731 /////------IOR------/////
1732 case 0x93:
1733 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_B];
1734 set_flag_n(Registers[REGISTER_A]);
1735 set_flag_z(Registers[REGISTER_A]);
1736 break;
1737
1738 case 0xA3:
1739 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_C];
1740 set_flag_n(Registers[REGISTER_A]);
1741 set_flag_z(Registers[REGISTER_A]);
1742 break;
1743
1744 case 0xB3:
1745 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_D];
1746 set_flag_n(Registers[REGISTER_A]);
1747 set_flag_z(Registers[REGISTER_A]);
1748 break;
1749
1750 case 0xC3:
1751 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_E];
1752 set_flag_n(Registers[REGISTER_A]);
1753 set_flag_z(Registers[REGISTER_A]);
1754 break;
1755
1756 case 0xD3:
1757 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_L];
1758 set_flag_n(Registers[REGISTER_A]);
1759 set_flag_z(Registers[REGISTER_A]);
1760 break;
1761
1762 case 0xE3:
1763 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_H];
1764 set_flag_n(Registers[REGISTER_A]);
1765 set_flag_z(Registers[REGISTER_A]);
1766 break;
1767
1768 case 0xF3:
1769 Registers[REGISTER_A] = Registers[REGISTER_A] & Registers[REGISTER_M];
1770 set_flag_n(Registers[REGISTER_A]);
1771 set_flag_z(Registers[REGISTER_A]);
1772 break;
1773
1774 /////-----NOTA-----/////
1775 case 0x6A:
1776
1777 break;
1778
1779
1780 /////-----XOR----/////
1781 case 0x95:
1782 Registers[REGISTER_A] = Registers[REGISTER_A] ^ Registers[REGISTER_B];
1783 set_flag_n(Registers[REGISTER_A]);
1784 set_flag_z(Registers[REGISTER_A]);
1785 break;
1786 case 0xA5:
1787 Registers[REGISTER_A] = Registers[REGISTER_A] ^ Registers[REGISTER_C];
1788 set_flag_n(Registers[REGISTER_A]);
1789 set_flag_z(Registers[REGISTER_A]);
1790 break;
1791 case 0xB5:
1792 Registers[REGISTER_A] = Registers[REGISTER_A] ^ Registers[REGISTER_D];
1793 set_flag_n(Registers[REGISTER_A]);
1794 set_flag_z(Registers[REGISTER_A]);
1795 break;
1796 case 0xC5:
1797 Registers[REGISTER_A] = Registers[REGISTER_A] ^ Registers[REGISTER_E];
1798 set_flag_n(Registers[REGISTER_A]);
1799 set_flag_z(Registers[REGISTER_A]);
1800 break;
1801 case 0xD5:
1802 Registers[REGISTER_A] = Registers[REGISTER_A] ^ Registers[REGISTER_L];
1803 set_flag_n(Registers[REGISTER_A]);
1804 set_flag_z(Registers[REGISTER_A]);
1805 break;
1806 case 0xE5:
1807 Registers[REGISTER_A] = Registers[REGISTER_A] ^ Registers[REGISTER_H];
1808 set_flag_n(Registers[REGISTER_A]);
1809 set_flag_z(Registers[REGISTER_A]);
1810 break;
1811 case 0xF5:
1812 Registers[REGISTER_A] = Registers[REGISTER_A] ^ Registers[REGISTER_M];
1813 set_flag_n(Registers[REGISTER_A]);
1814 set_flag_z(Registers[REGISTER_A]);
1815 break;
1816
1817 /////-----TST-----/////
1818 case 0x43:
1819
1820 break;
1821
1822 case 0x53:
1823
1824 break;
1825 /////-----DEC-----/////
1826 case 0x45:
1827
1828 break;
1829 case 0x55:
1830
1831 break;
1832 /////-----SAL-----/////
1833 case 0x48:
1834
1835 break;
1836
1837 case 0x58:
1838
1839 break;
1840 /////-----ASR-----/////
1841 case 0x49:
1842
1843 break;
1844 case 0x59:
1845
1846 break;
1847 /////-----SWI-----/////
1848 case 0x85:
1849
1850 break;
1851
1852 /////-----RTI-----/////
1853 case 0x86:
1854
1855 break;
1856 }
1857
1858
1859}
1860
1861
1862void Group_2_Move(BYTE opcode) {
1863 WORD address = 0;
1864
1865 BYTE source = opcode >> 4;
1866 BYTE dest = opcode & 0x0F;
1867 int destReg = 0;
1868 int sourceReg = 0;
1869 /////----MOVE DEST----/////
1870 switch (dest) {
1871 case 0x08:
1872 destReg = REGISTER_A;
1873 break;
1874
1875 case 0x09:
1876 destReg = REGISTER_B;
1877 break;
1878
1879 case 0x0A:
1880 destReg = REGISTER_C;
1881 break;
1882
1883 case 0x0B:
1884 destReg = REGISTER_D;
1885 break;
1886
1887 case 0x0C:
1888 destReg = REGISTER_E;
1889 break;
1890
1891 case 0x0D:
1892 destReg = REGISTER_L;
1893 break;
1894
1895 case 0x0E:
1896 destReg = REGISTER_H;
1897 break;
1898
1899 case 0x0F:
1900 destReg = REGISTER_M;
1901 break;
1902 }
1903
1904 /////------MOVE SOURCE------/////
1905 switch (source) {
1906 case 0x07:
1907 sourceReg = REGISTER_A;
1908 break;
1909
1910 case 0x08:
1911 sourceReg = REGISTER_B;
1912 break;
1913
1914 case 0x09:
1915 sourceReg = REGISTER_C;
1916 break;
1917
1918 case 0x0A:
1919 sourceReg = REGISTER_D;
1920 break;
1921
1922 case 0x0B:
1923 sourceReg = REGISTER_E;
1924 break;
1925
1926 case 0x0C:
1927 sourceReg = REGISTER_L;
1928 break;
1929
1930 case 0x0D:
1931 sourceReg = REGISTER_H;
1932 break;
1933
1934 case 0x0E:
1935 sourceReg = REGISTER_M;
1936 break;
1937 }
1938
1939 if (sourceReg == REGISTER_M) {
1940 address = Registers[REGISTER_L];
1941 address += (WORD)Registers[REGISTER_H] << 8;
1942 Registers[destReg] = Memory[address];
1943 }
1944 Registers[destReg] = Registers[sourceReg];
1945
1946 if (destReg == REGISTER_M) {
1947 address = Registers[REGISTER_L];
1948 address += (WORD)Registers[REGISTER_H] << 8;
1949 Memory[address] = Registers[REGISTER_M];
1950 }
1951}
1952
1953
1954
1955void execute(BYTE opcode)
1956{
1957 if (((opcode >= 0x78) && (opcode <= 0x7F))
1958 || ((opcode >= 0x88) && (opcode <= 0x8F))
1959 || ((opcode >= 0x98) && (opcode <= 0x9F))
1960 || ((opcode >= 0xA8) && (opcode <= 0xAF))
1961 || ((opcode >= 0xB8) && (opcode <= 0xBF))
1962 || ((opcode >= 0xC8) && (opcode <= 0xCF))
1963 || ((opcode >= 0xD8) && (opcode <= 0xDF))
1964 || ((opcode >= 0xE8) && (opcode <= 0xEF)))
1965 {
1966 Group_2_Move(opcode);
1967 }
1968 else
1969 {
1970 Group_1(opcode);
1971 }
1972}
1973
1974void emulate()
1975{
1976 BYTE opcode;
1977 int sanity;
1978 ProgramCounter = 0;
1979 halt = false;
1980 memory_in_range = true;
1981 sanity = 0;
1982
1983 printf(" A B C D E L H X SP\n");
1984 while ((!halt) && (memory_in_range)) {
1985 sanity++;
1986 if (sanity > 500) halt = true;
1987 printf("%04X ", ProgramCounter); // Print current address
1988 opcode = fetch();
1989 execute(opcode);
1990
1991 printf("%s ", opcode_mneumonics[opcode]); // Print current opcode
1992
1993 printf("%02X ", Registers[REGISTER_A]);
1994 printf("%02X ", Registers[REGISTER_B]);
1995 printf("%02X ", Registers[REGISTER_C]);
1996 printf("%02X ", Registers[REGISTER_D]);
1997 printf("%02X ", Registers[REGISTER_E]);
1998 printf("%02X ", Registers[REGISTER_L]);
1999 printf("%02X ", Registers[REGISTER_H]);
2000 printf("%04X ", IndexRegister);
2001 printf("%04X ", StackPointer); // Print Stack Pointer
2002
2003 if ((Flags & FLAG_I) == FLAG_I)
2004 {
2005 printf("I=1 ");
2006 }
2007 else
2008 {
2009 printf("I=0 ");
2010 }
2011 if ((Flags & FLAG_N) == FLAG_N)
2012 {
2013 printf("N=1 ");
2014 }
2015 else
2016 {
2017 printf("N=0 ");
2018 }
2019 if ((Flags & FLAG_V) == FLAG_V)
2020 {
2021 printf("V=1 ");
2022 }
2023 else
2024 {
2025 printf("V=0 ");
2026 }
2027 if ((Flags & FLAG_Z) == FLAG_Z)
2028 {
2029 printf("Z=1 ");
2030 }
2031 else
2032 {
2033 printf("Z=0 ");
2034 }
2035 if ((Flags & FLAG_C) == FLAG_C)
2036 {
2037 printf("C=1 ");
2038 }
2039 else
2040 {
2041 printf("C=0 ");
2042 }
2043
2044 printf("\n"); // New line
2045 }
2046
2047 printf("\n"); // New line
2048}
2049
2050
2051////////////////////////////////////////////////////////////////////////////////
2052// Simulator/Emulator (End) //
2053////////////////////////////////////////////////////////////////////////////////
2054
2055
2056void initialise_filenames() {
2057 int i;
2058
2059 for (i = 0; i < MAX_FILENAME_SIZE; i++) {
2060 hex_file[i] = '\0';
2061 trc_file[i] = '\0';
2062 }
2063}
2064
2065
2066
2067
2068int find_dot_position(char* filename) {
2069 int dot_position;
2070 int i;
2071 char chr;
2072
2073 dot_position = 0;
2074 i = 0;
2075 chr = filename[i];
2076
2077 while (chr != '\0') {
2078 if (chr == '.') {
2079 dot_position = i;
2080 }
2081 i++;
2082 chr = filename[i];
2083 }
2084
2085 return (dot_position);
2086}
2087
2088
2089int find_end_position(char* filename) {
2090 int end_position;
2091 int i;
2092 char chr;
2093
2094 end_position = 0;
2095 i = 0;
2096 chr = filename[i];
2097
2098 while (chr != '\0') {
2099 end_position = i;
2100 i++;
2101 chr = filename[i];
2102 }
2103
2104 return (end_position);
2105}
2106
2107
2108bool file_exists(char* filename) {
2109 bool exists;
2110 FILE* ifp;
2111
2112 exists = false;
2113
2114 if ((ifp = fopen(filename, "r")) != NULL) {
2115 exists = true;
2116
2117 fclose(ifp);
2118 }
2119
2120 return (exists);
2121}
2122
2123
2124
2125void create_file(char* filename) {
2126 FILE* ofp;
2127
2128 if ((ofp = fopen(filename, "w")) != NULL) {
2129 fclose(ofp);
2130 }
2131}
2132
2133
2134
2135bool getline(FILE* fp, char* buffer) {
2136 bool rc;
2137 bool collect;
2138 char c;
2139 int i;
2140
2141 rc = false;
2142 collect = true;
2143
2144 i = 0;
2145 while (collect) {
2146 c = getc(fp);
2147
2148 switch (c) {
2149 case EOF:
2150 if (i > 0) {
2151 rc = true;
2152 }
2153 collect = false;
2154 break;
2155
2156 case '\n':
2157 if (i > 0) {
2158 rc = true;
2159 collect = false;
2160 buffer[i] = '\0';
2161 }
2162 break;
2163
2164 default:
2165 buffer[i] = c;
2166 i++;
2167 break;
2168 }
2169 }
2170
2171 return (rc);
2172}
2173
2174
2175
2176
2177
2178
2179void load_and_run(int args, _TCHAR** argv) {
2180 char chr;
2181 int ln;
2182 int dot_position;
2183 int end_position;
2184 long i;
2185 FILE* ifp;
2186 long address;
2187 long load_at;
2188 int code;
2189
2190 // Prompt for the .hex file
2191
2192 printf("\n");
2193 printf("Enter the hex filename (.hex): ");
2194
2195 if (args == 2) {
2196 ln = 0;
2197 chr = argv[1][ln];
2198 while (chr != '\0')
2199 {
2200 if (ln < MAX_FILENAME_SIZE)
2201 {
2202 hex_file[ln] = chr;
2203 trc_file[ln] = chr;
2204 ln++;
2205 }
2206 chr = argv[1][ln];
2207 }
2208 }
2209 else {
2210 ln = 0;
2211 chr = '\0';
2212 while (chr != '\n') {
2213 chr = getchar();
2214
2215 switch (chr) {
2216 case '\n':
2217 break;
2218 default:
2219 if (ln < MAX_FILENAME_SIZE) {
2220 hex_file[ln] = chr;
2221 trc_file[ln] = chr;
2222 ln++;
2223 }
2224 break;
2225 }
2226 }
2227
2228 }
2229 // Tidy up the file names
2230
2231 dot_position = find_dot_position(hex_file);
2232 if (dot_position == 0) {
2233 end_position = find_end_position(hex_file);
2234
2235 hex_file[end_position + 1] = '.';
2236 hex_file[end_position + 2] = 'h';
2237 hex_file[end_position + 3] = 'e';
2238 hex_file[end_position + 4] = 'x';
2239 hex_file[end_position + 5] = '\0';
2240 }
2241 else {
2242 hex_file[dot_position + 0] = '.';
2243 hex_file[dot_position + 1] = 'h';
2244 hex_file[dot_position + 2] = 'e';
2245 hex_file[dot_position + 3] = 'x';
2246 hex_file[dot_position + 4] = '\0';
2247 }
2248
2249 dot_position = find_dot_position(trc_file);
2250 if (dot_position == 0) {
2251 end_position = find_end_position(trc_file);
2252
2253 trc_file[end_position + 1] = '.';
2254 trc_file[end_position + 2] = 't';
2255 trc_file[end_position + 3] = 'r';
2256 trc_file[end_position + 4] = 'c';
2257 trc_file[end_position + 5] = '\0';
2258 }
2259 else {
2260 trc_file[dot_position + 0] = '.';
2261 trc_file[dot_position + 1] = 't';
2262 trc_file[dot_position + 2] = 'r';
2263 trc_file[dot_position + 3] = 'c';
2264 trc_file[dot_position + 4] = '\0';
2265 }
2266
2267 if (file_exists(hex_file)) {
2268 // Clear Registers and Memory
2269
2270 Registers[REGISTER_A] = 0;
2271 Registers[REGISTER_B] = 0;
2272 Registers[REGISTER_C] = 0;
2273 Registers[REGISTER_D] = 0;
2274 Registers[REGISTER_E] = 0;
2275 Registers[REGISTER_L] = 0;
2276 Registers[REGISTER_H] = 0;
2277 IndexRegister = 0;
2278 Flags = 0;
2279 ProgramCounter = 0;
2280 StackPointer = 0;
2281
2282 for (i = 0; i < MEMORY_SIZE; i++) {
2283 Memory[i] = 0x00;
2284 }
2285
2286 // Load hex file
2287
2288 if ((ifp = fopen(hex_file, "r")) != NULL) {
2289 printf("Loading file...\n\n");
2290
2291 load_at = 0;
2292
2293 while (getline(ifp, InputBuffer)) {
2294 if (sscanf(InputBuffer, "L=%x", &address) == 1) {
2295 load_at = address;
2296 }
2297 else if (sscanf(InputBuffer, "%x", &code) == 1) {
2298 if ((load_at >= 0) && (load_at <= MEMORY_SIZE)) {
2299 Memory[load_at] = (BYTE)code;
2300 }
2301 load_at++;
2302 }
2303 else {
2304 printf("ERROR> Failed to load instruction: %s \n", InputBuffer);
2305 }
2306 }
2307
2308 fclose(ifp);
2309 }
2310
2311 // Emulate
2312
2313 emulate();
2314 }
2315 else {
2316 printf("\n");
2317 printf("ERROR> Input file %s does not exist!\n", hex_file);
2318 printf("\n");
2319 }
2320}
2321
2322void building(int args, _TCHAR** argv) {
2323 char buffer[1024];
2324 load_and_run(args, argv);
2325 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",
2326 Memory[TEST_ADDRESS_1],
2327 Memory[TEST_ADDRESS_2],
2328 Memory[TEST_ADDRESS_3],
2329 Memory[TEST_ADDRESS_4],
2330 Memory[TEST_ADDRESS_5],
2331 Memory[TEST_ADDRESS_6],
2332 Memory[TEST_ADDRESS_7],
2333 Memory[TEST_ADDRESS_8],
2334 Memory[TEST_ADDRESS_9],
2335 Memory[TEST_ADDRESS_10],
2336 Memory[TEST_ADDRESS_11],
2337 Memory[TEST_ADDRESS_12]
2338 );
2339 sendto(sock, buffer, strlen(buffer), 0, (SOCKADDR*)&server_addr, sizeof(SOCKADDR));
2340}
2341
2342
2343
2344void test_and_mark() {
2345 char buffer[1024];
2346 bool testing_complete;
2347 int len = sizeof(SOCKADDR);
2348 char chr;
2349 int i;
2350 int j;
2351 bool end_of_program;
2352 long address;
2353 long load_at;
2354 int code;
2355 int mark;
2356 int passed;
2357
2358 printf("\n");
2359 printf("Automatic Testing and Marking\n");
2360 printf("\n");
2361
2362 testing_complete = false;
2363
2364 sprintf(buffer, "Test Student %s", STUDENT_NUMBER);
2365 sendto(sock, buffer, strlen(buffer), 0, (SOCKADDR*)&server_addr, sizeof(SOCKADDR));
2366
2367 while (!testing_complete) {
2368 memset(buffer, '\0', sizeof(buffer));
2369
2370 if (recvfrom(sock, buffer, sizeof(buffer) - 1, 0, (SOCKADDR*)&client_addr, &len) != SOCKET_ERROR) {
2371 printf("Incoming Data: %s \n", buffer);
2372
2373 //if (strcmp(buffer, "Testing complete") == 1)
2374 if (sscanf(buffer, "Testing complete %d", &mark) == 1) {
2375 testing_complete = true;
2376 printf("Current mark = %d\n", mark);
2377
2378 }
2379 else if (sscanf(buffer, "Tests passed %d", &passed) == 1) {
2380 //testing_complete = true;
2381 printf("Passed = %d\n", passed);
2382
2383 }
2384 else if (strcmp(buffer, "Error") == 0) {
2385 printf("ERROR> Testing abnormally terminated\n");
2386 testing_complete = true;
2387 }
2388 else {
2389 // Clear Registers and Memory
2390
2391 Registers[REGISTER_A] = 0;
2392 Registers[REGISTER_B] = 0;
2393 Registers[REGISTER_C] = 0;
2394 Registers[REGISTER_D] = 0;
2395 Registers[REGISTER_E] = 0;
2396 Registers[REGISTER_L] = 0;
2397 Registers[REGISTER_H] = 0;
2398 IndexRegister = 0;
2399 Flags = 0;
2400 ProgramCounter = 0;
2401 StackPointer = 0;
2402 for (i = 0; i < MEMORY_SIZE; i++) {
2403 Memory[i] = 0;
2404 }
2405
2406 // Load hex file
2407
2408 i = 0;
2409 j = 0;
2410 load_at = 0;
2411 end_of_program = false;
2412 FILE* ofp;
2413 fopen_s(&ofp, "branch.txt", "a");
2414
2415 while (!end_of_program) {
2416 chr = buffer[i];
2417 switch (chr) {
2418 case '\0':
2419 end_of_program = true;
2420
2421 case ',':
2422 if (sscanf(InputBuffer, "L=%x", &address) == 1) {
2423 load_at = address;
2424 }
2425 else if (sscanf(InputBuffer, "%x", &code) == 1) {
2426 if ((load_at >= 0) && (load_at <= MEMORY_SIZE)) {
2427 Memory[load_at] = (BYTE)code;
2428 fprintf(ofp, "%02X\n", (BYTE)code);
2429 }
2430 load_at++;
2431 }
2432 else {
2433 printf("ERROR> Failed to load instruction: %s \n", InputBuffer);
2434 }
2435 j = 0;
2436 break;
2437
2438 default:
2439 InputBuffer[j] = chr;
2440 j++;
2441 break;
2442 }
2443 i++;
2444 }
2445 fclose(ofp);
2446 // Emulate
2447
2448 if (load_at > 1) {
2449 emulate();
2450 // Send and store results
2451 sprintf(buffer, "%02X%02X %02X%02X %02X%02X %02X%02X %02X%02X %02X%02X",
2452 Memory[TEST_ADDRESS_1],
2453 Memory[TEST_ADDRESS_2],
2454 Memory[TEST_ADDRESS_3],
2455 Memory[TEST_ADDRESS_4],
2456 Memory[TEST_ADDRESS_5],
2457 Memory[TEST_ADDRESS_6],
2458 Memory[TEST_ADDRESS_7],
2459 Memory[TEST_ADDRESS_8],
2460 Memory[TEST_ADDRESS_9],
2461 Memory[TEST_ADDRESS_10],
2462 Memory[TEST_ADDRESS_11],
2463 Memory[TEST_ADDRESS_12]
2464 );
2465 sendto(sock, buffer, strlen(buffer), 0, (SOCKADDR*)&server_addr, sizeof(SOCKADDR));
2466 }
2467 }
2468 }
2469 }
2470}
2471
2472
2473
2474int _tmain(int argc, _TCHAR* argv[])
2475{
2476 char chr;
2477 char dummy;
2478
2479 printf("\n");
2480 printf("Microprocessor Emulator\n");
2481 printf("UWE Computer and Network Systems Assignment 1\n");
2482 printf("\n");
2483
2484 initialise_filenames();
2485
2486 if (WSAStartup(MAKEWORD(2, 2), &data) != 0) return(0);
2487
2488 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); // Here we create our socket, which will be a UDP socket (SOCK_DGRAM).
2489 if (!sock) {
2490 // Creation failed!
2491 }
2492
2493 memset(&server_addr, 0, sizeof(SOCKADDR_IN));
2494 server_addr.sin_family = AF_INET;
2495 server_addr.sin_addr.s_addr = inet_addr(IP_ADDRESS_SERVER);
2496 server_addr.sin_port = htons(PORT_SERVER);
2497
2498 memset(&client_addr, 0, sizeof(SOCKADDR_IN));
2499 client_addr.sin_family = AF_INET;
2500 client_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
2501 client_addr.sin_port = htons(PORT_CLIENT);
2502
2503 chr = '\0';
2504 while ((chr != 'e') && (chr != 'E'))
2505 {
2506 printf("\n");
2507 printf("Please select option\n");
2508 printf("L - Load and run a hex file\n");
2509 printf("T - Have the server test and mark your emulator\n");
2510 printf("E - Exit\n");
2511 if (argc == 2) { building(argc, argv); exit(0); }
2512 printf("Enter option: ");
2513 chr = getchar();
2514 if (chr != 0x0A)
2515 {
2516 dummy = getchar(); // read in the <CR>
2517 }
2518 printf("\n");
2519
2520 switch (chr)
2521 {
2522 case 'L':
2523 case 'l':
2524 load_and_run(argc, argv);
2525 break;
2526
2527 case 'T':
2528 case 't':
2529 test_and_mark();
2530 break;
2531
2532 default:
2533 break;
2534 }
2535 }
2536
2537 closesocket(sock);
2538 WSACleanup();
2539
2540
2541 return 0;
2542}