filename = "try_to_fix_me.asm" # # Change the filename here to the path of your asm file # then copy the output to 'main.py' and replace the 'program' variable # with the list, then run the 'main.py' file with python 3.11+ # # there are 2 example programs, one that demonstrates bitmap mode # and one that demonstrates text mode, with typing useing the bios # interupts. # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # import re from termcolor import colored with open(filename,"r") as f: lines = f.readlines() def convert_to_int(value): if isinstance(value, str): # Check if the value is a string if value.startswith("0x"): # Handle hexadecimal strings return int(value, 16) else: # Handle decimal strings return int(value) elif isinstance(value, int): # Value is already an integer return value else: raise ValueError(f"Unsupported type for conversion: {type(value)}") def preprocess(lines, filename="main.asm"): errors = [] warnings = [] error_flag = False # Memory and stack tracking instruction_count = 0 memory_limit = 256 # Total memory available stack_balance = 0 program_length = 0 # To calculate and validate memory access # Valid registers and instructions valid_registers = {"a", "b", "c", "d", "e", "f"} valid_instructions = {"ldw", "mov", "add", "sub", "str", "ldr", "int", "push", "pop", "jsr", "ret", "xor", "and", "jmp", "mul", "div", "bne", "beq", "blt"} label_references = [] labels = {} # First pass: Parse instructions and calculate program length for line_number, line in enumerate(lines, start=1): code = line.split(";")[0].strip() # Strip comments and whitespace if not code: continue # Handle labels if code.endswith(":"): label_name = code[:-1] if label_name in labels: warnings.append((line_number, f"duplicate label '{label_name}'", line)) labels[label_name] = instruction_count continue # Parse instruction parts = re.split(r"\s+", code) instruction = parts[0].lower() if instruction in valid_instructions: if instruction in {"ldw", "mov", "add", "sub", "str", "ldr", "xor", "and", "mul", "div"}: instruction_count += 3 # These are 3-byte instructions elif instruction in {"bne", "beq", "blt"}: instruction_count += 4 # Conditional branches are 4-byte instructions elif instruction in {"push", "pop", "int", "jmp", "jsr", "ret"}: instruction_count += 3 # Fixed size for other instructions else: errors.append((line_number, f"unknown instruction '{instruction}'", line)) error_flag = True program_length = instruction_count # Final length of the program # Second pass: Validate instructions and operands for line_number, line in enumerate(lines, start=1): code = line.split(";")[0].strip() # Strip comments and whitespace if not code: continue # Skip labels if code.endswith(":"): continue parts = re.split(r"\s+", code) instruction = parts[0].lower() operands = parts[1:] if len(parts) > 1 else [] # Strip commas from registers and operands operands = [op.replace(",", "") for op in operands] # Validate instruction and operands if instruction == "ldw" and len(operands) == 2: reg, value = operands if reg not in valid_registers: errors.append((line_number, f"invalid register '{reg}'", line)) error_flag = True elif instruction == "str" and len(operands) == 2: reg, address = operands if reg not in valid_registers: errors.append((line_number, f"invalid register '{reg}'", line)) error_flag = True try: mem_address = int(address, 16) if mem_address < program_length: errors.append((line_number, f"illegal memory write to program space in '{code}'", line)) error_flag = True if mem_address > memory_limit: errors.append((line_number, f"illegal memory write out of bounds in '{code}'", line)) error_flag = True except ValueError: errors.append((line_number, f"invalid memory address '{address}'", line)) error_flag = True elif instruction in {"add", "sub", "mov", "xor", "and", "mul", "div"} and len(operands) == 2: reg1, reg2 = operands if reg1 not in valid_registers or reg2 not in valid_registers: errors.append((line_number, f"invalid register(s) in '{code}'", line)) error_flag = True elif instruction in {"push", "pop"} and len(operands) == 1: reg = operands[0] if reg not in valid_registers: errors.append((line_number, f"invalid register '{reg}'", line)) error_flag = True if instruction == "push": stack_balance += 1 if stack_balance > 16: # Example stack limit warnings.append((line_number, "stack overflow detected", line)) elif instruction == "pop": stack_balance -= 1 if stack_balance < 0: errors.append((line_number, f"stack underflow detected at '{code}'", line)) error_flag = True # Validate branch instructions with two registers and one label elif instruction in {"bne", "beq", "blt"}: if len(operands) != 3: errors.append((line_number, f"branch instruction '{instruction}' should have 2 registers and 1 label", line)) error_flag = True else: reg1, reg2, label = operands if reg1 not in valid_registers or reg2 not in valid_registers: errors.append((line_number, f"invalid register(s) in '{instruction}'", line)) error_flag = True label_references.append((line_number, label, line)) # The third operand should be a label elif instruction in {"jmp", "jsr"}: if len(operands) != 1: errors.append((line_number, f"'{instruction}' instruction should have 1 operand (label)", line)) error_flag = True label = operands[0] # The only operand should be a label label_references.append((line_number, label, line)) # Check undefined labels for line_number, label, line in label_references: if label not in labels: errors.append((line_number, f"undefined label '{label}'", line)) error_flag = True # Check stack balance at the end if stack_balance != 0: warnings.append((0, "stack imbalance detected, unbalanced push/pop operations", "")) # Print errors and warnings for line_number, message, code_line in errors: print(colored(f"{filename}:{line_number}: error: {message}", "red")) print(colored(f" {line_number} | {code_line}", "white")) print(colored(f" | {'^' * len(code_line)}", "cyan")) for line_number, message, code_line in warnings: if line_number == 0: print(colored(f"{filename}: warning: {message}", "yellow")) else: print(colored(f"{filename}:{line_number}: warning: {message}", "yellow")) print(colored(f" {line_number} | {code_line}", "white")) if program_length >= memory_limit: error_flag = True print(colored(f"GLOBAL: error: Program too big, size: {program_length}", "red")) # Final success message if not error_flag: print(colored("Preprocessing complete. No errors detected!", "green")) else: exit(1) preprocess(lines) lineNumber = 0 def _ValueError(message): print("ValueError: %s on line:" % message, lineNumber) def _IndexError(message): print("IndexError: %s on line:" % message, lineNumber) def _InstructionError(message): print("InstructionError: %s on line:" % message, lineNumber) # for line in lines: # line = line.split(";")[0] # filter out comments # print(line) # Dictionary to store labels and associated instructions label_to_instructions = {} current_label = None for line in lines: # Remove leading and trailing whitespace stripped_line = line.strip() if stripped_line.endswith(':'): # It's a label, use it as the new key in the dictionary current_label = stripped_line[:-1] # Remove the colon current_label = current_label.upper() label_to_instructions[current_label] = [] # Initialize empty instruction list elif stripped_line: # It's an instruction; add it to the current label's list if current_label is not None: label_to_instructions[current_label].append(stripped_line) # register letter to identifyer registerDict = {'a':0x0,'b':0x1,'c':0x2,'d':0x3,'e':0x4,'f':0x5} current_byte_offset = 0 # Tracks the current byte address label_addresses = {} # Maps label names to their resolved byte addresses for label in label_to_instructions: label_addresses[label] = current_byte_offset for line in label_to_instructions[label]: line = line.strip().split(";")[0] # strip comments line = line.rstrip(" ") # strip spaces at end line = line.replace(",", "") # stupid way to remove commas but it works line = line.split(" ") # get each part of the instruction line[0] = line[0].lower() # make instruction lowercase if line[0] == '': continue if line[0] in {"ldw","mov","add","sub","str","ldr","int","push","pop","jsr", "ret", 'xor', 'and', 'jmp', 'mul', 'div'}: # 3 byte instructions current_byte_offset += 3 elif line[0] in {'bne', 'beq', 'blt'}: # 4 byte instructions current_byte_offset += 4 current_byte_offset = 0 # Tracks the current byte address #print(label_addresses) outputBytes = [] for label in label_to_instructions: #print(label) if label_addresses[label] != current_byte_offset: raise IndexError(f"address mismatch, expected {label_addresses[label]}, got {current_byte_offset}") # Output the results for line in label_to_instructions[label]: line = line.strip().split(";")[0] # strip comments line = line.rstrip(" ") # strip spaces at end line = line.replace(",", "") # stupid way to remove commas but it works line = line.split(" ") # get each part of the instruction line[0] = line[0].lower() # make instruction lowercase if line[0] == '': continue #print(line) #! Code to convert to bytes bytes = [] try: if line[0] == 'ldw': # Load immediate to register bytes.append(0x1) # byte for load immediate value # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") bytes.append(convert_to_int(line[2])) # the actual value as an int elif line[0] == 'mov': # Load immediate to register bytes.append(0x2) # byte for load immediate value # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") #bytes.append(0x0) register = registerDict.get(line[2].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") #bytes.append(convert_to_int(line[2])) # the actual value as an int elif line[0] == 'add': # Load immediate to register bytes.append(0x3) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") register = registerDict.get(line[2].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") elif line[0] == 'sub': # Load immediate to register bytes.append(0x4) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") register = registerDict.get(line[2].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") elif line[0] == 'str': # Load immediate to register bytes.append(0x5) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") bytes.append(convert_to_int(line[2])) # the actual value as an int elif line[0] == 'ldr': # Load immediate to register bytes.append(0x6) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") bytes.append(convert_to_int(line[2])) # the actual value as an int elif line[0] == 'int': # Load immediate to register bytes.append(0xA) bytes.append(convert_to_int(line[1])) # the actual value as an int bytes.append(0x0) #! NEED THIS TO KEEP THE INSTRUCTION AT 3 BYTES elif line[0] == 'bne': # Load immediate to register bytes.append(0x8) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") register = registerDict.get(line[2].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") label = line[3].upper() if label == -1: _InstructionError("Missing Label") continue if label in label_to_instructions: bytes.append(label_addresses[label]) else: _InstructionError("Unknown Label") elif line[0] == 'beq': # Load immediate to register bytes.append(0x9) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") register = registerDict.get(line[2].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") label = line[3].upper() if label == -1: _InstructionError("Missing Label") continue if label in label_to_instructions: bytes.append(label_addresses[label]) else: _InstructionError("Unknown Label") elif line[0] == 'push': # Load immediate to register bytes.append(0xB) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") bytes.append(0x0) # padding elif line[0] == 'pop': # Load immediate to register bytes.append(0xC) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") bytes.append(0x0) # padding elif line[0] == 'jsr': # Load immediate to register bytes.append(0xD) # set register ID: label = line[1].upper() if label == -1: _InstructionError("Missing Label") continue if label in label_to_instructions: bytes.append(label_addresses[label]) else: _InstructionError("Unknown Label") bytes.append(0x0) # padding elif line[0] == 'ret': # Load immediate to register bytes.append(0xE) # set register ID: bytes.append(0x0) # padding bytes.append(0x0) # padding elif line[0] == 'xor': # Load immediate to register bytes.append(0xF) register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") register = registerDict.get(line[2].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") elif line[0] == 'and': # Load immediate to register bytes.append(0x10) register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") register = registerDict.get(line[2].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") elif line[0] == 'jmp': # Load immediate to register bytes.append(0x11) # set register ID: label = line[1].upper() if label == -1: _InstructionError("Missing Label") continue if label in label_to_instructions: bytes.append(label_addresses[label]) else: _InstructionError("Unknown Label") bytes.append(0x0) # padding elif line[0] == 'mul': # Load immediate to register bytes.append(0x12) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") register = registerDict.get(line[2].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") elif line[0] == 'div': # Load immediate to register bytes.append(0x13) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") register = registerDict.get(line[2].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") elif line[0] == 'blt': # Load immediate to register bytes.append(0x14) # set register ID: register = registerDict.get(line[1].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") register = registerDict.get(line[2].lower(),-1) if register >= 0 and register <= 5: bytes.append(register) else: _ValueError("Invalid Register") label = line[3].upper() if label == -1: _InstructionError("Missing Label") continue if label in label_to_instructions: bytes.append(label_addresses[label]) else: _InstructionError("Unknown Label") else: _InstructionError("Unknown Instruction") except IndexError: _IndexError("Maformed Instruction") except ValueError: _ValueError("Unknown Error") current_byte_offset += len(bytes) lineNumber+=1 outputBytes += bytes print(outputBytes)