{- |
Module      : Language.Egison.Parser
Licence     : MIT

This module provides the parser interface.
-}

module Language.Egison.Parser
       (
       -- * Parse
         readTopExprs
       , readTopExpr
       , readExprs
       , readExpr
       , parseTopExpr
       -- * Parse a file
       , loadLibraryFile
       , loadFile
       -- * Parser utils (for translator)
       , removeShebang
       , readUTF8File
       ) where

import           Control.Monad                 (unless)
import           Control.Monad.Except         (throwError)
import           Control.Monad.IO.Class       (liftIO)
import           Control.Monad.Reader         (asks, local)
import           Control.Monad.Trans.Class    (lift)

import           System.Directory             (doesFileExist, getHomeDirectory)
import           System.IO

import           Language.Egison.AST
import           Language.Egison.CmdOptions
import           Language.Egison.Data
import qualified Language.Egison.Parser.NonS  as NonS
import qualified Language.Egison.Parser.SExpr as SExpr
import           Language.Egison.RState
import           Paths_egison                 (getDataFileName)

readTopExprs :: String -> EvalM [TopExpr]
readTopExprs :: [Char] -> EvalM [TopExpr]
readTopExprs [Char]
expr = do
  Bool
isSExpr <- (EgisonOpts -> Bool)
-> StateT EvalState (ExceptT EgisonError RuntimeM) Bool
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks EgisonOpts -> Bool
optSExpr
  if Bool
isSExpr
     then ([Char] -> EvalM [TopExpr])
-> ([TopExpr] -> EvalM [TopExpr])
-> Either [Char] [TopExpr]
-> EvalM [TopExpr]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (EgisonError -> EvalM [TopExpr]
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (EgisonError -> EvalM [TopExpr])
-> ([Char] -> EgisonError) -> [Char] -> EvalM [TopExpr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> EgisonError
Parser) [TopExpr] -> EvalM [TopExpr]
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> Either [Char] [TopExpr]
SExpr.parseTopExprs [Char]
expr)
     else do Either [Char] [TopExpr]
r <- ExceptT EgisonError RuntimeM (Either [Char] [TopExpr])
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] [TopExpr])
forall (m :: * -> *) a. Monad m => m a -> StateT EvalState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ExceptT EgisonError RuntimeM (Either [Char] [TopExpr])
 -> StateT
      EvalState (ExceptT EgisonError RuntimeM) (Either [Char] [TopExpr]))
-> (RuntimeM (Either [Char] [TopExpr])
    -> ExceptT EgisonError RuntimeM (Either [Char] [TopExpr]))
-> RuntimeM (Either [Char] [TopExpr])
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] [TopExpr])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RuntimeM (Either [Char] [TopExpr])
-> ExceptT EgisonError RuntimeM (Either [Char] [TopExpr])
forall (m :: * -> *) a. Monad m => m a -> ExceptT EgisonError m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (RuntimeM (Either [Char] [TopExpr])
 -> StateT
      EvalState (ExceptT EgisonError RuntimeM) (Either [Char] [TopExpr]))
-> RuntimeM (Either [Char] [TopExpr])
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] [TopExpr])
forall a b. (a -> b) -> a -> b
$ [Char] -> RuntimeM (Either [Char] [TopExpr])
NonS.parseTopExprs [Char]
expr
             ([Char] -> EvalM [TopExpr])
-> ([TopExpr] -> EvalM [TopExpr])
-> Either [Char] [TopExpr]
-> EvalM [TopExpr]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (EgisonError -> EvalM [TopExpr]
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (EgisonError -> EvalM [TopExpr])
-> ([Char] -> EgisonError) -> [Char] -> EvalM [TopExpr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> EgisonError
Parser) [TopExpr] -> EvalM [TopExpr]
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return Either [Char] [TopExpr]
r

parseTopExpr :: String -> RuntimeM (Either String TopExpr)
parseTopExpr :: [Char] -> RuntimeM (Either [Char] TopExpr)
parseTopExpr [Char]
expr = do
  Bool
isSExpr <- (EgisonOpts -> Bool) -> ReaderT EgisonOpts (StateT RState IO) Bool
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks EgisonOpts -> Bool
optSExpr
  if Bool
isSExpr
     then Either [Char] TopExpr -> RuntimeM (Either [Char] TopExpr)
forall a. a -> ReaderT EgisonOpts (StateT RState IO) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> Either [Char] TopExpr
SExpr.parseTopExpr [Char]
expr)
     else [Char] -> RuntimeM (Either [Char] TopExpr)
NonS.parseTopExpr [Char]
expr

