Sockeye: Refactor ASTs
authorDaniel Schwyn <schwyda@student.ethz.ch>
Fri, 7 Jul 2017 14:49:49 +0000 (16:49 +0200)
committerDaniel Schwyn <schwyda@student.ethz.ch>
Fri, 7 Jul 2017 14:56:02 +0000 (16:56 +0200)
Also get rid of debugging backend

Signed-off-by: Daniel Schwyn <schwyda@student.ethz.ch>

tools/sockeye/Main.hs
tools/sockeye/SockeyeAST.hs [moved from tools/sockeye/SockeyeASTIntermediate.hs with 54% similarity]
tools/sockeye/SockeyeASTBackend.hs [deleted file]
tools/sockeye/SockeyeASTDecodingNet.hs [new file with mode: 0644]
tools/sockeye/SockeyeASTParser.hs [moved from tools/sockeye/SockeyeASTFrontend.hs with 59% similarity]
tools/sockeye/SockeyeBackendPrintAST.hs [deleted file]
tools/sockeye/SockeyeBackendProlog.hs
tools/sockeye/SockeyeChecker.hs
tools/sockeye/SockeyeNetBuilder.hs
tools/sockeye/SockeyeParser.hs

index 8df616b..1046e18 100644 (file)
@@ -22,15 +22,14 @@ import System.Exit
 import System.Environment
 import System.IO
 
-import SockeyeASTFrontend as ASTF
-import SockeyeASTIntermediate as ASTI
-import SockeyeASTBackend as ASTB
+import qualified SockeyeASTParser as ParseAST
+import qualified SockeyeAST as AST
+import qualified SockeyeASTDecodingNet as NetAST
 
 import SockeyeParser
 import SockeyeChecker
 import SockeyeNetBuilder
 
-import qualified SockeyeBackendPrintAST as PrintAST
 import qualified SockeyeBackendProlog as Prolog
 
 import Text.Groom(groom)
@@ -49,7 +48,7 @@ buildError :: ExitCode
 buildError = ExitFailure 4
 
 {- Compilation targets -}
