"""
  Abstract assembly language instructions.

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

import ir

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, cls, ops=(), src=(), dst=(), jumps=()):
        self.assem = cls
        self.ops = ops
        self.src = tuple(src)
        self.dst = tuple(dst)
        self.jumps = tuple(jumps)
        c = lambda s: tuple(map(type, s)) == (ir.Temp, )
        self.ismove = c(src) and c(dst) and cls.lower().startswith('mov')

    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