readTopExpr :: String -> EvalM TopExpr
readTopExpr :: [Char] -> EvalM TopExpr
readTopExpr [Char]
expr = do
  Bool
isSExpr <- (EgisonOpts -> Bool)
-> StateT EvalState (ExceptT EgisonError RuntimeM) Bool
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks EgisonOpts -> Bool
optSExpr
  if Bool
isSExpr
     then ([Char] -> EvalM TopExpr)
-> (TopExpr -> EvalM TopExpr)
-> Either [Char] TopExpr
-> EvalM TopExpr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (EgisonError -> EvalM TopExpr
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (EgisonError -> EvalM TopExpr)
-> ([Char] -> EgisonError) -> [Char] -> EvalM TopExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> EgisonError
Parser) TopExpr -> EvalM TopExpr
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> Either [Char] TopExpr
SExpr.parseTopExpr [Char]
expr)
     else do Either [Char] TopExpr
r <- ExceptT EgisonError RuntimeM (Either [Char] TopExpr)
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] TopExpr)
forall (m :: * -> *) a. Monad m => m a -> StateT EvalState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ExceptT EgisonError RuntimeM (Either [Char] TopExpr)
 -> StateT
      EvalState (ExceptT EgisonError RuntimeM) (Either [Char] TopExpr))
-> (RuntimeM (Either [Char] TopExpr)
    -> ExceptT EgisonError RuntimeM (Either [Char] TopExpr))
-> RuntimeM (Either [Char] TopExpr)
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] TopExpr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RuntimeM (Either [Char] TopExpr)
-> ExceptT EgisonError RuntimeM (Either [Char] TopExpr)
forall (m :: * -> *) a. Monad m => m a -> ExceptT EgisonError m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (RuntimeM (Either [Char] TopExpr)
 -> StateT
      EvalState (ExceptT EgisonError RuntimeM) (Either [Char] TopExpr))
-> RuntimeM (Either [Char] TopExpr)
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] TopExpr)
forall a b. (a -> b) -> a -> b
$ [Char] -> RuntimeM (Either [Char] TopExpr)
NonS.parseTopExpr [Char]
expr
             ([Char] -> EvalM TopExpr)
-> (TopExpr -> EvalM TopExpr)
-> Either [Char] TopExpr
-> EvalM TopExpr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (EgisonError -> EvalM TopExpr
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (EgisonError -> EvalM TopExpr)
-> ([Char] -> EgisonError) -> [Char] -> EvalM TopExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> EgisonError
Parser) TopExpr -> EvalM TopExpr
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return Either [Char] TopExpr
r

readExprs :: String -> EvalM [Expr]
readExprs :: [Char] -> EvalM [Expr]
readExprs [Char]
expr = do
  Bool
isSExpr <- (EgisonOpts -> Bool)
-> StateT EvalState (ExceptT EgisonError RuntimeM) Bool
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks EgisonOpts -> Bool
optSExpr
  if Bool
isSExpr
     then ([Char] -> EvalM [Expr])
-> ([Expr] -> EvalM [Expr]) -> Either [Char] [Expr] -> EvalM [Expr]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (EgisonError -> EvalM [Expr]
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (EgisonError -> EvalM [Expr])
-> ([Char] -> EgisonError) -> [Char] -> EvalM [Expr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> EgisonError
Parser) [Expr] -> EvalM [Expr]
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> Either [Char] [Expr]
SExpr.parseExprs [Char]
expr)
     else do Either [Char] [Expr]
r <- ExceptT EgisonError RuntimeM (Either [Char] [Expr])
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] [Expr])
forall (m :: * -> *) a. Monad m => m a -> StateT EvalState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ExceptT EgisonError RuntimeM (Either [Char] [Expr])
 -> StateT
      EvalState (ExceptT EgisonError RuntimeM) (Either [Char] [Expr]))
-> (RuntimeM (Either [Char] [Expr])
    -> ExceptT EgisonError RuntimeM (Either [Char] [Expr]))
-> RuntimeM (Either [Char] [Expr])
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] [Expr])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RuntimeM (Either [Char] [Expr])
-> ExceptT EgisonError RuntimeM (Either [Char] [Expr])
forall (m :: * -> *) a. Monad m => m a -> ExceptT EgisonError m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (RuntimeM (Either [Char] [Expr])
 -> StateT
      EvalState (ExceptT EgisonError RuntimeM) (Either [Char] [Expr]))
-> RuntimeM (Either [Char] [Expr])
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] [Expr])
forall a b. (a -> b) -> a -> b
$ [Char] -> RuntimeM (Either [Char] [Expr])
NonS.parseExprs [Char]
expr
             ([Char] -> EvalM [Expr])
