"""
  Abstract assembly language instructions.

  This is the second intermediate representation.
  
  Instructions are selected and scheduled at this stage.
"""

import ir
import target


class Frame:
    """ 
        Activation record abstraction. This class contains a flattened 
        function. Instructions are selected and scheduled at this stage.
        Frames differ per machine.
    """
    def __init__(self, name):
        self.name = name
        self.instructions = []
        self.stacksize = 0

    def __repr__(self):
        return 'Frame {}'.format(self.name)

    def lower_to(self, outs):
        for im in self.instructions:
            if isinstance(im.assem, target.Instruction):
                outs.emit(im.assem)
            else:
                outs.emit(im.assem.fromim(im))


class AbstractInstruction:
    """ 
        Abstract machine instruction class. This is a very simple
        abstraction of machine instructions.
    """
    def __init__(self, cls, ops=(), src=(), dst=(), jumps=(), others=(), ismove=False):
        assert type(cls) is type or isinstance(cls, target.Instruction)
        self.assem = cls
        self.ops = tuple(ops)
        self.src = tuple(src)
        self.dst = tuple(dst)
        self.jumps = tuple(jumps)
        self.others = tuple(others)
        c = lambda s: tuple(map(type, s)) == (ir.Temp, )
        self.ismove = ismove

    def __repr__(self):
        return self.render()

    def render(self):
        """
            Substitutes source, dst and labels in the string
        """
        x = str(self.assem)
        for i, s in enumerate(self.src):
            p = '%s{}'.format(i)
            x = x.replace(p, str(s))
        for i, d in enumerate(self.dst):
            p = '%d{}'.format(i)
            x = x.replace(p, str(d))
        for i, j in enumerate(self.jumps):
            p = '%l{}'.format(i)
            x = x.replace(p, str(j))
        return x