merged changes to function branch

diff --cc CompInt.hs
index 0000000000000000000000000000000000000000,1188466da980b4d1886b4d3deff9d5e199fa08fc..d5aa2ca052ada77068d47afd86bb901eeb053a98
mode 000000,100644..100644
--- /dev/null
--- 2/CompInt.hs
+++ b/CompInt.hs
@@@ -1,0 -1,54 +1,53 @@@
 -import Data.Map as Map hiding (showTree)
+ -- automatically generated by BNF Converter
+ module Main where
+ 
+ 
+ import IO ( stdin, hGetContents )
+ import System ( getArgs, getProgName )
+ 
+ import Lexsyntax
+ import Parsyntax
+ import Skelsyntax
+ import Printsyntax
+ import Abssyntax
+ 
+ import Typecheck
+ import Interpret
+ import Compile
 -
 -cHeader = "#include <stdio.h>\nint read(){\nint n;\nscanf(\"%d\",&n);\nreturn n;\n}\nint main(void){\n"
 -
 -cFooter = "return 0;}"
+ 
+ import ErrM
+ 
+ type ParseFun a = [Token] -> Err a
+ 
+ myLLexer = myLexer
+ 
 -runFile :: ([Stm] -> IO()) -> ParseFun Stms -> FilePath -> IO ()
++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 :: Int -> String -> IO ()
+ putStrV v s = if v > 1 then putStrLn s else return ()
+ 
 -run :: ([Stm] -> IO()) -> ParseFun Stms -> String -> IO ()
++runFile :: ([Func] -> [Stm] -> IO()) -> ParseFun Program -> FilePath -> IO ()
+ runFile e p f = readFile f >>= run e p
+ 
 -      Ok (Program s) -> do
 -              typeCheck s
 -              e s
++run :: ([Func] -> [Stm] -> IO()) -> ParseFun Program -> String -> IO ()
+ run e p s = let ts = myLLexer s in case p ts of
+       Bad s    -> do
+               putStrLn "\nParse              Failed...\n"
+               putStrLn "Tokens:"
+               putStrLn $ show ts
+               putStrLn s
 -              [] -> hGetContents stdin >>= run interpret pStms
 -              "-c":f:[] -> runFile (writeFile (f++".c") . compile)  pStms f
 -              f:[] -> runFile interpret pStms f
++      Ok (Program s) -> let (fun,st) = splitFunStm (s) in do
++              typeCheck fun st
++              e fun st
+ 
+ main :: IO ()
+ main = do 
+       args <- getArgs
+       case args of
++              [] -> hGetContents stdin >>= run interpret pProgram
++              "-c":f:[] -> runFile (\fun st -> writeFile (f++".c") $ compile fun st)  pProgram f
++              f:[] -> runFile interpret pProgram f
+               _ -> print "Too many arguments"

