mos-tui 1.0.2 → 1.0.3

package/core/OS_CP.c

@@ -9,7 +9,7 @@ char IR[4];         // IR (Instruction register) of size 4
 char R[4];          // R (General Purpose register) of size 4
 int IC;             // Instruction Counter
 int C;              // Toggle Register
-int SI;             // Supervisor Interept
+int SI;             // Supervisor Interrupt
 
 
 FILE *fin, *fout;
@@ -36,7 +36,6 @@ int lenString(char s[]) {
     while (s[ans] != '\0') {
         ans++;
     }
-
     return ans;
 }
 
@@ -56,14 +55,49 @@ void init() {
     SI = 0;    
 }
 
-void LOAD() {
-    int m = 0;          // It Points location at which instructions are stored
+// ── MEMORY DUMP ──────────────────────────────────────────────────────────────
+// Writes memory_dump.txt in the same directory as output.txt.
+// Format per line:  ADDR|C0C1C2C3|TYPE
+//   TYPE: I=instruction, D=data, E=empty
+void dump_memory() {
+    char *dumppath = getenv("MOS_MEMDUMP");
+    if (!dumppath) return;
+
+    FILE *fd = fopen(dumppath, "w");
+    if (!fd) return;
+
+    // Write registers first
+    fprintf(fd, "REG|IC=%d|C=%d|SI=%d\n", IC, C, SI);
+    fprintf(fd, "REG|IR=%c%c%c%c\n",  IR[0],IR[1],IR[2],IR[3]);
+    fprintf(fd, "REG|R=%c%c%c%c\n",   R[0], R[1], R[2], R[3]);
+
+    // Write all 100 memory cells
+    for (int i = 0; i < 100; i++) {
+        char c0=M[i][0], c1=M[i][1], c2=M[i][2], c3=M[i][3];
+        // Determine cell type
+        char type = 'E'; // empty
+        bool all_space = (c0==' ' && c1==' ' && c2==' ' && c3==' ');
+        if (!all_space) {
+            // Instruction if first two chars look like a known opcode
+            if ((c0=='L'&&c1=='R') || (c0=='S'&&c1=='R') ||
+                (c0=='C'&&c1=='R') || (c0=='B'&&c1=='T') ||
+                (c0=='G'&&c1=='D') || (c0=='P'&&c1=='D') ||
+                (c0=='H'&&c1==' ') || (c0=='H'&&c1=='\0')) {
+                type = 'I';
+            } else {
+                type = 'D';
+            }
+        }
+        fprintf(fd, "%02d|%c%c%c%c|%c\n", i, c0, c1, c2, c3, type);
+    }
+    fclose(fd);
+}
 
-    char word[100];     // Stores each instruction which is to be executed
+void LOAD() {
+    int m = 0;
+    char word[100];
 
     while (fgets(word, sizeof(word), fin)) {
-        // printf("%s", word);
-
         if (cmpString(word, "$AMJ", 4)) {
             printf("%s", "AMJ (initializing the String)\n");
             init();
@@ -73,17 +107,13 @@ void LOAD() {
             printf("%s", "DTA (Starting Execution)\n");
             START_EXECUTION();
         }
-
         else if (cmpString(word, "$END", 4)) {
             printf("%s", "END (Instruction Completed)\n");
             continue;
         }
         else {
             int k = 0;
-            while (k < lenString(word) && word[k] != '\n')
-            {
-
-                // Validation for memory overflow
+            while (k < lenString(word) && word[k] != '\n') {
                 if (m >= 100) {
                     printf("Memory overflow\n");
                     return;
@@ -97,7 +127,6 @@ void LOAD() {
     }
 }
 
-// START EXECUTION
 void START_EXECUTION() {
     IC = 0;
     EXECUTE_USER_PROGRAM();
@@ -105,123 +134,87 @@ void START_EXECUTION() {
 
 void EXECUTE_USER_PROGRAM() {
     int step = 0;
-    while (true)
-    {
-        // To avoid Infinite loop
+    while (true) {
         if (step++ > 1000) {
             printf("Infinite loop detected\n");
             break;
         }
-        // Fetch the Instruction
         for (int i = 0; i < 4; i++) {
             IR[i] = M[IC][i];
         }
-
         IC++;
-        
-        // Decode and Execute the Instructions
 
-
-
-        // LR Instruction (Load Register)
         if (IR[0] == 'L' && IR[1] == 'R') {
             int addr = (IR[2]-'0')*10 + (IR[3]-'0');
             if (!(IR[2] >= '0' && IR[2] <= '9' && IR[3] >= '0' && IR[3] <= '9')) {
-                printf("Invalid operand\n");
-                break;
+                printf("Invalid operand\n"); break;
             }
             if (addr < 0 || addr >= 100) {
-                printf("Memory address out of bounds\n");
-                break;
+                printf("Memory address out of bounds\n"); break;
             }
             for (int i = 0; i < 4; i++) R[i] = M[addr][i];
         }
-
-        // SR (Store Register)
         else if (IR[0] == 'S' && IR[1] == 'R') {
             int addr = (IR[2]-'0')*10 + (IR[3]-'0');
             if (!(IR[2] >= '0' && IR[2] <= '9' && IR[3] >= '0' && IR[3] <= '9')) {
-                printf("Invalid operand\n");
-                break;
+                printf("Invalid operand\n"); break;
             }
             if (addr < 0 || addr >= 100) {
-                printf("Memory address out of bounds\n");
-                break;
+                printf("Memory address out of bounds\n"); break;
             }
             for (int i = 0; i < 4; i++) M[addr][i] = R[i];
         }
-        
-        // CR (Compare Register)
         else if (IR[0] == 'C' && IR[1] == 'R') {
             int addr = (IR[2]-'0')*10 + (IR[3]-'0');
             if (!(IR[2] >= '0' && IR[2] <= '9' && IR[3] >= '0' && IR[3] <= '9')) {
-                printf("Invalid operand\n");
-                break;
+                printf("Invalid operand\n"); break;
             }
             if (addr < 0 || addr >= 100) {
-                printf("Memory address out of bounds\n");
-                break;
+                printf("Memory address out of bounds\n"); break;
             }
             C = 1;
             for (int i = 0; i < 4; i++) {
-                if (R[i] != M[addr][i]) {
-                    C = 0;
-                    break;
-                }
+                if (R[i] != M[addr][i]) { C = 0; break; }
             }
         }
-
-        // BT (Branch if True)
         else if (IR[0] == 'B' && IR[1] == 'T') {
             int addr = (IR[2]-'0')*10 + (IR[3]-'0');
             if (!(IR[2] >= '0' && IR[2] <= '9' && IR[3] >= '0' && IR[3] <= '9')) {
-                printf("Invalid operand\n");
-                break;
+                printf("Invalid operand\n"); break;
             }
             if (addr < 0 || addr >= 100) {
-                printf("Memory address out of bounds\n");
-                break;
+                printf("Memory address out of bounds\n"); break;
             }
-            if (C == 1)
-                IC = addr;
+            if (C == 1) IC = addr;
         }
-        
-        // GD (Get Data)
         else if (IR[0] == 'G' && IR[1] == 'D') {
-            SI = 1;
-            MOS();
+            SI = 1; MOS();
         }
-
-        // PD (Put Data)
         else if (IR[0] == 'P' && IR[1] == 'D') {
-            SI = 2;
-            MOS();
+            SI = 2; MOS();
         }
-
-        // H (Halt)
         else if (IR[0] == 'H') {
-            SI = 3;
-            MOS();
+            SI = 3; MOS();
+            dump_memory();   // dump memory state on HALT
             break;
         }
-
         else {
             printf("Invalid instruction: %c%c%c%c\n", IR[0], IR[1], IR[2], IR[3]);
+            dump_memory();   // dump even on error so TUI can show state
             break;
         }        
     }
+    // Always dump if we exited via step limit
+    dump_memory();
 }
 
 void READ() {
     char word[40];
     int addr = (IR[2]-'0')*10 + (IR[3]-'0');
-
-    // Reading if Input file is not Empty
     if (fgets(word, sizeof(word), fin) == NULL) {
         printf("No data available for GD\n");
         return;
     }
-
     int k = 0;
     for (int i = addr; i < addr + 10 && i < 100; i++) {
         for (int j = 0; j < 4; j++) {
@@ -235,7 +228,6 @@ void READ() {
 
 void WRITE() {
     int addr = (IR[2]-'0')*10 + (IR[3]-'0');
-
     for (int i = addr; i < addr + 10 && i < 100; i++) {
         for (int j = 0; j < 4; j++) {
             fputc(M[i][j], fout);
@@ -249,33 +241,23 @@ void TERMINATE() {
 }
 
 void MOS() {
-    if (SI == 1)
-        READ();
-    else if (SI == 2)
-        WRITE();
-    else if (SI == 3)
-        TERMINATE();
+    if (SI == 1)      READ();
+    else if (SI == 2) WRITE();
+    else if (SI == 3) TERMINATE();
 }
 
 int main() {
     clock_t start, end;
-
     start = clock();
 
-    char *infile = getenv("MOS_INPUT");
+    char *infile  = getenv("MOS_INPUT");
     char *outfile = getenv("MOS_OUTPUT");
 
-    fin = fopen(infile ? infile : "input.txt", "r");
+    fin  = fopen(infile  ? infile  : "input.txt",  "r");
     fout = fopen(outfile ? outfile : "output.txt", "w");
 
-    if (fin == NULL) {
-        printf("Input file not found\n");
-        return 0;
-    }
-    if (fout == NULL) {
-        printf("Output file error\n");
-        return 0;
-    }
+    if (fin == NULL)  { printf("Input file not found\n");  return 1; }
+    if (fout == NULL) { printf("Output file error\n");     return 1; }
 
     LOAD();
 
@@ -287,15 +269,4 @@ int main() {
     printf("Execution time: %f seconds\n", time_taken);
     
     return 0;
-}
-
-
-/*
-// Validations Added
-1. Checking if Input and Output File exists
-2. checking Memery Overflow
-3. Invalid Instruction
-4. Avoid Infinite Loop if Halt Instruction is not available
-5. Added Validation for Correct Operand
-6. Vadidation if input file is Empty
-*/
+}