Nombres cambiados

Author: ahidalgob

.gitignore

@@ -1,5 +1,7 @@
 *.hi
 *.o
+*.pbm
 Lexer.hs
 Parser.hs
 retina
+^intento$

SemanticChecker.hs ContextChecker.hs

@@ -3,9 +3,9 @@
 -- Augusto Hidalgo 13-10665
 -- Genesis Kufatty 13-10708
 
-module SemanticChecker where
+module ContextChecker where
 import AST
-import OurMonad
+import OurContextMonad
 import Control.Monad.Error
 import Control.Monad.State
 import Control.Monad.Writer
@@ -39,7 +39,7 @@ typeNConvert NumberN = Number
 ----------------------------------------------------------
 -- checkConstrN ------------------------------------------
 ----------------------------------------------------------
-checkConstrN :: ConstrN -> OurMonad ()
+checkConstrN :: ConstrN -> OurContextMonad ()
 checkConstrN (PN ldfN instrListN) = do
     addFunctionSign "home" [] Void
     addFunctionSign "openeye" [] Void
@@ -62,11 +62,11 @@ checkConstrN (LDFN l) = do
 checkConstrN (LDN l) = do
     mapM_ proccessTypeAndList l 
     where 
-        proccessTypeAndList :: (TypeN, [VarN]) -> OurMonad ()
+        proccessTypeAndList :: (TypeN, [VarN]) -> OurContextMonad ()
         proccessTypeAndList (tN, varNList) = do
             let t = typeNConvert tN
             mapM_ (adder t) varNList -- lanza error sin pos y en el with catcharlo y lanzarlo bien
-        adder :: OurType -> VarN -> OurMonad ()
+        adder :: OurType -> VarN -> OurContextMonad ()
         adder t varN = do 
             let (s,me) = case varN of
                     (VarN st) -> (st, Nothing)
@@ -85,7 +85,7 @@ checkConstrN (LDN l) = do
 ----------------------------------------------------------
 -- checkFuncDefN -----------------------------------------
 ----------------------------------------------------------
-checkFuncDefN :: FuncDefN -> OurMonad ()
+checkFuncDefN :: FuncDefN -> OurContextMonad ()
 checkFuncDefN funcDefN = do
     let (funId, paramList, instrListN, lineNum, retType) = case funcDefN of
             DFN s p i (ln,_) -> (s,(map (\(x,y) -> (y, typeNConvert x))).listLPN $ p,i,ln, Void)
@@ -118,14 +118,14 @@ checkFuncDefN funcDefN = do
 ----------------------------------------------------------
 -- checkInstrListN ---------------------------------------
 ----------------------------------------------------------
-checkInstrListN :: InstrListN -> OurMonad Returned
+checkInstrListN :: InstrListN -> OurContextMonad Returned
 checkInstrListN (LIN instrList) = do
     (foldl (|+|) No) <$> (mapM checkInstrN instrList)
 
 ----------------------------------------------------------
 -- checkInstrN -------------------------------------------
 ----------------------------------------------------------
-checkInstrN :: InstrN -> OurMonad Returned
+checkInstrN :: InstrN -> OurContextMonad Returned
 checkInstrN (WithDoN ldn lin (lineNum,_)) = do
     newScope
     checkConstrN ldn `catchError` (reThrow lineNum)
@@ -134,7 +134,7 @@ checkInstrN (WithDoN ldn lin (lineNum,_)) = do
     removeLastScope
     return res
     where
-        reThrow :: Int -> OurError -> OurMonad ()
+        reThrow :: Int -> OurError -> OurContextMonad ()
         reThrow lineNum (OurErrorNoPos s) = throwError $ OurError lineNum s
         reThrow lineNum e = throwError e
 
@@ -228,7 +228,7 @@ checkInstrN (ExprN expN) = do
 ----------------------------------------------------------
 -- checkExpN ---------------------------------------------
 ----------------------------------------------------------
-checkExpN :: ExpN -> OurMonad OurType
+checkExpN :: ExpN -> OurContextMonad OurType
 checkExpN (IdN s (lineNum,_)) = do
     bo <- lookInSymTable s
     when (bo==Nothing) $ throwError $ OurError lineNum $ "'"++s++"' no esta declarada en este alcance."
@@ -297,7 +297,7 @@ checkExpN (NumberLiteralN s _) = do
 ----------------------------------------------------------
 -- checkWordListN ----------------------------------------
 ----------------------------------------------------------
