def translate(self):
code_pkg = CodePackage()
code_pkg.op_code = NumericValue(self.instruction.mode.rel)
if self.value.is_type(ValueType.ADDRESS):
code_pkg.additional = self.value
code_pkg.size = self.instruction.mode.rel_sz
return code_pkg
def translate(self):
return CodePackage(
op_code=NumericValue(self.instruction.mode.rel),
additional=self.value if self.value.is_address() else NoneValue(),
size=self.instruction.mode.rel_sz,
max_size=self.instruction.mode.rel_sz,
)
def translate(self):
if not self.instruction.mode.ext:
raise ValueError(
"Instruction [{}] does not support extended addressing".format(
self.instruction.mnemonic))
return CodePackage(op_code=NumericValue(self.instruction.mode.ext),
additional=self.value,
size=self.instruction.mode.ext_sz)
def translate(self):
if self.instruction.mnemonic == "FCB":
return CodePackage(additional=self.value, size=1)
if self.instruction.mnemonic == "FDB":
return CodePackage(additional=NumericValue(self.value.int,
size_hint=4),
size=2)
if self.instruction.mnemonic == "ORG":
return CodePackage(address=self.value)
if self.instruction.mnemonic == "FCC":
return CodePackage(additional=self.value,
size=self.value.byte_len())
return CodePackage()
def translate(self):
if not self.instruction.mode.inh:
raise OperandTypeError("Instruction [{}] requires an operand".format(self.instruction.mnemonic))
return CodePackage(
op_code=NumericValue(self.instruction.mode.inh),
size=self.instruction.mode.inh_sz,
max_size=self.instruction.mode.inh_sz,
)
def translate(self):
if not self.instruction.mode.dir:
raise OperandTypeError(
"Instruction [{}] does not support direct addressing".format(self.instruction.mnemonic)
)
return CodePackage(
op_code=NumericValue(self.instruction.mode.dir),
additional=self.value,
size=self.instruction.mode.dir_sz,
max_size=self.instruction.mode.dir_sz,
)
def __init__(self, line):
self.is_empty = True
self.is_comment_only = False
self.instruction = None
self.label = ""
self.operand = None
self.original_operand = None
self.comment = None
self.mnemonic = ""
self.state = None
self.code_pkg = CodePackage()
self.parse_line(line)
def translate(self):
return CodePackage()
def translate(self):
if not self.instruction.mode.ind:
raise ValueError(
"Instruction [{}] does not support indexed addressing".format(
self.instruction.mnemonic))
raw_post_byte = 0x00
size = self.instruction.mode.ind_sz
additional = NoneValue()
# Determine register (if any)
if "X" in self.right:
raw_post_byte |= 0x00
if "Y" in self.right:
raw_post_byte |= 0x20
if "U" in self.right:
raw_post_byte |= 0x40
if "S" in self.right:
raw_post_byte |= 0x60
if self.left == "":
raw_post_byte |= 0x80
if "-" in self.right or "+" in self.right:
if "+" in self.right:
raw_post_byte |= 0x00
if "++" in self.right:
raw_post_byte |= 0x01
if "-" in self.right:
raw_post_byte |= 0x02
if "--" in self.right:
raw_post_byte |= 0x03
else:
raw_post_byte |= 0x04
elif self.left == "A" or self.left == "B" or self.left == "D":
raw_post_byte |= 0x80
if self.left == "A":
raw_post_byte |= 0x06
if self.left == "B":
raw_post_byte |= 0x05
if self.left == "D":
raw_post_byte |= 0x0B
else:
if "+" in self.right or "-" in self.right:
raise ValueError("[{}] invalid indexed expression".format(
self.operand_string))
if type(self.left) == str:
self.left = NumericValue(self.left)
if self.left.is_type(ValueType.ADDRESS):
raise ValueError(
"[{}] cannot translate address in left hand side".format(
self.operand_string))
numeric = self.left
if numeric.byte_len() == 2:
size += 2
if "PC" in self.right:
raw_post_byte |= 0x8D
additional = numeric
else:
raw_post_byte |= 0x89
additional = numeric
elif numeric.byte_len() == 1:
if "PC" in self.right:
raw_post_byte |= 0x8C
additional = numeric
size += 1
else:
if numeric.int <= 0x1F:
raw_post_byte |= numeric.int
else:
raw_post_byte |= 0x88
additional = numeric
size += 1
return CodePackage(op_code=NumericValue(self.instruction.mode.ind),
post_byte=NumericValue(raw_post_byte),
additional=additional,
size=size)
def translate(self):
if not self.instruction.mode.ind:
raise ValueError(
"Instruction [{}] does not support indexed addressing".format(
self.instruction.mnemonic))
size = self.instruction.mode.ind_sz
if not type(self.value) == str and self.value.is_type(
ValueType.ADDRESS):
size += 2
return CodePackage(op_code=NumericValue(self.instruction.mode.ind),
post_byte=NumericValue(0x9F),
additional=self.value,
size=size)
if not type(self.value) == str and self.value.is_type(
ValueType.NUMERIC):
size += 2
return CodePackage(op_code=NumericValue(self.instruction.mode.ind),
post_byte=NumericValue(0x9F),
additional=self.value,
size=size)
raw_post_byte = 0x80
additional = NoneValue()
if "X" in self.right:
raw_post_byte |= 0x00
if "Y" in self.right:
raw_post_byte |= 0x20
if "U" in self.right:
raw_post_byte |= 0x40
if "S" in self.right:
raw_post_byte |= 0x60
if self.left == "":
if "-" in self.right or "+" in self.right:
if self.right == "X+" or self.right == "Y+" or self.right == "U+" or self.right == "S+":
raise ValueError(
"[{}] not allowed as an extended indirect value".
format(self.right))
if self.right == "-X" or self.right == "-Y" or self.right == "-U" or self.right == "-S":
raise ValueError(
"[{}] not allowed as an extended indirect value".
format(self.right))
if "++" in self.right:
raw_post_byte |= 0x11
if "--" in self.right:
raw_post_byte |= 0x13
else:
raw_post_byte |= 0x14
elif self.left == "A" or self.left == "B" or self.left == "D":
if self.left == "A":
raw_post_byte |= 0x16
if self.left == "B":
raw_post_byte |= 0x15
if self.left == "D":
raw_post_byte |= 0x1B
else:
if "+" in self.right or "-" in self.right:
raise ValueError("[{}] invalid indexed expression".format(
self.operand_string))
if type(self.left) == str:
self.left = NumericValue(self.left)
if self.left.is_type(ValueType.ADDRESS):
raise ValueError(
"[{}] cannot translate address in left hand side".format(
self.operand_string))
numeric = self.left
if numeric.byte_len() == 2:
size += 2
if "PC" in self.right:
raw_post_byte |= 0x9D
additional = numeric
else:
raw_post_byte |= 0x99
additional = numeric
elif numeric.byte_len() == 1:
size += 1
if "PC" in self.right:
raw_post_byte |= 0x9C
additional = numeric
else:
raw_post_byte |= 0x98
additional = numeric
return CodePackage(op_code=NumericValue(self.instruction.mode.ind),
post_byte=NumericValue(raw_post_byte),
additional=additional,
size=size)
def translate(self):
code_pkg = CodePackage()
code_pkg.op_code = NumericValue(self.instruction.mode.imm)
code_pkg.size = self.instruction.mode.imm_sz
code_pkg.post_byte = 0x00
if self.instruction.mnemonic == "PSHS" or self.instruction.mnemonic == "PULS":
if not self.operand_string:
raise ValueError("one or more registers must be specified")
registers = self.operand_string.split(",")
for register in registers:
if register not in REGISTERS:
raise ValueError("[{}] unknown register".format(register))
code_pkg.post_byte |= 0x06 if register == "D" else 0x00
code_pkg.post_byte |= 0x01 if register == "CC" else 0x00
code_pkg.post_byte |= 0x02 if register == "A" else 0x00
code_pkg.post_byte |= 0x04 if register == "B" else 0x00
code_pkg.post_byte |= 0x08 if register == "DP" else 0x00
code_pkg.post_byte |= 0x10 if register == "X" else 0x00
code_pkg.post_byte |= 0x20 if register == "Y" else 0x00
code_pkg.post_byte |= 0x40 if register == "U" else 0x00
code_pkg.post_byte |= 0x80 if register == "PC" else 0x00
if self.instruction.mnemonic == "EXG" or self.instruction.mnemonic == "TFR":
registers = self.operand_string.split(",")
if len(registers) != 2:
raise ValueError("[{}] requires exactly 2 registers".format(
self.instruction.mnemonic))
if registers[0] not in REGISTERS:
raise ValueError("[{}] unknown register".format(registers[0]))
if registers[1] not in REGISTERS:
raise ValueError("[{}] unknown register".format(registers[1]))
code_pkg.post_byte |= 0x00 if registers[0] == "D" else 0x00
code_pkg.post_byte |= 0x00 if registers[1] == "D" else 0x00
code_pkg.post_byte |= 0x10 if registers[0] == "X" else 0x00
code_pkg.post_byte |= 0x01 if registers[1] == "X" else 0x00
code_pkg.post_byte |= 0x20 if registers[0] == "Y" else 0x00
code_pkg.post_byte |= 0x02 if registers[1] == "Y" else 0x00
code_pkg.post_byte |= 0x30 if registers[0] == "U" else 0x00
code_pkg.post_byte |= 0x03 if registers[1] == "U" else 0x00
code_pkg.post_byte |= 0x40 if registers[0] == "S" else 0x00
code_pkg.post_byte |= 0x04 if registers[1] == "S" else 0x00
code_pkg.post_byte |= 0x50 if registers[0] == "PC" else 0x00
code_pkg.post_byte |= 0x05 if registers[1] == "PC" else 0x00
code_pkg.post_byte |= 0x80 if registers[0] == "A" else 0x00
code_pkg.post_byte |= 0x08 if registers[1] == "A" else 0x00
code_pkg.post_byte |= 0x90 if registers[0] == "B" else 0x00
code_pkg.post_byte |= 0x09 if registers[1] == "B" else 0x00
code_pkg.post_byte |= 0xA0 if registers[0] == "CC" else 0x00
code_pkg.post_byte |= 0x0A if registers[1] == "CC" else 0x00
code_pkg.post_byte |= 0xB0 if registers[0] == "DP" else 0x00
code_pkg.post_byte |= 0x0B if registers[1] == "DP" else 0x00
if code_pkg.post_byte not in \
[
0x01, 0x10, 0x02, 0x20, 0x03, 0x30, 0x04, 0x40,
0x05, 0x50, 0x12, 0x21, 0x13, 0x31, 0x14, 0x41,
0x15, 0x51, 0x23, 0x32, 0x24, 0x42, 0x25, 0x52,
0x34, 0x43, 0x35, 0x53, 0x45, 0x54, 0x89, 0x98,
0x8A, 0xA8, 0x8B, 0xB8, 0x9A, 0xA9, 0x9B, 0xB9,
0xAB, 0xBA, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55,
0x88, 0x99, 0xAA, 0xBB
]:
raise ValueError("[{}] of [{}] to [{}] not allowed".format(
self.instruction.mnemonic, registers[0], registers[1]))
code_pkg.post_byte = NumericValue(code_pkg.post_byte)
return code_pkg
def translate(self):
return CodePackage(additional=self.value)
def translate(self):
if not self.instruction.mode.ind:
raise OperandTypeError(
"Instruction [{}] does not support indexed addressing".format(self.instruction.mnemonic)
)
raw_post_byte = 0x00
post_byte_choices = []
size = self.instruction.mode.ind_sz
max_size = size
additional = NoneValue()
additional_needs_resolution = False
# Determine register (if any)
if "X" in self.right:
raw_post_byte |= 0x00
if "Y" in self.right:
raw_post_byte |= 0x20
if "U" in self.right:
raw_post_byte |= 0x40
if "S" in self.right:
raw_post_byte |= 0x60
if self.left == "":
raw_post_byte |= 0x80
if "-" in self.right or "+" in self.right:
if "+" in self.right:
raw_post_byte |= 0x00
if "++" in self.right:
raw_post_byte |= 0x01
if "-" in self.right:
raw_post_byte |= 0x02
if "--" in self.right:
raw_post_byte |= 0x03
else:
raw_post_byte |= 0x04
elif self.left == "A" or self.left == "B" or self.left == "D":
raw_post_byte |= 0x80
if self.left == "A":
raw_post_byte |= 0x06
if self.left == "B":
raw_post_byte |= 0x05
if self.left == "D":
raw_post_byte |= 0x0B
else:
if "+" in self.right or "-" in self.right:
raise OperandTypeError("[{}] invalid indexed expression".format(self.operand_string))
if self.left.is_address():
additional_needs_resolution = True
self.left = NumericValue(self.left.int)
if self.left.is_expression():
additional_needs_resolution = True
if self.left.is_address_expression():
additional_needs_resolution = True
additional = self.left
if "PCR" in self.right:
if additional_needs_resolution:
raw_post_byte |= 0x00
post_byte_choices = [0x8C, 0x8D]
max_size += 2
else:
size += 2 if self.left.is_extended() else 1
max_size = size
raw_post_byte |= 0x8D if self.left.is_extended() else 0x8C
else:
if additional.int <= 0x1F:
raw_post_byte |= additional.int
else:
size += additional.byte_len()
max_size = size
raw_post_byte |= 0x89 if self.left.is_extended() else 0x88
return CodePackage(
op_code=NumericValue(self.instruction.mode.ind),
post_byte=NumericValue(raw_post_byte),
additional=additional,
size=size,
additional_needs_resolution=additional_needs_resolution,
post_byte_choices=post_byte_choices,
max_size=max_size,
)
def translate(self):
if not self.instruction.mode.ind:
raise OperandTypeError(
"Instruction [{}] does not support indexed addressing".format(self.instruction.mnemonic)
)
size = self.instruction.mode.ind_sz
if not type(self.value) == str and self.value.is_address():
size += 2
return CodePackage(
op_code=NumericValue(self.instruction.mode.ind),
post_byte=NumericValue(0x9F),
additional=self.value,
size=size,
max_size=size,
)
if not type(self.value) == str and self.value.is_numeric():
size += 2
return CodePackage(
op_code=NumericValue(self.instruction.mode.ind),
post_byte=NumericValue(0x9F),
additional=self.value,
size=size,
max_size=size,
)
raw_post_byte = 0x80
post_byte_choices = []
size = self.instruction.mode.ind_sz
max_size = size
additional = NoneValue()
additional_needs_resolution = False
if "X" in self.right:
raw_post_byte |= 0x00
if "Y" in self.right:
raw_post_byte |= 0x20
if "U" in self.right:
raw_post_byte |= 0x40
if "S" in self.right:
raw_post_byte |= 0x60
if self.left == "":
if "-" in self.right or "+" in self.right:
if self.right == "X+" or self.right == "Y+" or self.right == "U+" or self.right == "S+":
raise OperandTypeError("[{}] not allowed as an extended indirect value".format(self.right))
if self.right == "-X" or self.right == "-Y" or self.right == "-U" or self.right == "-S":
raise OperandTypeError("[{}] not allowed as an extended indirect value".format(self.right))
if "++" in self.right:
raw_post_byte |= 0x11
if "--" in self.right:
raw_post_byte |= 0x13
else:
raw_post_byte |= 0x14
elif self.left == "A" or self.left == "B" or self.left == "D":
if self.left == "A":
raw_post_byte |= 0x16
if self.left == "B":
raw_post_byte |= 0x15
if self.left == "D":
raw_post_byte |= 0x1B
else:
if "+" in self.right or "-" in self.right:
raise OperandTypeError("[{}] invalid indexed expression".format(self.operand_string))
if type(self.left) == str:
self.left = Value.create_from_str(self.left)
if self.left.is_address():
additional_needs_resolution = True
self.left = NumericValue(self.left.int)
if self.left.is_expression():
additional_needs_resolution = True
if self.left.is_address_expression():
additional_needs_resolution = True
additional = self.left
if "PCR" in self.right:
if additional_needs_resolution:
raw_post_byte |= 0x00
post_byte_choices = [0x9C, 0x9D]
max_size += 2
else:
size += 2 if self.left.is_extended() else 1
max_size = size
raw_post_byte |= 0x9D if self.left.is_extended() else 0x9C
else:
size += additional.byte_len()
max_size = size
raw_post_byte |= 0x99 if self.left.is_extended() else 0x98
return CodePackage(
op_code=NumericValue(self.instruction.mode.ind),
post_byte=NumericValue(raw_post_byte),
post_byte_choices=post_byte_choices,
additional=additional,
size=size,
max_size=max_size,
additional_needs_resolution=additional_needs_resolution,
)
