from ..ir import Module
from ..irutils import Verifier
from target import Target
from ppci import CompilerError
from .canon import make as canonicalize
from .registerallocator import RegisterAllocator
import logging


class CodeGenerator:
    """ Generic code generator """
    def __init__(self, target):
        # TODO: schedule traces in better order.
        # This is optional!
        assert isinstance(target, Target), target
        self.logger = logging.getLogger('codegen')
        self.target = target
        self.ins_sel = target.ins_sel
        self.ra = RegisterAllocator()
        self.verifier = Verifier()

    def generateFunc(self, irfunc, outs):
        """ Generate code for one function into a frame """
        self.logger.info('Generating code for {}'.format(irfunc.name))
        # Create a frame for this function:
        frame = self.target.FrameClass(irfunc.name)

        # Canonicalize the intermediate language:
        canonicalize(irfunc, frame)
        self.logger.info('after canonicalize', extra={'irfunc': irfunc})
        self.verifier.verify_function(irfunc)
        self.ins_sel.munchFunction(irfunc, frame)
        self.logger.info('Selected instructions', extra={'ppci_frame': frame})

        # Do register allocation:
        self.ra.allocFrame(frame)
        self.logger.info('Registers allocated, now adding final glue')
        # TODO: Peep-hole here?

        # Add label and return and stack adjustment:
        frame.EntryExitGlue3()

        # Materialize the register allocated instructions into a stream of
        # real instructions.
        frame.lower_to(outs)
        self.logger.info('Instructions materialized')
        return frame

    def generate(self, ircode, outs):
        """ Generate code into output stream """
        assert isinstance(ircode, Module)
        outs.selectSection('code')

        # Munch program into a bunch of frames. One frame per function.
        # Each frame has a flat list of abstract instructions.
        # Generate code for all functions:
        self.frames = [self.generateFunc(f, outs) for f in ircode.Functions]
        return self.frames