-checkWordListN :: [WordN] -> OurMonad ()
+checkWordListN :: [WordN] -> OurContextMonad ()
 checkWordListN (wordList) = do
     mapM_ checkWord wordList
     where checkWord (PWEN exp) = do

Makefile

@@ -1,4 +1,4 @@
-retina: Lexer Parser OurMonad SemanticChecker
+retina: Lexer Parser OurContextMonad ContextChecker
 	ghc --make -w retina.hs
 
 Lexer: Lexer.x
@@ -7,11 +7,11 @@ Lexer: Lexer.x
 Parser: Parser.y
 	happy Parser.y
 
-OurMonad: OurMonad.hs
-	ghc --make -w OurMonad.hs
+OurContextMonad: OurContextMonad.hs
+	ghc --make -w OurContextMonad.hs
 
-SemanticChecker: SemanticChecker.hs
-	ghc --make -w SemanticChecker.hs
+ContextChecker: ContextChecker.hs
+	ghc --make -w ContextChecker.hs
 
 AST: AST.hs
 	ghc --make -w AST.hs

OurMonad.hs OurContextMonad.hs

@@ -1,9 +1,9 @@
 -- Retina - Proyecto de Traductores
--- OurMonad, Monad para realizar el analisis de contexto y sus funciones respectivas.
+-- OurContextMonad, Monad para realizar el analisis de contexto y sus funciones respectivas.
 -- Augusto Hidalgo 13-10665
 -- Genesis Kufatty 13-10708
 
-module OurMonad where
+module OurContextMonad where
 
 import Control.Monad.Error
 import Control.Monad.State
@@ -29,11 +29,11 @@ data Scope = Scope {getList::[(String, OurType)]}
 
 data FuncSign = FuncSign {getId::String, getType:: OurType, getParamList::[(String,OurType)]}
 
-data SymTable = SymTable {getScopes::[Scope], getFuncSigns::[FuncSign]}
+data ContextSymTable = ContextSymTable {getScopes::[Scope], getFuncSigns::[FuncSign]}
 
-data OurState = OurState {getSymTable::SymTable, getReturnT::(Maybe OurType)}
+data OurContextState = OurContextState {getSymTable::ContextSymTable, getReturnT::(Maybe OurType)}
 
-emptyState = OurState (SymTable [] []) Nothing
+emptyContextState = OurContextState (ContextSymTable [] []) Nothing
 
 data OurLog = OurLog {getScopesLog::String, getWarningsLog::String}
 
@@ -49,43 +49,43 @@ scopeToOurLog s = OurLog s ""
 warningToOurLog s = OurLog "" s
 
 
-type OurMonad a = StateT OurState (WriterT OurLog (Either OurError)) a
+type OurContextMonad a = StateT OurContextState (WriterT OurLog (Either OurError)) a
 
-runOurMonad :: OurMonad a -> OurState -> Either OurError ((a, OurState), OurLog)
-runOurMonad f a = runWriterT (runStateT f a)
+runOurContextMonad :: OurContextMonad a -> OurContextState -> Either OurError ((a, OurContextState), OurLog)
+runOurContextMonad f a = runWriterT (runStateT f a)
 
-getLog f a = show $ snd $ getRight $ runOurMonad f a `catchError` (\(OurError pos s) -> error $ "\nError en linea "++show pos++":\n"++s)
+getLog f a = show $ snd $ getRight $ runOurContextMonad f a `catchError` (\(OurError pos s) -> error $ "\nError en linea "++show pos++":\n"++s)
     where
         getRight (Right x) = x
 
 
 lookInList :: String -> [(String, OurType)] -> Maybe OurType
 lookInList s l = snd <$> find ((==s).fst) l
 
-lookInLastScope :: String -> OurMonad (Maybe OurType)
+lookInLastScope :: String -> OurContextMonad (Maybe OurType)
 lookInLastScope s = lookInList s.getList.head'.getScopes.getSymTable <$> get
                     where head' [] = Scope []
                           head' (a:as) = a
 
-lookInSymTable :: String -> OurMonad (Maybe OurType)
+lookInSymTable :: String -> OurContextMonad (Maybe OurType)
 lookInSymTable s = msum . map (lookInList s) . (map getList).getScopes.getSymTable <$> get
 
-newScope :: OurMonad ()
+newScope :: OurContextMonad ()
 newScope = do
     oldState <- get
     let oldSymTable = getSymTable oldState
         oldScopes = getScopes oldSymTable
         newSymTable = oldSymTable {getScopes = (Scope []):oldScopes}
     put $ oldState {getSymTable = newSymTable}
 
