Some refactoring.

bitutilities.py

@@ -1,5 +1,5 @@
+import copy
 from collections import deque
-from typing import Tuple, List, Any
 
 from typing_extensions import Self
 from lib.prettytable import PrettyTable
@@ -236,12 +236,12 @@ def binary_multiplication_method_1(first_term: BasicRegister, second_term: Basic
     :return: Register containing the product.
     :rtype: BasicRegister
     """
-    first_term, second_term = align_registers(first_term, second_term)
+
     n: int = len(first_term)
 
     rg1 = BasicRegister(deque([False] * n))
-    rg2 = BasicRegister(first_term.memory)
-    rg3 = BasicRegister(second_term.memory)
+    rg2 = copy.copy(first_term)
+    rg3 = copy.copy(second_term)
     ct = Counter(n)
 
     data_table = [["iter", "RG1", "RG2", "RG3", "CT", "MicroOperations"]]
@@ -278,11 +278,11 @@ def binary_multiplication_method_2(first_term: BasicRegister, second_term: Basic
     :return: Register containing the product.
     :rtype: BasicRegister
     """
-    first_term, second_term = align_registers(first_term, second_term)
+
     n: int = len(first_term)
 
     rg1 = BasicRegister(deque([False] * (2*n)))
-    rg2 = BasicRegister(first_term.memory)
+    rg2 = copy.copy(first_term)
     rg3 = BasicRegister(deque([False] * n + list(second_term.memory)))
 
     i = 0
@@ -317,7 +317,7 @@ def binary_multiplication_method_3(first_term: BasicRegister, second_term: Basic
     :return: Register containing the product.
     :rtype: BasicRegister
     """
-    first_term, second_term = align_registers(first_term, second_term)
+
     n: int = len(first_term)
 
     data_table = [["iter", "RG2", "RG1", "RG3", "CT", "MicroOperations"]]
@@ -361,11 +361,11 @@ def binary_multiplication_method_4(first_term: BasicRegister, second_term: Basic
     :return: Register containing the product.
     :rtype: BasicRegister
     """
-    first_term, second_term = align_registers(first_term, second_term)
+
     n: int = len(first_term)
 
     rg1 = BasicRegister(deque([False] * (2*n+1)))
-    rg2 = BasicRegister(first_term.memory)
+    rg2 = copy.copy(first_term)
     rg3 = BasicRegister(deque([False]) + second_term.memory + deque([False] * n))
 
     data_table = [["iter", "RG1", "RG2", "RG3", "MicroOperations"]]
@@ -389,6 +389,7 @@ def binary_multiplication_method_4(first_term: BasicRegister, second_term: Basic
 
     return BasicRegister(deque(list(rg1.memory)[:-1])), data_table
 
+
 def binary_division_method_1(first_term: BasicRegister, second_term: BasicRegister) \
         -> tuple[BasicRegister, list[list[str]]]:
     """
@@ -401,7 +402,6 @@ def binary_division_method_1(first_term: BasicRegister, second_term: BasicRegist
     :rtype: BasicRegister
     """
 
-    first_term, second_term = align_registers(first_term, second_term)
     n: int = len(first_term)
 
     rg1 = BasicRegister(deque([False, False]) + second_term.memory)
@@ -431,6 +431,7 @@ def binary_division_method_1(first_term: BasicRegister, second_term: BasicRegist
 
     return BasicRegister(deque(list(rg3.memory)[1:])), data_table
 
+
 def binary_division_method_2(first_term: BasicRegister, second_term: BasicRegister) \
         -> tuple[BasicRegister, list[list[str]]]:
     """
@@ -443,7 +444,6 @@ def binary_division_method_2(first_term: BasicRegister, second_term: BasicRegist
     :rtype: BasicRegister
     """
 
-    first_term, second_term = align_registers(first_term, second_term)
     n: int = len(first_term)
 
     rg1 = BasicRegister(deque([False]) + second_term.memory + deque([False]*n))

main.py

@@ -1,7 +1,90 @@
 import bitutilities as bu
 
+operation = ""
+method = ""
+
+user_input = []
+
+
+def process_command(symbol):
+    global operation, method
+
+    if symbol.lower() in "asmdq":
+        operation = symbol
+    elif operation == "m" and symbol in "1234":
+        method = symbol
+    elif operation == "d" and symbol in "12":
+        method = symbol
+    elif symbol in " ;:":
+        pass
+    else:
+        print(f"Error: unexpected instruction '{symbol}', skipping")
+
+
+def perform_operation(first_register: bu.BasicRegister, second_register: bu.BasicRegister):
+    global operation, method
+
+    match operation:
+        case "a":
+            result, carry = bu.binary_sum_with_carry(first_register, second_register)
+            print(f"\nSum: {result}\nCarry: {int(carry)}")
+            operation, method = "", ""
+        case "s":
+            result, carry = bu.binary_subtraction_second_complement(first_register, second_register)
+            print(f"\nSubtraction: {result}\nCarry: {int(carry)}")
+            operation, method = "", ""
+        case "m":
+            match method:
+                case "1":
+                    result, data_table = bu.binary_multiplication_method_1(first_register, second_register)
+                    print(f"\nMultiplication (method 1):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    operation, method = "", ""
+                case "2":
+                    result, data_table = bu.binary_multiplication_method_2(first_register, second_register)
+                    print(f"\nMultiplication (method 2):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    operation, method = "", ""
+                case "3":
+                    result, data_table = bu.binary_multiplication_method_3(first_register, second_register)
+                    print(f"\nMultiplication (method 3):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    operation, method = "", ""
+                case "4":
+                    result, data_table = bu.binary_multiplication_method_4(first_register, second_register)
+                    print(f"\nMultiplication (method 4):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    operation, method = "", ""
+                case _:
+                    pass
+        case "d":
+            match method:
+                case "1":
+                    result, data_table = bu.binary_division_method_1(first_register, second_register)
+                    print(f"\nDivision (method 1):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    operation, method = "", ""
+                case "2":
+                    result, data_table = bu.binary_division_method_2(first_register, second_register)
+                    print(f"\nDivision (method 2):\n{bu.format_device_state_table(data_table)}\nResult: {result}")
+                    operation, method = "", ""
+                case _:
+                    pass
+        case "q":
+            exit(0)
+
+        case _:
+            pass
+
+
+def get_prompt_text(operation: any, method: any) -> str:
+    response = "({} {})"
+
+    if operation:
+        response += " {}"
+    if operation and method:
+        response += "/{}"
+
+    return response
+
 
 def input_handler(first_register: bu.BasicRegister, second_register: bu.BasicRegister):
+    global user_input, operation
     first_register, second_register = bu.align_registers(first_register, second_register)
 
     print()
@@ -9,44 +92,25 @@ def input_handler(first_register: bu.BasicRegister, second_register: bu.BasicReg
     print(second_register)
 
     while True:
+        prompt_text: str = get_prompt_text(operation, method).format(first_register, second_register, operation, method)
         print()
-        match input("Choose the operation:\n[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, [q]uit\n>>> "):
-            case "a":
-                print(f"Sum:\n{bu.binary_sum(first_register, second_register)}")
-            case "s":
-                print(f"Subtraction:\n{bu.binary_subtraction(first_register, second_register)}")
-            case "m":
-                match input("Choose method to use (1-4):\n>>> "):
-                    case "1":
-                        result, data_table = bu.binary_multiplication_method_1(first_register, second_register)
-                        print(f"Multiplication:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    case "2":
-                        result, data_table = bu.binary_multiplication_method_2(first_register, second_register)
-                        print(f"Multiplication:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    case "3":
-                        result, data_table = bu.binary_multiplication_method_3(first_register, second_register)
-                        print(f"Multiplication:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    case "4":
-                        result, data_table = bu.binary_multiplication_method_4(first_register, second_register)
-                        print(f"Multiplication:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    case _:
-                        print("Such method does not exist, try again.")
-            case "d":
-                match input("Choose method to use (1-2):\n>>> "):
-                    case "1":
-                        result, data_table = bu.binary_division_method_1(first_register, second_register)
-                        print(f"Division:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-                    case "2":
-                        result, data_table = bu.binary_division_method_2(first_register, second_register)
-                        print(f"Division:\n{bu.format_device_state_table(data_table)}\nResult: {result}")
-            case "q":
-                exit()
-            case _:
-                print("Not an available operation, try again.")
+        if operation == "":
+            raw_user_input = input("Choose the operation:\n[a]ddition, [s]ubtraction, [m]ultiplication, [d]ivision, "
+                                   "[q]uit\n" + prompt_text + " > ")
+        elif operation == "m":
+            raw_user_input = input("Choose method to use (1-4):\n" + prompt_text + " > ")
+        elif operation == "d":
+            raw_user_input = input("Choose method to use (1-2):\n" + prompt_text + " > ")
+
+        user_input = list(raw_user_input)
+
+        for symbol in user_input:
+            process_command(symbol)
+            perform_operation(first_register, second_register)
 
 
 if __name__ == '__main__':
-    reg: bu.BasicRegister = bu.BasicRegister(bu.get_memory("memory"))
-    reg2: bu.BasicRegister = bu.BasicRegister(bu.get_memory("more memory"))
+    reg1: bu.BasicRegister = bu.BasicRegister(bu.get_memory("first operand"))
+    reg2: bu.BasicRegister = bu.BasicRegister(bu.get_memory("second operand"))
 
-    input_handler(reg, reg2)
+    input_handler(reg1, reg2)