def __init__(self, snapshot, ctl_parser, config=None, asm_hex=False, asm_lower=False, final=True, self_refs=False): ctl_parser.apply_asm_data_directives(snapshot) self.config = config or {} dconfig = DisassemblerConfig(asm_hex, asm_lower, self.config.get('DefbSize', 8), self.config.get('DefmSize', 65), self.config.get('DefwSize', 1), self.config.get('Wrap', 0)) self.disassembler = get_component('Disassembler', snapshot, dconfig) self.ref_calc = get_component('SnapshotReferenceCalculator') self.ctl_parser = ctl_parser if asm_hex: if asm_lower: self.address_fmt = '{0:04x}' else: self.address_fmt = '{0:04X}' else: self.address_fmt = '{0}' self.entry_map = {} self.build(final, self_refs)
def __init__(self, snapshot, config): self.snapshot = snapshot self.defb_size = config.defb_size self.defm_size = config.defm_size self.defw_size = config.defw_size self.wrap = config.wrap self.op_formatter = get_component('OperandFormatter', config) self.defb = 'DEFB ' self.defm = 'DEFM ' self.defs = 'DEFS ' self.defw = 'DEFW ' if config.asm_lower: self.defb = self.defb.lower() self.defm = self.defm.lower() self.defs = self.defs.lower() self.defw = self.defw.lower() self.ops = {k: (v[0], v[1].lower()) for k, v in self.ops.items()} self.after_CB = {k: v.lower() for k, v in self.after_CB.items()} self.after_DD = { k: (v[0], v[1].lower()) for k, v in self.after_DD.items() } self.after_ED = { k: (v[0], v[1].lower()) for k, v in self.after_ED.items() } self.after_DDCB = { k: (v[0], v[1].lower()) for k, v in self.after_DDCB.items() }
def substitute_labels(self, entries, remote_entries, labels, mode, warn): self.remote_entries = remote_entries self.labels = labels self.asm_mode = mode self.warn = warn self.instructions = { i.address: (i, e, labels.get(i.address)) for e in entries for i in e.instructions if i.address is not None } self.remote_instructions = [ i.address for e in remote_entries for i in e.instructions ] self.base_address = min(self.instructions) last_i = self.instructions[max(self.instructions)][0] self.end_address = last_i.address + (get_size(last_i.operation, last_i.address) or 1) self.op_evaluator = get_component('OperandEvaluator') for entry in entries: for instruction in entry.instructions: if instruction.keep is None or instruction.keep: operation = instruction.operation if operation.upper().startswith(('.BYTE', '.WORD')): operands = [ self._replace_addresses(entry, instruction, op) for op in self.op_evaluator.split_operands( operation[5:]) ] instruction.operation = operation[:6] + ','.join( operands) elif not operation.upper().startswith('.FILL'): instruction.operation = self._replace_addresses( entry, instruction, operation)
def calculate_references(self, entries, remote_entries): references = {} referrers = defaultdict(set) instructions = { i.address: (i, e) for e in remote_entries + entries for i in e.instructions } op_evaluator = get_component('OperandEvaluator') for entry in entries: for instruction in entry.instructions: operation = instruction.operation.upper() if operation.startswith( ('BC', 'BEQ', 'BMI', 'BNE', 'BPL', 'BV', 'J', '.WORD')): addr_str = get_address(instruction.operation) if addr_str: address = op_evaluator.eval_int(addr_str) if instruction.keep is None or ( instruction.keep and address not in instruction.keep): ref_i, ref_e = instructions.get( address, (None, None)) if ref_i and ref_e.ctl != 'i' and ( ref_e.ctl == 'c' or operation.startswith( ('JMP (', '.WORD')) or ref_e.ctl is None): references[instruction] = (ref_i, addr_str, True) referrers[ref_i].add(entry) return references, referrers
def __init__(self, skoolfile, preserve_base, assembler, min_address, max_address, keep_lines): self.skoolfile = skoolfile self.mode = Mode() self.memory_map = [] self.end_address = 65536 self.keep_lines = keep_lines self.assembler = assembler self.composer = get_component('ControlDirectiveComposer', preserve_base) with open_file(skoolfile) as f: self._parse_skool(f, min_address, max_address)
def run(snafile, options, config): words = set() dict_fname = config['Dictionary'] if dict_fname: if find_file(dict_fname): info("Using dictionary file: {}".format(dict_fname)) with open_file(config['Dictionary']) as f: for line in f: word = line.strip().lower() if word: words.add(word) else: info("Dictionary file '{}' not found".format(dict_fname)) ctl_config = Config(config['TextChars'], config['TextMinLengthCode'], config['TextMinLengthData'], words) snapshot, start, end = make_snapshot(snafile, options.org, options.start, options.end, options.page) ctls = get_component('ControlFileGenerator').generate_ctls(snapshot, start, end, options.code_map, ctl_config) write_ctl(ctls, options.ctl_hex)
from functools import partial from skoolkit.components import get_component OP_EVALUATOR = get_component('OperandEvaluator') def assemble(operation, address): try: return _assemble(operation, address) or () except: return () def get_size(operation, address): return len(assemble(operation, address)) def _assemble(operation, address): if operation.upper().startswith(('.BYTE ', '.FILL ', '.WORD ')): directive = operation.upper()[:5] items = OP_EVALUATOR.split_operands(operation[6:].strip()) if directive == '.BYTE': return _assemble_byte(items) if directive == '.WORD': return _assemble_word(items) return _assemble_fill(items) parts = operation.split(None, 1) a = MNEMONICS[parts[0].upper()] if isinstance(a, tuple):
def __init__(self, preserve_base): self.preserve_base = preserve_base self.op_evaluator = get_component('OperandEvaluator')