-> ([Expr] -> EvalM [Expr]) -> Either [Char] [Expr] -> EvalM [Expr]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (EgisonError -> EvalM [Expr]
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (EgisonError -> EvalM [Expr])
-> ([Char] -> EgisonError) -> [Char] -> EvalM [Expr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> EgisonError
Parser) [Expr] -> EvalM [Expr]
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return Either [Char] [Expr]
r

readExpr :: String -> EvalM Expr
readExpr :: [Char] -> EvalM Expr
readExpr [Char]
expr = do
  Bool
isSExpr <- (EgisonOpts -> Bool)
-> StateT EvalState (ExceptT EgisonError RuntimeM) Bool
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks EgisonOpts -> Bool
optSExpr
  if Bool
isSExpr
     then ([Char] -> EvalM Expr)
-> (Expr -> EvalM Expr) -> Either [Char] Expr -> EvalM Expr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (EgisonError -> EvalM Expr
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (EgisonError -> EvalM Expr)
-> ([Char] -> EgisonError) -> [Char] -> EvalM Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> EgisonError
Parser) Expr -> EvalM Expr
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> Either [Char] Expr
SExpr.parseExpr [Char]
expr)
     else do Either [Char] Expr
r <- ExceptT EgisonError RuntimeM (Either [Char] Expr)
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] Expr)
forall (m :: * -> *) a. Monad m => m a -> StateT EvalState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (ExceptT EgisonError RuntimeM (Either [Char] Expr)
 -> StateT
      EvalState (ExceptT EgisonError RuntimeM) (Either [Char] Expr))
-> (RuntimeM (Either [Char] Expr)
    -> ExceptT EgisonError RuntimeM (Either [Char] Expr))
-> RuntimeM (Either [Char] Expr)
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] Expr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RuntimeM (Either [Char] Expr)
-> ExceptT EgisonError RuntimeM (Either [Char] Expr)
forall (m :: * -> *) a. Monad m => m a -> ExceptT EgisonError m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (RuntimeM (Either [Char] Expr)
 -> StateT
      EvalState (ExceptT EgisonError RuntimeM) (Either [Char] Expr))
-> RuntimeM (Either [Char] Expr)
-> StateT
     EvalState (ExceptT EgisonError RuntimeM) (Either [Char] Expr)
forall a b. (a -> b) -> a -> b
$ [Char] -> RuntimeM (Either [Char] Expr)
NonS.parseExpr [Char]
expr
             ([Char] -> EvalM Expr)
-> (Expr -> EvalM Expr) -> Either [Char] Expr -> EvalM Expr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (EgisonError -> EvalM Expr
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (EgisonError -> EvalM Expr)
-> ([Char] -> EgisonError) -> [Char] -> EvalM Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> EgisonError
Parser) Expr -> EvalM Expr
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return Either [Char] Expr
r

-- |Load a libary file
loadLibraryFile :: FilePath -> EvalM [TopExpr]
loadLibraryFile :: [Char] -> EvalM [TopExpr]
loadLibraryFile [Char]
file = do
  [Char]
homeDir <- IO [Char] -> StateT EvalState (ExceptT EgisonError RuntimeM) [Char]
forall a. IO a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO [Char]
getHomeDirectory
  Bool
