Simple parse-dump main function, also fixed about everything

src/Ubc/Parse/Syntax/Struct.hs

@@ -1,71 +1,56 @@
 module Ubc.Parse.Syntax.Struct
 ( Struct(..)
-, parseStruct
+, parse
 )
 where
 
-import Data.Functor ( (<&>) )
-import Control.Arrow ( (>>>) )
+import Control.Monad ((<$!>))
 
 import Text.Parsec
-    ( char,
-      choice,
-      getState,
-      lookAhead,
+    ( choice,
       many,
-      modifyState,
       try,
-      ParsecT )
+      ParsecT,
+      )
 
-import Ubc.Parse.Syntax.ParserState (ParserState)
-import Ubc.Parse.Syntax.Scope.StructScope (StructScope(..))
-import Ubc.Parse.Syntax.Scope (Scope(..))
 import Ubc.Parse.Syntax.Data.Struct (Struct(..))
+import Ubc.Parse.Syntax.VariableType (VariableType)
 
 import qualified Ubc.Parse.Syntax.Language as UbcLanguage
-import qualified Ubc.Parse.Syntax.Scope.StructScope as StructScope
-import qualified Ubc.Parse.Syntax.ParserState as ParserState
-import qualified Ubc.Parse.Syntax.Scope as Scope
 import qualified Ubc.Parse.Syntax.VariableType as VariableType
+import qualified Ubc.Parse.Syntax.Data.Struct as Struct
+import qualified Ubc.Parse.Syntax.Function as Function
 
+type VariableName = String
+data StructStatement = Variable VariableName VariableType
+        | Function Function.Function
 
-parseStruct :: Monad m => ParsecT String ParserState m Struct
-parseStruct = do
+parse :: Monad m => ParsecT String u m Struct
+parse = do
         _ <- UbcLanguage.reserved "struct"
-
         structIdentifier <- UbcLanguage.identifier
-        let structScope = StructScope
-                { structName = structIdentifier 
-                , variables = []
-                }
 
-        modifyState (ParserState.pushScope . ScopeStruct $ structScope)
+        foldl accumulateStruct (Struct structIdentifier [] []) <$!> UbcLanguage.braces (many structMember)
 
-        _ <- UbcLanguage.braces (many structMember)
+accumulateStruct :: Struct -> StructStatement -> Struct
+accumulateStruct s (Variable n t) = Struct.addVariable s n t
+accumulateStruct s (Function f) = Struct.addFunction s f
 
-        structScope' <- getState <&> Scope.expectScopeStruct . snd . ParserState.popScope
-
-        return $ Struct (StructScope.structName structScope') (StructScope.variables structScope')
-
-structMember :: Monad m => ParsecT String ParserState m ()
+structMember :: Monad m => ParsecT String u m StructStatement
 structMember = choice [ structVariableOrFunction ]
 
-structVariableOrFunction :: Monad m => ParsecT String ParserState m ()
+structVariableOrFunction :: Monad m => ParsecT String u m StructStatement
 structVariableOrFunction = do
         (typeName, identifier) <- try $ do
                 typeName <- UbcLanguage.typeName
                 objectIdentifier <- UbcLanguage.identifier
-                return (typeName, objectIdentifier)
-        choice 
-                [ lookAhead (char ';') *> parseVariable typeName identifier
+                return (VariableType.fromString typeName, objectIdentifier)
+        choice
+                [ parseVariable typeName identifier
+                , Function <$!> Function.parsePrefixed typeName identifier
                 ] -- TODO: Functions on structs
 
-parseVariable :: Monad m => String -> String -> ParsecT String ParserState m ()
+parseVariable :: Monad m => VariableType -> String -> ParsecT String u m StructStatement
 parseVariable variableType variableName = do
         _ <- UbcLanguage.semicolon
-
-        modifyState (ParserState.modifyScope (Scope.expectScopeStruct 
-                        >>> StructScope.modifyVariables ((variableName, VariableType.fromString variableType):)
-                        >>> Scope.ScopeStruct
-                        )
-                )
+        return $ Variable variableName variableType