-module Typecheck (typeCheckExp, typeCheckStm, typeCheckVar) where
+module Typecheck where -- (typeCheckExp, typeCheckStm, typeCheckVar, State) where
import Abssyntax
-import Control.Monad.State
+import Control.Monad.State hiding (State)
import Data.Map as Map
import Prelude hiding (lookup)
type Types = [Map Ident Type]
+type Function = (Type, [Type])
+
+data State = State {variables::Types,functions::[Map Ident Function],function::Ident}
+
inList :: Eq a => a -> [a] -> Bool
inList _ [] = False
assert True _ = return ()
assert False s = fail s
-typeCheckExp :: (MonadState Types m) => Exp -> m Type
+typeCheckExp :: (MonadState State m) => Exp -> m Type
typeCheckExp (BiOpExp e o e') = do
t1 <- typeCheckExp e
t2 <- typeCheckExp e'
TBool <- typeCheckExp e
return TBool
-typeCheckVar :: (MonadState Types m) => Ident -> m Type
+typeCheckVar :: (MonadState State m) => Ident -> m Type
typeCheckVar i = do
- ms <- get
- findVariable i ms
+ s <- get
+ findVariable i $ variables s
-findVariable :: (MonadState Types m) => Ident -> Types -> m Type
+findVariable :: (MonadState State m) => Ident -> Types -> m Type
findVariable i [] = fail $ "Variable "++show i++" not found in any scope."
findVariable i (m:ms) = if member i m then lookup i m else findVariable i ms
-pushAndPop :: (MonadState Types m) => m a -> m ()
+pushAndPop :: (MonadState State m) => m a -> m ()
pushAndPop s = do
- modify (empty:)
+ modify (\s -> s { variables = empty:variables s})
s
- modify tail
+ modify (\s -> s { variables = tail $ variables s})
-typeCheckStm :: (MonadState Types m) => Stm -> m ()
+typeCheckStm :: (MonadState State m) => Stm -> m ()
typeCheckStm SNoop = return ()
typeCheckStm (SExp e) = do
typeCheckExp e
typeCheckExp e
return ()
-addVariable :: (MonadState Types m) => Ident -> Type -> m ()
+addVariable :: (MonadState State m) => Ident -> Type -> m ()
addVariable i t = do
- (m:ms) <- get
- case insertLookupWithKey (\k a1 a2 -> a1) i t m of
- (Nothing,m') -> put (m':ms)
+ s <- get
+ let (m:ms) = variables s in case insertLookupWithKey (\k a1 a2 -> a1) i t m of
+ (Nothing,m') -> modify (\s -> s{ variables = m':ms})
_ -> fail $ "Duplicate variable declaration: "++show i
import Printsyntax
import Abssyntax
-import Typecheck
-import Control.Monad.State
+import Control.Monad.State hiding (State)
import Data.Map as Map hiding (showTree)
+import Typecheck
import ErrM
type Verbosity = Int
+
+splitFunStm :: [FuncStm] -> ([Func],[Stm])
+splitFunStm [] = ([],[])
+splitFunStm ((F f):fss) = let (fs,ss) = splitFunStm fss in (f:fs,ss)
+splitFunStm ((S s):fss) = let (fs,ss) = splitFunStm fss in (fs,s:ss)
+
putStrV :: Verbosity -> String -> IO ()
putStrV v s = if v > 1 then putStrLn s else return ()
-runFile :: Verbosity -> ParseFun Stms -> FilePath -> IO ()
+runFile :: Verbosity -> ParseFun Program -> FilePath -> IO ()
runFile v p f = putStrLn f >> readFile f >>= run v p
-run :: Verbosity -> ParseFun Stms -> String -> IO ()
+run :: Verbosity -> ParseFun Program -> String -> IO ()
run v p s = let ts = myLLexer s in case p ts of
Bad s -> do
putStrLn "\nParse Failed...\n"
putStrV v "Tokens:"
putStrV v $ show ts
putStrLn s
- Ok (Program s) -> do
+ Ok (Program s) -> let (fun,st) = splitFunStm (s) in do
putStrLn "\nParse Successful!"
showTree v (Program s)
- runStateT (mapM typeCheckStm s) [empty]
+ runStateT (mapM typeCheckStm st) State{variables=[empty], functions=[empty], function=(Ident "")}
print "The program is type-correct!!"
return ()
main :: IO ()
main = do args <- getArgs
case args of
- [] -> hGetContents stdin >>= run 2 pStms
- "-s":fs -> mapM_ (runFile 0 pStms) fs
- fs -> mapM_ (runFile 2 pStms) fs
+ [] -> hGetContents stdin >>= run 2 pProgram
+ "-s":fs -> mapM_ (runFile 0 pProgram) fs
+ fs -> mapM_ (runFile 2 pProgram) fs