doesExist <- IO Bool -> StateT EvalState (ExceptT EgisonError RuntimeM) Bool
forall a. IO a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> StateT EvalState (ExceptT EgisonError RuntimeM) Bool)
-> IO Bool -> StateT EvalState (ExceptT EgisonError RuntimeM) Bool
forall a b. (a -> b) -> a -> b
$ [Char] -> IO Bool
doesFileExist ([Char] -> IO Bool) -> [Char] -> IO Bool
forall a b. (a -> b) -> a -> b
$ [Char]
homeDir [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"/.egison/" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
file
  if Bool
doesExist
    then [Char] -> EvalM [TopExpr]
loadFile ([Char] -> EvalM [TopExpr]) -> [Char] -> EvalM [TopExpr]
forall a b. (a -> b) -> a -> b
$ [Char]
homeDir [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"/.egison/" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
file
    else IO [Char] -> StateT EvalState (ExceptT EgisonError RuntimeM) [Char]
forall a. IO a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO ([Char] -> IO [Char]
getDataFileName [Char]
file) StateT EvalState (ExceptT EgisonError RuntimeM) [Char]
-> ([Char] -> EvalM [TopExpr]) -> EvalM [TopExpr]
forall a b.
StateT EvalState (ExceptT EgisonError RuntimeM) a
-> (a -> StateT EvalState (ExceptT EgisonError RuntimeM) b)
-> StateT EvalState (ExceptT EgisonError RuntimeM) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [Char] -> EvalM [TopExpr]
loadFile

-- |Load a file
loadFile :: FilePath -> EvalM [TopExpr]
loadFile :: [Char] -> EvalM [TopExpr]
loadFile [Char]
file = do
  Bool
doesExist <- IO Bool -> StateT EvalState (ExceptT EgisonError RuntimeM) Bool
forall a. IO a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> StateT EvalState (ExceptT EgisonError RuntimeM) Bool)
-> IO Bool -> StateT EvalState (ExceptT EgisonError RuntimeM) Bool
forall a b. (a -> b) -> a -> b
$ [Char] -> IO Bool
doesFileExist [Char]
file
  Bool
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
doesExist (StateT EvalState (ExceptT EgisonError RuntimeM) ()
 -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a b. (a -> b) -> a -> b
$ EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a.
EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (EgisonError -> StateT EvalState (ExceptT EgisonError RuntimeM) ())
-> EgisonError
-> StateT EvalState (ExceptT EgisonError RuntimeM) ()
forall a b. (a -> b) -> a -> b
$ [Char] -> EgisonError
Default ([Char]
"file does not exist: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
file)
  [Char]
input <- IO [Char] -> StateT EvalState (ExceptT EgisonError RuntimeM) [Char]
forall a. IO a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Char]
 -> StateT EvalState (ExceptT EgisonError RuntimeM) [Char])
-> IO [Char]
-> StateT EvalState (ExceptT EgisonError RuntimeM) [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> IO [Char]
readUTF8File [Char]
file
  let useSExpr :: Bool
useSExpr = [Char] -> Bool
checkIfUseSExpr [Char]
file
  [TopExpr]
exprs <- (EgisonOpts -> EgisonOpts) -> EvalM [TopExpr] -> EvalM [TopExpr]
forall a.
(EgisonOpts -> EgisonOpts)
-> StateT EvalState (ExceptT EgisonError RuntimeM) a
-> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (\EgisonOpts
opt -> EgisonOpts
opt { optSExpr = useSExpr })
                 ([Char] -> EvalM [TopExpr]
readTopExprs (Bool -> [Char] -> [Char]
removeShebang Bool
useSExpr [Char]
input))
  [[TopExpr]] -> [TopExpr]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[TopExpr]] -> [TopExpr])
-> StateT EvalState (ExceptT EgisonError RuntimeM) [[TopExpr]]
-> EvalM [TopExpr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TopExpr -> EvalM [TopExpr])
-> [TopExpr]
-> StateT EvalState (ExceptT EgisonError RuntimeM) [[TopExpr]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM TopExpr -> EvalM [TopExpr]
recursiveLoad [TopExpr]
exprs
 where
  recursiveLoad :: TopExpr -> EvalM [TopExpr]
recursiveLoad (Load [Char]
file)     = [Char] -> EvalM [TopExpr]
loadLibraryFile [Char]
file
  recursiveLoad (LoadFile [Char]
file) = [Char] -> EvalM [TopExpr]
loadFile [Char]
file
  recursiveLoad TopExpr
expr            = [TopExpr] -> EvalM [TopExpr]
forall a. a -> StateT EvalState (ExceptT EgisonError RuntimeM) a
forall (m :: * -> *) a. Monad m => a -> m a
return [TopExpr
expr]

removeShebang :: Bool -> String -> String
removeShebang :: Bool -> [Char] -> [Char]
removeShebang Bool
useSExpr cs :: [Char]
cs@(Char
'#':Char
'!':[Char]
_) = if Bool
useSExpr then Char
';' Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: [Char]
cs else [Char]
"--" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
cs
removeShebang Bool
_        [Char]
cs             = [Char]
cs

readUTF8File :: FilePath -> IO String
readUTF8File :: [Char] -> IO [Char]
readUTF8File [Char]
name = do
  Handle
h <- [Char] -> IOMode -> IO Handle
openFile [Char]
name IOMode
ReadMode
  Handle -> TextEncoding -> IO ()
hSetEncoding Handle
h TextEncoding
utf8
  Handle -> IO [Char]
hGetContents Handle
h

checkIfUseSExpr :: String -> Bool
checkIfUseSExpr :: [Char] -> Bool
checkIfUseSExpr [Char]
file = Int -> [Char] -> [Char]
forall a. Int -> [a] -> [a]
drop ([Char] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
file Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
5) [Char]
file [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
".segi"