diff --cc Compile.hs
index 0e1cf22a1c0b0239f43af889962496e9ce2c37f7,2252fc539064b6666fead76092317d1a16f31593..eb70d0c8223e9e71ec356cce274f850ad454239b
--- 1/Compile.hs
--- 2/Compile.hs
+++ b/Compile.hs
@@@ -3,6 -3,13 +3,13 @@@ module Compile (compile,compileExp, com
  import Abssyntax
  import Prelude hiding (lookup)
  
 -compile :: [Stm] -> String
 -compile s = cHeader++concat (map compileStm s)++cFooter
+ cHeader = "#include <stdio.h>\nint read(){\nint n;\nscanf(\"%d\",&n);\nreturn n;\n}\nint main(void){\n"
+ 
+ cFooter = "return 0;}"
+ 
++compile :: [Func] -> [Stm] -> String
++compile f s = cHeader++concat (map compileStm s)++cFooter
+ 
  compileExp :: Exp -> String
  compileExp (EBool True) = "1";
  compileExp (EBool False) = "0";

diff --cc Interpret.hs
index 0e3928587d30ecb247b6833adc4a28ffaff1840f,0728d5181c967cf6d109f3327f2d8905e6738b1e..5afcefb10b28cd6ac4a390e71958499b5cfdc956
--- 1/Interpret.hs
--- 2/Interpret.hs
+++ b/Interpret.hs
@@@ -1,9 -1,7 +1,9 @@@
- module Interpret (eval, execute,addFunction, emptyState, Value(..), State(..)) where
 -module Interpret (interpret, eval, execute, Value(VInt, VBool)) where
++module Interpret (interpret, eval, execute,addFunction, emptyState, Value(..), State(..)) where
  
  import Abssyntax
 -import Control.Monad.State
 +import Control.Monad.State hiding (State)
 +import Control.Monad.Error
 +import Control.Concurrent.MVar
  import Data.Map as Map
  import Prelude hiding (lookup)
  
@@@ -17,12 -13,12 +17,18 @@@ instance Show Value wher
        show (VBool False) = "0"
  
  type Variables = [Map Ident Value]
 +type Function = ([Decl],[Stm])
 +
 +data State = State {variables::Variables,functions::(Map Ident Function),ret::(MVar Value)}
  
 -interpret :: [Stm] -> IO ()
 -interpret s = runStateT (mapM execute s) [empty] >> return ()
++interpret :: [Func] -> [Stm] -> IO ()
++interpret fun st = do
++      mv <- newEmptyMVar
++      runStateT (do mapM Interpret.addFunction fun; mapM execute st) emptyState{ret=mv}
++      return ()
+ 
  --eval :: (MonadState Variables m) => Exp -> m Value
 -eval :: Exp -> StateT Variables IO Value
 +eval :: Exp -> StateT State IO Value
  eval (EBool b) = return (VBool b)
  eval (EInt n) = return (VInt n)
  eval (EVar i) = getVariableValue i

diff --cc Interpreter.hs
index e41759db1c93d656391b6d0d53bf4c20193fb152,694ce2367ea328c1e4b2ebb270ab743a99f5e87a..ae73abba4a1cff690a8bab18e84c977298c73809
--- 1/Interpreter.hs
--- 2/Interpreter.hs
+++ b/Interpreter.hs
@@@ -13,9 -13,8 +13,6 @@@ import Abssynta
  
  import Typecheck
  import Interpret
- import Control.Monad.State hiding (State)
- import Control.Concurrent.MVar
 -import Control.Monad.State
--import Data.Map as Map hiding (showTree)
  
  import ErrM
  
@@@ -43,16 -37,14 +40,14 @@@ run v p s = let ts = myLLexer s in cas
                putStrV v "Tokens:"
                putStrV v $ show ts
                putStrLn s
 -      Ok (Program s) -> do
 -              --putStrLn "\nParse Successful!"
 -              --showTree v (Program s)
 -              typeCheck s
 -              --print "The program is type-correct!!"
 -              --print "Running program:"
 -              interpret s
 -              --print "Done running program!"
 +      Ok (Program s) -> let (fun,st) = splitFunStm (s) in do
 +              putStrLn "\nParse Successful!"
 +              showTree v (Program s)
-               runStateT (do mapM Typecheck.addFunction fun; mapM typeCheckFunction fun; mapM typeCheckStm st) Typecheck.emptyState
++              typeCheck fun st
 +              print "The program is type-correct!!"
 +              print "Running program:"
-               mv <- newEmptyMVar
-               runStateT (do mapM Interpret.addFunction fun; mapM execute st) Interpret.emptyState{ret=mv}
++              interpret fun st
 +              print "Done running program!"
-               return ()
  
  showTree :: (Show a, Print a) => Int -> a -> IO ()
  showTree v tree

diff --cc Typecheck.hs
index 5c70ccf02c04118b27f297e854d887be05c58a13,1b0baa00ed5d48dc760f029f9759e8bb821eed9c..a8c10e55f5dc570e99e79fd9b30b9ad085664d11
--- 1/Typecheck.hs
--- 2/Typecheck.hs
+++ b/Typecheck.hs
@@@ -1,4 -1,4 +1,4 @@@
- module Typecheck (typeCheckExp, typeCheckStm, typeCheckVar, typeCheckFunction, addFunction, emptyState, State(..)) where 
 -module Typecheck (typeCheck,typeCheckExp, typeCheckStm, typeCheckVar) where 
++module Typecheck (typeCheck, typeCheckExp, typeCheckStm, typeCheckVar, typeCheckFunction, addFunction, emptyState, State(..)) where 
  
  
  import Abssyntax
@@@ -17,7 -16,10 +17,12 @@@ assert :: Monad m => Bool -> String -> 
  assert True _ = return ()
  assert False s = fail s
  
 -typeCheck :: [Stm] -> IO ()
 -typeCheck s = runStateT (mapM typeCheckStm s) [empty] >> return ()
++typeCheck :: [Func] -> [Stm] -> IO ()
++typeCheck fun st = do
++      runStateT (do mapM addFunction fun; mapM typeCheckFunction fun; mapM typeCheckStm st) emptyState
++      return ()
+ 
 -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'