Merge remote-tracking branch 'origin/main'

python)
- Removed class, there's individual functions now
- No more "self", that's too much work for practical exam
- Removed expand_macro function, it was unnecessary
- Overall refinement for better understanding
- Added comments

Codes/Group A/Assignment-A1/Code-A1.py

@@ -1,4 +1,4 @@
-# Assignment-A1
+# Assignment-A1 - Pass 1 assembler
 
 try:
     source = open('source.txt','r')

Codes/Group A/Code-A2.py

@@ -1,54 +1,51 @@
-class MacroProcessor:
+# Assignment-A2 - Two-pass macro processor code in Python
-    def __init__(self):
-        self.macro_name_table = {}
-        self.macro_definition_table = {}
-        self.mdt_index = 0
 
-    def process_pass1(self, source_code):
+# BEGINNING OF CODE
-        inside_macro = False
+# Required databases
-        current_macro_name = None
+macro_definition_table = {} # Storing all macro definitions with their names
+macro_name_table = {} # Storing macro names and their index
+##########################################################################
+def process_pass1(source_code):
+  mdt_index = 0
   macro_definition = []
+  current_macro_name = None
+  inside_macro = False
 
   for line in source_code:
-            tokens = line.strip().split()
+    tokens = line.strip().split() # store each word of the line of source code
 
-            if not tokens:
+    if (not tokens): # skips blank lines
       continue
 
-            if tokens[0] == 'MACRO':
+    if (tokens[0] == 'MACRO'): # beginning of macro definition
       inside_macro = True
       continue
 
-            if inside_macro and tokens[0] == 'MEND':
+    if (inside_macro == True and tokens[0] == 'MEND'): # if end of macro is reached
       inside_macro = False
-                self.macro_definition_table[current_macro_name] = macro_definition[:]
+      macro_definition_table[current_macro_name] = macro_definition[:]
-                self.macro_name_table[current_macro_name] = self.mdt_index
+      macro_name_table[current_macro_name] = mdt_index
-                self.mdt_index += len(macro_definition)
+      mdt_index += len(macro_definition)
       macro_definition = []
       current_macro_name = None
       continue
 
-            if inside_macro:
+    if (inside_macro == True): # processing contents of macro
-                if not current_macro_name:
+      if (not current_macro_name):
         current_macro_name = tokens[0]
       macro_definition.append(line.strip())
-            else:
+##########################################################################
-                pass
+def process_pass2(source_code):
-
-    def process_pass2(self, source_code):
   output = []
   inside_macro = False
 
   for line in source_code:
     tokens = line.strip().split()
 
-            if not tokens:
+    if (not tokens or tokens[0] == 'MACRO'): # skipping spaces, MACRO and MEND keywords
-                continue
-
-            if tokens[0] == 'MACRO':
       inside_macro = True
       continue
-            elif tokens[0] == 'MEND':
+    elif (tokens[0] == 'MEND'):
       inside_macro = False
       continue
 
@@ -56,34 +53,29 @@ class MacroProcessor:
       continue
 
     macro_name = tokens[0]
-            if macro_name in self.macro_name_table:
+    if macro_name in macro_name_table: # expand macro from source code
-                macro_def = self.macro_definition_table[macro_name]
       args = tokens[1:]
-                output.extend(self.expand_macro(macro_def, args))
+      macro_def = macro_definition_table[macro_name]
-            else:
+      for expanded_line in macro_def:
+        for i, arg in enumerate(args):
+          expanded_line = expanded_line.replace(f"&ARG{i+1}", arg)
+        output.append(expanded_line)
+    else: # append line if not a macro
       output.append(line.strip())
 
   return output
-
+##########################################################################
-    def expand_macro(self, macro_def, args):
+def display():
-        expanded_lines = []
-        for line in macro_def:
-            for i, arg in enumerate(args):
-                line = line.replace(f"&ARG{i+1}", arg)
-            expanded_lines.append(line)
-        return expanded_lines
-
-    def display_tables(self):
   print("Macro Name Table (MNT):")
-        for name, index in self.macro_name_table.items():
+  for name, index in macro_name_table.items():
-            print(f"Macro Name: {name}, MDT Index: {index}")
+    print(f"Macro Name: {name} | Index: {index}")
 
-        print("\nMacro Definition Table (MDT):")
+  print("Macro Definition Table (MDT):")
-        for name, definition in self.macro_definition_table.items():
+  for name, definition in macro_definition_table.items():
-            print(f"Macro Name: {name}")
+    print(f"Macro: {name}")
     for line in definition:
       print(f"\t{line}")
-
+##########################################################################
 source_code = [
     "MACRO",
     "INCR &ARG1",
@@ -96,16 +88,13 @@ source_code = [
     "START",
     "INCR A",
     "DECR B",
-    "END",
+    "END"
 ]
-
+##########################################################################
-macro_processor = MacroProcessor()
+process_pass1(source_code)
-
+display()
-macro_processor.process_pass1(source_code)
+print("PASS 2:")
-macro_processor.display_tables()
+expanded_code = process_pass2(source_code)
-
+for i in expanded_code:
-expanded_code = macro_processor.process_pass2(source_code)
+  print(i)
-
+# END OF CODE
-print("\nExpanded Source Code (Pass 2):")
-for line in expanded_code:
-    print(line)