module Main where
  
import System (getArgs)
import System.FilePath (dropExtension, addExtension, takeBaseName)
import System.Cmd (rawSystem)
  
import LexLambdaMini
import ParLambdaMini
import qualified AbsLambdaMini as Parse
import PrintLambdaMini
import ErrM

import qualified Compiler as C
import Preprocessor
import Typechecker
import LLVMUtils (writeBitcodeToFile)

main = mapM_ processFile =<< getArgs

processFile f = do
  str <- readFile f
  case buildAST str of
    Left err -> error err
    Right (prog, types) -> compile f prog types
  where buildAST str = do
          tree  <- parse str
          let pp = preprocess tree
          typecheck pp
          let withClosures = createClosures pp
          types <- typecheck withClosures
          return (withClosures, types)
        parse str =
          case pProgram $ myLexer str of
            Ok tree -> Right tree
            Bad err -> Left err

-- Take a .lambda file and produce a native executable of the same name. Also
-- creates an intermediate .bc file, and links against main.bc for the entry
-- point.
compile fileName prog types = do
    (code, entryPoint) <- C.compile (dropExtension fileName) prog types
    let bitcodeFile = addExtension (dropExtension fileName) ".bc"
    writeBitcodeToFile bitcodeFile code
    let executable = takeBaseName fileName
    rawSystem "llvm-ld" [bitcodeFile, "main.bc", "-native", "-o", executable]