-removeLastScope :: OurMonad ()
+removeLastScope :: OurContextMonad ()
 removeLastScope = do
     oldState <- get
     let oldSymTable = getSymTable oldState
         newSymTable = oldSymTable {getScopes = tail.getScopes $ oldSymTable }
     put $ oldState { getSymTable = newSymTable}
 
-addToSymTable :: (String, OurType) -> OurMonad ()
+addToSymTable :: (String, OurType) -> OurContextMonad ()
 addToSymTable pair = do
     oldState <- get
     let oldSymTable = getSymTable oldState
@@ -95,15 +95,15 @@ addToSymTable pair = do
         newSymTable = oldSymTable { getScopes = newScopeList }
     put $ oldState { getSymTable = newSymTable }
 
-addFunctionSign :: String -> [(String, OurType)] -> OurType -> OurMonad () -- No crea el scope
+addFunctionSign :: String -> [(String, OurType)] -> OurType -> OurContextMonad () -- No crea el scope
 addFunctionSign s params typ = do 
     oldState <- get
     let newFunc = FuncSign s typ params
         oldSymTable = getSymTable oldState
         newSymTable = oldSymTable { getFuncSigns = newFunc:(getFuncSigns oldSymTable) }
     put $ oldState { getSymTable = newSymTable }
 
-lookFunction :: String -> OurMonad Bool
+lookFunction :: String -> OurContextMonad Bool
 lookFunction s = do
     oldState <- get  
     let funcsList = map (getId) (getFuncSigns.getSymTable $ oldState)
@@ -113,29 +113,29 @@ lookFunction s = do
             _ -> True
     return ans
 
-getFunctionReturnType :: String -> OurMonad OurType
+getFunctionReturnType :: String -> OurContextMonad OurType
 getFunctionReturnType s = do
     oldState <- get
     let listFunc = getFuncSigns.getSymTable $ oldState
         func = filter ((==s).getId) listFunc 
     return $ getType.head $ func
 
-checkFunction :: String -> [OurType] -> OurMonad (Bool,Int)
+checkFunction :: String -> [OurType] -> OurContextMonad (Bool,Int)
 checkFunction s list = do
     oldState <- get
     let listF = getParamList $ head $ filter ((==s).getId) (getFuncSigns.getSymTable $ oldState)
         listType = map snd listF
     return (listType==list,length listType)
 
-setReturnType :: Maybe OurType -> OurMonad ()
+setReturnType :: Maybe OurType -> OurContextMonad ()
 setReturnType typeR = do 
     oldState <- get
     put $ oldState { getReturnT = typeR }
 
-getReturnType :: OurMonad (Maybe OurType)
+getReturnType :: OurContextMonad (Maybe OurType)
 getReturnType = get >>= (return.getReturnT)
 
-lastScopeToLog :: String -> OurMonad ()
+lastScopeToLog :: String -> OurContextMonad ()
 lastScopeToLog scopeName = do
     scopes <- getScopes.getSymTable <$> get
     let nested = length scopes
@@ -145,6 +145,6 @@ lastScopeToLog scopeName = do
     tell.scopeToOurLog $ concatMap (\s -> ident++"|> "++s++"\n" ) $ map showVarAndType $ reverse.getList $ lastScope
     where
         showVarAndType (s, t) = s ++" : "++ show t
-warningToLog :: String -> OurMonad ()
+warningToLog :: String -> OurContextMonad ()
 warningToLog warning = do
     tell.warningToOurLog $ warning++"\n"

retina.hs

@@ -6,8 +6,8 @@
 import Lexer
 import AST
 import qualified Parser as P
-import SemanticChecker
-import OurMonad
+import ContextChecker
+import OurContextMonad
 import System.Environment
 
 main = do
@@ -18,8 +18,7 @@ main = do
                         putStrLn "Error lexicografico (alex isn't happy)"
                         mapM_ printToken $ reverse $ tokenList ls
                     else do
-                        --Imprimir AST
                         --printConstrN 0 . (P.parse) . reverse . tokenList $ ls 
-                        putStrLn $ getLog (checkConstrN $ (P.parse) . reverse . tokenList $ ls) emptyState
+                        putStrLn $ getLog (checkConstrN $ (P.parse) . reverse . tokenList $ ls) emptyContextState
 
         Left e -> putStrLn e