"""
  Abstract assembly language instructions.

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

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 makeIns(*args, **kwargs):
    return AbstractInstruction(*args, **kwargs)

class AbstractInstruction:
    """ 
        Abstract machine instruction class. This is a very simple
        abstraction of machine instructions.
    """
    def __init__(self, assem, src=(), dst=(), jumps=()):
        self.assem = assem
        self.src = tuple(src)
        self.dst = tuple(dst)
        self.jumps = tuple(jumps)

    def __repr__(self):
        s = str(self.src) if self.src else ''
        d = str(self.dst) if self.dst else ''
        l = str(self.jumps) if self.jumps else ''
        #return self.assem + s + d + l
        return self.render()

    def render(self):
        """
            Substitutes source, dst and labels in the string
        """
        x = 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