from asmnodes import ASymbol, AInstruction
from ppci import CompilerError

"""
  Base classes for defining a target
"""

# Machine code interface:
class Operand:
   """ Single machine operand """
   pass

class Register(Operand):
    def __init__(self, name):
        self.name = name

class Instruction:
   def __init__(self, opcode):
      self.opcode = opcode

class Target:
    def __init__(self):
        self.registers = []
        self.instructions = []

    def mapOperand(self, operand):
        """ Try to map an operand to a target type """
        if type(operand) is ASymbol:
            # Try to map to register:
            regs = {}
            for r in self.registers:
                regs[r.name] = r
            if operand.name in regs:
                return regs[operand.name]
        else:
            return

    def mapInstruction(self, vi):
        """ Map ast tree to real instruction for this target """

        # map to real operands:
        rops = tuple(map(self.mapOperand, vi.operands))
        optypes = tuple(map(type, rops))

        # look for a suitable instruction
        for ic in self.instructions:
            if ic.mnemonic == vi.opcode and ic.operands == optypes:
                ri = ic(*rops)
                return ri
        raise CompilerError('No suitable instruction found')