def getLiteral(self, arg):
if type(arg) is OctalLiteral:
return int(str(arg[1]), 16)
elif type(arg) is DecimalLiteral:
return int(str(arg[0]), 10)
elif type(arg) is BinaryLiteral:
return int(str(arg[0]), 2)
elif type(arg) is MemoryLiteral:
return unpack_bytes(clean_memory(str(arg)), 2)
elif type(arg) is VariableIdentifier:
return unpack_bytes(self.variables[str(arg)]['start'], 2)
elif type(arg) is MemoryVariable:
return unpack_bytes(self.variables[str(arg)[1:-1]]['start'], 2)
def mov_mem_reg(self):
a = self.program_scanner.nextRegister()
b = self.program_scanner.nextBytes(2)
a = unpack_bytes(self.registers.get(a))
for byte in a:
self.memory[b] = byte
b += 1
def compile(self):
self.sanitizer = Sanitizer(self.variables, self.data)
for tree in self.tree:
for el in tree.elements:
if isinstance(el, Label):
self.labels[str(el[0])] = len(self.program)
next
try:
if isinstance(el, Operation):
if self.data_section is True:
self.data_section = False
for d in unpack_bytes(self.data_length, 2, 10)[::-1]:
self.data.insert(0, d)
el = el[0]
args = [x for x in el.elements[1:] if str(x) != ',']
args = getattr(self.sanitizer, str(type(el)))(args)
getattr(self, str(type(el)))(args)
elif isinstance(el, Data):
args = [x for x in el.elements[1:] if str(x) != ',']
size = int(getattr(program_scanner, "%s_SIZE" % type(el.elements[0])))
args = getattr(self.sanitizer, "Data")(args, size)
getattr(self, "Data")(*args)
except exp.AssemblyException:
print('Assembly Error')
raise
self.code.extend(self.header)
self.code.extend(self.data)
self.code.extend(self.program)
def MOV_R_L(self, args):
a, b = str(args[0]), self.getLiteral(args[1])
b = unpack_bytes(b, Registers.sizeOf(a))
if len(b) > Registers.sizeOf(a):
raise exp.InvalidOperandSize
return regToCode[a], b
def SUB_R_L(self, args):
a, b = str(args[0]), self.getLiteral(args[1])
if ((len(hex(b)) - 2) + 0.5) > Registers.sizeOf(a):
raise exp.RegisterSizeMismatch
try:
return regToCode[str(args[0])], unpack_bytes(b, Registers.sizeOf(a))
except KeyError:
raise exp.InvalidOperandRegister
def MOV_R_M(self, args):
a, b = args[0], args[1]
self.program.append(opToCode['mov_reg_mem'])
self.program.append(a)
if type(b) is bytearray:
self.program.extend(b)
elif type(b) is VariableIdentifier:
try:
self.program.extend(unpack_bytes(self.variables[str(b)]['start'], 2))
except KeyError:
raise exp.UnknownVariable
def Data(self, args, size=1):
a, b = args[0], args[1]
b = filter(lambda x: str(x) != ',', b)
clean_list = []
for value in b:
value = self.getLiteral(value)
unpacked = unpack_bytes(value, size)
if len(unpacked) > size:
raise exp.InvalidDataSize
clean_list.append(unpacked)
return str(a), size, clean_list
def INT(self, args):
a = self.getLiteral(args[0])
if len(unpack_bytes(a)) != 1:
raise exp.InvalidInterrupt
return self.getLiteral(args[0]),
def JMP_NZ(self, args):
a = args[0]
self.program.append(opToCode['jmp_nz'])
self.program.extend(unpack_bytes(self.labels[a], 2))
def read_int(self):
a = pack_bytes(unpack_bytes(int(input("")), 2, 2))
self.registers.set('ax', a)
