Sockeye: Parser for new syntax
authorDaniel Schwyn <schwyda@student.ethz.ch>
Fri, 30 Jun 2017 15:53:10 +0000 (17:53 +0200)
committerDaniel Schwyn <schwyda@student.ethz.ch>
Fri, 30 Jun 2017 15:53:10 +0000 (17:53 +0200)
Signed-off-by: Daniel Schwyn <schwyda@student.ethz.ch>

tools/sockeye/SockeyeASTFrontend.hs
tools/sockeye/SockeyeParser.hs

index c215c2a..53e3dab 100644 (file)
@@ -44,16 +44,16 @@ data ModuleBody = ModuleBody
 
 data NetSpec
     = NodeDeclSpec NodeDecl
-    | ModuleInstSpec ModuleInstantiation
+    | ModuleInstSpec ModuleInst
     deriving (Show)
 
-data ModuleInstantiation
-    = ModuleInstantiation
+data ModuleInst
+    = ModuleInst
         { moduleName     :: String
         , nameSpace      :: Identifier
         , arguments      :: [ModuleArg]
-        , inputMappings  :: [ModuleParamMap]
-        , outputMappings :: [ModuleParamMap]
+        , inputMappings  :: [ModulePortMap]
+        , outputMappings :: [ModulePortMap]
         } deriving (Show)
 
 data ModuleArg
@@ -62,8 +62,8 @@ data ModuleArg
     | ParamArg !String
     deriving (Show)
 
-data ModuleParamMap
-    = ModuleParamMap
+data ModulePortMap
+    = ModulePortMap
         { port   :: Identifier
         , nodeId :: Identifier
         } deriving (Show)
index 4ee0d42..94b1328 100644 (file)
@@ -64,30 +64,31 @@ sockeyeFile = do
 
 sockeyeSpec = do
     modules <- many sockeyeModule
-    -- net <- many netSpec
+    net <- many netSpec
     return AST.SockeyeSpec
         { AST.modules = modules
-        , AST.net     = []
+        , AST.net     = net
         }
 
 sockeyeModule = do
     reserved "module"
     name <- moduleName
-    params <- option [] $ parens (commaSep parameter)
+    params <- option [] $ parens (commaSep moduleParam)
     body <- braces moduleBody
     return AST.Module
         { AST.name       = name
         , AST.parameters = params
         , AST.moduleBody = body
         }
+
+moduleParam = do
+    paramType <- choice [intType, addrType]
+    paramName <- parameterName
+    return AST.ModuleParam
+        { AST.paramName = paramName
+        , AST.paramType = paramType 
+        }
     where
-        parameter = do
-            paramType <- choice [intType, addrType]
-            paramName <- parameterName
-            return AST.ModuleParam
-                { AST.paramName = paramName
-                , AST.paramType = paramType 
-                }
         intType = do
             symbol "int"
             return AST.NumberParam
@@ -112,42 +113,73 @@ moduleBody = do
             reserved "output"
             commaSep1 identifier
 
-netSpec = choice [decl]
+netSpec = choice [inst, decl]
     where
-        -- inst = do
-        --     moduleInst <- moduleInst
-        --     return $ AST.ModuleInstSpec moduleInst
+        inst = do
+            moduleInst <- moduleInst
+            return $ AST.ModuleInstSpec moduleInst
         decl = do
             nodeDecl <- nodeDecl
             return $ AST.NodeDeclSpec nodeDecl
 
--- moduleInst = do
---     name <- moduleName
---     args <- option [] parens $ commaSep1 $ choice [ address
---                                                  , decimal <?> ""
---                                                  ]
+moduleInst = do
+    (name, args) <- try $ do
+        name <- moduleName
+        args <- option [] $ parens (commaSep moduleArg)
+        symbol "as"
+        return (name, args)
+    nameSpace <- nonIndexedIdentifier
+    symbol "with"
+    inputMappings <- many inputMapping
+    outputMappings <- many outputMapping
+    return AST.ModuleInst
+        { AST.moduleName = name
+        , AST.nameSpace  = nameSpace
+        , AST.arguments  = args 
+        , AST.inputMappings = inputMappings
+        , AST.outputMappings = outputMappings
+        }
+    where
+        inputMapping = do
+            nodeId <- try $ identifier <* symbol ">"
+            port <- identifier
+            return AST.ModulePortMap
+                { AST.port   = port
+                , AST.nodeId = nodeId
+                }
+        outputMapping = do
+            nodeId <- try $ identifier <* symbol "<"
+            port <- identifier
+            return AST.ModulePortMap
+                { AST.port   = port
+                , AST.nodeId = nodeId
+                }
 
-address = choice [address, param]
+moduleArg = choice [addressArg, numberArg, paramArg]
     where
-        address = do
-            num <- addressLiteral
-            return $ AST.NumberAddress (fromIntegral num)
-        param = do
+        addressArg = do
+            addr <- addressLiteral
+            return $ AST.AddressArg (fromIntegral addr)
+        numberArg = do
+            num <- numberLiteral
+            return $ AST.NumberArg (fromIntegral num)
+        paramArg = do
             name <- parameterName
-            return $ AST.ParamAddress name
+            return $ AST.ParamArg name
 
 nodeDecl = do
-    nodeIds <- choice [try single, try multiple]
+    nodeIds <- try $ choice [single, multiple]
     nodeSpec <- nodeSpec
     return $ AST.NodeDecl
         { AST.nodeIds = nodeIds
         , AST.nodeSpec = nodeSpec
         }
     where single = do
-            nodeId <- singleIdentifier <* reserved "is"
+            nodeId <- singleIdentifier
+            reserved "is"
             return [nodeId]
           multiple = do
-            nodeIds <- many1 $ choice [multiIdentifier, singleIdentifier]
+            nodeIds <- many1 $ nonIndexedIdentifier
             reserved "are"
             return nodeIds
 
@@ -184,6 +216,8 @@ identifier = choice [ multiIdentifier
                     , singleIdentifier
                     ]
 
+nonIndexedIdentifier = choice [multiIdentifier, singleIdentifier]
+
 nodeSpec = do
     nodeType <- optionMaybe $ try nodeType
     accept <- option [] accept 
@@ -228,6 +262,15 @@ blockSpec = choice [range, length, singleton]
             bits <- decimal <?> "number of bits"
             return $ AST.Length base (fromIntegral bits)
 
+address = choice [address, param]
+    where
+        address = do
+            addr <- addressLiteral
+            return $ AST.NumberAddress (fromIntegral addr)
+        param = do
+            name <- parameterName
+            return $ AST.ParamAddress name
+
 mapSpec = do
     block <- blockSpec
     reserved "to"
@@ -240,10 +283,7 @@ mapDest = choice [baseAddress, direct]
             destNode <- identifier
             return $ AST.Direct destNode
         baseAddress = do
-            destNode <- try $ do 
-                iden <- identifier
-                reserved "at"
-                return iden
+            destNode <- try $ identifier <* reserved "at"
             destBase <- address
             return $ AST.BaseAddress destNode destBase