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, )