import hashlib
# Import compiler components:
from ..frontends.ks import KsParser
#from .codegenerator import CodeGenerator
#from .nodes import ExportedSymbol
#from .errors import CompilerException
#from .. import version
version='0.0.1'

class KsCompiler:
   def __repr__(self):
      return 'LCFOS compiler {0}'.format(version)

   def generateSignature(self, src):
      return hashlib.md5(bytes(src,encoding='ascii')).hexdigest()

   def compilesource(self, src):
      """ Front end that handles the stages: """
      self.errorlist = []
      # Pass 1: parsing and type checking
      tokens = lexer.tokenize(src) # Lexical stage
      p = Parser(tokens)
      try:
         ast = p.parseModule() # Parse a module
      except CompilerException as e:
         p.errorlist.append( (e.row, e.col, e.msg) )
      if len(p.errorlist) > 0:
         self.errorlist = p.errorlist
         return
      # Pass 2: code generation
      CodeGenerator().generatecode(ast)
      # Attach a signature:
      ast.signature = self.generateSignature(src)
      # Generate exported symbols:
      ast.exports = []
      for proc in ast.procs:
         if proc.public:
            sym = ExportedSymbol(proc.name, proc.typ)
            sym.imageoffset = proc.entrypoint
            ast.exports.append(sym)
      return ast

   def compileProject(self, project):
      mods = []
      for fname in project.files:
         print('Compiling {0}...'.format(fname))
         source = project.loadProjectFile(fname)
         mod = self.compilesource(source)
         mods.append(mod)
      return mods