713 lines
22 KiB
Python
713 lines
22 KiB
Python
# WARNING! ЭТОТ КОД - ПОЛНОЕ ГОВНИЩЕ
|
|
# Если вы Роман Сакутин - немедленно закройте данную страницу!!!
|
|
|
|
code = open("main.asm").read().strip().lower().split("\n")
|
|
program = bytearray()
|
|
n = 0
|
|
errors = 0
|
|
|
|
def get_arg_type(arg: str) -> str:
|
|
if arg in ["ax", "bx", "cx", "dx", "ex", "fx"]:
|
|
return "reg"
|
|
elif arg.isdecimal():
|
|
return "dec"
|
|
elif arg.startswith("0x") and all(c in "0123456789abcdefABCDEF" for c in arg[2:]) and len(arg) > 2:
|
|
return "hex"
|
|
return "unk"
|
|
|
|
def get_reg_hex(arg: str) -> int:
|
|
return int(arg[0], 16)
|
|
|
|
def get_hex(arg: str) -> int:
|
|
global errorsE
|
|
value = int(arg[2:], 16)
|
|
if value > 65535:
|
|
print(f"[err] line {n}: value too large")
|
|
errors += 1
|
|
return value
|
|
|
|
def get_dec(arg: str) -> int:
|
|
global errors
|
|
value = int(arg)
|
|
if value > 65535:
|
|
print(f"[err] line {n}: value too large")
|
|
errors += 1
|
|
return value
|
|
|
|
for line in code:
|
|
line = line.split(";")[0]
|
|
n += 1
|
|
args = line.split()
|
|
if len(args) == 0:
|
|
continue
|
|
|
|
if args[0].startswith(":") and args[0].endswith(":") and get_arg_type(args[0].replace(":", "")) == "hex":
|
|
value = get_hex(args[0].replace(":", ""))
|
|
program.extend([0xFF, value >> 8, value & 255])
|
|
|
|
elif args[0] == "hlt":
|
|
program.append(0x00)
|
|
|
|
elif args[0] == "mov":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg":
|
|
print(f"[err] line {n}: the first argument must be a register")
|
|
errors += 1
|
|
continue
|
|
if arg2_type == "reg":
|
|
reg1 = get_reg_hex(args[1])
|
|
reg2 = get_reg_hex(args[2])
|
|
program.extend([1, (reg1 << 4) + reg2])
|
|
elif arg2_type == "hex":
|
|
reg = get_reg_hex(args[1])
|
|
value = get_hex(args[2])
|
|
program.extend([reg, value >> 8, value & 255])
|
|
elif arg2_type == "dec":
|
|
reg = get_reg_hex(args[1])
|
|
value = get_dec(args[2])
|
|
program.extend([reg, value >> 8, value & 255])
|
|
else:
|
|
print(f"[err] line {n}: invalid second argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "jmp":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
exit(-1)
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "reg":
|
|
reg = get_reg_hex(args[1])
|
|
program.extend([3, reg])
|
|
elif arg_type == "hex":
|
|
value = get_hex(args[1])
|
|
program.extend([2, value >> 8, value & 255])
|
|
elif arg_type == "dec":
|
|
value = get_dec(args[1])
|
|
program.extend([2, value >> 8, value & 255])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "cmp":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg" or arg2_type != "reg":
|
|
print(f"[err] line {n}: all two arguments must be registers")
|
|
errors += 1
|
|
continue
|
|
|
|
reg1 = get_reg_hex(args[1])
|
|
reg2 = get_reg_hex(args[2])
|
|
|
|
program.extend([4, (reg1 << 4) + reg2])
|
|
|
|
elif args[0] == "je":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "hex":
|
|
value = get_hex(args[1])
|
|
program.extend([5, value >> 8, value & 255])
|
|
elif arg_type == "dec":
|
|
value = get_dec(args[1])
|
|
program.extend([5, value >> 8, value & 255])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "jne":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "hex":
|
|
value = get_hex(args[1])
|
|
program.extend([6, value >> 8, value & 255])
|
|
elif arg_type == "dec":
|
|
value = get_dec(args[1])
|
|
program.extend([6, value >> 8, value & 255])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "jg":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "hex":
|
|
value = get_hex(args[1])
|
|
program.extend([7, value >> 8, value & 255])
|
|
elif arg_type == "dec":
|
|
value = get_dec(args[1])
|
|
program.extend([7, value >> 8, value & 255])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "jl":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "hex":
|
|
value = get_hex(args[1])
|
|
program.extend([8, value >> 8, value & 255])
|
|
elif arg_type == "dec":
|
|
value = get_dec(args[1])
|
|
program.extend([8, value >> 8, value & 255])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "add":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg":
|
|
print(f"[err] line {n}: first argument must be integers")
|
|
errors += 1
|
|
continue
|
|
reg1 = get_reg_hex(args[1])
|
|
if arg2_type == "reg":
|
|
reg2 = get_reg_hex(args[2])
|
|
program.extend([0x10, (reg1 << 4) + reg2])
|
|
elif arg2_type == "dec":
|
|
value = get_dec(args[2])
|
|
program.extend([0x30, value >> 8, value & 255, reg1])
|
|
elif arg2_type == "hex":
|
|
value = get_hex(args[2])
|
|
program.extend([0x30, value >> 8, value & 255, reg1])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
|
|
elif args[0] == "sub":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg":
|
|
print(f"[err] line {n}: first argument must be integers")
|
|
errors += 1
|
|
continue
|
|
reg1 = get_reg_hex(args[1])
|
|
if arg2_type == "reg":
|
|
reg2 = get_reg_hex(args[2])
|
|
program.extend([0x11, (reg1 << 4) + reg2])
|
|
elif arg2_type == "dec":
|
|
value = get_dec(args[2])
|
|
program.extend([0x31, value >> 8, value & 255, reg1])
|
|
elif arg2_type == "hex":
|
|
value = get_hex(args[2])
|
|
program.extend([0x31, value >> 8, value & 255, reg1])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
|
|
elif args[0] == "inc":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "reg":
|
|
reg = get_reg_hex(args[1])
|
|
program.extend([0x12, reg])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "dec":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "reg":
|
|
reg = get_reg_hex(args[1])
|
|
program.extend([0x13, reg])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "mul":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg":
|
|
print(f"[err] line {n}: first argument must be integers")
|
|
errors += 1
|
|
continue
|
|
reg1 = get_reg_hex(args[1])
|
|
if arg2_type == "reg":
|
|
reg2 = get_reg_hex(args[2])
|
|
program.extend([0x14, (reg1 << 4) + reg2])
|
|
elif arg2_type == "dec":
|
|
value = get_dec(args[2])
|
|
program.extend([0x32, value >> 8, value & 255, reg1])
|
|
elif arg2_type == "hex":
|
|
value = get_hex(args[2])
|
|
program.extend([0x32, value >> 8, value & 255, reg1])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
|
|
elif args[0] == "div":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg":
|
|
print(f"[err] line {n}: first argument must be integers")
|
|
errors += 1
|
|
continue
|
|
reg1 = get_reg_hex(args[1])
|
|
if arg2_type == "reg":
|
|
reg2 = get_reg_hex(args[2])
|
|
program.extend([0x15, (reg1 << 4) + reg2])
|
|
elif arg2_type == "dec":
|
|
value = get_dec(args[2])
|
|
program.extend([0x33, value >> 8, value & 255, reg1])
|
|
elif arg2_type == "hex":
|
|
value = get_hex(args[2])
|
|
program.extend([0x33, value >> 8, value & 255, reg1])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
|
|
elif args[0] == "rod":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg":
|
|
print(f"[err] line {n}: first argument must be integers")
|
|
errors += 1
|
|
continue
|
|
reg1 = get_reg_hex(args[1])
|
|
if arg2_type == "reg":
|
|
reg2 = get_reg_hex(args[2])
|
|
program.extend([0x16, (reg1 << 4) + reg2])
|
|
elif arg2_type == "dec":
|
|
value = get_dec(args[2])
|
|
program.extend([0x34, value >> 8, value & 255, reg1])
|
|
elif arg2_type == "hex":
|
|
value = get_hex(args[2])
|
|
program.extend([0x34, value >> 8, value & 255, reg1])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
|
|
elif args[0] == "and":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg" or arg2_type != "reg":
|
|
print(f"[err] line {n}: all two arguments must be registers")
|
|
errors += 1
|
|
continue
|
|
|
|
reg1 = get_reg_hex(args[1])
|
|
reg2 = get_reg_hex(args[2])
|
|
|
|
program.extend([0x17, (reg1 << 4) + reg2])
|
|
|
|
elif args[0] == "or":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg" or arg2_type != "reg":
|
|
print(f"[err] line {n}: all two arguments must be registers")
|
|
errors += 1
|
|
continue
|
|
|
|
reg1 = get_reg_hex(args[1])
|
|
reg2 = get_reg_hex(args[2])
|
|
|
|
program.extend([0x18, (reg1 << 4) + reg2])
|
|
|
|
elif args[0] == "xor":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg" or arg2_type != "reg":
|
|
print(f"[err] line {n}: all two arguments must be registers")
|
|
errors += 1
|
|
continue
|
|
|
|
reg1 = get_reg_hex(args[1])
|
|
reg2 = get_reg_hex(args[2])
|
|
|
|
program.extend([0x19, (reg1 << 4) + reg2])
|
|
|
|
elif args[0] == "not":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "reg":
|
|
reg = get_reg_hex(args[1])
|
|
program.extend([0x1A, reg])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "shl":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg":
|
|
print(f"[err] line {n}: first argument must be integers")
|
|
errors += 1
|
|
continue
|
|
reg1 = get_reg_hex(args[1])
|
|
if arg2_type == "reg":
|
|
reg2 = get_reg_hex(args[2])
|
|
program.extend([0x1B, (reg1 << 4) + reg2])
|
|
elif arg2_type == "dec":
|
|
value = get_dec(args[2])
|
|
program.extend([0x35, value >> 8, value & 255, reg1])
|
|
elif arg2_type == "hex":
|
|
value = get_hex(args[2])
|
|
program.extend([0x35, value >> 8, value & 255, reg1])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
|
|
elif args[0] == "shr":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg":
|
|
print(f"[err] line {n}: first argument must be integers")
|
|
errors += 1
|
|
continue
|
|
reg1 = get_reg_hex(args[1])
|
|
if arg2_type == "reg":
|
|
reg2 = get_reg_hex(args[2])
|
|
program.extend([0x1C, (reg1 << 4) + reg2])
|
|
elif arg2_type == "dec":
|
|
value = get_dec(args[2])
|
|
program.extend([0x36, value >> 8, value & 255, reg1])
|
|
elif arg2_type == "hex":
|
|
value = get_hex(args[2])
|
|
program.extend([0x36, value >> 8, value & 255, reg1])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
|
|
elif args[0] == "save":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg":
|
|
print(f"[err] line {n}: first argument must be integers")
|
|
errors += 1
|
|
continue
|
|
reg1 = get_reg_hex(args[1])
|
|
if arg2_type == "reg":
|
|
reg2 = get_reg_hex(args[2])
|
|
program.extend([0x1D, (reg1 << 4) + reg2])
|
|
elif arg2_type == "dec":
|
|
value = get_dec(args[2])
|
|
program.extend([0x37, value >> 8, value & 255, reg1])
|
|
elif arg2_type == "hex":
|
|
value = get_hex(args[2])
|
|
program.extend([0x37, value >> 8, value & 255, reg1])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
|
|
elif args[0] == "load":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg":
|
|
print(f"[err] line {n}: first argument must be integers")
|
|
errors += 1
|
|
continue
|
|
reg1 = get_reg_hex(args[1])
|
|
if arg2_type == "reg":
|
|
reg2 = get_reg_hex(args[2])
|
|
program.extend([0x1E, (reg1 << 4) + reg2])
|
|
elif arg2_type == "dec":
|
|
value = get_dec(args[2])
|
|
program.extend([0x38, value >> 8, value & 255, reg1])
|
|
elif arg2_type == "hex":
|
|
value = get_hex(args[2])
|
|
program.extend([0x38, value >> 8, value & 255, reg1])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
|
|
elif args[0] == "ret":
|
|
program.extend([0x20])
|
|
|
|
elif args[0] == "call":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "hex":
|
|
value = get_hex(args[1])
|
|
program.extend([0x21, value >> 8, value & 255])
|
|
elif arg_type == "dec":
|
|
value = get_dec(args[1])
|
|
program.extend([0x21, value >> 8, value & 255])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "wr":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg" or arg2_type != "reg":
|
|
print(f"[err] line {n}: all two arguments must be registers")
|
|
errors += 1
|
|
continue
|
|
|
|
reg1 = get_reg_hex(args[1])
|
|
reg2 = get_reg_hex(args[2])
|
|
|
|
program.extend([0x40, (reg1 << 4) + reg2])
|
|
|
|
elif args[0] == "rd":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg" or arg2_type != "reg":
|
|
print(f"[err] line {n}: all two arguments must be registers")
|
|
errors += 1
|
|
continue
|
|
|
|
reg1 = get_reg_hex(args[1])
|
|
reg2 = get_reg_hex(args[2])
|
|
|
|
program.extend([0x41, (reg1 << 4) + reg2])
|
|
|
|
elif args[0] == "awr":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg" or arg2_type != "reg":
|
|
print(f"[err] line {n}: all two arguments must be registers")
|
|
errors += 1
|
|
continue
|
|
|
|
reg1 = get_reg_hex(args[1])
|
|
reg2 = get_reg_hex(args[2])
|
|
|
|
program.extend([0x42, (reg1 << 4) + reg2])
|
|
|
|
elif args[0] == "ard":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg" or arg2_type != "reg":
|
|
print(f"[err] line {n}: all two arguments must be registers")
|
|
errors += 1
|
|
continue
|
|
|
|
reg1 = get_reg_hex(args[1])
|
|
reg2 = get_reg_hex(args[2])
|
|
|
|
program.extend([0x43, (reg1 << 4) + reg2])
|
|
|
|
elif args[0] == "del":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "reg":
|
|
reg = get_reg_hex(args[1])
|
|
program.extend([0x44, reg])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "uwr":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "reg":
|
|
reg = get_reg_hex(args[1])
|
|
program.extend([0x45, reg])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "del":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "reg":
|
|
reg = get_reg_hex(args[1])
|
|
program.extend([0x46, reg])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "del":
|
|
if len(args) != 2:
|
|
print(f"[err] line {n}: one argument required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg_type = get_arg_type(args[1])
|
|
if arg_type == "reg":
|
|
reg = get_reg_hex(args[1])
|
|
program.extend([0x47, reg])
|
|
else:
|
|
print(f"[err] line {n}: invalid argument")
|
|
errors += 1
|
|
continue
|
|
|
|
elif args[0] == "pin":
|
|
if len(args) != 3:
|
|
print(f"[err] line {n}: two arguments required")
|
|
errors += 1
|
|
continue
|
|
|
|
arg1_type = get_arg_type(args[1])
|
|
arg2_type = get_arg_type(args[2])
|
|
|
|
if arg1_type != "reg" or arg2_type != "reg":
|
|
print(f"[err] line {n}: all two arguments must be registers")
|
|
errors += 1
|
|
continue
|
|
|
|
reg1 = get_reg_hex(args[1])
|
|
reg2 = get_reg_hex(args[2])
|
|
|
|
program.extend([0x48, (reg1 << 4) + reg2])
|
|
|
|
else:
|
|
print(f"[err] line {n}: unknown instruction: {args[0]}")
|
|
errors += 1
|
|
continue
|
|
|
|
|
|
if errors > 0:
|
|
exit(1)
|
|
#print(list(map(hex, program)))
|
|
open("prog.bin", "wb").write(program) |