-data Target = None | PrintAST | Prolog
+data Target = None | Prolog
 
 {- Possible options for the Sockeye Compiler -}
 data Options = Options { optInputFile  :: FilePath
@@ -91,9 +90,6 @@ options =
     [ Option "P" ["Prolog"]
         (NoArg (\opts -> return $ optSetTarget Prolog opts))
         "Generate a prolog file that can be loaded into the SKB (default)."
-    , Option "A" ["AST"]
-        (NoArg (\opts -> return $ optSetTarget PrintAST opts))
-        "Print the AST."
     , Option "C" ["Check"]
         (NoArg (\opts -> return $ optSetTarget None opts))
         "Just check the file, do not compile."
@@ -127,7 +123,7 @@ compilerOpts argv =
             exitWith $ usageError
 
 {- Runs the parser -}
-parseFile :: FilePath -> IO (ASTF.SockeyeSpec)
+parseFile :: FilePath -> IO (ParseAST.SockeyeSpec)
 parseFile file = do
     src <- readFile file
     case parseSockeye file src of
@@ -137,7 +133,7 @@ parseFile file = do
         Right ast -> return ast
 
 {- Runs the checker -}
-checkAST :: ASTF.SockeyeSpec -> IO ASTI.SockeyeSpec
+checkAST :: ParseAST.SockeyeSpec -> IO AST.SockeyeSpec
 checkAST parsedAst = do
     case checkSockeye parsedAst of 
         Left fail -> do
@@ -146,7 +142,7 @@ checkAST parsedAst = do
         Right intermAst -> return intermAst
 
 {- Builds the decoding net from the Sockeye AST -}
-buildNet :: ASTI.SockeyeSpec -> IO ASTB.NetSpec
+buildNet :: AST.SockeyeSpec -> IO NetAST.NetSpec
 buildNet ast = do
     case sockeyeBuildNet ast of 
         Left fail -> do
@@ -155,9 +151,8 @@ buildNet ast = do
         Right netAst -> return netAst
 
 {- Compiles the AST with the appropriate backend -}
-compile :: Target -> ASTB.NetSpec -> IO String
+compile :: Target -> NetAST.NetSpec -> IO String
 compile None     _   = return ""
-compile PrintAST ast = return $ PrintAST.compile ast
 compile Prolog   ast = return $ Prolog.compile ast
 
 {- Outputs the compilation result -}
@@ -175,6 +170,6 @@ main = do
     ast <- checkAST parsedAst
     netAst <- buildNet ast
     putStrLn $ groom netAst
-    -- out <- compile (optTarget opts) ast
-    -- output (optOutputFile opts) out
+    out <- compile (optTarget opts) netAst
+    output (optOutputFile opts) out
     
\ No newline at end of file
similarity index 54%
rename from tools/sockeye/SockeyeASTIntermediate.hs
rename to tools/sockeye/SockeyeAST.hs
index f2f71c5..6a62563 100644 (file)
@@ -1,5 +1,5 @@
 {-
-  SockeyeASTIntermediate.hs: Intermediate AST for Sockeye
+  SockeyeAST.hs: AST for Sockeye
 
   Part of Sockeye
 
   Attn: Systems Group.
 -}
 
-module SockeyeASTIntermediate
-    ( module SockeyeASTIntermediate
-    , module SockeyeASTFrontend
-    ) where
+module SockeyeAST where
 
 import Data.Map (Map)
 import Data.Set (Set)
 
-import SockeyeASTFrontend
-    ( Identifier(SimpleIdent, TemplateIdent)
-    , prefix, varName, suffix
-    , ModuleParamType(NumberParam, AddressParam)
-    , ModuleArg(AddressArg, NumberArg, ParamArg)
-    , NodeSpec(NodeSpec)
-    , nodeType, accept, translate, overlay
-    , NodeType(Memory, Device)
-    , BlockSpec(SingletonBlock, RangeBlock, LengthBlock)
-    , address, base, limit, bits
-    , MapSpec(MapSpec)
-    , block, destNode, destBase
-    , Address(NumberAddress, ParamAddress)
-    , ForLimit(NumberLimit, ParamLimit)
-    )
-
 newtype SockeyeSpec = SockeyeSpec
     { modules :: Map String Module }
     deriving (Show)
@@ -50,6 +31,15 @@ data Module = Module
     , moduleInsts  :: [ModuleInst]
     } deriving (Show)
 
+data ModuleParamType 
+    = NumberParam
+    | AddressParam
+    deriving (Eq)
+
+instance Show ModuleParamType where
+    show NumberParam = "nat"
+    show AddressParam = "addr"
+
 data Port
     = Port Identifier
     | MultiPort (For Port)
@@ -66,6 +56,12 @@ data ModuleInst
     | MultiModuleInst (For ModuleInst)
     deriving (Show)
 
+data ModuleArg
+    = AddressArg !Word
+    | NumberArg !Word
+    | ParamArg !String
+    deriving (Show)
+
 data PortMap
     = PortMap
         { mappedId   :: Identifier
@@ -82,6 +78,52 @@ data NodeDecl
     | MultiNodeDecl (For NodeDecl)
     deriving (Show)
 
+data Identifier
+    = SimpleIdent !String
+    | TemplateIdent
+        { prefix  :: !String
+        , varName :: !String
+        , suffix  :: Maybe Identifier
+        }
+    deriving (Show)
+
+data NodeSpec = NodeSpec
+    { nodeType  :: Maybe NodeType
+    , accept    :: [BlockSpec]
+    , translate :: [MapSpec]
+    , overlay   :: Maybe Identifier
+    } deriving (Show)
+
+data NodeType
+    = Memory
+    | Device
+    deriving (Show)
+
+data BlockSpec 
+    = SingletonBlock
+        { address :: !Address }
+    | RangeBlock
+        { base  :: !Address
+        , limit :: !Address
+        }
+    | LengthBlock
+        { base :: !Address
+        , bits :: !Word
+        }
+    deriving (Show)
+
+data MapSpec 
+    = MapSpec
+        { block    :: BlockSpec
+        , destNode :: Identifier
+        , destBase :: Maybe Address
+        } deriving (Show)
+
+data Address
+    = NumberAddress !Word
+    | ParamAddress !String
+    deriving (Show)
+
 data For a 
     = For
         { varRanges :: Map String ForRange
@@ -93,3 +135,8 @@ data ForRange
     { start :: ForLimit
     , end   :: ForLimit
     } deriving (Show)
+
+data ForLimit 
+    = NumberLimit !Word
+    | ParamLimit !String
+    deriving (Show)
diff --git a/tools/sockeye/SockeyeASTBackend.hs b/tools/sockeye/SockeyeASTBackend.hs
deleted file mode 100644 (file)
index cb6e4bd..0000000
+++ /dev/null
@@ -1,103 +0,0 @@
-{-
-  SockeyeASTBackend.hs: Backend AST for Sockeye
-
-  Part of Sockeye
-
-  Copyright (c) 2017, ETH Zurich.
-
-  All rights reserved.
-
-  This file is distributed under the terms in the attached LICENSE file.
-  If you do not find this file, copies can be found by writing to:
-  ETH Zurich D-INFK, CAB F.78, Universitaetstr. 6, CH-8092 Zurich,
-  Attn: Systems Group.
--}
-
-module SockeyeASTBackend where
-
-import Data.List
-import Numeric (showHex)
-
-{-
-Nodes are identfied by strings
--}
-newtype NodeId = NodeId String deriving (Eq, Ord)
-
-{-
-Addresses are natural numbers
--}
-newtype Addr = Addr Word deriving (Eq, Ord)
-
-{-
-A block is a contigous set of addresses
--}
-data BlockSpec = BlockSpec
-    { base  :: Addr
-    , limit :: Addr
-    } deriving (Eq, Ord)
-
-{-
-A mapping of a source address block to a destination node
-at a base address
--}
-data MapSpec = MapSpec { srcBlock :: BlockSpec
-                       , destNode :: NodeId
-                       , destBase :: Addr
-                       }
-
-{-
-Node can either be memory, device or other
--}
-data NodeType = Memory
-              | Device
-              | Other
-
-{-
-A node is specified as a list of blocks it accepts,
-a list of mappings and possibly an overlay on another block
--}
-data NodeSpec = NodeSpec { nodeType  :: NodeType
-                         , accept    :: [BlockSpec]
-                         , translate :: [MapSpec]
-                         , overlay   :: Maybe NodeId
-                         }
-
-{-
-A decoding net is specified as a list 
-of Node IDs mapped to Nodes
--}
-newtype NetSpec = NetSpec [(NodeId, NodeSpec)]
-
-{- Pretty Printing -}
-instance Show NodeId where
-    show (NodeId id) = id
-
-instance Show Addr where
-    show (Addr addr) = "0x" ++ showHex addr ""
-
-instance Show BlockSpec where
-    show blockSpec = show (base blockSpec) ++ "-" ++ show (limit blockSpec)
-
-instance Show MapSpec where
-    show mapSpec = let srcStr  = show $ srcBlock mapSpec
-                       nodeStr = show $ destNode mapSpec
-                       baseStr = show $ destBase mapSpec
-                   in srcStr ++ " to " ++ nodeStr ++ " at " ++ baseStr
-
-instance Show NodeType where
-  show Memory = "memory"
-  show Device = "device"
-  show Other  = "other"
-
-instance Show NodeSpec where
-    show nodeSpec = let typeStr      = show $ nodeType nodeSpec
-                        acceptStr    = "accept [" ++ intercalate ", " (map show (accept nodeSpec)) ++ "]"
-                        translateStr = "map [" ++ intercalate ", " (map show (translate nodeSpec)) ++ "]"
-                        overlayStr   = case overlay nodeSpec of
-                                        Nothing     -> ""
-                                        Just nodeId -> "over " ++ show nodeId
-                    in intercalate " " [typeStr, acceptStr, translateStr, overlayStr]
-
-instance Show NetSpec where
-    show (NetSpec netSpec) = unlines $ map nodeStr netSpec
-                             where nodeStr (id, node) = show id ++ " is " ++ show node
\ No newline at end of file
diff --git a/tools/sockeye/SockeyeASTDecodingNet.hs b/tools/sockeye/SockeyeASTDecodingNet.hs
new file mode 100644 (file)
index 0000000..10bccf2
--- /dev/null
@@ -0,0 +1,77 @@
+{-
+  SockeyeASTDecodingNet.hs: Decoding net AST for Sockeye
+
+  Part of Sockeye
+
+  Copyright (c) 2017, ETH Zurich.
+
+  All rights reserved.
+
+  This file is distributed under the terms in the attached LICENSE file.
+  If you do not find this file, copies can be found by writing to:
+  ETH Zurich D-INFK, CAB F.78, Universitaetstr. 6, CH-8092 Zurich,
+  Attn: Systems Group.
+-}
+
+module SockeyeASTDecodingNet where
+
+{-
+Nodes are identfied by strings
+-}
+newtype NodeId = NodeId String
+  deriving (Eq, Ord, Show)
+
+{-
+Addresses are natural numbers
+-}
+newtype Addr = Addr Word
+  deriving (Eq, Ord, Show)
+
+{-
+A block is a contigous set of addresses
+-}
+data BlockSpec = BlockSpec
+    { base  :: Addr
+    , limit :: Addr
+    } deriving (Eq, Ord, Show)
+
+{-
+A mapping of a source address block to a destination node
+at a base address
+-}
+data MapSpec = MapSpec
+    { srcBlock :: BlockSpec
+    , destNode :: NodeId
+    , destBase :: Addr
+    } deriving (Show)
+
+{-
+Node can either be memory, device or other
+-}
+data NodeType
+    = Memory
+    | Device
+    | Other
+
+instance Show NodeType where
+    show Memory = "memory"
+    show Device = "device"
+    show Other  = "other"
+
+{-
+A node is specified as a list of blocks it accepts,
+a list of mappings and possibly an overlay on another block
+-}
+data NodeSpec = NodeSpec
+    { nodeType  :: NodeType
+    , accept    :: [BlockSpec]
+    , translate :: [MapSpec]
+    , overlay   :: Maybe NodeId
+    } deriving (Show)
+
+{-
+A decoding net is specified as a list 
+of Node IDs mapped to Nodes
+-}
+newtype NetSpec = NetSpec [(NodeId, NodeSpec)]
+    deriving (Show)
similarity index 59%
rename from tools/sockeye/SockeyeASTFrontend.hs
rename to tools/sockeye/SockeyeASTParser.hs
index 2035e51..69344a6 100644 (file)
@@ -1,5 +1,5 @@
 {-
-    SockeyeASTFrontend.hs: Frontend AST for Sockeye
+    SockeyeASTParser.hs: AST for the Sockeye parser
 
     Part of Sockeye
 
     Attn: Systems Group.
 -}
 
-module SockeyeASTFrontend where
+module SockeyeASTParser 
+( module SockeyeASTParser
+, module SockeyeAST
+) where
+
+import SockeyeAST
+    ( Identifier(SimpleIdent, TemplateIdent)
+    , prefix, varName, suffix
+    , ModuleParamType(NumberParam, AddressParam)
+    , ModuleArg(AddressArg, NumberArg, ParamArg)
+    , NodeSpec(NodeSpec)
+    , nodeType, accept, translate, overlay
+    , NodeType(Memory, Device)
+    , BlockSpec(SingletonBlock, RangeBlock, LengthBlock)
+    , address, base, limit, bits
+    , MapSpec(MapSpec)
+    , block, destNode, destBase
+    , Address(NumberAddress, ParamAddress)
+    , ForLimit(NumberLimit, ParamLimit)
+    )
 
 data SockeyeSpec = SockeyeSpec
     { modules :: [Module]
@@ -31,15 +50,6 @@ data ModuleParam = ModuleParam
     , paramType :: ModuleParamType
     } deriving (Show)
 
-data ModuleParamType 
-    = NumberParam
-    | AddressParam
-    deriving (Eq)
-
-instance Show ModuleParamType where
-    show NumberParam = "nat"
-    show AddressParam = "addr"
-
 data ModuleBody = ModuleBody
     { ports     :: [PortDef]
     , moduleNet :: [NetSpec]
@@ -68,12 +78,6 @@ data ModuleInst
     | MultiModuleInst (For ModuleInst)
     deriving (Show)
 
-data ModuleArg
-    = AddressArg !Word
-    | NumberArg !Word
-    | ParamArg !String
-    deriving (Show)
-
 data PortMap
     = InputPortMap
         { mappedId   :: Identifier
@@ -94,52 +98,6 @@ data NodeDecl
     | MultiNodeDecl (For NodeDecl)
     deriving (Show)
 
-data Identifier
-    = SimpleIdent !String
-    | TemplateIdent
-        { prefix  :: !String
-        , varName :: !String
-        , suffix  :: Maybe Identifier
-        }
-    deriving (Show)
-
-data NodeSpec = NodeSpec
-    { nodeType  :: Maybe NodeType
-    , accept    :: [BlockSpec]
-    , translate :: [MapSpec]
-    , overlay   :: Maybe Identifier
-    } deriving (Show)
-
-data NodeType
-    = Memory
-    | Device
-    deriving (Show)
-
-data BlockSpec 
-    = SingletonBlock
-        { address :: !Address }
-    | RangeBlock
-        { base  :: !Address
-        , limit :: !Address
-        }
-    | LengthBlock
-        { base :: !Address
-        , bits :: !Word
-        }
-    deriving (Show)
-
-data MapSpec 
-    = MapSpec
-        { block    :: BlockSpec
-        , destNode :: Identifier
-        , destBase :: Maybe Address
-        } deriving (Show)
-
-data Address
-    = NumberAddress !Word
-    | ParamAddress !String
-    deriving (Show)
-
 data For a 
     = For
         { varRanges :: [ForVarRange]
@@ -152,8 +110,3 @@ data ForVarRange
     , start :: ForLimit
     , end   :: ForLimit
     } deriving (Show)
-
-data ForLimit 
-    = NumberLimit !Word
-    | ParamLimit !String
-    deriving (Show)
diff --git a/tools/sockeye/SockeyeBackendPrintAST.hs b/tools/sockeye/SockeyeBackendPrintAST.hs
deleted file mode 100644 (file)
index b90a99c..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-{-
-  SockeyeBackendPrintAST.hs: Backend for printing the AST for Sockeye
-
-  Part of Sockeye
-
-  Copyright (c) 2017, ETH Zurich.
-
-  All rights reserved.
-
-  This file is distributed under the terms in the attached LICENSE file.
-  If you do not find this file, copies can be found by writing to:
-  ETH Zurich D-INFK, CAB F.78, Universitaetstr. 6, CH-8092 Zurich,
-  Attn: Systems Group.
--}
-
-module SockeyeBackendPrintAST
-( compile ) where
-
-import qualified SockeyeASTBackend as AST
-
-compile :: AST.NetSpec -> String
-compile = show
index ef6635b..dffd567 100644 (file)
@@ -20,7 +20,7 @@ import Data.List
 import Data.Char
 import Numeric (showHex)
 
-import qualified SockeyeASTBackend as AST
+import qualified SockeyeASTDecodingNet as AST
 
 compile :: AST.NetSpec -> String
 compile = generate
index a92ec0a..3eea4c3 100644 (file)
@@ -27,11 +27,11 @@ import Data.Set (Set)
 import qualified Data.Set as Set
 import Data.Either
 
-import qualified SockeyeASTFrontend as ASTF
-import qualified SockeyeASTIntermediate as ASTI
+import qualified SockeyeASTParser as ParseAST
+import qualified SockeyeAST as AST
 
 data Context = Context
-    { spec       :: ASTI.SockeyeSpec
+    { spec       :: AST.SockeyeSpec
     , moduleName :: !String
     , vars       :: Set String
     , instModule :: String
@@ -44,9 +44,9 @@ data FailedCheckType
     | NoSuchModule String
     | NoSuchParameter String
     | NoSuchVariable String
-    | ParamTypeMismatch String ASTI.ModuleParamType ASTI.ModuleParamType
+    | ParamTypeMismatch String AST.ModuleParamType AST.ModuleParamType
     | WrongNumberOfArgs Int Int
-    | ArgTypeMismatch String ASTI.ModuleParamType ASTI.ModuleParamType
+    | ArgTypeMismatch String AST.ModuleParamType AST.ModuleParamType
 
 instance Show FailedCheckType where
     show (DuplicateModule name)          = concat ["Multiple definitions for module '", name, "'"]
@@ -100,10 +100,10 @@ checkFailure context fs = CheckFailure $ map failCheck fs
             , inModule = moduleName context
             }
 
-checkSockeye :: ASTF.SockeyeSpec -> Either CheckFailure ASTI.SockeyeSpec
+checkSockeye :: ParseAST.SockeyeSpec -> Either CheckFailure AST.SockeyeSpec
 checkSockeye ast = do
     let
-        emptySpec = ASTI.SockeyeSpec Map.empty
+        emptySpec = AST.SockeyeSpec Map.empty
         initContext = Context
             { spec       = emptySpec
             , moduleName = ""
@@ -122,36 +122,36 @@ checkSockeye ast = do
 class SymbolSource a b where
     buildSymbolTable :: Context -> a -> Either CheckFailure b
 
-instance SymbolSource ASTF.SockeyeSpec ASTI.SockeyeSpec where
+instance SymbolSource ParseAST.SockeyeSpec AST.SockeyeSpec where
     buildSymbolTable context ast = do
         let
-            modules = (rootModule ast):(ASTF.modules ast)
-            names = map ASTF.name modules
+            modules = (rootModule ast):(ParseAST.modules ast)
+            names = map ParseAST.name modules
         checkDuplicates context names DuplicateModule
         symbolTables <- buildSymbolTable context modules
         let
             moduleMap = Map.fromList $ zip names symbolTables
-        return ASTI.SockeyeSpec
-                { ASTI.modules = moduleMap }
+        return AST.SockeyeSpec
+                { AST.modules = moduleMap }
 
-instance SymbolSource ASTF.Module ASTI.Module where
+instance SymbolSource ParseAST.Module AST.Module where
     buildSymbolTable context ast = do
         let
-            name = ASTF.name ast
-            paramNames = map ASTF.paramName (ASTF.parameters ast)
-            paramTypes = map ASTF.paramType (ASTF.parameters ast)
+            name = ParseAST.name ast
+            paramNames = map ParseAST.paramName (ParseAST.parameters ast)
+            paramTypes = map ParseAST.paramType (ParseAST.parameters ast)
             moduleContext = context
                 { moduleName = name}
         checkDuplicates moduleContext paramNames DuplicateParameter
         let
             paramTypeMap = Map.fromList $ zip paramNames paramTypes
-        return ASTI.Module
-            { ASTI.paramNames   = paramNames
-            , ASTI.paramTypeMap = paramTypeMap
-            , ASTI.inputPorts   = []
-            , ASTI.outputPorts  = []
-            , ASTI.nodeDecls    = []
-            , ASTI.moduleInsts  = []
+        return AST.Module
+            { AST.paramNames   = paramNames
+            , AST.paramTypeMap = paramTypeMap
+            , AST.inputPorts   = []
+            , AST.outputPorts  = []
+            , AST.nodeDecls    = []
+            , AST.moduleInsts  = []
             }
 
 instance SymbolSource a b => SymbolSource [a] [b] where
@@ -163,27 +163,27 @@ instance SymbolSource a b => SymbolSource [a] [b] where
 class Checkable a b where
     check :: Context -> a -> Either CheckFailure b
 
-instance Checkable ASTF.SockeyeSpec ASTI.SockeyeSpec where
+instance Checkable ParseAST.SockeyeSpec AST.SockeyeSpec where
     check context ast = do
         let
-            modules = (rootModule ast):(ASTF.modules ast)
-            names = map ASTF.name modules
+            modules = (rootModule ast):(ParseAST.modules ast)
+            names = map ParseAST.name modules
         checked <- check context modules
         let
             sockeyeSpec = spec context
             checkedMap = Map.fromList $ zip names checked
         return sockeyeSpec
-            { ASTI.modules = checkedMap }
+            { AST.modules = checkedMap }
 
-instance Checkable ASTF.Module ASTI.Module where
+instance Checkable ParseAST.Module AST.Module where
     check context ast = do
         let
-            name = ASTF.name ast
+            name = ParseAST.name ast
             bodyContext = context
                 { moduleName = name}
-            body = ASTF.moduleBody ast
-            portDefs = ASTF.ports body
-            netSpecs = ASTF.moduleNet body
+            body = ParseAST.moduleBody ast
+            portDefs = ParseAST.ports body
+            netSpecs = ParseAST.moduleNet body
         inputPorts  <- check bodyContext $ filter isInPort  portDefs
         outputPorts <- check bodyContext $ filter isOutPort portDefs
         checkedNetSpecs <- check bodyContext netSpecs
@@ -192,46 +192,46 @@ instance Checkable ASTF.Module ASTI.Module where
             checkedModuleInsts = rights checkedNetSpecs
             mod = getCurrentModule bodyContext
         return mod
-            { ASTI.inputPorts  = inputPorts
-            , ASTI.outputPorts = outputPorts
-            , ASTI.nodeDecls   = checkedNodeDecls
-            , ASTI.moduleInsts = checkedModuleInsts
+            { AST.inputPorts  = inputPorts
+            , AST.outputPorts = outputPorts
+            , AST.nodeDecls   = checkedNodeDecls
+            , AST.moduleInsts = checkedModuleInsts
             }
         where
-            isInPort (ASTF.InputPortDef _) = True
-            isInPort (ASTF.MultiPortDef for) = isInPort $ ASTF.body for
+            isInPort (ParseAST.InputPortDef _) = True
+            isInPort (ParseAST.MultiPortDef for) = isInPort $ ParseAST.body for
             isInPort _ = False
             isOutPort = not . isInPort
 
-instance Checkable ASTF.PortDef ASTI.Port where
-    check context (ASTF.MultiPortDef for) = do
+instance Checkable ParseAST.PortDef AST.Port where
+    check context (ParseAST.MultiPortDef for) = do
         checkedFor <- check context for
-        return $ ASTI.MultiPort checkedFor
+        return $ AST.MultiPort checkedFor
     check context portDef = do
-        checkedId <- check context (ASTF.portId portDef)
-        return $ ASTI.Port checkedId
+        checkedId <- check context (ParseAST.portId portDef)
+        return $ AST.Port checkedId
 
-instance Checkable ASTF.NetSpec (Either ASTI.NodeDecl ASTI.ModuleInst) where
-    check context (ASTF.NodeDeclSpec decl) = do
+instance Checkable ParseAST.NetSpec (Either AST.NodeDecl AST.ModuleInst) where
+    check context (ParseAST.NodeDeclSpec decl) = do
         checkedDecl <- check context decl
         return $ Left checkedDecl
-    check context (ASTF.ModuleInstSpec inst) = do
+    check context (ParseAST.ModuleInstSpec inst) = do
         checkedInst <- check context inst
         return $ Right checkedInst
 
-instance Checkable ASTF.ModuleInst ASTI.ModuleInst where
-    check context (ASTF.MultiModuleInst for) = do
+instance Checkable ParseAST.ModuleInst AST.ModuleInst where
+    check context (ParseAST.MultiModuleInst for) = do
         checkedFor <- check context for
-        return $ ASTI.MultiModuleInst checkedFor
+        return $ AST.MultiModuleInst checkedFor
     check context ast = do
         let
-            nameSpace = ASTF.nameSpace ast
-            name = ASTF.moduleName ast
-            arguments = ASTF.arguments ast
-            portMaps = ASTF.portMappings ast
+            nameSpace = ParseAST.nameSpace ast
+            name = ParseAST.moduleName ast
+            arguments = ParseAST.arguments ast
+            portMaps = ParseAST.portMappings ast
         mod <- getModule context name
         let
-            paramNames = ASTI.paramNames mod
+            paramNames = AST.paramNames mod
             instContext = context
                 { instModule = name }
         checkedArgs <- checkArgs instContext arguments
@@ -240,23 +240,23 @@ instance Checkable ASTF.ModuleInst ASTI.ModuleInst where
         outPortMap <- check instContext $ filter isOutMap portMaps
         let
             argMap = Map.fromList $ zip paramNames checkedArgs
-        return ASTI.ModuleInst
-            { ASTI.nameSpace  = checkedNameSpace
-            , ASTI.moduleName = name
-            , ASTI.arguments  = argMap
-            , ASTI.inPortMap  = inPortMap
-            , ASTI.outPortMap = outPortMap
+        return AST.ModuleInst
+            { AST.nameSpace  = checkedNameSpace
+            , AST.moduleName = name
+            , AST.arguments  = argMap
+            , AST.inPortMap  = inPortMap
+            , AST.outPortMap = outPortMap
             }
         where
-            isInMap (ASTF.InputPortMap {}) = True
-            isInMap (ASTF.MultiPortMap for) = isInMap $ ASTF.body for
+            isInMap (ParseAST.InputPortMap {}) = True
+            isInMap (ParseAST.MultiPortMap for) = isInMap $ ParseAST.body for
             isInMap _ = False
             isOutMap = not . isInMap
             checkArgs context args = do
                 mod <- getInstantiatedModule context
                 let
-                    typeMap = ASTI.paramTypeMap mod
-                    paramNames = ASTI.paramNames mod
+                    typeMap = AST.paramTypeMap mod
+                    paramNames = AST.paramNames mod
                     paramTypes = map (typeMap Map.!) paramNames
                     params = zip paramNames paramTypes
                 checkArgCount paramNames args
@@ -271,76 +271,76 @@ instance Checkable ASTF.ModuleInst ASTI.ModuleInst where
                             else Left $ checkFailure context [WrongNumberOfArgs paramc argc]
                     checkArgType (name, expected) arg = do
                         case arg of
-                            ASTF.AddressArg value -> do
-                                if expected == ASTI.AddressParam
-                                    then return $ ASTI.AddressArg value
-                                    else Left $ mismatch ASTI.AddressParam
-                            ASTF.NumberArg value -> do
-                                if expected == ASTI.NumberParam
-                                    then return $ ASTI.NumberArg value
-                                    else Left $ mismatch ASTI.NumberParam
-                            ASTF.ParamArg pName -> do
+                            ParseAST.AddressArg value -> do
+                                if expected == AST.AddressParam
+                                    then return $ AST.AddressArg value
+                                    else Left $ mismatch AST.AddressParam
+                            ParseAST.NumberArg value -> do
+                                if expected == AST.NumberParam
+                                    then return $ AST.NumberArg value
+                                    else Left $ mismatch AST.NumberParam
+                            ParseAST.ParamArg pName -> do
                                 checkParamType context pName expected
-                                return $ ASTI.ParamArg pName
+                                return $ AST.ParamArg pName
                         where
                             mismatch t = checkFailure context [ArgTypeMismatch name expected t]
 
-instance Checkable ASTF.PortMap ASTI.PortMap where
-    check context (ASTF.MultiPortMap for) = do
+instance Checkable ParseAST.PortMap AST.PortMap where
+    check context (ParseAST.MultiPortMap for) = do
         checkedFor <- check context for
-        return $ ASTI.MultiPortMap checkedFor
+        return $ AST.MultiPortMap checkedFor
     check context portMap = do
         let
-            mappedId = ASTF.mappedId portMap
-            mappedPort = ASTF.mappedPort portMap
+            mappedId = ParseAST.mappedId portMap
+            mappedPort = ParseAST.mappedPort portMap
             idents = [mappedId, mappedPort]
         checkedIds <- check context idents
-        return $ ASTI.PortMap
-            { ASTI.mappedId   = head checkedIds
-            , ASTI.mappedPort = last checkedIds
+        return $ AST.PortMap
+            { AST.mappedId   = head checkedIds
+            , AST.mappedPort = last checkedIds
             }
 
-instance Checkable ASTF.NodeDecl ASTI.NodeDecl where
-    check context (ASTF.MultiNodeDecl for) = do
+instance Checkable ParseAST.NodeDecl AST.NodeDecl where
+    check context (ParseAST.MultiNodeDecl for) = do
         checkedFor <- check context for
-        return $ ASTI.MultiNodeDecl checkedFor
+        return $ AST.MultiNodeDecl checkedFor
     check context ast = do
         let
-            nodeId = ASTF.nodeId ast
-            nodeSpec = ASTF.nodeSpec ast
+            nodeId = ParseAST.nodeId ast
+            nodeSpec = ParseAST.nodeSpec ast
         checkedId <- check context nodeId
         checkedSpec <- check context nodeSpec
-        return ASTI.NodeDecl
-            { ASTI.nodeId   = checkedId
-            , ASTI.nodeSpec = checkedSpec
+        return AST.NodeDecl
+            { AST.nodeId   = checkedId
+            , AST.nodeSpec = checkedSpec
             }
 
-instance Checkable ASTF.Identifier ASTI.Identifier where
-    check _ (ASTF.SimpleIdent name) = return $ ASTI.SimpleIdent name
+instance Checkable ParseAST.Identifier AST.Identifier where
+    check _ (ParseAST.SimpleIdent name) = return $ AST.SimpleIdent name
     check context ast = do
         let
-            prefix = ASTF.prefix ast
-            varName = ASTF.varName ast
-            suffix = ASTF.suffix ast
+            prefix = ParseAST.prefix ast
+            varName = ParseAST.varName ast
+            suffix = ParseAST.suffix ast
         checkVarInScope context varName
         checkedSuffix <- case suffix of
             Nothing    -> return Nothing
             Just ident -> do
                 checkedIdent <- check context ident
                 return $ Just checkedIdent
-        return ASTI.TemplateIdent
-            { ASTI.prefix  = prefix
-            , ASTI.varName = varName
-            , ASTI.suffix  = checkedSuffix
+        return AST.TemplateIdent
+            { AST.prefix  = prefix
+            , AST.varName = varName
+            , AST.suffix  = checkedSuffix
             }
 
-instance Checkable ASTF.NodeSpec ASTI.NodeSpec where
+instance Checkable ParseAST.NodeSpec AST.NodeSpec where
     check context ast = do
         let 
-            nodeType = ASTF.nodeType ast
-            accept = ASTF.accept ast
-            translate = ASTF.translate ast
-            overlay = ASTF.overlay ast
+            nodeType = ParseAST.nodeType ast
+            accept = ParseAST.accept ast
+            translate = ParseAST.translate ast
+            overlay = ParseAST.overlay ast
         checkedAccept <- check context accept
         checkedTranslate <- check context translate
         checkedOverlay <- case overlay of
@@ -348,39 +348,39 @@ instance Checkable ASTF.NodeSpec ASTI.NodeSpec where
             Just ident -> do
                 checkedIdent <- check context ident
                 return $ Just checkedIdent
-        return ASTI.NodeSpec
-            { ASTI.nodeType  = nodeType
-            , ASTI.accept    = checkedAccept
-            , ASTI.translate = checkedTranslate
-            , ASTI.overlay   = checkedOverlay
+        return AST.NodeSpec
+            { AST.nodeType  = nodeType
+            , AST.accept    = checkedAccept
+            , AST.translate = checkedTranslate
+            , AST.overlay   = checkedOverlay
             }
 
-instance Checkable ASTF.BlockSpec ASTI.BlockSpec where
-    check context (ASTF.SingletonBlock address) = do
+instance Checkable ParseAST.BlockSpec AST.BlockSpec where
+    check context (ParseAST.SingletonBlock address) = do
         checkedAddress <- check context address
-        return ASTI.SingletonBlock
-            { ASTI.address = checkedAddress }
-    check context (ASTF.RangeBlock base limit) = do
+        return AST.SingletonBlock
+            { AST.address = checkedAddress }
+    check context (ParseAST.RangeBlock base limit) = do
         let
             addresses = [base, limit]
         checkedAddresses <- check context addresses
-        return ASTI.RangeBlock
-            { ASTI.base  = head checkedAddresses
-            , ASTI.limit = last checkedAddresses
+        return AST.RangeBlock
+            { AST.base  = head checkedAddresses
+            , AST.limit = last checkedAddresses
             }
-    check context (ASTF.LengthBlock base bits) = do
+    check context (ParseAST.LengthBlock base bits) = do
         checkedBase <- check context base
-        return ASTI.LengthBlock
-            { ASTI.base = checkedBase
-            , ASTI.bits = bits
+        return AST.LengthBlock
+            { AST.base = checkedBase
+            , AST.bits = bits
             }
 
-instance Checkable ASTF.MapSpec ASTI.MapSpec where
+instance Checkable ParseAST.MapSpec AST.MapSpec where
     check context ast = do
         let
-            block = ASTF.block ast
-            destNode = ASTF.destNode ast
-            destBase = ASTF.destBase ast
+            block = ParseAST.block ast
+            destNode = ParseAST.destNode ast
+            destBase = ParseAST.destBase ast
         checkedBlock <- check context block
         checkedDestNode <- check context destNode
         checkedDestBase <- case destBase of
@@ -388,25 +388,25 @@ instance Checkable ASTF.MapSpec ASTI.MapSpec where
             Just address -> do
                 checkedAddress <- check context address
                 return $ Just checkedAddress
-        return ASTI.MapSpec
-            { ASTI.block    = checkedBlock
-            , ASTI.destNode = checkedDestNode
-            , ASTI.destBase = checkedDestBase
+        return AST.MapSpec
+            { AST.block    = checkedBlock
+            , AST.destNode = checkedDestNode
+            , AST.destBase = checkedDestBase
             }
 
-instance Checkable ASTF.Address ASTI.Address where
-    check _ (ASTF.NumberAddress value) = do
-        return $ ASTI.NumberAddress value
-    check context (ASTF.ParamAddress name) = do
-        checkParamType context name ASTI.AddressParam
-        return $ ASTI.ParamAddress name
+instance Checkable ParseAST.Address AST.Address where
+    check _ (ParseAST.NumberAddress value) = do
+        return $ AST.NumberAddress value
+    check context (ParseAST.ParamAddress name) = do
+        checkParamType context name AST.AddressParam
+        return $ AST.ParamAddress name
 
-instance Checkable a b => Checkable (ASTF.For a) (ASTI.For b) where
+instance Checkable a b => Checkable (ParseAST.For a) (AST.For b) where
     check context ast = do
         let
-            varRanges = ASTF.varRanges ast
-            varNames = map ASTF.var varRanges
-            body = ASTF.body ast
+            varRanges = ParseAST.varRanges ast
+            varNames = map ParseAST.var varRanges
+            body = ParseAST.body ast
         checkDuplicates context varNames DuplicateVariable
         ranges <- check context varRanges
         let
@@ -417,71 +417,71 @@ instance Checkable a b => Checkable (ASTF.For a) (ASTI.For b) where
         checkedBody <- check bodyContext body
         let
             checkedVarRanges = Map.fromList $ zip varNames ranges
-        return ASTI.For
-                { ASTI.varRanges = checkedVarRanges
-                , ASTI.body      = checkedBody
+        return AST.For
+                { AST.varRanges = checkedVarRanges
+                , AST.body      = checkedBody
                 }
 
-instance Checkable ASTF.ForVarRange ASTI.ForRange where
+instance Checkable ParseAST.ForVarRange AST.ForRange where
     check context ast = do
         let
-            limits = [ASTF.start ast, ASTF.end ast]
+            limits = [ParseAST.start ast, ParseAST.end ast]
         checkedLimits <- check context limits
-        return ASTI.ForRange
-            { ASTI.start = head checkedLimits
-            , ASTI.end   = last checkedLimits
+        return AST.ForRange
+            { AST.start = head checkedLimits
+            , AST.end   = last checkedLimits
             }
 
-instance Checkable ASTF.ForLimit ASTI.ForLimit where
-    check _ (ASTF.NumberLimit value) = do
-        return $ ASTI.NumberLimit value
-    check context (ASTF.ParamLimit name) = do
-        checkParamType context name ASTI.NumberParam
-        return $ ASTI.ParamLimit name
+instance Checkable ParseAST.ForLimit AST.ForLimit where
+    check _ (ParseAST.NumberLimit value) = do
+        return $ AST.NumberLimit value
+    check context (ParseAST.ParamLimit name) = do
+        checkParamType context name AST.NumberParam
+        return $ AST.ParamLimit name
 
 instance Checkable a b => Checkable [a] [b] where
     check context as = forAll (check context) as
 --
 -- Helpers
 --
-rootModule :: ASTF.SockeyeSpec -> ASTF.Module
+rootModule :: ParseAST.SockeyeSpec -> ParseAST.Module
 rootModule spec =
     let
-        body = ASTF.ModuleBody
-            { ASTF.ports = []
-            , ASTF.moduleNet = ASTF.net spec
+        body = ParseAST.ModuleBody
+            { ParseAST.ports = []
+            , ParseAST.moduleNet = ParseAST.net spec
             }
-    in ASTF.Module
-        { ASTF.name       = "@root"
-        , ASTF.parameters = []
-        , ASTF.moduleBody = body
+    in ParseAST.Module
+        { ParseAST.name       = "@root"
+        , ParseAST.parameters = []
+        , ParseAST.moduleBody = body
         }
 
-getModule :: Context -> String -> Either CheckFailure ASTI.Module
+getModule :: Context -> String -> Either CheckFailure AST.Module
 getModule context name = do
     let
-        modMap = ASTI.modules $ spec context
+        modMap = AST.modules $ spec context
     case Map.lookup name modMap of
         Nothing -> Left $ checkFailure context [NoSuchModule name]
         Just m  -> return m
 
-getCurrentModule :: Context -> ASTI.Module
+getCurrentModule :: Context -> AST.Module
 getCurrentModule context =
     let
-        modMap = ASTI.modules $ spec context
+        modMap = AST.modules $ spec context
     in modMap Map.! (moduleName context)
 
-getInstantiatedModule :: Context -> Either CheckFailure ASTI.Module
+getInstantiatedModule :: Context -> Either CheckFailure AST.Module
 getInstantiatedModule context =
     let
         modName = instModule context
     in getModule context modName
 
-getParameterType :: Context -> String -> Either CheckFailure ASTI.ModuleParamType
+getParameterType :: Context -> String -> Either CheckFailure AST.ModuleParamType
 getParameterType context name = do
     let
         mod = getCurrentModule context
-        paramMap = ASTI.paramTypeMap mod
+        paramMap = AST.paramTypeMap mod
     case Map.lookup name paramMap of
         Nothing -> Left $ checkFailure context [NoSuchParameter name]
         Just t  -> return t
@@ -515,7 +515,7 @@ checkVarInScope context name = do
         else Left $ checkFailure context [NoSuchVariable name]
 
 
-checkParamType :: Context -> String -> ASTI.ModuleParamType -> Either CheckFailure ()
+checkParamType :: Context -> String -> AST.ModuleParamType -> Either CheckFailure ()
 checkParamType context name expected = do
     actual <- getParameterType context name
     if actual == expected
index 6464a7e..bd4ef74 100644 (file)
@@ -20,8 +20,8 @@
 module SockeyeNetBuilder
 ( sockeyeBuildNet ) where
 
-import qualified SockeyeASTIntermediate as ASTI
-import qualified SockeyeASTBackend as ASTB
+import qualified SockeyeAST as AST
+import qualified SockeyeASTDecodingNet as NetAST
 
 newtype CheckFailure = CheckFailure
     { message :: String }
@@ -29,5 +29,5 @@ newtype CheckFailure = CheckFailure
 instance Show CheckFailure where
     show f = unlines $ ["", message f]
 
-sockeyeBuildNet :: ASTI.SockeyeSpec -> Either CheckFailure ASTB.NetSpec
-sockeyeBuildNet _ = Left $ CheckFailure "Net Builder not yet implemented"
\ No newline at end of file
+sockeyeBuildNet :: AST.SockeyeSpec -> Either CheckFailure NetAST.NetSpec
+sockeyeBuildNet _ = Left $ CheckFailure "Net Builder not yet implemented"
index 4bb5653..ee86671 100644 (file)
@@ -20,12 +20,11 @@ import Control.Monad
 
 import Data.Maybe (fromMaybe)
 
-
 import Text.Parsec
 import qualified Text.Parsec.Token as P
 import Text.Parsec.Language (javaStyle)
 
-import qualified SockeyeASTFrontend as AST
+import qualified SockeyeASTParser as AST
 
 {- Parser main function -}
 parseSockeye :: String -> String -> Either ParseError AST.SockeyeSpec