· 5 years ago · Feb 18, 2020, 06:36 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}
426
427
428void set_flag_z(BYTE inReg) {
429 BYTE reg;
430 reg = inReg;
431 if (reg == 0) // zero set
432 {
433 Flags = Flags | FLAG_Z;
434 }
435 else
436 {
437 Flags = Flags & (0xFF - FLAG_Z);
438 }
439}
440
441
442void Group_1(BYTE opcode){
443 BYTE LB = 0;
444 BYTE HB = 0;
445
446 WORD address = 0;
447 WORD data = 0;
448 WORD param1;
449 WORD param2;
450 WORD temp_word;
451
452 switch (opcode) {
453 case 0xB7: //LD Immidiate
454 data = fetch();
455 Registers[REGISTER_A] = data;
456 set_flag_n(Registers[REGISTER_A]);
457 set_flag_z(Registers[REGISTER_A]);
458 Flags = Flags & (0xFF - FLAG_C);
459 break;
460
461 case 0xC7:
462 HB = fetch();
463 LB = fetch();
464 address += (WORD)((WORD)HB << 8) + LB;
465 if (address >= 0 && address < MEMORY_SIZE) {
466 Registers[REGISTER_A] = Memory[address];
467 }
468 set_flag_n(Registers[REGISTER_A]);
469 set_flag_z(Registers[REGISTER_A]);
470 Flags = Flags & (0xFF - FLAG_C);
471 break;
472
473 case 0xD7:
474 address += IndexRegister;
475 HB = fetch(); LB = fetch();
476 address += (WORD)((WORD)HB << 8) + LB;
477 if (address >= 0 && address < MEMORY_SIZE) {
478 Registers[REGISTER_A] = Memory[address];
479 }
480 set_flag_n(Registers[REGISTER_A]);
481 set_flag_z(Registers[REGISTER_A]);
482 Flags = Flags & (0xFF - FLAG_C);
483 break;
484
485 ///-------------ST------------///
486
487 case 0x10:
488 HB = fetch();
489 LB = fetch(); address += (WORD)((WORD)HB << 8) + LB;
490 if (address >= 0 && address < MEMORY_SIZE) {
491 Memory[address] = Registers[REGISTER_A];
492 }
493 set_flag_n(Registers[REGISTER_A]);
494 set_flag_z(Registers[REGISTER_A]);
495 Flags = Flags & (0xFF - FLAG_C);
496 break;
497
498 case 0x20:
499 address += IndexRegister;
500 HB = fetch();
501 LB = fetch();
502 address += (WORD)((WORD)HB << 8) + LB
503 ; if (address >= 0 && address < MEMORY_SIZE) {
504 Memory[address] = Registers[REGISTER_A];
505 }
506 set_flag_n(Registers[REGISTER_A]);
507 set_flag_z(Registers[REGISTER_A]);
508 Flags = Flags & (0xFF - FLAG_C);
509 break;
510
511 ////------MVI------///
512
513 case 0x2A:
514 data = fetch();
515 Registers[REGISTER_B] = data;
516 set_flag_n(Registers[REGISTER_A]);
517 set_flag_z(Registers[REGISTER_A]);
518 Flags = Flags & (0xFF - FLAG_C);
519 break;
520
521 case 0x2B:
522 data = fetch();
523 Registers[REGISTER_C] = data;
524 set_flag_n(Registers[REGISTER_A]);
525 set_flag_z(Registers[REGISTER_A]);
526 Flags = Flags & (0xFF - FLAG_C);
527 break;
528
529 case 0x2C:
530 data = fetch();
531 Registers[REGISTER_D] = data;
532 set_flag_n(Registers[REGISTER_A]);
533 set_flag_z(Registers[REGISTER_A]);
534 Flags = Flags & (0xFF - FLAG_C);
535 break;
536
537 case 0x2D:
538 data = fetch();
539 Registers[REGISTER_E] = data;
540 set_flag_n(Registers[REGISTER_A]);
541 set_flag_z(Registers[REGISTER_A]);
542 Flags = Flags & (0xFF - FLAG_C);
543 break;
544
545 case 0x2E:
546 data = fetch();
547 Registers[REGISTER_L] = 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 0x2F:
554 data = fetch();
555 Registers[REGISTER_H] = data;
556 set_flag_n(Registers[REGISTER_A]);
557 set_flag_z(Registers[REGISTER_A]);
558 Flags = Flags & (0xFF - FLAG_C);
559 break;
560 ////----LODS-----///
561 case 0x4F:
562 data = fetch();
563 StackPointer = data << 8;
564 StackPointer += fetch();
565 break;
566
567 case 0x5f:
568 HB = fetch();
569 LB = fetch();
570 address += (WORD)((WORD)HB << 8) + LB;
571 if (address >= 0 && address < MEMORY_SIZE - 1) {
572 StackPointer = (WORD)Memory[address] << 8;
573 StackPointer += Memory[address + 1];
574 }
575 break;
576
577 case 0x6f:
578 address += IndexRegister;
579 HB = fetch();
580 LB = fetch();
581 address += (WORD)((WORD)HB << 8) + LB;
582 if (address >= 0 && address < MEMORY_SIZE - 1) {
583 StackPointer = (WORD)Memory[address] << 8;
584 StackPointer += Memory[address + 1];
585 }
586 break;
587
588
589 /////-----ADC-----/////
590
591 case 0x90:
592 param1 = Registers[REGISTER_A];
593 param2 = Registers[REGISTER_B];
594 temp_word = (WORD)param1 + (WORD)param2;
595 if ((Flags & FLAG_C) != 0) {
596 temp_word++;
597 }
598 if (temp_word >= 0x100) {
599 Flags = Flags | FLAG_C; // Set carry flag
600 }
601 else {
602 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
603 }
604 set_flag_n((BYTE)temp_word);
605 set_flag_z((BYTE)temp_word);
606 set_flag_v(param1, param2, (BYTE)temp_word);
607 Registers[REGISTER_A] = (BYTE)temp_word;
608 break;
609
610 case 0xA0:
611 param1 = Registers[REGISTER_A];
612 param2 = Registers[REGISTER_C];
613 temp_word = (WORD)param1 + (WORD)param2;
614 if ((Flags & FLAG_C) != 0) {
615 temp_word++;
616 }
617 if (temp_word >= 0x100) {
618 Flags = Flags | FLAG_C; // Set carry flag
619 }
620 else {
621 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
622 }
623 set_flag_n((BYTE)temp_word);
624 set_flag_z((BYTE)temp_word);
625 set_flag_v(param1, param2, (BYTE)temp_word);
626 Registers[REGISTER_A] = (BYTE)temp_word;
627 break;
628
629 case 0xB0:
630 param1 = Registers[REGISTER_A];
631 param2 = Registers[REGISTER_D];
632 temp_word = (WORD)param1 + (WORD)param2;
633 if ((Flags & FLAG_C) != 0) {
634 temp_word++;
635 }
636 if (temp_word >= 0x100) {
637 Flags = Flags | FLAG_C; // Set carry flag
638 }
639 else {
640 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
641 }
642 set_flag_n((BYTE)temp_word);
643 set_flag_z((BYTE)temp_word);
644 set_flag_v(param1, param2, (BYTE)temp_word);
645 Registers[REGISTER_A] = (BYTE)temp_word;
646 break;
647
648 case 0xC0:
649 param1 = Registers[REGISTER_A];
650 param2 = Registers[REGISTER_E];
651 temp_word = (WORD)param1 + (WORD)param2;
652 if ((Flags & FLAG_C) != 0) {
653 temp_word++;
654 }
655 if (temp_word >= 0x100) {
656 Flags = Flags | FLAG_C; // Set carry flag
657 }
658 else {
659 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
660 }
661 set_flag_n((BYTE)temp_word);
662 set_flag_z((BYTE)temp_word);
663 set_flag_v(param1, param2, (BYTE)temp_word);
664 Registers[REGISTER_A] = (BYTE)temp_word;
665 break;
666
667 case 0xD0:
668 param1 = Registers[REGISTER_A];
669 param2 = Registers[REGISTER_L];
670 temp_word = (WORD)param1 + (WORD)param2;
671 if ((Flags & FLAG_C) != 0) {
672 temp_word++;
673 }
674 if (temp_word >= 0x100) {
675 Flags = Flags | FLAG_C; // Set carry flag
676 }
677 else {
678 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
679 }
680 set_flag_n((BYTE)temp_word);
681 set_flag_z((BYTE)temp_word);
682 set_flag_v(param1, param2, (BYTE)temp_word);
683 Registers[REGISTER_A] = (BYTE)temp_word;
684 break;
685
686 case 0xE0:
687 param1 = Registers[REGISTER_A];
688 param2 = Registers[REGISTER_H];
689 temp_word = (WORD)param1 + (WORD)param2;
690 if ((Flags & FLAG_C) != 0) {
691 temp_word++;
692 }
693 if (temp_word >= 0x100) {
694 Flags = Flags | FLAG_C; // Set carry flag
695 }
696 else {
697 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
698 }
699 set_flag_n((BYTE)temp_word);
700 set_flag_z((BYTE)temp_word);
701 set_flag_v(param1, param2, (BYTE)temp_word);
702 Registers[REGISTER_A] = (BYTE)temp_word;
703 break;
704
705 case 0xF0:
706 param1 = Registers[REGISTER_A];
707 param2 = Registers[REGISTER_M];
708 temp_word = (WORD)param1 + (WORD)param2;
709 if ((Flags & FLAG_C) != 0) {
710 temp_word++;
711 }
712 if (temp_word >= 0x100) {
713 Flags = Flags | FLAG_C; // Set carry flag
714 }
715 else {
716 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
717 }
718 set_flag_n((BYTE)temp_word);
719 set_flag_z((BYTE)temp_word);
720 set_flag_v(param1, param2, (BYTE)temp_word);
721 Registers[REGISTER_A] = (BYTE)temp_word;
722 break;
723
724 /////-------CMP--------/////
725
726 case 0x92:
727 param1 = Registers[REGISTER_A];
728 param2 = Registers[REGISTER_B];
729 temp_word = (WORD)param1 - (WORD)param2;
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 break;
740
741 case 0xA2:
742 param1 = Registers[REGISTER_A];
743 param2 = Registers[REGISTER_C];
744 temp_word = (WORD)param1 - (WORD)param2;
745 if (temp_word >= 0x100) {
746 Flags = Flags | FLAG_C; // Set carry flag
747 }
748 else {
749 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
750 }
751 set_flag_n((BYTE)temp_word);
752 set_flag_z((BYTE)temp_word);
753 set_flag_v(param1, param2, (BYTE)temp_word);
754 break;
755
756 case 0xB2:
757 param1 = Registers[REGISTER_A];
758 param2 = Registers[REGISTER_D];
759 temp_word = (WORD)param1 - (WORD)param2;
760 if (temp_word >= 0x100) {
761 Flags = Flags | FLAG_C; // Set carry flag
762 }
763 else {
764 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
765 }
766 set_flag_n((BYTE)temp_word);
767 set_flag_z((BYTE)temp_word);
768 set_flag_v(param1, param2, (BYTE)temp_word);
769 break;
770
771 case 0xC2:
772 param1 = Registers[REGISTER_A];
773 param2 = Registers[REGISTER_E];
774 temp_word = (WORD)param1 - (WORD)param2;
775 if (temp_word >= 0x100) {
776 Flags = Flags | FLAG_C; // Set carry flag
777 }
778 else {
779 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
780 }
781 set_flag_n((BYTE)temp_word);
782 set_flag_z((BYTE)temp_word);
783 set_flag_v(param1, param2, (BYTE)temp_word);
784 break;
785
786 case 0xD2:
787 param1 = Registers[REGISTER_A];
788 param2 = Registers[REGISTER_L];
789 temp_word = (WORD)param1 - (WORD)param2;
790 if (temp_word >= 0x100) {
791 Flags = Flags | FLAG_C; // Set carry flag
792 }
793 else {
794 Flags = Flags & (0xFF - FLAG_C); // Clear carry flag
795 }
796 set_flag_n((BYTE)temp_word);
797 set_flag_z((BYTE)temp_word);
798 set_flag_v(param1, param2, (BYTE)temp_word);
799 break;
800
801 case 0xE2:
802 param1 = Registers[REGISTER_A];
803 param2 = Registers[REGISTER_H];
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 0xF2:
817 param1 = Registers[REGISTER_A];
818 param2 = Registers[REGISTER_M];
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
832 //////-----------TSA-------------//////
833
834 case 0x75:
835 Registers[REGISTER_A] = Flags;
836 break;
837
838
839 //////-----------TAS-------------//////
840
841 case 0x74:
842 Flags = Registers[REGISTER_A];
843 break;
844
845 //////-----------SEC-------------//////
846 case 0x16:
847 Flags = Flags | FLAG_C;
848 break;
849
850 /////-----------CLC----------/////
851
852 case 0x15:
853 Flags = Flags & (0xFF - FLAG_C);
854 break;
855
856 /////----------CLI------------/////
857 case 0x17:
858 Flags = Flags & (0xFF - FLAG_I);
859 break;
860 /////----------STI------------/////
861 case 0x18:
862 Flags = Flags | FLAG_I;
863 break;
864
865 /////----------SEV------------/////
866 Flags = Flags | FLAG_V;
867
868 /////----------CLV------------/////
869 Flags = Flags & (0xFF - FLAG_V);
870
871 /////-----------PSH-----------/////
872 case 0x11:
873 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
874 Memory[StackPointer] = Registers[REGISTER_A];
875 StackPointer--;
876 }
877 break;
878
879 case 0x21:
880 Memory[StackPointer] = Flags;
881 StackPointer--;
882 break;
883
884 case 0x31:
885 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
886 Memory[StackPointer] = Registers[REGISTER_B];
887 StackPointer--;
888 }
889 break;
890
891 case 0x41:
892 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
893 Memory[StackPointer] = Registers[REGISTER_C];
894 StackPointer--;
895 }
896 break;
897
898 case 0x51:
899 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
900 Memory[StackPointer] = Registers[REGISTER_D];
901 StackPointer--;
902 }
903 break;
904
905 case 0x61:
906 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
907 Memory[StackPointer] = Registers[REGISTER_E];
908 StackPointer--;
909 }
910 break;
911
912 case 0x71:
913 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
914 Memory[StackPointer] = Registers[REGISTER_L];
915 StackPointer--;
916 }
917 break;
918
919 case 0x81:
920 if ((StackPointer >= 1) && (StackPointer < MEMORY_SIZE)) {
921 Memory[StackPointer] = Registers[REGISTER_H];
922 StackPointer--;
923 }
924 break;
925
926 /////-----------POP------------////
927
928 case 0x12:
929 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
930 StackPointer ++;
931 Registers[REGISTER_A] = Memory[StackPointer];
932 }
933 break;
934
935 case 0x22:
936 StackPointer++;
937 Flags = Memory[StackPointer];
938 break;
939
940 case 0x32:
941 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
942 StackPointer++;
943 Registers[REGISTER_B] = Memory[StackPointer];
944 }
945 break;
946
947 case 0x42:
948 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
949 StackPointer++;
950 Registers[REGISTER_C] = Memory[StackPointer];
951 }
952 break;
953
954 case 0x52:
955 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
956 StackPointer++;
957 Registers[REGISTER_D] = Memory[StackPointer];
958 }
959 break;
960
961 case 0x62:
962 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
963 StackPointer++;
964 Registers[REGISTER_E] = Memory[StackPointer];
965 }
966 break;
967
968 case 0x72:
969 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
970 StackPointer++;
971 Registers[REGISTER_L] = Memory[StackPointer];
972 }
973 break;
974
975 case 0x82:
976 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 1)) {
977 StackPointer++;
978 Registers[REGISTER_H] = Memory[StackPointer];
979 }
980 break;
981
982 //////------JMP------//////
983 case 0xFA:
984 HB = fetch();
985 LB = fetch();
986 address = ((WORD)HB << 8) + (WORD)LB;
987 ProgramCounter = address;
988 break;
989
990 //////-----JPR-----------////
991 case 0x33:
992 HB = fetch();
993 LB = fetch();
994 address = ((WORD)HB << 8) + (WORD)LB;
995 ProgramCounter = address;
996 break;
997
998 /////------RTN---------/////
999 case 0x0E:
1000 HB = fetch();
1001 LB = fetch();
1002 address = ((WORD)HB << 8) + (WORD)LB;
1003 if ((StackPointer >= 0) && (StackPointer < MEMORY_SIZE - 2)) {
1004 StackPointer++;
1005 HB = Memory[StackPointer];
1006 StackPointer++;
1007 LB = Memory[StackPointer];
1008 }
1009 ProgramCounter = ((WORD)HB << 8) + (WORD)LB;
1010 break;
1011
1012 /////------BRA-------/////
1013
1014
1015
1016 }
1017}
1018
1019void Group_2_Move(BYTE opcode) {
1020 switch (opcode) {
1021 int destination;
1022 int source;
1023
1024 int destReg;
1025 int sourceReg;
1026
1027 WORD address;
1028
1029 destination = opcode & 0x0F;
1030
1031 switch (destination)
1032 {
1033 case 0x08:
1034 destReg = REGISTER_A;
1035 break;
1036
1037 case 0x09:
1038 destReg = REGISTER_B;
1039 break;
1040
1041 case 0x0A:
1042 destReg = REGISTER_C;
1043 break;
1044
1045 case 0x0B:
1046 destReg = REGISTER_D;
1047 break;
1048
1049 case 0x0C:
1050 destReg = REGISTER_E;
1051 break;
1052
1053 case 0x0D:
1054 destReg = REGISTER_L;
1055 break;
1056
1057 case 0x0E:
1058 destReg = REGISTER_H;
1059 break;
1060
1061 case 0x0F:
1062 destReg = REGISTER_M;
1063 break;
1064 }
1065
1066 source = (opcode >> 4) & 0x0F;
1067
1068 switch (source)
1069 {
1070 case 0x07:
1071 sourceReg = REGISTER_A;
1072 break;
1073
1074 case 0x08:
1075 sourceReg = REGISTER_B;
1076 break;
1077
1078 case 0x09:
1079 sourceReg = REGISTER_C;
1080 break;
1081
1082 case 0x0A:
1083 sourceReg = REGISTER_D;
1084 break;
1085
1086 case 0x0B:
1087 sourceReg = REGISTER_E;
1088 break;
1089
1090 case 0x0C:
1091 sourceReg = REGISTER_L;
1092 break;
1093 case 0x0D:
1094 sourceReg = REGISTER_H;
1095 break;
1096
1097 case 0x0E:
1098 sourceReg = REGISTER_M;
1099 break;
1100 }
1101
1102 if (sourceReg == REGISTER_M)
1103 {
1104 address = (WORD)Registers[REGISTER_H] << 8 + (WORD)Registers[REGISTER_L];
1105 Registers[REGISTER_M] = Memory[address];
1106 }
1107
1108 Registers[destReg] = Registers[sourceReg];
1109
1110 if (destReg == REGISTER_M)
1111 {
1112 address = (WORD)Registers[REGISTER_H] << 8 + (WORD)Registers[REGISTER_L];
1113 Memory[address] = Registers[REGISTER_M];
1114 }
1115 break;
1116
1117 //////---------MOVE-----------//////
1118
1119
1120
1121
1122
1123
1124 }
1125}
1126
1127
1128
1129void execute(BYTE opcode)
1130{
1131 if (((opcode >= 0x78) && (opcode <= 0x7F))
1132 || ((opcode >= 0x88) && (opcode <= 0x8F))
1133 || ((opcode >= 0x98) && (opcode <= 0x9F))
1134 || ((opcode >= 0xA8) && (opcode <= 0xAF))
1135 || ((opcode >= 0xB8) && (opcode <= 0xBF))
1136 || ((opcode >= 0xC8) && (opcode <= 0xCF))
1137 || ((opcode >= 0xD8) && (opcode <= 0xDF))
1138 || ((opcode >= 0xE8) && (opcode <= 0xEF)))
1139 {
1140 Group_2_Move(opcode);
1141 }
1142 else
1143 {
1144 Group_1(opcode);
1145 }
1146}
1147
1148void emulate()
1149{
1150 BYTE opcode;
1151 int sanity;
1152 ProgramCounter = 0;
1153 halt = false;
1154 memory_in_range = true;
1155 sanity = 0;
1156
1157 printf(" A B C D E L H X SP\n");
1158 while ((!halt) && (memory_in_range)) {
1159 sanity++;
1160 if (sanity > 500) halt = true;
1161 printf("%04X ", ProgramCounter); // Print current address
1162 opcode = fetch();
1163 execute(opcode);
1164
1165 printf("%s ", opcode_mneumonics[opcode]); // Print current opcode
1166
1167 printf("%02X ", Registers[REGISTER_A]);
1168 printf("%02X ", Registers[REGISTER_B]);
1169 printf("%02X ", Registers[REGISTER_C]);
1170 printf("%02X ", Registers[REGISTER_D]);
1171 printf("%02X ", Registers[REGISTER_E]);
1172 printf("%02X ", Registers[REGISTER_L]);
1173 printf("%02X ", Registers[REGISTER_H]);
1174 printf("%04X ", IndexRegister);
1175 printf("%04X ", StackPointer); // Print Stack Pointer
1176
1177 if ((Flags & FLAG_I) == FLAG_I)
1178 {
1179 printf("I=1 ");
1180 }
1181 else
1182 {
1183 printf("I=0 ");
1184 }
1185 if ((Flags & FLAG_N) == FLAG_N)
1186 {
1187 printf("N=1 ");
1188 }
1189 else
1190 {
1191 printf("N=0 ");
1192 }
1193 if ((Flags & FLAG_V) == FLAG_V)
1194 {
1195 printf("V=1 ");
1196 }
1197 else
1198 {
1199 printf("V=0 ");
1200 }
1201 if ((Flags & FLAG_Z) == FLAG_Z)
1202 {
1203 printf("Z=1 ");
1204 }
1205 else
1206 {
1207 printf("Z=0 ");
1208 }
1209 if ((Flags & FLAG_C) == FLAG_C)
1210 {
1211 printf("C=1 ");
1212 }
1213 else
1214 {
1215 printf("C=0 ");
1216 }
1217
1218 printf("\n"); // New line
1219 }
1220
1221 printf("\n"); // New line
1222}
1223
1224
1225////////////////////////////////////////////////////////////////////////////////
1226// Simulator/Emulator (End) //
1227////////////////////////////////////////////////////////////////////////////////
1228
1229
1230void initialise_filenames() {
1231 int i;
1232
1233 for (i=0; i<MAX_FILENAME_SIZE; i++) {
1234 hex_file [i] = '\0';
1235 trc_file [i] = '\0';
1236 }
1237}
1238
1239
1240
1241
1242int find_dot_position(char *filename) {
1243 int dot_position;
1244 int i;
1245 char chr;
1246
1247 dot_position = 0;
1248 i = 0;
1249 chr = filename[i];
1250
1251 while (chr != '\0') {
1252 if (chr == '.') {
1253 dot_position = i;
1254 }
1255 i++;
1256 chr = filename[i];
1257 }
1258
1259 return (dot_position);
1260}
1261
1262
1263int find_end_position(char *filename) {
1264 int end_position;
1265 int i;
1266 char chr;
1267
1268 end_position = 0;
1269 i = 0;
1270 chr = filename[i];
1271
1272 while (chr != '\0') {
1273 end_position = i;
1274 i++;
1275 chr = filename[i];
1276 }
1277
1278 return (end_position);
1279}
1280
1281
1282bool file_exists(char *filename) {
1283 bool exists;
1284 FILE *ifp;
1285
1286 exists = false;
1287
1288 if ( ( ifp = fopen( filename, "r" ) ) != NULL ) {
1289 exists = true;
1290
1291 fclose(ifp);
1292 }
1293
1294 return (exists);
1295}
1296
1297
1298
1299void create_file(char *filename) {
1300 FILE *ofp;
1301
1302 if ( ( ofp = fopen( filename, "w" ) ) != NULL ) {
1303 fclose(ofp);
1304 }
1305}
1306
1307
1308
1309bool getline(FILE *fp, char *buffer) {
1310 bool rc;
1311 bool collect;
1312 char c;
1313 int i;
1314
1315 rc = false;
1316 collect = true;
1317
1318 i = 0;
1319 while (collect) {
1320 c = getc(fp);
1321
1322 switch (c) {
1323 case EOF:
1324 if (i > 0) {
1325 rc = true;
1326 }
1327 collect = false;
1328 break;
1329
1330 case '\n':
1331 if (i > 0) {
1332 rc = true;
1333 collect = false;
1334 buffer[i] = '\0';
1335 }
1336 break;
1337
1338 default:
1339 buffer[i] = c;
1340 i++;
1341 break;
1342 }
1343 }
1344
1345 return (rc);
1346}
1347
1348
1349
1350
1351
1352
1353void load_and_run(int args,_TCHAR** argv) {
1354 char chr;
1355 int ln;
1356 int dot_position;
1357 int end_position;
1358 long i;
1359 FILE *ifp;
1360 long address;
1361 long load_at;
1362 int code;
1363
1364 // Prompt for the .hex file
1365
1366 printf("\n");
1367 printf("Enter the hex filename (.hex): ");
1368
1369 if(args == 2){
1370 ln = 0;
1371 chr = argv[1][ln];
1372 while (chr != '\0')
1373 {
1374 if (ln < MAX_FILENAME_SIZE)
1375 {
1376 hex_file [ln] = chr;
1377 trc_file [ln] = chr;
1378 ln++;
1379 }
1380 chr = argv[1][ln];
1381 }
1382 } else {
1383 ln = 0;
1384 chr = '\0';
1385 while (chr != '\n') {
1386 chr = getchar();
1387
1388 switch(chr) {
1389 case '\n':
1390 break;
1391 default:
1392 if (ln < MAX_FILENAME_SIZE) {
1393 hex_file [ln] = chr;
1394 trc_file [ln] = chr;
1395 ln++;
1396 }
1397 break;
1398 }
1399 }
1400
1401 }
1402 // Tidy up the file names
1403
1404 dot_position = find_dot_position(hex_file);
1405 if (dot_position == 0) {
1406 end_position = find_end_position(hex_file);
1407
1408 hex_file[end_position + 1] = '.';
1409 hex_file[end_position + 2] = 'h';
1410 hex_file[end_position + 3] = 'e';
1411 hex_file[end_position + 4] = 'x';
1412 hex_file[end_position + 5] = '\0';
1413 } else {
1414 hex_file[dot_position + 0] = '.';
1415 hex_file[dot_position + 1] = 'h';
1416 hex_file[dot_position + 2] = 'e';
1417 hex_file[dot_position + 3] = 'x';
1418 hex_file[dot_position + 4] = '\0';
1419 }
1420
1421 dot_position = find_dot_position(trc_file);
1422 if (dot_position == 0) {
1423 end_position = find_end_position(trc_file);
1424
1425 trc_file[end_position + 1] = '.';
1426 trc_file[end_position + 2] = 't';
1427 trc_file[end_position + 3] = 'r';
1428 trc_file[end_position + 4] = 'c';
1429 trc_file[end_position + 5] = '\0';
1430 } else {
1431 trc_file[dot_position + 0] = '.';
1432 trc_file[dot_position + 1] = 't';
1433 trc_file[dot_position + 2] = 'r';
1434 trc_file[dot_position + 3] = 'c';
1435 trc_file[dot_position + 4] = '\0';
1436 }
1437
1438 if (file_exists(hex_file)) {
1439 // Clear Registers and Memory
1440
1441 Registers[REGISTER_A] = 0;
1442 Registers[REGISTER_B] = 0;
1443 Registers[REGISTER_C] = 0;
1444 Registers[REGISTER_D] = 0;
1445 Registers[REGISTER_E] = 0;
1446 Registers[REGISTER_L] = 0;
1447 Registers[REGISTER_H] = 0;
1448 IndexRegister = 0;
1449 Flags = 0;
1450 ProgramCounter = 0;
1451 StackPointer = 0;
1452
1453 for (i=0; i<MEMORY_SIZE; i++) {
1454 Memory[i] = 0x00;
1455 }
1456
1457 // Load hex file
1458
1459 if ( ( ifp = fopen( hex_file, "r" ) ) != NULL ) {
1460 printf("Loading file...\n\n");
1461
1462 load_at = 0;
1463
1464 while (getline(ifp, InputBuffer)) {
1465 if (sscanf(InputBuffer, "L=%x", &address) == 1) {
1466 load_at = address;
1467 } else if (sscanf(InputBuffer, "%x", &code) == 1) {
1468 if ((load_at >= 0) && (load_at <= MEMORY_SIZE)) {
1469 Memory[load_at] = (BYTE)code;
1470 }
1471 load_at++;
1472 } else {
1473 printf("ERROR> Failed to load instruction: %s \n", InputBuffer);
1474 }
1475 }
1476
1477 fclose(ifp);
1478 }
1479
1480 // Emulate
1481
1482 emulate();
1483 } else {
1484 printf("\n");
1485 printf("ERROR> Input file %s does not exist!\n", hex_file);
1486 printf("\n");
1487 }
1488}
1489
1490void building(int args, _TCHAR** argv) {
1491 char buffer[1024];
1492 load_and_run(args,argv);
1493 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",
1494 Memory[TEST_ADDRESS_1],
1495 Memory[TEST_ADDRESS_2],
1496 Memory[TEST_ADDRESS_3],
1497 Memory[TEST_ADDRESS_4],
1498 Memory[TEST_ADDRESS_5],
1499 Memory[TEST_ADDRESS_6],
1500 Memory[TEST_ADDRESS_7],
1501 Memory[TEST_ADDRESS_8],
1502 Memory[TEST_ADDRESS_9],
1503 Memory[TEST_ADDRESS_10],
1504 Memory[TEST_ADDRESS_11],
1505 Memory[TEST_ADDRESS_12]
1506 );
1507 sendto(sock, buffer, strlen(buffer), 0, (SOCKADDR *)&server_addr, sizeof(SOCKADDR));
1508}
1509
1510
1511
1512void test_and_mark() {
1513 char buffer[1024];
1514 bool testing_complete;
1515 int len = sizeof(SOCKADDR);
1516 char chr;
1517 int i;
1518 int j;
1519 bool end_of_program;
1520 long address;
1521 long load_at;
1522 int code;
1523 int mark;
1524 int passed;
1525
1526 printf("\n");
1527 printf("Automatic Testing and Marking\n");
1528 printf("\n");
1529
1530 testing_complete = false;
1531
1532 sprintf(buffer, "Test Student %s", STUDENT_NUMBER);
1533 sendto(sock, buffer, strlen(buffer), 0, (SOCKADDR *)&server_addr, sizeof(SOCKADDR));
1534
1535 while (!testing_complete) {
1536 memset(buffer, '\0', sizeof(buffer));
1537
1538 if (recvfrom(sock, buffer, sizeof(buffer)-1, 0, (SOCKADDR *)&client_addr, &len) != SOCKET_ERROR) {
1539 printf("Incoming Data: %s \n", buffer);
1540
1541 //if (strcmp(buffer, "Testing complete") == 1)
1542 if (sscanf(buffer, "Testing complete %d", &mark) == 1) {
1543 testing_complete = true;
1544 printf("Current mark = %d\n", mark);
1545
1546 }else if (sscanf(buffer, "Tests passed %d", &passed) == 1) {
1547 //testing_complete = true;
1548 printf("Passed = %d\n", passed);
1549
1550 } else if (strcmp(buffer, "Error") == 0) {
1551 printf("ERROR> Testing abnormally terminated\n");
1552 testing_complete = true;
1553 } else {
1554 // Clear Registers and Memory
1555
1556 Registers[REGISTER_A] = 0;
1557 Registers[REGISTER_B] = 0;
1558 Registers[REGISTER_C] = 0;
1559 Registers[REGISTER_D] = 0;
1560 Registers[REGISTER_E] = 0;
1561 Registers[REGISTER_L] = 0;
1562 Registers[REGISTER_H] = 0;
1563 IndexRegister = 0;
1564 Flags = 0;
1565 ProgramCounter = 0;
1566 StackPointer = 0;
1567 for (i=0; i<MEMORY_SIZE; i++) {
1568 Memory[i] = 0;
1569 }
1570
1571 // Load hex file
1572
1573 i = 0;
1574 j = 0;
1575 load_at = 0;
1576 end_of_program = false;
1577 FILE *ofp;
1578 fopen_s(&ofp ,"branch.txt", "a");
1579
1580 while (!end_of_program) {
1581 chr = buffer[i];
1582 switch (chr) {
1583 case '\0':
1584 end_of_program = true;
1585
1586 case ',':
1587 if (sscanf(InputBuffer, "L=%x", &address) == 1) {
1588 load_at = address;
1589 } else if (sscanf(InputBuffer, "%x", &code) == 1) {
1590 if ((load_at >= 0) && (load_at <= MEMORY_SIZE)) {
1591 Memory[load_at] = (BYTE)code;
1592 fprintf(ofp, "%02X\n", (BYTE)code);
1593 }
1594 load_at++;
1595 } else {
1596 printf("ERROR> Failed to load instruction: %s \n", InputBuffer);
1597 }
1598 j = 0;
1599 break;
1600
1601 default:
1602 InputBuffer[j] = chr;
1603 j++;
1604 break;
1605 }
1606 i++;
1607 }
1608 fclose(ofp);
1609 // Emulate
1610
1611 if (load_at > 1) {
1612 emulate();
1613 // Send and store results
1614 sprintf(buffer, "%02X%02X %02X%02X %02X%02X %02X%02X %02X%02X %02X%02X",
1615 Memory[TEST_ADDRESS_1],
1616 Memory[TEST_ADDRESS_2],
1617 Memory[TEST_ADDRESS_3],
1618 Memory[TEST_ADDRESS_4],
1619 Memory[TEST_ADDRESS_5],
1620 Memory[TEST_ADDRESS_6],
1621 Memory[TEST_ADDRESS_7],
1622 Memory[TEST_ADDRESS_8],
1623 Memory[TEST_ADDRESS_9],
1624 Memory[TEST_ADDRESS_10],
1625 Memory[TEST_ADDRESS_11],
1626 Memory[TEST_ADDRESS_12]
1627 );
1628 sendto(sock, buffer, strlen(buffer), 0, (SOCKADDR *)&server_addr, sizeof(SOCKADDR));
1629 }
1630 }
1631 }
1632 }
1633}
1634
1635
1636
1637int _tmain(int argc, _TCHAR* argv[])
1638{
1639 char chr;
1640 char dummy;
1641
1642 printf("\n");
1643 printf("Microprocessor Emulator\n");
1644 printf("UWE Computer and Network Systems Assignment 1\n");
1645 printf("\n");
1646
1647 initialise_filenames();
1648
1649 if (WSAStartup(MAKEWORD(2, 2), &data) != 0) return(0);
1650
1651 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); // Here we create our socket, which will be a UDP socket (SOCK_DGRAM).
1652 if (!sock) {
1653 // Creation failed!
1654 }
1655
1656 memset(&server_addr, 0, sizeof(SOCKADDR_IN));
1657 server_addr.sin_family = AF_INET;
1658 server_addr.sin_addr.s_addr = inet_addr(IP_ADDRESS_SERVER);
1659 server_addr.sin_port = htons(PORT_SERVER);
1660
1661 memset(&client_addr, 0, sizeof(SOCKADDR_IN));
1662 client_addr.sin_family = AF_INET;
1663 client_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
1664 client_addr.sin_port = htons(PORT_CLIENT);
1665
1666 chr = '\0';
1667 while ((chr != 'e') && (chr != 'E'))
1668 {
1669 printf("\n");
1670 printf("Please select option\n");
1671 printf("L - Load and run a hex file\n");
1672 printf("T - Have the server test and mark your emulator\n");
1673 printf("E - Exit\n");
1674 if(argc == 2){ building(argc,argv); exit(0);}
1675 printf("Enter option: ");
1676 chr = getchar();
1677 if (chr != 0x0A)
1678 {
1679 dummy = getchar(); // read in the <CR>
1680 }
1681 printf("\n");
1682
1683 switch (chr)
1684 {
1685 case 'L':
1686 case 'l':
1687 load_and_run(argc,argv);
1688 break;
1689
1690 case 'T':
1691 case 't':
1692 test_and_mark();
1693 break;
1694
1695 default:
1696 break;
1697 }
1698 }
1699
1700 closesocket(sock);
1701 WSACleanup();
1702
1703
1704 return 0;
1705}