-- Module      : Verismith.Verilog2005.Parser
-- Description : Partial Verilog 2005 parser to reconstruct the AST.
-- Copyright   : (c) 2023 Quentin Corradi
-- License     : GPL-3
-- Maintainer  : q [dot] corradi22 [at] imperial [dot] ac [dot] uk
-- Stability   : experimental
-- Portability : POSIX
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE CPP #-}

module Verismith.Verilog2005.Parser
  ( parseVerilog2005,
  )
where

import Control.Applicative (liftA2)
import Control.Lens hiding ((<|))
import Data.Functor.Compose
import Control.Monad (join)
import Control.Monad.Trans.Class
import Control.Monad.Trans.Writer.CPS
import qualified Data.ByteString as B
import Data.ByteString.Internal (c2w)
import qualified Data.ByteString.Lazy as LB
import Data.Data (Data, constrIndex, toConstr)
import Data.Bifunctor
import qualified Data.HashMap.Strict as HashMap
import qualified Data.HashSet as HashSet
import qualified Data.IntMap.Strict as IntMap
import Data.Foldable
import Data.List
import Data.List.NonEmpty (NonEmpty (..), (<|))
import qualified Data.List.NonEmpty as NE
import Data.Maybe (isJust)
import qualified Data.Vector.Unboxed as V
import Text.Parsec hiding (satisfy, uncons)
import Text.Parsec.Error
import Text.Parsec.Expr
import Text.Parsec.Pos
import Text.Printf (printf)
import Verismith.Utils
import Verismith.Verilog2005.AST
import Verismith.Verilog2005.Lexer
import Verismith.Verilog2005.PrettyPrinter
import Verismith.Verilog2005.Token
import Verismith.Verilog2005.Utils

#if MIN_VERSION_base(4,19,0)
import qualified Data.Functor as DF (unzip)
#else
import qualified Data.List.NonEmpty as DF (unzip)
#endif

-- | The parser monad with LocalCompDir (local values of compiler directives) as local state
-- | and a writer monad for the list of warnings as the base monad
type Parser = ParsecT [PosToken] LocalCompDir (Writer [String])

-- | A production rule associated to a token without data
type Produce a = (Token, a)

type LProduce a = [Produce a]

-- | A branching in the parser based on a token without data
type Branch a = Produce (Parser a)

type LBranch a = [Branch a]

-- | Same as above but parametrised by attributes
type AProduce a = Produce (Attributes -> a)

type LAProduce a = [AProduce a]

type ABranch a = AProduce (Parser a)

type LABranch a = [ABranch a]

type APBranch a = Produce (Attributes -> SourcePos -> Parser a)

type LAPBranch a = [APBranch a]

-- | An error that is not merged with other errors and expected tokens
hardfail :: String -> Parser a
hardfail :: forall a. String -> Parser a
hardfail String
m =
  (State [PosToken] LocalCompDir
 -> Writer
      [String]
      (Consumed (Writer [String] (Reply [PosToken] LocalCompDir a))))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) s u a.
Monad m =>
(State s u -> m (Consumed (m (Reply s u a)))) -> ParsecT s u m a
mkPT ((State [PosToken] LocalCompDir
  -> Writer
       [String]
       (Consumed (Writer [String] (Reply [PosToken] LocalCompDir a))))
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> (State [PosToken] LocalCompDir
    -> Writer
         [String]
         (Consumed (Writer [String] (Reply [PosToken] LocalCompDir a))))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall a b. (a -> b) -> a -> b
$ \State [PosToken] LocalCompDir
s -> Consumed (Writer [String] (Reply [PosToken] LocalCompDir a))
-> Writer
     [String]
     (Consumed (Writer [String] (Reply [PosToken] LocalCompDir a)))
forall a. a -> WriterT [String] Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Consumed (Writer [String] (Reply [PosToken] LocalCompDir a))
 -> Writer
      [String]
      (Consumed (Writer [String] (Reply [PosToken] LocalCompDir a))))
-> Consumed (Writer [String] (Reply [PosToken] LocalCompDir a))
-> Writer
     [String]
     (Consumed (Writer [String] (Reply [PosToken] LocalCompDir a)))
forall a b. (a -> b) -> a -> b
$ Writer [String] (Reply [PosToken] LocalCompDir a)
-> Consumed (Writer [String] (Reply [PosToken] LocalCompDir a))
forall a. a -> Consumed a
Consumed (Writer [String] (Reply [PosToken] LocalCompDir a)
 -> Consumed (Writer [String] (Reply [PosToken] LocalCompDir a)))
-> Writer [String] (Reply [PosToken] LocalCompDir a)
-> Consumed (Writer [String] (Reply [PosToken] LocalCompDir a))
forall a b. (a -> b) -> a -> b
$ Reply [PosToken] LocalCompDir a
-> Writer [String] (Reply [PosToken] LocalCompDir a)
forall a. a -> WriterT [String] Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Reply [PosToken] LocalCompDir a
 -> Writer [String] (Reply [PosToken] LocalCompDir a))
-> Reply [PosToken] LocalCompDir a
-> Writer [String] (Reply [PosToken] LocalCompDir a)
forall a b. (a -> b) -> a -> b
$ ParseError -> Reply [PosToken] LocalCompDir a
forall s u a. ParseError -> Reply s u a
Error (ParseError -> Reply [PosToken] LocalCompDir a)
-> ParseError -> Reply [PosToken] LocalCompDir a
forall a b. (a -> b) -> a -> b
$ Message -> SourcePos -> ParseError
newErrorMessage (String -> Message
Message String
m) (State [PosToken] LocalCompDir -> SourcePos
forall s u. State s u -> SourcePos
statePos State [PosToken] LocalCompDir
s)

-- | Warning formatting
warn :: SourcePos -> String -> Parser ()
warn :: SourcePos -> String -> Parser ()
warn SourcePos
pos String
s = Writer [String] () -> Parser ()
forall (m :: * -> *) a.
Monad m =>
m a -> ParsecT [PosToken] LocalCompDir m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Writer [String] () -> Parser ())
-> Writer [String] () -> Parser ()
forall a b. (a -> b) -> a -> b
$ [String] -> Writer [String] ()
forall w (m :: * -> *). (Monoid w, Monad m) => w -> WriterT w m ()
tell [String -> Line -> Line -> String -> String
forall r. PrintfType r => String -> r
printf String
"Line %d, column %d: %s" (SourcePos -> Line
sourceLine SourcePos
pos) (SourcePos -> Line
sourceColumn SourcePos
pos) String
s]

-- | Gets a number from a Token, erases the data associated with it
getConsIndex :: Data a => a -> Int
getConsIndex :: forall a. Data a => a -> Line
getConsIndex = Constr -> Line
constrIndex (Constr -> Line) -> (a -> Constr) -> a -> Line
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Constr
forall a. Data a => a -> Constr
toConstr

-- | Efficient token branching utility
mkActionMap :: LProduce a -> IntMap.IntMap a
mkActionMap :: forall a. LProduce a -> IntMap a
mkActionMap =
  (Line -> a -> a -> a) -> [(Line, a)] -> IntMap a
forall a. (Line -> a -> a -> a) -> [(Line, a)] -> IntMap a
IntMap.fromListWithKey (\Line
k a
_ a
_ -> String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ String
"Conflict on " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Line -> String
forall a. Show a => a -> String
show Line
k)
    ([(Line, a)] -> IntMap a)
-> (LProduce a -> [(Line, a)]) -> LProduce a -> IntMap a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Produce a -> (Line, a)) -> LProduce a -> [(Line, a)]
forall a b. (a -> b) -> [a] -> [b]
map ((Token -> Line) -> Produce a -> (Line, a)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first Token -> Line
forall a. Data a => a -> Line
getConsIndex)

-- | Updates the position information
nextPos :: SourcePos -> PosToken -> [PosToken] -> SourcePos
nextPos :: SourcePos -> PosToken -> [PosToken] -> SourcePos
nextPos SourcePos
pos PosToken
_ [PosToken]
ptl = case [PosToken]
ptl of
  PosToken (Position Word
l Word
c (PSDefine ByteString
_) :| [Position]
_) Token
_ : [PosToken]
_ ->
    SourcePos -> Line -> SourcePos
setSourceColumn (SourcePos -> Line -> SourcePos
setSourceLine SourcePos
pos (Line -> SourcePos) -> Line -> SourcePos
forall a b. (a -> b) -> a -> b
$ Word -> Line
forall a. Enum a => a -> Line
fromEnum Word
l) (Line -> SourcePos) -> Line -> SourcePos
forall a b. (a -> b) -> a -> b
$ Word -> Line
forall a. Enum a => a -> Line
fromEnum Word
c
  PosToken (Position Word
l Word
c (PSFile String
f) :| [Position]
_) Token
_ : [PosToken]
_ -> String -> Line -> Line -> SourcePos
newPos String
f (Word -> Line
forall a. Enum a => a -> Line
fromEnum Word
l) (Word -> Line
forall a. Enum a => a -> Line
fromEnum Word
c)
  PosToken (Position Word
l Word
c (PSLine String
f Bool
_) :| [Position]
_) Token
_ : [PosToken]
_ -> String -> Line -> Line -> SourcePos
newPos String
f (Word -> Line
forall a. Enum a => a -> Line
fromEnum Word
l) (Word -> Line
forall a. Enum a => a -> Line
fromEnum Word
c)
  [] -> SourcePos
pos

-- | Parse exactly one token and produce a value
producePrim :: (Token -> Maybe a) -> Parser a
producePrim :: forall a. (Token -> Maybe a) -> Parser a
producePrim Token -> Maybe a
f = (PosToken -> String)
-> (SourcePos -> PosToken -> [PosToken] -> SourcePos)
-> (PosToken -> Maybe a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall s (m :: * -> *) t a u.
Stream s m t =>
(t -> String)
-> (SourcePos -> t -> s -> SourcePos)
-> (t -> Maybe a)
-> ParsecT s u m a
tokenPrim PosToken -> String
forall a. Show a => a -> String
show SourcePos -> PosToken -> [PosToken] -> SourcePos
nextPos (Token -> Maybe a
f (Token -> Maybe a) -> (PosToken -> Token) -> PosToken -> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PosToken -> Token
_ptToken)

-- | Parse exactly one token and branches
branchPrim :: (Token -> Maybe (Parser a)) -> Parser a
branchPrim :: forall a. (Token -> Maybe (Parser a)) -> Parser a
branchPrim = ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (ParsecT [PosToken] LocalCompDir (Writer [String]) a)
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> ((Token
     -> Maybe (ParsecT [PosToken] LocalCompDir (Writer [String]) a))
    -> ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         (ParsecT [PosToken] LocalCompDir (Writer [String]) a))
-> (Token
    -> Maybe (ParsecT [PosToken] LocalCompDir (Writer [String]) a))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Token
 -> Maybe (ParsecT [PosToken] LocalCompDir (Writer [String]) a))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (ParsecT [PosToken] LocalCompDir (Writer [String]) a)
forall a. (Token -> Maybe a) -> Parser a
producePrim

-- | Parse these annoying compiler directives that can appear anywhere
anywherecompdir :: Parser ()
anywherecompdir :: Parser ()
anywherecompdir = Parser () -> Parser ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$
  (Token -> Maybe (Parser ())) -> Parser ()
forall a. (Token -> Maybe (Parser a)) -> Parser a
branchPrim ((Token -> Maybe (Parser ())) -> Parser ())
-> (Token -> Maybe (Parser ())) -> Parser ()
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
    Token
CDCelldefine -> Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$ (LocalCompDir -> LocalCompDir) -> Parser ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
modifyState ((LocalCompDir -> LocalCompDir) -> Parser ())
-> (LocalCompDir -> LocalCompDir) -> Parser ()
forall a b. (a -> b) -> a -> b
$ (Bool -> Identity Bool) -> LocalCompDir -> Identity LocalCompDir
Lens' LocalCompDir Bool
lcdCell ((Bool -> Identity Bool) -> LocalCompDir -> Identity LocalCompDir)
-> Bool -> LocalCompDir -> LocalCompDir
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
True
    Token
CDEndcelldefine -> Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$ (LocalCompDir -> LocalCompDir) -> Parser ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
modifyState ((LocalCompDir -> LocalCompDir) -> Parser ())
-> (LocalCompDir -> LocalCompDir) -> Parser ()
forall a b. (a -> b) -> a -> b
$ (Bool -> Identity Bool) -> LocalCompDir -> Identity LocalCompDir
Lens' LocalCompDir Bool
lcdCell ((Bool -> Identity Bool) -> LocalCompDir -> Identity LocalCompDir)
-> Bool -> LocalCompDir -> LocalCompDir
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
False
    Token
_ -> Maybe (Parser ())
forall a. Maybe a
Nothing

-- | Basic one token parsing able to produce a value using a function, uninformative error on failure
fproduce :: (Token -> Maybe a) -> Parser a
fproduce :: forall a. (Token -> Maybe a) -> Parser a
fproduce Token -> Maybe a
f = (Token -> Maybe a) -> Parser a
forall a. (Token -> Maybe a) -> Parser a
producePrim Token -> Maybe a
f Parser a -> Parser () -> Parser a
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
anywherecompdir

-- | Branches on a Token without data, informative error on failure
lproduce :: LProduce a -> Parser a
lproduce :: forall a. LProduce a -> Parser a
lproduce LProduce a
l =
  (Token -> Maybe a) -> Parser a
forall a. (Token -> Maybe a) -> Parser a
fproduce (\Token
t -> Line -> IntMap a -> Maybe a
forall a. Line -> IntMap a -> Maybe a
IntMap.lookup (Token -> Line
forall a. Data a => a -> Line
getConsIndex Token
t) (IntMap a -> Maybe a) -> IntMap a -> Maybe a
forall a b. (a -> b) -> a -> b
$ LProduce a -> IntMap a
forall a. LProduce a -> IntMap a
mkActionMap LProduce a
l)
    Parser a -> [String] -> Parser a
forall s u (m :: * -> *) a.
ParsecT s u m a -> [String] -> ParsecT s u m a
`labels` ((Token, a) -> String) -> LProduce a -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (\(Token
d, a
_) -> Token -> String
forall a. Show a => a -> String
show Token
d) LProduce a
l

-- | Maps a function on the data given by branching on a Token without data
maplproduce :: (a -> b) -> LProduce a -> LProduce b
maplproduce :: forall a b. (a -> b) -> LProduce a -> LProduce b
maplproduce = (Produce a -> Produce b) -> [Produce a] -> [Produce b]
forall a b. (a -> b) -> [a] -> [b]
map ((Produce a -> Produce b) -> [Produce a] -> [Produce b])
-> ((a -> b) -> Produce a -> Produce b)
-> (a -> b)
-> [Produce a]
-> [Produce b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> Produce a -> Produce b
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second

-- | Same as above but for branching with attributes
maplaproduce :: (a -> b) -> LAProduce a -> LAProduce b
maplaproduce :: forall a b. (a -> b) -> LAProduce a -> LAProduce b
maplaproduce a -> b
f = (AProduce a -> AProduce b) -> [AProduce a] -> [AProduce b]
forall a b. (a -> b) -> [a] -> [b]
map ((AProduce a -> AProduce b) -> [AProduce a] -> [AProduce b])
-> (AProduce a -> AProduce b) -> [AProduce a] -> [AProduce b]
forall a b. (a -> b) -> a -> b
$ ((Attributes -> a) -> Attributes -> b) -> AProduce a -> AProduce b
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (a -> b
f (a -> b) -> (Attributes -> a) -> Attributes -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
.)

-- | Try to consume the provided token, informative error on failure
consume :: Token -> Parser ()
consume :: Token -> Parser ()
consume Token
et = (Token -> Maybe ()) -> Parser ()
forall a. (Token -> Maybe a) -> Parser a
fproduce (\Token
at -> if Token
at Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Token
et then () -> Maybe ()
forall a. a -> Maybe a
Just () else Maybe ()
forall a. Maybe a
Nothing) Parser () -> String -> Parser ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> Token -> String
forall a. Show a => a -> String
show Token
et

-- | Try to consume the provided token and returns true on success (cannot fail)
optConsume :: Token -> Parser Bool
optConsume :: Token -> Parser Bool
optConsume Token
et = Bool -> Parser Bool -> Parser Bool
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Bool
False (Parser Bool -> Parser Bool) -> Parser Bool -> Parser Bool
forall a b. (a -> b) -> a -> b
$ (Token -> Maybe Bool) -> Parser Bool
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Bool) -> Parser Bool)
-> (Token -> Maybe Bool) -> Parser Bool
forall a b. (a -> b) -> a -> b
$ \Token
at -> if Token
at Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Token
et then Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True else Maybe Bool
forall a. Maybe a
Nothing

-- | Branch on the next token using a function
fbranch :: (Token -> Maybe (Parser a)) -> Parser a
fbranch :: forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch = ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (ParsecT [PosToken] LocalCompDir (Writer [String]) a)
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> ((Token
     -> Maybe (ParsecT [PosToken] LocalCompDir (Writer [String]) a))
    -> ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         (ParsecT [PosToken] LocalCompDir (Writer [String]) a))
-> (Token
    -> Maybe (ParsecT [PosToken] LocalCompDir (Writer [String]) a))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Token
 -> Maybe (ParsecT [PosToken] LocalCompDir (Writer [String]) a))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (ParsecT [PosToken] LocalCompDir (Writer [String]) a)
forall a. (Token -> Maybe a) -> Parser a
fproduce

-- | Branch on the next token but remembers position of the branching
fpbranch :: (SourcePos -> Token -> Maybe (Parser a)) -> Parser a
fpbranch :: forall a. (SourcePos -> Token -> Maybe (Parser a)) -> Parser a
fpbranch SourcePos -> Token -> Maybe (Parser a)
f = ParsecT [PosToken] LocalCompDir (Writer [String]) (Parser a)
-> Parser a
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (ParsecT [PosToken] LocalCompDir (Writer [String]) (Parser a)
 -> Parser a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Parser a)
-> Parser a
forall a b. (a -> b) -> a -> b
$ (ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
-> (SourcePos
    -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Parser a))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Parser a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Token -> Maybe (Parser a))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Parser a)
forall a. (Token -> Maybe a) -> Parser a
producePrim ((Token -> Maybe (Parser a))
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Parser a))
-> (SourcePos -> Token -> Maybe (Parser a))
-> SourcePos
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Parser a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourcePos -> Token -> Maybe (Parser a)
f) ParsecT [PosToken] LocalCompDir (Writer [String]) (Parser a)
-> Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Parser a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
anywherecompdir

-- | Parse attributes then branches on the next token using a LABranch
lbranch :: LBranch a -> Parser a
lbranch :: forall a. LBranch a -> Parser a
lbranch = ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (ParsecT [PosToken] LocalCompDir (Writer [String]) a)
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> (LBranch a
    -> ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         (ParsecT [PosToken] LocalCompDir (Writer [String]) a))
-> LBranch a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LBranch a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (ParsecT [PosToken] LocalCompDir (Writer [String]) a)
forall a. LProduce a -> Parser a
lproduce

-- | Parse attributes then branches on the next token using a LABranch
labranch :: LABranch a -> Parser a
labranch :: forall a. LABranch a -> Parser a
labranch LABranch a
l = Parser Attributes
attributes Parser Attributes
-> (Attributes
    -> ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Attributes
a -> LABranch a
-> Parser
     (Attributes -> ParsecT [PosToken] LocalCompDir (Writer [String]) a)
forall a. LProduce a -> Parser a
lproduce LABranch a
l Parser
  (Attributes -> ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> ((Attributes
     -> ParsecT [PosToken] LocalCompDir (Writer [String]) a)
    -> ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Attributes -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
p -> Attributes -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
p Attributes
a

-- | Maps a function on the data given by a branching with attributes
maplbranch :: (a -> b) -> LBranch a -> LBranch b
maplbranch :: forall a b. (a -> b) -> LBranch a -> LBranch b
maplbranch = (Parser a -> Parser b)
-> LProduce (Parser a) -> LProduce (Parser b)
forall a b. (a -> b) -> LProduce a -> LProduce b
maplproduce ((Parser a -> Parser b)
 -> LProduce (Parser a) -> LProduce (Parser b))
-> ((a -> b) -> Parser a -> Parser b)
-> (a -> b)
-> LProduce (Parser a)
-> LProduce (Parser b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> Parser a -> Parser b
forall a b.
(a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap

-- | Maps a function on the data given by a single branch with attributes
mapabranch :: (a -> b) -> ABranch a -> ABranch b
mapabranch :: forall a b. (a -> b) -> ABranch a -> ABranch b
mapabranch a -> b
f = ((Attributes -> Parser a) -> Attributes -> Parser b)
-> (Token, Attributes -> Parser a)
-> (Token, Attributes -> Parser b)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (((Attributes -> Parser a) -> Attributes -> Parser b)
 -> (Token, Attributes -> Parser a)
 -> (Token, Attributes -> Parser b))
-> ((Attributes -> Parser a) -> Attributes -> Parser b)
-> (Token, Attributes -> Parser a)
-> (Token, Attributes -> Parser b)
forall a b. (a -> b) -> a -> b
$ \Attributes -> Parser a
p Attributes
a -> a -> b
f (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Attributes -> Parser a
p Attributes
a

-- | Maps a function on the data given by a branching with attributes
maplabranch :: (a -> b) -> LABranch a -> LABranch b
maplabranch :: forall a b. (a -> b) -> LABranch a -> LABranch b
maplabranch = (ABranch a -> ABranch b) -> [ABranch a] -> [ABranch b]
forall a b. (a -> b) -> [a] -> [b]
map ((ABranch a -> ABranch b) -> [ABranch a] -> [ABranch b])
-> ((a -> b) -> ABranch a -> ABranch b)
-> (a -> b)
-> [ABranch a]
-> [ABranch b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> ABranch a -> ABranch b
forall a b. (a -> b) -> ABranch a -> ABranch b
mapabranch

-- | Specialised repeating combinator
monoAccum :: Monoid a => Parser a -> Parser a
monoAccum :: forall a. Monoid a => Parser a -> Parser a
monoAccum Parser a
p = Parser a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe a)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser a
p ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe a)
-> (Maybe a -> Parser a) -> Parser a
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Parser a -> (a -> Parser a) -> Maybe a -> Parser a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (a -> Parser a
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty) (\a
x -> (a
x a -> a -> a
forall a. Semigroup a => a -> a -> a
<>) (a -> a) -> Parser a -> Parser a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a -> Parser a
forall a. Monoid a => Parser a -> Parser a
monoAccum Parser a
p)

-- | What many1 should have been
manyNE :: Parser a -> Parser (NonEmpty a)
manyNE :: forall a. Parser a -> Parser (NonEmpty a)
manyNE = ([a] -> NonEmpty a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [a]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
forall a b.
(a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> NonEmpty a
forall a. HasCallStack => [a] -> NonEmpty a
NE.fromList (ParsecT [PosToken] LocalCompDir (Writer [String]) [a]
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a))
-> (Parser a
    -> ParsecT [PosToken] LocalCompDir (Writer [String]) [a])
-> Parser a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser a -> ParsecT [PosToken] LocalCompDir (Writer [String]) [a]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many1

-- | Consume a closing delimiter
closeConsume :: SourcePos -> Token -> Token -> Parser ()
closeConsume :: SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
o Token
c =
  (Token -> Maybe ()) -> Parser ()
forall a. (Token -> Maybe a) -> Parser a
fproduce (\Token
t -> if Token
t Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== Token
c then () -> Maybe ()
forall a. a -> Maybe a
Just () else Maybe ()
forall a. Maybe a
Nothing)
    Parser () -> String -> Parser ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String -> String -> String -> Line -> Line -> String
forall r. PrintfType r => String -> r
printf
      String
"closing %s to match opening %s at %d:%d"
      (Token -> String
forall a. Show a => a -> String
show Token
c)
      (Token -> String
forall a. Show a => a -> String
show Token
o)
      (SourcePos -> Line
sourceLine SourcePos
p)
      (SourcePos -> Line
sourceColumn SourcePos
p)

-- | Enclose a parser with tokens and keep track of the opening token position
enclosed :: Token -> Token -> Parser a -> Parser a
enclosed :: forall a. Token -> Token -> Parser a -> Parser a
enclosed Token
l Token
r Parser a
x = do
  SourcePos
p <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  Token -> Parser ()
consume Token
l
  a
res <- Parser a
x
  SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
l Token
r
  a -> Parser a
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return a
res

-- | Enclosed between parentheses/brackets/braces
parens :: Parser a -> Parser a
parens :: forall a. Parser a -> Parser a
parens = Token -> Token -> Parser a -> Parser a
forall a. Token -> Token -> Parser a -> Parser a
enclosed Token
SymParenL Token
SymParenR

brackets :: Parser a -> Parser a
brackets :: forall a. Parser a -> Parser a
brackets = Token -> Token -> Parser a -> Parser a
forall a. Token -> Token -> Parser a -> Parser a
enclosed Token
SymBrackL Token
SymBrackR

braces :: Parser a -> Parser a
braces :: forall a. Parser a -> Parser a
braces = Token -> Token -> Parser a -> Parser a
forall a. Token -> Token -> Parser a -> Parser a
enclosed Token
SymBraceL Token
SymBraceR

-- | Comma separated list
csl :: Parser a -> Parser [a]
csl :: forall a. Parser a -> Parser [a]
csl Parser a
p = Parser a
-> Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [a]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy Parser a
p (Parser ()
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) [a])
-> Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [a]
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymComma

-- | Comma separated list with at least 1 element
csl1 :: Parser a -> Parser (NonEmpty a)
csl1 :: forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser a
p = [a] -> NonEmpty a
forall a. HasCallStack => [a] -> NonEmpty a
NE.fromList ([a] -> NonEmpty a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [a]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a
-> Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [a]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy1 Parser a
p (Token -> Parser ()
consume Token
SymComma)

-- | Warning on 0 element to follow SystemVerilog2017 syntax when 1 is required in Verilog2005
wempty :: String -> Parser [a] -> Parser [a]
wempty :: forall a. String -> Parser [a] -> Parser [a]
wempty String
s Parser [a]
p = do
  SourcePos
pos <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  [a]
l <- Parser [a]
p
  if [a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
l then SourcePos -> String -> Parser ()
warn SourcePos
pos (String -> Parser ()) -> String -> Parser ()
forall a b. (a -> b) -> a -> b
$ String -> String -> String
forall r. PrintfType r => String -> r
printf String
"Zero %s is a SystemVerilog feature" String
s else () -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  [a] -> Parser [a]
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return [a]
l

-- | Comma separated list potentially ended by a comma to be lenient
xcsl :: String -> Parser a -> Parser [a]
xcsl :: forall a. String -> Parser a -> Parser [a]
xcsl String
s Parser a
p = do
  Maybe a
x <- Parser a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe a)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser a
p
  case Maybe a
x of
    Maybe a
Nothing -> [a] -> Parser [a]
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
    Just a
h -> do
      SourcePos
pos <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
      Bool
b <- Token -> Parser Bool
optConsume Token
SymComma
      if Bool
b
        then do
          [a]
t <- String -> Parser a -> Parser [a]
forall a. String -> Parser a -> Parser [a]
xcsl String
s Parser a
p
          if [a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
t
            then SourcePos -> String -> Parser ()
warn SourcePos
pos (String -> String -> String
forall r. PrintfType r => String -> r
printf String
"Extraneous comma at the end of %s is not correct Verilog" String
s)
            else () -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
          [a] -> Parser [a]
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([a] -> Parser [a]) -> [a] -> Parser [a]
forall a b. (a -> b) -> a -> b
$ a
h a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
t
        else [a] -> Parser [a]
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return [a
Item [a]
h]

-- | Comma separated list potentially ended by a comma to be lenient
xcsl1 :: String -> Parser a -> Parser (NonEmpty a)
xcsl1 :: forall a. String -> Parser a -> Parser (NonEmpty a)
xcsl1 String
s Parser a
p = do
  a
x <- Parser a
p
  SourcePos
pos <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  Bool
b <- Token -> Parser Bool
optConsume Token
SymComma
  if Bool
b
    then ((a
x a -> NonEmpty a -> NonEmpty a
forall a. a -> NonEmpty a -> NonEmpty a
<|) (NonEmpty a -> NonEmpty a)
-> Parser (NonEmpty a) -> Parser (NonEmpty a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> Parser a -> Parser (NonEmpty a)
forall a. String -> Parser a -> Parser (NonEmpty a)
xcsl1 String
s Parser a
p)
        Parser (NonEmpty a) -> Parser (NonEmpty a) -> Parser (NonEmpty a)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> SourcePos -> String -> Parser ()
warn SourcePos
pos (String -> String -> String
forall r. PrintfType r => String -> r
printf String
"Extraneous comma at the end of %s is not correct Verilog" String
s)
          Parser () -> Parser (NonEmpty a) -> Parser (NonEmpty a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> NonEmpty a -> Parser (NonEmpty a)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return [a
Item (NonEmpty a)
x]
    else NonEmpty a -> Parser (NonEmpty a)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return [a
Item (NonEmpty a)
x]

-- | Just read the definition
wxcsl :: String -> Parser a -> Parser [a]
wxcsl :: forall a. String -> Parser a -> Parser [a]
wxcsl String
m = String -> Parser [a] -> Parser [a]
forall a. String -> Parser [a] -> Parser [a]
wempty String
m (Parser [a] -> Parser [a])
-> (Parser a -> Parser [a]) -> Parser a -> Parser [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Parser a -> Parser [a]
forall a. String -> Parser a -> Parser [a]
xcsl String
m

-- | Safe parsing comma separated list with at least 1 elements
scsl1 :: Bool -> Parser a -> (a -> Parser b) -> Parser (NonEmpty b)
scsl1 :: forall a b.
Bool -> Parser a -> (a -> Parser b) -> Parser (NonEmpty b)
scsl1 Bool
safety Parser a
d a -> Parser b
p = do
  b
h <- Parser a
d Parser a -> (a -> Parser b) -> Parser b
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Parser b
p
  [b]
t <- Parser b -> ParsecT [PosToken] LocalCompDir (Writer [String]) [b]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (Parser b -> ParsecT [PosToken] LocalCompDir (Writer [String]) [b])
-> Parser b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [b]
forall a b. (a -> b) -> a -> b
$ ((if Bool
safety then Parser a -> Parser a
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try else Parser a -> Parser a
forall a. a -> a
id) (Parser a -> Parser a) -> Parser a -> Parser a
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymComma Parser () -> Parser a -> Parser a
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser a
d) Parser a -> (a -> Parser b) -> Parser b
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Parser b
p
  NonEmpty b -> Parser (NonEmpty b)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty b -> Parser (NonEmpty b))
-> NonEmpty b -> Parser (NonEmpty b)
forall a b. (a -> b) -> a -> b
$ b
h b -> [b] -> NonEmpty b
forall a. a -> [a] -> NonEmpty a
:| [b]
t

-- | Safe parsing of several elements of type B then of type C
-- | when B and C start with a common part of type A
smanythen :: Parser a -> (a -> Parser b) -> (a -> Parser c) -> Parser ([b], [c])
smanythen :: forall a b c.
Parser a -> (a -> Parser b) -> (a -> Parser c) -> Parser ([b], [c])
smanythen Parser a
pa a -> Parser b
pb a -> Parser c
pc = do
  Maybe (Either b c)
h <- ParsecT [PosToken] LocalCompDir (Writer [String]) (Either b c)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe (Either b c))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT [PosToken] LocalCompDir (Writer [String]) (Either b c)
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (Maybe (Either b c)))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Either b c)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe (Either b c))
forall a b. (a -> b) -> a -> b
$ Parser a
pa Parser a
-> (a
    -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Either b c))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Either b c)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
a -> b -> Either b c
forall a b. a -> Either a b
Left (b -> Either b c)
-> Parser b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Either b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Parser b
pb a
a ParsecT [PosToken] LocalCompDir (Writer [String]) (Either b c)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Either b c)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Either b c)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> c -> Either b c
forall a b. b -> Either a b
Right (c -> Either b c)
-> Parser c
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Either b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Parser c
pc a
a
  case Maybe (Either b c)
h of
    Maybe (Either b c)
Nothing -> ([b], [c]) -> Parser ([b], [c])
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([], [])
    Just (Left b
hb) -> ([b] -> [b]) -> ([b], [c]) -> ([b], [c])
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (b
hb b -> [b] -> [b]
forall a. a -> [a] -> [a]
:) (([b], [c]) -> ([b], [c]))
-> Parser ([b], [c]) -> Parser ([b], [c])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a -> (a -> Parser b) -> (a -> Parser c) -> Parser ([b], [c])
forall a b c.
Parser a -> (a -> Parser b) -> (a -> Parser c) -> Parser ([b], [c])
smanythen Parser a
pa a -> Parser b
pb a -> Parser c
pc
    Just (Right c
hc) -> (,) [] ([c] -> ([b], [c])) -> ([c] -> [c]) -> [c] -> ([b], [c])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (c
hc c -> [c] -> [c]
forall a. a -> [a] -> [a]
:) ([c] -> ([b], [c]))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [c]
-> Parser ([b], [c])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser c -> ParsecT [PosToken] LocalCompDir (Writer [String]) [c]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (Parser a
pa Parser a -> (a -> Parser c) -> Parser c
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> Parser c
pc)

-- | Parenthesised comma separated list
pcsl :: Parser a -> Parser [a]
pcsl :: forall a. Parser a -> Parser [a]
pcsl = Parser [a] -> Parser [a]
forall a. Parser a -> Parser a
parens (Parser [a] -> Parser [a])
-> (Parser a -> Parser [a]) -> Parser a -> Parser [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser a -> Parser [a]
forall a. Parser a -> Parser [a]
csl

pcsl1 :: Parser a -> Parser (NonEmpty a)
pcsl1 :: forall a. Parser a -> Parser (NonEmpty a)
pcsl1 = Parser (NonEmpty a) -> Parser (NonEmpty a)
forall a. Parser a -> Parser a
parens (Parser (NonEmpty a) -> Parser (NonEmpty a))
-> (Parser a -> Parser (NonEmpty a))
-> Parser a
-> Parser (NonEmpty a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser a -> Parser (NonEmpty a)
forall a. Parser a -> Parser (NonEmpty a)
csl1

bcsl1 :: Parser a -> Parser (NonEmpty a)
bcsl1 :: forall a. Parser a -> Parser (NonEmpty a)
bcsl1 = Parser (NonEmpty a) -> Parser (NonEmpty a)
forall a. Parser a -> Parser a
braces (Parser (NonEmpty a) -> Parser (NonEmpty a))
-> (Parser a -> Parser (NonEmpty a))
-> Parser a
-> Parser (NonEmpty a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser a -> Parser (NonEmpty a)
forall a. Parser a -> Parser (NonEmpty a)
csl1

parseBS :: Parser B.ByteString
parseBS :: Parser ByteString
parseBS =
  (Token -> Maybe ByteString) -> Parser ByteString
forall a. (Token -> Maybe a) -> Parser a
fproduce (\Token
t -> case Token
t of IdSimple ByteString
s -> ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
s; IdEscaped ByteString
s -> ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
s; Token
_ -> Maybe ByteString
forall a. Maybe a
Nothing)
    Parser ByteString -> String -> Parser ByteString
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"identifier"

-- | Extracts an identifier
ident :: Parser Identifier
ident :: Parser Identifier
ident = ByteString -> Identifier
Identifier (ByteString -> Identifier)
-> Parser ByteString -> Parser Identifier
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString
parseBS

lenientIdent :: Parser Identifier
lenientIdent :: Parser Identifier
lenientIdent = do
  SourcePos
pos <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  (Token -> Maybe (Parser Identifier)) -> Parser Identifier
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch
    ( \Token
t -> case Token
t of
        IdSimple ByteString
s -> Parser Identifier -> Maybe (Parser Identifier)
forall a. a -> Maybe a
Just (Parser Identifier -> Maybe (Parser Identifier))
-> Parser Identifier -> Maybe (Parser Identifier)
forall a b. (a -> b) -> a -> b
$ Identifier -> Parser Identifier
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Identifier -> Parser Identifier)
-> Identifier -> Parser Identifier
forall a b. (a -> b) -> a -> b
$ ByteString -> Identifier
Identifier ByteString
s
        IdEscaped ByteString
s -> Parser Identifier -> Maybe (Parser Identifier)
forall a. a -> Maybe a
Just (Parser Identifier -> Maybe (Parser Identifier))
-> Parser Identifier -> Maybe (Parser Identifier)
forall a b. (a -> b) -> a -> b
$ Identifier -> Parser Identifier
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Identifier -> Parser Identifier)
-> Identifier -> Parser Identifier
forall a b. (a -> b) -> a -> b
$ ByteString -> Identifier
Identifier ByteString
s
        IdSystem ByteString
s -> Parser Identifier -> Maybe (Parser Identifier)
forall a. a -> Maybe a
Just (Parser Identifier -> Maybe (Parser Identifier))
-> Parser Identifier -> Maybe (Parser Identifier)
forall a b. (a -> b) -> a -> b
$ do
          SourcePos -> String -> Parser ()
warn
            SourcePos
pos
            String
"Dollar prefixed identifier outside system function or task is not correct Verilog"
          Identifier -> Parser Identifier
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Identifier -> Parser Identifier)
-> Identifier -> Parser Identifier
forall a b. (a -> b) -> a -> b
$ ByteString -> Identifier
Identifier ByteString
s
        Token
_ -> Maybe (Parser Identifier)
forall a. Maybe a
Nothing
    )
    Parser Identifier -> String -> Parser Identifier
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"identifier"

-- | Library prefixed cell for config blocks
dot1Ident :: Parser Dot1Ident
dot1Ident :: Parser Dot1Ident
dot1Ident = do
  ByteString
f <- Parser ByteString
parseBS
  Maybe Identifier
s <- Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser Identifier
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier))
-> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymDot Parser () -> Parser Identifier -> Parser Identifier
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Identifier
ident
  Dot1Ident -> Parser Dot1Ident
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Dot1Ident -> Parser Dot1Ident) -> Dot1Ident -> Parser Dot1Ident
forall a b. (a -> b) -> a -> b
$ case Maybe Identifier
s of Maybe Identifier
Nothing -> Maybe ByteString -> Identifier -> Dot1Ident
Dot1Ident Maybe ByteString
forall a. Maybe a
Nothing (Identifier -> Dot1Ident) -> Identifier -> Dot1Ident
forall a b. (a -> b) -> a -> b
$ ByteString -> Identifier
Identifier ByteString
f; Just Identifier
s -> Maybe ByteString -> Identifier -> Dot1Ident
Dot1Ident (ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
f) Identifier
s

attribute :: Parser Attribute
attribute :: Parser Attribute
attribute = do
  ByteString
attr <- Parser ByteString
parseBS
  Maybe (GenExpr Identifier (Maybe CRangeExpr) ())
value <- ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenExpr Identifier (Maybe CRangeExpr) ())
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (GenExpr Identifier (Maybe CRangeExpr) ()))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (GenExpr Identifier (Maybe CRangeExpr) ())
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe (GenExpr Identifier (Maybe CRangeExpr) ())))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenExpr Identifier (Maybe CRangeExpr) ())
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (GenExpr Identifier (Maybe CRangeExpr) ()))
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymEq
    Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenExpr Identifier (Maybe CRangeExpr) ())
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenExpr Identifier (Maybe CRangeExpr) ())
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> PGenExpr GenExpr Identifier (Maybe CRangeExpr) ()
forall i r a. PGenExpr GenExpr i r a
genExpr (Identifier -> Parser Identifier
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Identifier -> Parser Identifier)
-> (ByteString -> Identifier) -> ByteString -> Parser Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Identifier
Identifier) (ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
constRangeExpr) (() -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()) Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just Maybe DimRange -> Maybe (Maybe CRangeExpr)
constifyMaybeRange
  Attribute -> Parser Attribute
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Attribute -> Parser Attribute) -> Attribute -> Parser Attribute
forall a b. (a -> b) -> a -> b
$ ByteString
-> Maybe (GenExpr Identifier (Maybe CRangeExpr) ()) -> Attribute
Attribute ByteString
attr Maybe (GenExpr Identifier (Maybe CRangeExpr) ())
value

-- TODO: this is likely incorrectly used but I leave this bug on purpose atm
attributeOne :: Parser [Attribute]
attributeOne :: Parser [Attribute]
attributeOne = Token -> Token -> Parser [Attribute] -> Parser [Attribute]
forall a. Token -> Token -> Parser a -> Parser a
enclosed Token
SymParenAster Token
SymAsterParen (Parser [Attribute] -> Parser [Attribute])
-> Parser [Attribute] -> Parser [Attribute]
forall a b. (a -> b) -> a -> b
$ NonEmpty Attribute -> [Attribute]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty Attribute -> [Attribute])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Attribute)
-> Parser [Attribute]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Attribute
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Attribute)
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser Attribute
attribute

-- | Flattened list of attributes
attributes :: Parser Attributes
attributes :: Parser Attributes
attributes = Parser [Attribute] -> Parser Attributes
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser [Attribute]
attributeOne

-- | Number after base
number :: Base -> Parser Number
number :: Base -> Parser Number
number Base
b = case Base
b of
  Base
BBin -> NonEmpty BXZ -> Number
NBinary (NonEmpty BXZ -> Number)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty BXZ)
-> Parser Number
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Token -> Maybe (NonEmpty BXZ))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty BXZ)
forall a. (Token -> Maybe a) -> Parser a
fproduce (\Token
t -> case Token
t of LitBinary [BXZ]
b -> NonEmpty BXZ -> Maybe (NonEmpty BXZ)
forall a. a -> Maybe a
Just (NonEmpty BXZ -> Maybe (NonEmpty BXZ))
-> NonEmpty BXZ -> Maybe (NonEmpty BXZ)
forall a b. (a -> b) -> a -> b
$ [BXZ] -> NonEmpty BXZ
forall a. HasCallStack => [a] -> NonEmpty a
NE.fromList [BXZ]
b; Token
_ -> Maybe (NonEmpty BXZ)
forall a. Maybe a
Nothing)
  Base
BOct -> NonEmpty OXZ -> Number
NOctal (NonEmpty OXZ -> Number)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty OXZ)
-> Parser Number
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Token -> Maybe (NonEmpty OXZ))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty OXZ)
forall a. (Token -> Maybe a) -> Parser a
fproduce (\Token
t -> case Token
t of LitOctal [OXZ]
o -> NonEmpty OXZ -> Maybe (NonEmpty OXZ)
forall a. a -> Maybe a
Just (NonEmpty OXZ -> Maybe (NonEmpty OXZ))
-> NonEmpty OXZ -> Maybe (NonEmpty OXZ)
forall a b. (a -> b) -> a -> b
$ [OXZ] -> NonEmpty OXZ
forall a. HasCallStack => [a] -> NonEmpty a
NE.fromList [OXZ]
o; Token
_ -> Maybe (NonEmpty OXZ)
forall a. Maybe a
Nothing)
  Base
BDec -> (Token -> Maybe Number) -> Parser Number
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Number) -> Parser Number)
-> (Token -> Maybe Number) -> Parser Number
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
    LitXZ Bool
b -> Number -> Maybe Number
forall a. a -> Maybe a
Just (Number -> Maybe Number) -> Number -> Maybe Number
forall a b. (a -> b) -> a -> b
$ Bool -> Number
NXZ Bool
b
    LitDecimal Natural
i -> Number -> Maybe Number
forall a. a -> Maybe a
Just (Number -> Maybe Number) -> Number -> Maybe Number
forall a b. (a -> b) -> a -> b
$ Natural -> Number
NDecimal Natural
i
    Token
_ -> Maybe Number
forall a. Maybe a
Nothing
  Base
BHex -> NonEmpty HXZ -> Number
NHex (NonEmpty HXZ -> Number)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty HXZ)
-> Parser Number
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Token -> Maybe (NonEmpty HXZ))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty HXZ)
forall a. (Token -> Maybe a) -> Parser a
fproduce (\Token
t -> case Token
t of LitHex [HXZ]
h -> NonEmpty HXZ -> Maybe (NonEmpty HXZ)
forall a. a -> Maybe a
Just (NonEmpty HXZ -> Maybe (NonEmpty HXZ))
-> NonEmpty HXZ -> Maybe (NonEmpty HXZ)
forall a b. (a -> b) -> a -> b
$ [HXZ] -> NonEmpty HXZ
forall a. HasCallStack => [a] -> NonEmpty a
NE.fromList [HXZ]
h; Token
_ -> Maybe (NonEmpty HXZ)
forall a. Maybe a
Nothing)

type PGenExpr g i r a =
  (B.ByteString -> Parser i) ->
  Parser r ->
  Parser a ->
  (i -> Maybe Identifier) ->
  (Maybe DimRange -> Maybe r) ->
  Parser (g i r a)

-- | Parametric primary expression
genPrim :: PGenExpr GenPrim i r a
genPrim :: forall i r a. PGenExpr GenPrim i r a
genPrim ByteString -> Parser i
pi Parser r
pr Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe r
cr = (SourcePos -> Token -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a)
forall a. (SourcePos -> Token -> Maybe (Parser a)) -> Parser a
fpbranch ((SourcePos -> Token -> Maybe (Parser (GenPrim i r a)))
 -> Parser (GenPrim i r a))
-> (SourcePos -> Token -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a)
forall a b. (a -> b) -> a -> b
$ \SourcePos
p Token
t -> case Token
t of
  -- try parse braceL and let that decide the path, otherwise it is wrong for constExpr
  Token
SymBraceL -> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a. a -> Maybe a
Just (Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a b. (a -> b) -> a -> b
$ do
    GenExpr i (Maybe DimRange) a
e <- PGenExpr GenExpr i (Maybe DimRange) a
forall i r a. PGenExpr GenExpr i r a
genExpr ByteString -> Parser i
pi Parser (Maybe DimRange)
dimRange Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe (Maybe DimRange)
forall a. a -> Maybe a
Just
    SourcePos
p2 <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
    Bool
b <- Token -> Parser Bool
optConsume Token
SymBraceL
    GenPrim i r a
ee <- if Bool
b
      then case (i -> Maybe Identifier)
-> (Maybe DimRange -> Maybe (Maybe CRangeExpr))
-> GenExpr i (Maybe DimRange) a
-> Maybe (GenExpr Identifier (Maybe CRangeExpr) a)
forall si di r a.
(si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenExpr si (Maybe DimRange) a
-> Maybe (GenExpr di r a)
trConstifyGenExpr i -> Maybe Identifier
ci Maybe DimRange -> Maybe (Maybe CRangeExpr)
constifyMaybeRange GenExpr i (Maybe DimRange) a
e of
        Maybe (GenExpr Identifier (Maybe CRangeExpr) a)
Nothing -> String -> Parser (GenPrim i r a)
forall a. String -> Parser a
hardfail String
"Replication takes a constant expression as multiplicity"
        Just GenExpr Identifier (Maybe CRangeExpr) a
e -> GenExpr Identifier (Maybe CRangeExpr) a
-> NonEmpty (GenExpr i r a) -> GenPrim i r a
forall i r a.
GenExpr Identifier (Maybe CRangeExpr) a
-> NonEmpty (GenExpr i r a) -> GenPrim i r a
PrimMultConcat GenExpr Identifier (Maybe CRangeExpr) a
e (NonEmpty (GenExpr i r a) -> GenPrim i r a)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (GenExpr i r a))
-> Parser (GenPrim i r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (GenExpr i r a)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (GenExpr i r a))
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser (GenExpr i r a)
parseExpr Parser (GenPrim i r a) -> Parser () -> Parser (GenPrim i r a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p2 Token
SymBraceL Token
SymBraceR
      else case (i -> Maybe i)
-> (Maybe DimRange -> Maybe r)
-> GenExpr i (Maybe DimRange) a
-> Maybe (GenExpr i r a)
forall si di r a.
(si -> Maybe di)
-> (Maybe DimRange -> Maybe r)
-> GenExpr si (Maybe DimRange) a
-> Maybe (GenExpr di r a)
trConstifyGenExpr i -> Maybe i
forall a. a -> Maybe a
Just Maybe DimRange -> Maybe r
cr GenExpr i (Maybe DimRange) a
e of
        Maybe (GenExpr i r a)
Nothing -> String -> Parser (GenPrim i r a)
forall a. String -> Parser a
hardfail String
"Invalid kind of expression"
        Just GenExpr i r a
e -> NonEmpty (GenExpr i r a) -> GenPrim i r a
forall i r a. NonEmpty (GenExpr i r a) -> GenPrim i r a
PrimConcat (NonEmpty (GenExpr i r a) -> GenPrim i r a)
-> ([GenExpr i r a] -> NonEmpty (GenExpr i r a))
-> [GenExpr i r a]
-> GenPrim i r a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GenExpr i r a
e GenExpr i r a -> [GenExpr i r a] -> NonEmpty (GenExpr i r a)
forall a. a -> [a] -> NonEmpty a
:|) ([GenExpr i r a] -> GenPrim i r a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> Parser (GenPrim i r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (Token -> Parser ()
consume Token
SymComma Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (GenExpr i r a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a. Parser a -> Parser [a]
csl Parser (GenExpr i r a)
parseExpr)
    SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
SymBraceL Token
SymBraceR
    GenPrim i r a -> Parser (GenPrim i r a)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return GenPrim i r a
ee
  Token
SymParenL -> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a. a -> Maybe a
Just (Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a b. (a -> b) -> a -> b
$ GenMinTypMax (GenExpr i r a) -> GenPrim i r a
forall i r a. GenMinTypMax (GenExpr i r a) -> GenPrim i r a
PrimMinTypMax (GenMinTypMax (GenExpr i r a) -> GenPrim i r a)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenMinTypMax (GenExpr i r a))
-> Parser (GenPrim i r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (GenExpr i r a)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenMinTypMax (GenExpr i r a))
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser (GenExpr i r a)
parseExpr Parser (GenPrim i r a) -> Parser () -> Parser (GenPrim i r a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
SymParenL Token
SymParenR
  LitDecimal Natural
i -> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a. a -> Maybe a
Just (Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a b. (a -> b) -> a -> b
$
    GenPrim i r a -> Parser (GenPrim i r a) -> Parser (GenPrim i r a)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option (Maybe Natural -> Bool -> Number -> GenPrim i r a
forall i r a. Maybe Natural -> Bool -> Number -> GenPrim i r a
PrimNumber Maybe Natural
forall a. Maybe a
Nothing Bool
True (Number -> GenPrim i r a) -> Number -> GenPrim i r a
forall a b. (a -> b) -> a -> b
$ Natural -> Number
NDecimal Natural
i) (Parser (GenPrim i r a) -> Parser (GenPrim i r a))
-> Parser (GenPrim i r a) -> Parser (GenPrim i r a)
forall a b. (a -> b) -> a -> b
$
      (Token -> Maybe (Parser (GenPrim i r a))) -> Parser (GenPrim i r a)
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token -> Maybe (Parser (GenPrim i r a)))
 -> Parser (GenPrim i r a))
-> (Token -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a)
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
        NumberBase Bool
s Base
b -> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a. a -> Maybe a
Just (Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a b. (a -> b) -> a -> b
$ Maybe Natural -> Bool -> Number -> GenPrim i r a
forall i r a. Maybe Natural -> Bool -> Number -> GenPrim i r a
PrimNumber (Natural -> Maybe Natural
forall a. a -> Maybe a
Just Natural
i) Bool
s (Number -> GenPrim i r a)
-> Parser Number -> Parser (GenPrim i r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Base -> Parser Number
number Base
b
        Token
_ -> Maybe (Parser (GenPrim i r a))
forall a. Maybe a
Nothing
  LitReal ByteString
s -> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a. a -> Maybe a
Just (Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a b. (a -> b) -> a -> b
$ GenPrim i r a -> Parser (GenPrim i r a)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (GenPrim i r a -> Parser (GenPrim i r a))
-> GenPrim i r a -> Parser (GenPrim i r a)
forall a b. (a -> b) -> a -> b
$ ByteString -> GenPrim i r a
forall i r a. ByteString -> GenPrim i r a
PrimReal ByteString
s
  NumberBase Bool
s Base
b -> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a. a -> Maybe a
Just (Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a b. (a -> b) -> a -> b
$ Maybe Natural -> Bool -> Number -> GenPrim i r a
forall i r a. Maybe Natural -> Bool -> Number -> GenPrim i r a
PrimNumber Maybe Natural
forall a. Maybe a
Nothing Bool
s (Number -> GenPrim i r a)
-> Parser Number -> Parser (GenPrim i r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Base -> Parser Number
number Base
b
  LitString ByteString
s -> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a. a -> Maybe a
Just (Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a b. (a -> b) -> a -> b
$ GenPrim i r a -> Parser (GenPrim i r a)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (GenPrim i r a -> Parser (GenPrim i r a))
-> GenPrim i r a -> Parser (GenPrim i r a)
forall a b. (a -> b) -> a -> b
$ ByteString -> GenPrim i r a
forall i r a. ByteString -> GenPrim i r a
PrimString ByteString
s
  IdSystem ByteString
s ->
    Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a. a -> Maybe a
Just (Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a b. (a -> b) -> a -> b
$ ByteString -> [GenExpr i r a] -> GenPrim i r a
forall i r a. ByteString -> [GenExpr i r a] -> GenPrim i r a
PrimSysFun ByteString
s ([GenExpr i r a] -> GenPrim i r a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> Parser (GenPrim i r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (ParsecT [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a. Parser a -> Parser a
parens (ParsecT [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a b. (a -> b) -> a -> b
$ String
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a. String -> Parser [a] -> Parser [a]
wempty String
"system function argument" (ParsecT [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a b. (a -> b) -> a -> b
$ Parser (GenExpr i r a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a. Parser a -> Parser [a]
csl Parser (GenExpr i r a)
parseExpr)
  IdSimple ByteString
s -> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a. a -> Maybe a
Just (Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a b. (a -> b) -> a -> b
$ ByteString -> Parser (GenPrim i r a)
idp ByteString
s
  IdEscaped ByteString
s -> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a. a -> Maybe a
Just (Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a)))
-> Parser (GenPrim i r a) -> Maybe (Parser (GenPrim i r a))
forall a b. (a -> b) -> a -> b
$ ByteString -> Parser (GenPrim i r a)
idp ByteString
s
  Token
_ -> Maybe (Parser (GenPrim i r a))
forall a. Maybe a
Nothing
  where
    parseExpr :: Parser (GenExpr i r a)
parseExpr = PGenExpr GenExpr i r a
forall i r a. PGenExpr GenExpr i r a
genExpr ByteString -> Parser i
pi Parser r
pr Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe r
cr
    fp :: i -> Parser (GenPrim i r a)
fp i
s = i -> a -> [GenExpr i r a] -> GenPrim i r a
forall i r a. i -> a -> [GenExpr i r a] -> GenPrim i r a
PrimFun i
s (a -> [GenExpr i r a] -> GenPrim i r a)
-> Parser a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     ([GenExpr i r a] -> GenPrim i r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a
pa ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  ([GenExpr i r a] -> GenPrim i r a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> Parser (GenPrim i r a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a. Parser a -> Parser a
parens (String
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a. String -> Parser [a] -> Parser [a]
wempty String
"function argument" (ParsecT [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a b. (a -> b) -> a -> b
$ Parser (GenExpr i r a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenExpr i r a]
forall a. Parser a -> Parser [a]
csl Parser (GenExpr i r a)
parseExpr)
    idp :: ByteString -> Parser (GenPrim i r a)
idp ByteString
s = ByteString -> Parser i
pi ByteString
s Parser i -> (i -> Parser (GenPrim i r a)) -> Parser (GenPrim i r a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \i
ss -> i -> Parser (GenPrim i r a)
fp i
ss Parser (GenPrim i r a)
-> Parser (GenPrim i r a) -> Parser (GenPrim i r a)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> i -> r -> GenPrim i r a
forall i r a. i -> r -> GenPrim i r a
PrimIdent i
ss (r -> GenPrim i r a) -> Parser r -> Parser (GenPrim i r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser r
pr

-- | Unary operator can only be applied on primary expressions
genBase :: PGenExpr GenExpr i r a
genBase :: forall i r a. PGenExpr GenExpr i r a
genBase ByteString -> Parser i
pi Parser r
pr Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe r
cr = do
  Maybe (UnaryOperator, a)
op <- ParsecT
  [PosToken] LocalCompDir (Writer [String]) (UnaryOperator, a)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (UnaryOperator, a))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (UnaryOperator, a)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe (UnaryOperator, a)))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (UnaryOperator, a)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (UnaryOperator, a))
forall a b. (a -> b) -> a -> b
$
    ParsecT [PosToken] LocalCompDir (Writer [String]) UnaryOperator
-> Parser a
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (UnaryOperator, a)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f (a, b)
mkpair
      ( (Token -> Maybe UnaryOperator)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) UnaryOperator
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe UnaryOperator)
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) UnaryOperator)
-> (Token -> Maybe UnaryOperator)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) UnaryOperator
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
          Token
UnTilde -> UnaryOperator -> Maybe UnaryOperator
forall a. a -> Maybe a
Just UnaryOperator
UnNot
          Token
UnBang -> UnaryOperator -> Maybe UnaryOperator
forall a. a -> Maybe a
Just UnaryOperator
UnLNot
          Token
UnTildeAmp -> UnaryOperator -> Maybe UnaryOperator
forall a. a -> Maybe a
Just UnaryOperator
UnNand
          Token
UnTildeBar -> UnaryOperator -> Maybe UnaryOperator
forall a. a -> Maybe a
Just UnaryOperator
UnNor
          Token
AmBar -> UnaryOperator -> Maybe UnaryOperator
forall a. a -> Maybe a
Just UnaryOperator
UnOr
          Token
AmHat -> UnaryOperator -> Maybe UnaryOperator
forall a. a -> Maybe a
Just UnaryOperator
UnXor
          Token
AmAmp -> UnaryOperator -> Maybe UnaryOperator
forall a. a -> Maybe a
Just UnaryOperator
UnAnd
          Token
AmTildeHat -> UnaryOperator -> Maybe UnaryOperator
forall a. a -> Maybe a
Just UnaryOperator
UnXNor
          Token
SymPlus -> UnaryOperator -> Maybe UnaryOperator
forall a. a -> Maybe a
Just UnaryOperator
UnPlus
          Token
SymDash -> UnaryOperator -> Maybe UnaryOperator
forall a. a -> Maybe a
Just UnaryOperator
UnMinus
          Token
_ -> Maybe UnaryOperator
forall a. Maybe a
Nothing
      )
      Parser a
pa
  GenPrim i r a
p <- PGenExpr GenPrim i r a
forall i r a. PGenExpr GenPrim i r a
genPrim ByteString -> Parser i
pi Parser r
pr Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe r
cr
  GenExpr i r a -> Parser (GenExpr i r a)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (GenExpr i r a -> Parser (GenExpr i r a))
-> GenExpr i r a -> Parser (GenExpr i r a)
forall a b. (a -> b) -> a -> b
$ GenExpr i r a
-> ((UnaryOperator, a) -> GenExpr i r a)
-> Maybe (UnaryOperator, a)
-> GenExpr i r a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (GenPrim i r a -> GenExpr i r a
forall i r a. GenPrim i r a -> GenExpr i r a
ExprPrim GenPrim i r a
p) (((UnaryOperator, a) -> GenPrim i r a -> GenExpr i r a)
-> GenPrim i r a -> (UnaryOperator, a) -> GenExpr i r a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((UnaryOperator -> a -> GenPrim i r a -> GenExpr i r a)
-> (UnaryOperator, a) -> GenPrim i r a -> GenExpr i r a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry UnaryOperator -> a -> GenPrim i r a -> GenExpr i r a
forall i r a. UnaryOperator -> a -> GenPrim i r a -> GenExpr i r a
ExprUnOp) GenPrim i r a
p) Maybe (UnaryOperator, a)
op

-- | Facility for expression parsing
genExprBuildParser :: PGenExpr GenExpr i r a
genExprBuildParser :: forall i r a. PGenExpr GenExpr i r a
genExprBuildParser ByteString -> Parser i
pi Parser r
pr Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe r
cr =
  OperatorTable
  [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)
forall s (m :: * -> *) t u a.
Stream s m t =>
OperatorTable s u m a -> ParsecT s u m a -> ParsecT s u m a
buildExpressionParser
    [ (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of Token
BinAsterAster -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinPower; Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing,
      (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
        Token
SymAster -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinTimes
        Token
BinSlash -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinDiv
        Token
BinPercent -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinMod
        Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing,
      (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of Token
SymPlus -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinPlus; Token
SymDash -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinMinus; Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing,
      (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
        Token
BinLtLt -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinLSL
        Token
BinGtGt -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinLSR
        Token
BinLtLtLt -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinASL
        Token
BinGtGtGt -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinASR
        Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing,
      (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
        Token
BinLt -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinLT
        Token
SymLtEq -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinLEq
        Token
BinGt -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinGT
        Token
BinGtEq -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinGEq
        Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing,
      (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
        Token
BinEqEq -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinEq
        Token
BinBangEq -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinNEq
        Token
BinEqEqEq -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinCEq
        Token
BinBangEqEq -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinCNEq
        Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing,
      (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of Token
AmAmp -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinAnd; Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing,
      (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of Token
AmHat -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinXor; Token
AmTildeHat -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinXNor; Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing,
      (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of Token
AmBar -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinOr; Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing,
      (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of Token
BinAmpAmp -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinLAnd; Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing,
      (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall {l} {i} {r}.
(Item l
 ~ Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a),
 IsList l) =>
(Token -> Maybe BinaryOperator) -> l
infixop ((Token -> Maybe BinaryOperator)
 -> Item
      (OperatorTable
         [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)))
-> (Token -> Maybe BinaryOperator)
-> Item
     (OperatorTable
        [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of Token
BinBarBar -> BinaryOperator -> Maybe BinaryOperator
forall a. a -> Maybe a
Just BinaryOperator
BinLOr; Token
_ -> Maybe BinaryOperator
forall a. Maybe a
Nothing
    ]
    (PGenExpr GenExpr i r a
forall i r a. PGenExpr GenExpr i r a
genBase ByteString -> Parser i
pi Parser r
pr Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe r
cr)
  where
    infixop :: (Token -> Maybe BinaryOperator) -> l
infixop Token -> Maybe BinaryOperator
fp = [ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenExpr i r a -> GenExpr i r a -> GenExpr i r a)
-> Assoc
-> Operator
     [PosToken] LocalCompDir (Writer [String]) (GenExpr i r a)
forall s u (m :: * -> *) a.
ParsecT s u m (a -> a -> a) -> Assoc -> Operator s u m a
Infix ((\BinaryOperator
op a
a GenExpr i r a
l -> GenExpr i r a
-> BinaryOperator -> a -> GenExpr i r a -> GenExpr i r a
forall i r a.
GenExpr i r a
-> BinaryOperator -> a -> GenExpr i r a -> GenExpr i r a
ExprBinOp GenExpr i r a
l BinaryOperator
op a
a) (BinaryOperator
 -> a -> GenExpr i r a -> GenExpr i r a -> GenExpr i r a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) BinaryOperator
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (a -> GenExpr i r a -> GenExpr i r a -> GenExpr i r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Token -> Maybe BinaryOperator)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) BinaryOperator
forall a. (Token -> Maybe a) -> Parser a
fproduce Token -> Maybe BinaryOperator
fp ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (a -> GenExpr i r a -> GenExpr i r a -> GenExpr i r a)
-> Parser a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenExpr i r a -> GenExpr i r a -> GenExpr i r a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a
pa) Assoc
AssocLeft]

-- | Parametric expression
genExpr :: PGenExpr GenExpr i r a
genExpr :: forall i r a. PGenExpr GenExpr i r a
genExpr ByteString -> Parser i
pi Parser r
pr Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe r
cr = do
  GenExpr i r a
e <- PGenExpr GenExpr i r a
forall i r a. PGenExpr GenExpr i r a
genExprBuildParser ByteString -> Parser i
pi Parser r
pr Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe r
cr
  Bool
b <- Token -> Parser Bool
optConsume Token
SymQuestion
  if Bool
b
    then GenExpr i r a
-> a -> GenExpr i r a -> GenExpr i r a -> GenExpr i r a
forall i r a.
GenExpr i r a
-> a -> GenExpr i r a -> GenExpr i r a -> GenExpr i r a
ExprCond GenExpr i r a
e (a -> GenExpr i r a -> GenExpr i r a -> GenExpr i r a)
-> Parser a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenExpr i r a -> GenExpr i r a -> GenExpr i r a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a
pa ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenExpr i r a -> GenExpr i r a -> GenExpr i r a)
-> Parser (GenExpr i r a)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenExpr i r a -> GenExpr i r a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> PGenExpr GenExpr i r a
forall i r a. PGenExpr GenExpr i r a
genExpr ByteString -> Parser i
pi Parser r
pr Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe r
cr ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenExpr i r a -> GenExpr i r a)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenExpr i r a -> GenExpr i r a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymColon ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenExpr i r a -> GenExpr i r a)
-> Parser (GenExpr i r a) -> Parser (GenExpr i r a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> PGenExpr GenExpr i r a
forall i r a. PGenExpr GenExpr i r a
genExpr ByteString -> Parser i
pi Parser r
pr Parser a
pa i -> Maybe Identifier
ci Maybe DimRange -> Maybe r
cr
    else GenExpr i r a -> Parser (GenExpr i r a)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return GenExpr i r a
e

expr :: Parser Expr
expr :: Parser Expr
expr = GenExpr HierIdent (Maybe DimRange) Attributes -> Expr
Expr (GenExpr HierIdent (Maybe DimRange) Attributes -> Expr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenExpr HierIdent (Maybe DimRange) Attributes)
-> Parser Expr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PGenExpr GenExpr HierIdent (Maybe DimRange) Attributes
forall i r a. PGenExpr GenExpr i r a
genExpr (Bool -> ByteString -> Parser HierIdent
trHierIdent Bool
True) Parser (Maybe DimRange)
dimRange Parser Attributes
attributes HierIdent -> Maybe Identifier
constifyIdent Maybe DimRange -> Maybe (Maybe DimRange)
forall a. a -> Maybe a
Just

constExpr :: Parser CExpr
constExpr :: Parser CExpr
constExpr =
  GenExpr Identifier (Maybe CRangeExpr) Attributes -> CExpr
CExpr
    (GenExpr Identifier (Maybe CRangeExpr) Attributes -> CExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenExpr Identifier (Maybe CRangeExpr) Attributes)
-> Parser CExpr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PGenExpr GenExpr Identifier (Maybe CRangeExpr) Attributes
forall i r a. PGenExpr GenExpr i r a
genExpr
      (Identifier -> Parser Identifier
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Identifier -> Parser Identifier)
-> (ByteString -> Identifier) -> ByteString -> Parser Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Identifier
Identifier)
      (ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
constRangeExpr)
      Parser Attributes
attributes
      Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just
      Maybe DimRange -> Maybe (Maybe CRangeExpr)
constifyMaybeRange

-- | Minimum, Typical, Maximum on a base type recognised by the argument parser
mtm :: Parser a -> Parser (GenMinTypMax a)
mtm :: forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser a
p = do
  a
x <- Parser a
p
  Bool
b <- Token -> Parser Bool
optConsume Token
SymColon
  if Bool
b
    then a -> a -> a -> GenMinTypMax a
forall et. et -> et -> et -> GenMinTypMax et
MTMFull a
x (a -> a -> GenMinTypMax a)
-> Parser a
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (a -> GenMinTypMax a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser a
p ParsecT
  [PosToken] LocalCompDir (Writer [String]) (a -> GenMinTypMax a)
-> Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (a -> GenMinTypMax a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymColon ParsecT
  [PosToken] LocalCompDir (Writer [String]) (a -> GenMinTypMax a)
-> Parser a -> Parser (GenMinTypMax a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser a
p
    else GenMinTypMax a -> Parser (GenMinTypMax a)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (GenMinTypMax a -> Parser (GenMinTypMax a))
-> GenMinTypMax a -> Parser (GenMinTypMax a)
forall a b. (a -> b) -> a -> b
$ a -> GenMinTypMax a
forall et. et -> GenMinTypMax et
MTMSingle a
x

-- | Ranges
range2 :: Parser Range2
range2 :: Parser Range2
range2 = Parser Range2 -> Parser Range2
forall a. Parser a -> Parser a
brackets (Parser Range2 -> Parser Range2) -> Parser Range2 -> Parser Range2
forall a b. (a -> b) -> a -> b
$ CExpr -> CExpr -> Range2
Range2 (CExpr -> CExpr -> Range2)
-> Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (CExpr -> Range2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser CExpr
constExpr ParsecT [PosToken] LocalCompDir (Writer [String]) (CExpr -> Range2)
-> Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (CExpr -> Range2)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymColon ParsecT [PosToken] LocalCompDir (Writer [String]) (CExpr -> Range2)
-> Parser CExpr -> Parser Range2
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser CExpr
constExpr

genRangeExpr :: Parser e -> (e -> Maybe CExpr) -> Parser (GenRangeExpr e)
genRangeExpr :: forall e. Parser e -> (e -> Maybe CExpr) -> Parser (GenRangeExpr e)
genRangeExpr Parser e
pe e -> Maybe CExpr
constf =
  Parser (GenRangeExpr e) -> Parser (GenRangeExpr e)
forall a. Parser a -> Parser a
brackets (Parser (GenRangeExpr e) -> Parser (GenRangeExpr e))
-> Parser (GenRangeExpr e) -> Parser (GenRangeExpr e)
forall a b. (a -> b) -> a -> b
$ do
    e
b <- Parser e
pe
    Maybe (CExpr -> GenRangeExpr e)
f <- ParsecT
  [PosToken] LocalCompDir (Writer [String]) (CExpr -> GenRangeExpr e)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (CExpr -> GenRangeExpr e))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (CExpr -> GenRangeExpr e)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe (CExpr -> GenRangeExpr e)))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (CExpr -> GenRangeExpr e)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (CExpr -> GenRangeExpr e))
forall a b. (a -> b) -> a -> b
$ ParsecT
  [PosToken] LocalCompDir (Writer [String]) (CExpr -> GenRangeExpr e)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (CExpr -> GenRangeExpr e)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (CExpr -> GenRangeExpr e)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (CExpr -> GenRangeExpr e))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (CExpr -> GenRangeExpr e)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (CExpr -> GenRangeExpr e)
forall a b. (a -> b) -> a -> b
$ (Token -> Maybe (CExpr -> GenRangeExpr e))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (CExpr -> GenRangeExpr e)
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe (CExpr -> GenRangeExpr e))
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (CExpr -> GenRangeExpr e))
-> (Token -> Maybe (CExpr -> GenRangeExpr e))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (CExpr -> GenRangeExpr e)
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
      Token
SymColon -> case e -> Maybe CExpr
constf e
b of
        Maybe CExpr
Nothing -> Maybe (CExpr -> GenRangeExpr e)
forall a. Maybe a
Nothing
        Just CExpr
m -> (CExpr -> GenRangeExpr e) -> Maybe (CExpr -> GenRangeExpr e)
forall a. a -> Maybe a
Just ((CExpr -> GenRangeExpr e) -> Maybe (CExpr -> GenRangeExpr e))
-> (CExpr -> GenRangeExpr e) -> Maybe (CExpr -> GenRangeExpr e)
forall a b. (a -> b) -> a -> b
$ Range2 -> GenRangeExpr e
forall e. Range2 -> GenRangeExpr e
GREPair (Range2 -> GenRangeExpr e)
-> (CExpr -> Range2) -> CExpr -> GenRangeExpr e
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CExpr -> CExpr -> Range2
Range2 CExpr
m
      Token
SymPlusColon -> (CExpr -> GenRangeExpr e) -> Maybe (CExpr -> GenRangeExpr e)
forall a. a -> Maybe a
Just ((CExpr -> GenRangeExpr e) -> Maybe (CExpr -> GenRangeExpr e))
-> (CExpr -> GenRangeExpr e) -> Maybe (CExpr -> GenRangeExpr e)
forall a b. (a -> b) -> a -> b
$ e -> Bool -> CExpr -> GenRangeExpr e
forall e. e -> Bool -> CExpr -> GenRangeExpr e
GREBaseOff e
b Bool
False
      Token
SymDashColon -> (CExpr -> GenRangeExpr e) -> Maybe (CExpr -> GenRangeExpr e)
forall a. a -> Maybe a
Just ((CExpr -> GenRangeExpr e) -> Maybe (CExpr -> GenRangeExpr e))
-> (CExpr -> GenRangeExpr e) -> Maybe (CExpr -> GenRangeExpr e)
forall a b. (a -> b) -> a -> b
$ e -> Bool -> CExpr -> GenRangeExpr e
forall e. e -> Bool -> CExpr -> GenRangeExpr e
GREBaseOff e
b Bool
True
      Token
_ -> Maybe (CExpr -> GenRangeExpr e)
forall a. Maybe a
Nothing
    Parser (GenRangeExpr e)
-> ((CExpr -> GenRangeExpr e) -> Parser (GenRangeExpr e))
-> Maybe (CExpr -> GenRangeExpr e)
-> Parser (GenRangeExpr e)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (GenRangeExpr e -> Parser (GenRangeExpr e)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (GenRangeExpr e -> Parser (GenRangeExpr e))
-> GenRangeExpr e -> Parser (GenRangeExpr e)
forall a b. (a -> b) -> a -> b
$ e -> GenRangeExpr e
forall e. e -> GenRangeExpr e
GRESingle e
b) (((CExpr -> GenRangeExpr e)
 -> Parser CExpr -> Parser (GenRangeExpr e))
-> Parser CExpr
-> (CExpr -> GenRangeExpr e)
-> Parser (GenRangeExpr e)
forall a b c. (a -> b -> c) -> b -> a -> c
flip (CExpr -> GenRangeExpr e)
-> Parser CExpr -> Parser (GenRangeExpr e)
forall a b.
(a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Parser CExpr
constExpr) Maybe (CExpr -> GenRangeExpr e)
f

constRangeExpr :: Parser (CRangeExpr)
constRangeExpr :: ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
constRangeExpr = Parser CExpr
-> (CExpr -> Maybe CExpr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
forall e. Parser e -> (e -> Maybe CExpr) -> Parser (GenRangeExpr e)
genRangeExpr Parser CExpr
constExpr CExpr -> Maybe CExpr
forall a. a -> Maybe a
Just

-- | Specify terminal
specTerm :: Parser SpecTerm
specTerm :: Parser SpecTerm
specTerm = Identifier -> Maybe CRangeExpr -> SpecTerm
SpecTerm (Identifier -> Maybe CRangeExpr -> SpecTerm)
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe CRangeExpr -> SpecTerm)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe CRangeExpr -> SpecTerm)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
-> Parser SpecTerm
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
constRangeExpr

-- | Reference and constant minimum typical maximum
cmtmRef :: Parser (Identified (Maybe CMinTypMax))
cmtmRef :: Parser (Identified (Maybe (GenMinTypMax CExpr)))
cmtmRef = Identifier
-> Maybe (GenMinTypMax CExpr)
-> Identified (Maybe (GenMinTypMax CExpr))
forall t. Identifier -> t -> Identified t
Identified (Identifier
 -> Maybe (GenMinTypMax CExpr)
 -> Identified (Maybe (GenMinTypMax CExpr)))
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (GenMinTypMax CExpr)
      -> Identified (Maybe (GenMinTypMax CExpr)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe (GenMinTypMax CExpr)
   -> Identified (Maybe (GenMinTypMax CExpr)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (GenMinTypMax CExpr))
-> Parser (Identified (Maybe (GenMinTypMax CExpr)))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT
  [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (GenMinTypMax CExpr))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT
  [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a. Parser a -> Parser a
brackets (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a b. (a -> b) -> a -> b
$ Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser CExpr
constExpr)

-- | Sized reference
instName :: Parser InstanceName
instName :: Parser InstanceName
instName = Identifier -> Maybe Range2 -> InstanceName
InstanceName (Identifier -> Maybe Range2 -> InstanceName)
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe Range2 -> InstanceName)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe Range2 -> InstanceName)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Range2)
-> Parser InstanceName
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Range2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Range2)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Range2
range2

-- | Signedness and range, both optional
signRange :: Parser SignRange
signRange :: Parser SignRange
signRange = Bool -> Maybe Range2 -> SignRange
SignRange (Bool -> Maybe Range2 -> SignRange)
-> Parser Bool
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe Range2 -> SignRange)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Parser Bool
optConsume Token
KWSigned ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe Range2 -> SignRange)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Range2)
-> Parser SignRange
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Range2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Range2)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Range2
range2

-- | Index for each dimension then bit range
genDimRange :: Parser e -> (e -> Maybe CExpr) -> Parser (Maybe (GenDimRange e))
genDimRange :: forall e.
Parser e -> (e -> Maybe CExpr) -> Parser (Maybe (GenDimRange e))
genDimRange Parser e
pe e -> Maybe CExpr
constf = do
  [GenRangeExpr e]
l <- ParsecT [PosToken] LocalCompDir (Writer [String]) (GenRangeExpr e)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenRangeExpr e]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT [PosToken] LocalCompDir (Writer [String]) (GenRangeExpr e)
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) [GenRangeExpr e])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenRangeExpr e)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [GenRangeExpr e]
forall a b. (a -> b) -> a -> b
$ Parser e
-> (e -> Maybe CExpr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenRangeExpr e)
forall e. Parser e -> (e -> Maybe CExpr) -> Parser (GenRangeExpr e)
genRangeExpr Parser e
pe e -> Maybe CExpr
constf
  case [GenRangeExpr e]
l of
    [] -> Maybe (GenDimRange e) -> Parser (Maybe (GenDimRange e))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (GenDimRange e)
forall a. Maybe a
Nothing
    GenRangeExpr e
h : [GenRangeExpr e]
t ->
      Parser (Maybe (GenDimRange e))
-> ((GenRangeExpr e, [e]) -> Parser (Maybe (GenDimRange e)))
-> Maybe (GenRangeExpr e, [e])
-> Parser (Maybe (GenDimRange e))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
        (String -> Parser (Maybe (GenDimRange e))
forall a. String -> Parser a
hardfail String
"Only the last bracketed expression is allowed to be a range")
        (Maybe (GenDimRange e) -> Parser (Maybe (GenDimRange e))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe (GenDimRange e) -> Parser (Maybe (GenDimRange e)))
-> ((GenRangeExpr e, [e]) -> Maybe (GenDimRange e))
-> (GenRangeExpr e, [e])
-> Parser (Maybe (GenDimRange e))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenDimRange e -> Maybe (GenDimRange e)
forall a. a -> Maybe a
Just (GenDimRange e -> Maybe (GenDimRange e))
-> ((GenRangeExpr e, [e]) -> GenDimRange e)
-> (GenRangeExpr e, [e])
-> Maybe (GenDimRange e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GenRangeExpr e -> [e] -> GenDimRange e)
-> (GenRangeExpr e, [e]) -> GenDimRange e
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (([e] -> GenRangeExpr e -> GenDimRange e)
-> GenRangeExpr e -> [e] -> GenDimRange e
forall a b c. (a -> b -> c) -> b -> a -> c
flip [e] -> GenRangeExpr e -> GenDimRange e
forall e. [e] -> GenRangeExpr e -> GenDimRange e
GenDimRange))
        (Maybe (GenRangeExpr e, [e]) -> Parser (Maybe (GenDimRange e)))
-> Maybe (GenRangeExpr e, [e]) -> Parser (Maybe (GenDimRange e))
forall a b. (a -> b) -> a -> b
$ (GenRangeExpr e -> Maybe (GenRangeExpr e, [e]))
-> (GenRangeExpr e
    -> (GenRangeExpr e, [e]) -> Maybe (GenRangeExpr e, [e]))
-> NonEmpty (GenRangeExpr e)
-> Maybe (GenRangeExpr e, [e])
forall (m :: * -> *) a b.
(Applicative m, Monad m) =>
(a -> m b) -> (a -> b -> m b) -> NonEmpty a -> m b
foldrMapM1
          (\GenRangeExpr e
x -> (GenRangeExpr e, [e]) -> Maybe (GenRangeExpr e, [e])
forall a. a -> Maybe a
Just (GenRangeExpr e
x, []))
          (\GenRangeExpr e
x (GenRangeExpr e
y, [e]
t) -> (,) GenRangeExpr e
y ([e] -> (GenRangeExpr e, [e]))
-> (e -> [e]) -> e -> (GenRangeExpr e, [e])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> [e] -> [e]
forall a. a -> [a] -> [a]
: [e]
t) (e -> (GenRangeExpr e, [e]))
-> Maybe e -> Maybe (GenRangeExpr e, [e])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> case GenRangeExpr e
x of GRESingle e
e -> e -> Maybe e
forall a. a -> Maybe a
Just e
e; GenRangeExpr e
_ -> Maybe e
forall a. Maybe a
Nothing)
          (GenRangeExpr e
h GenRangeExpr e -> [GenRangeExpr e] -> NonEmpty (GenRangeExpr e)
forall a. a -> [a] -> NonEmpty a
:| [GenRangeExpr e]
t)

dimRange :: Parser (Maybe DimRange)
dimRange :: Parser (Maybe DimRange)
dimRange = Parser Expr -> (Expr -> Maybe CExpr) -> Parser (Maybe DimRange)
forall e.
Parser e -> (e -> Maybe CExpr) -> Parser (Maybe (GenDimRange e))
genDimRange Parser Expr
expr Expr -> Maybe CExpr
constifyExpr

constDimRange :: Parser (Maybe CDimRange)
constDimRange :: Parser (Maybe CDimRange)
constDimRange = Parser CExpr -> (CExpr -> Maybe CExpr) -> Parser (Maybe CDimRange)
forall e.
Parser e -> (e -> Maybe CExpr) -> Parser (Maybe (GenDimRange e))
genDimRange Parser CExpr
constExpr CExpr -> Maybe CExpr
forall a. a -> Maybe a
Just

-- | Hierarchical identifier
trHierIdent :: Bool -> B.ByteString -> Parser HierIdent
trHierIdent :: Bool -> ByteString -> Parser HierIdent
trHierIdent Bool
safety ByteString
s = do
  [(Maybe CExpr, Identifier)]
l <- ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr, Identifier)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [(Maybe CExpr, Identifier)]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr, Identifier)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      [(Maybe CExpr, Identifier)])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr, Identifier)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [(Maybe CExpr, Identifier)]
forall a b. (a -> b) -> a -> b
$
    ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr, Identifier)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f (a, b)
mkpair
      ((if Bool
safety then ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try else ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall a. a -> a
id) (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall a b. (a -> b) -> a -> b
$ Parser CExpr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser CExpr -> Parser CExpr
forall a. Parser a -> Parser a
brackets Parser CExpr
constExpr) ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymDot)
      Parser Identifier
ident
  HierIdent -> Parser HierIdent
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (HierIdent -> Parser HierIdent) -> HierIdent -> Parser HierIdent
forall a b. (a -> b) -> a -> b
$
    ([(Identifier, Maybe CExpr)]
 -> Identity [(Identifier, Maybe CExpr)])
-> HierIdent -> Identity HierIdent
Lens' HierIdent [(Identifier, Maybe CExpr)]
hiPath (([(Identifier, Maybe CExpr)]
  -> Identity [(Identifier, Maybe CExpr)])
 -> HierIdent -> Identity HierIdent)
-> ([(Identifier, Maybe CExpr)] -> [(Identifier, Maybe CExpr)])
-> HierIdent
-> HierIdent
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ [(Identifier, Maybe CExpr)] -> [(Identifier, Maybe CExpr)]
forall a. [a] -> [a]
reverse (HierIdent -> HierIdent) -> HierIdent -> HierIdent
forall a b. (a -> b) -> a -> b
$ 
      (HierIdent -> (Maybe CExpr, Identifier) -> HierIdent)
-> HierIdent -> [(Maybe CExpr, Identifier)] -> HierIdent
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl'
        (\(HierIdent [(Identifier, Maybe CExpr)]
p Identifier
i) (Maybe CExpr
index, Identifier
ss) -> [(Identifier, Maybe CExpr)] -> Identifier -> HierIdent
HierIdent ((Identifier
i, Maybe CExpr
index) (Identifier, Maybe CExpr)
-> [(Identifier, Maybe CExpr)] -> [(Identifier, Maybe CExpr)]
forall a. a -> [a] -> [a]
: [(Identifier, Maybe CExpr)]
p) Identifier
ss)
        ([(Identifier, Maybe CExpr)] -> Identifier -> HierIdent
HierIdent [] (Identifier -> HierIdent) -> Identifier -> HierIdent
forall a b. (a -> b) -> a -> b
$ ByteString -> Identifier
Identifier ByteString
s)
        [(Maybe CExpr, Identifier)]
l

hierIdent :: Bool -> Parser HierIdent
hierIdent :: Bool -> Parser HierIdent
hierIdent Bool
safety = Parser ByteString
parseBS Parser ByteString
-> (ByteString -> Parser HierIdent) -> Parser HierIdent
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Bool -> ByteString -> Parser HierIdent
trHierIdent Bool
safety

-- | Lvalues
lval :: Parser (Maybe dr) -> Parser (LValue dr)
lval :: forall dr. Parser (Maybe dr) -> Parser (LValue dr)
lval Parser (Maybe dr)
p = NonEmpty (LValue dr) -> LValue dr
forall dr. NonEmpty (LValue dr) -> LValue dr
LVConcat (NonEmpty (LValue dr) -> LValue dr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty (LValue dr))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (LValue dr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [PosToken] LocalCompDir (Writer [String]) (LValue dr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty (LValue dr))
forall a. Parser a -> Parser (NonEmpty a)
bcsl1 (Parser (Maybe dr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (LValue dr)
forall dr. Parser (Maybe dr) -> Parser (LValue dr)
lval Parser (Maybe dr)
p) ParsecT [PosToken] LocalCompDir (Writer [String]) (LValue dr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (LValue dr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (LValue dr)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (HierIdent -> Maybe dr -> LValue dr)
-> Parser HierIdent
-> Parser (Maybe dr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (LValue dr)
forall a b c.
(a -> b -> c)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 HierIdent -> Maybe dr -> LValue dr
forall dr. HierIdent -> Maybe dr -> LValue dr
LVSingle (Bool -> Parser HierIdent
hierIdent Bool
True) Parser (Maybe dr)
p

netLV :: Parser NetLValue
netLV :: Parser NetLValue
netLV = Parser (Maybe CDimRange) -> Parser NetLValue
forall dr. Parser (Maybe dr) -> Parser (LValue dr)
lval Parser (Maybe CDimRange)
constDimRange

varLV :: Parser VarLValue
varLV :: Parser VarLValue
varLV = Parser (Maybe DimRange) -> Parser VarLValue
forall dr. Parser (Maybe dr) -> Parser (LValue dr)
lval Parser (Maybe DimRange)
dimRange

-- | Assignments
varAssign :: Parser VarAssign
varAssign :: Parser VarAssign
varAssign = VarLValue -> Expr -> VarAssign
forall dr. LValue dr -> Expr -> Assign dr
Assign (VarLValue -> Expr -> VarAssign)
-> Parser VarLValue
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Expr -> VarAssign)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VarLValue
varLV ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Expr -> VarAssign)
-> Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Expr -> VarAssign)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymEq ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Expr -> VarAssign)
-> Parser Expr -> Parser VarAssign
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
expr

-- | Common abtract types for variables, parameters, functions and tasks
abstractType :: Parser AbsType
abstractType :: Parser AbsType
abstractType = (Token -> Maybe AbsType) -> Parser AbsType
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe AbsType) -> Parser AbsType)
-> (Token -> Maybe AbsType) -> Parser AbsType
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
  Token
KWInteger -> AbsType -> Maybe AbsType
forall a. a -> Maybe a
Just AbsType
ATInteger
  Token
KWReal -> AbsType -> Maybe AbsType
forall a. a -> Maybe a
Just AbsType
ATReal
  Token
KWRealtime -> AbsType -> Maybe AbsType
forall a. a -> Maybe a
Just AbsType
ATRealtime
  Token
KWTime -> AbsType -> Maybe AbsType
forall a. a -> Maybe a
Just AbsType
ATTime
  Token
_ -> Maybe AbsType
forall a. Maybe a
Nothing

-- | Common types for variables, parameters, functions and tasks
comType :: Parser t -> Parser (ComType t)
comType :: forall t. Parser t -> Parser (ComType t)
comType Parser t
p = AbsType -> ComType t
forall t. AbsType -> ComType t
CTAbstract (AbsType -> ComType t)
-> Parser AbsType
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (ComType t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser AbsType
abstractType ParsecT [PosToken] LocalCompDir (Writer [String]) (ComType t)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (ComType t)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (ComType t)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> t -> SignRange -> ComType t
forall t. t -> SignRange -> ComType t
CTConcrete (t -> SignRange -> ComType t)
-> Parser t
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (SignRange -> ComType t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser t
p ParsecT
  [PosToken] LocalCompDir (Writer [String]) (SignRange -> ComType t)
-> Parser SignRange
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (ComType t)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SignRange
signRange

-- | Net types
netType :: LProduce NetType
netType :: LProduce NetType
netType =
  [ (Token
KWSupply0, NetType
NTSupply0),
    (Token
KWSupply1, NetType
NTSupply1),
    (Token
KWTri, NetType
NTTri),
    (Token
KWTriand, NetType
NTTriAnd),
    (Token
KWTrior, NetType
NTTriOr),
    (Token
KWTri0, NetType
NTTri0),
    (Token
KWTri1, NetType
NTTri1),
    (Token
KWUwire, NetType
NTUwire),
    (Token
KWWire, NetType
NTWire),
    (Token
KWWand, NetType
NTWAnd),
    (Token
KWWor, NetType
NTWOr)
  ]

-- | Parses local and nonlocal parameters declarations
trParamDecl :: Bool -> Parser (NonEmpty (Identifier, Parameter))
trParamDecl :: Bool -> Parser (NonEmpty (Identifier, Parameter))
trParamDecl Bool
safety = do
  ComType ()
t <- Parser () -> Parser (ComType ())
forall t. Parser t -> Parser (ComType t)
comType (Parser () -> Parser (ComType ()))
-> Parser () -> Parser (ComType ())
forall a b. (a -> b) -> a -> b
$ () -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
  Bool
-> Parser Identifier
-> (Identifier -> Parser (Identifier, Parameter))
-> Parser (NonEmpty (Identifier, Parameter))
forall a b.
Bool -> Parser a -> (a -> Parser b) -> Parser (NonEmpty b)
scsl1 Bool
safety Parser Identifier
ident ((Identifier -> Parser (Identifier, Parameter))
 -> Parser (NonEmpty (Identifier, Parameter)))
-> (Identifier -> Parser (Identifier, Parameter))
-> Parser (NonEmpty (Identifier, Parameter))
forall a b. (a -> b) -> a -> b
$ \Identifier
s -> Token -> Parser ()
consume Token
SymEq Parser ()
-> Parser (Identifier, Parameter) -> Parser (Identifier, Parameter)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (,) Identifier
s (Parameter -> (Identifier, Parameter))
-> (GenMinTypMax CExpr -> Parameter)
-> GenMinTypMax CExpr
-> (Identifier, Parameter)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ComType () -> GenMinTypMax CExpr -> Parameter
Parameter ComType ()
t (GenMinTypMax CExpr -> (Identifier, Parameter))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> Parser (Identifier, Parameter)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser CExpr
constExpr

paramDecl :: Bool -> Parser (NonEmpty (Identifier, Parameter))
paramDecl :: Bool -> Parser (NonEmpty (Identifier, Parameter))
paramDecl Bool
b = Bool -> Parser (NonEmpty (Identifier, Parameter))
trParamDecl Bool
b Parser (NonEmpty (Identifier, Parameter))
-> Parser () -> Parser (NonEmpty (Identifier, Parameter))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi

-- | Function and task input arguments
funArgDecl :: Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl ())))
funArgDecl :: Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl ())))
funArgDecl Bool
safety =
  [ ( Token
KWInput,
      \Attributes
a -> do
        ComType Bool
kind <- Parser Bool -> Parser (ComType Bool)
forall t. Parser t -> Parser (ComType t)
comType (Parser Bool -> Parser (ComType Bool))
-> Parser Bool -> Parser (ComType Bool)
forall a b. (a -> b) -> a -> b
$ Token -> Parser Bool
optConsume Token
KWReg
        Bool
-> Parser Identifier
-> (Identifier -> Parser (AttrIded (TFBlockDecl ())))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl ())))
forall a b.
Bool -> Parser a -> (a -> Parser b) -> Parser (NonEmpty b)
scsl1 Bool
safety Parser Identifier
ident (\Identifier
s -> AttrIded (TFBlockDecl ()) -> Parser (AttrIded (TFBlockDecl ()))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (AttrIded (TFBlockDecl ()) -> Parser (AttrIded (TFBlockDecl ())))
-> AttrIded (TFBlockDecl ()) -> Parser (AttrIded (TFBlockDecl ()))
forall a b. (a -> b) -> a -> b
$ Attributes
-> Identifier -> TFBlockDecl () -> AttrIded (TFBlockDecl ())
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
a Identifier
s (TFBlockDecl () -> AttrIded (TFBlockDecl ()))
-> TFBlockDecl () -> AttrIded (TFBlockDecl ())
forall a b. (a -> b) -> a -> b
$ () -> ComType Bool -> TFBlockDecl ()
forall t. t -> ComType Bool -> TFBlockDecl t
TFBDPort () ComType Bool
kind)
    )
  ]

taskArgDecl :: Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl Dir)))
taskArgDecl :: Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl Dir)))
taskArgDecl Bool
safety =
  [ (Token
KWInput, Dir
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl Dir)))
forall {t}.
t
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl t)))
pp Dir
DirIn),
    (Token
KWInout, Dir
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl Dir)))
forall {t}.
t
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl t)))
pp Dir
DirInOut),
    (Token
KWOutput, Dir
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl Dir)))
forall {t}.
t
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl t)))
pp Dir
DirOut)
  ]
  where
    pp :: t
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl t)))
pp t
dir Attributes
a = do
      ComType Bool
kind <- Parser Bool -> Parser (ComType Bool)
forall t. Parser t -> Parser (ComType t)
comType (Parser Bool -> Parser (ComType Bool))
-> Parser Bool -> Parser (ComType Bool)
forall a b. (a -> b) -> a -> b
$ Token -> Parser Bool
optConsume Token
KWReg
      Bool
-> Parser Identifier
-> (Identifier -> Parser (AttrIded (TFBlockDecl t)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl t)))
forall a b.
Bool -> Parser a -> (a -> Parser b) -> Parser (NonEmpty b)
scsl1 Bool
safety Parser Identifier
ident (\Identifier
s -> AttrIded (TFBlockDecl t) -> Parser (AttrIded (TFBlockDecl t))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (AttrIded (TFBlockDecl t) -> Parser (AttrIded (TFBlockDecl t)))
-> AttrIded (TFBlockDecl t) -> Parser (AttrIded (TFBlockDecl t))
forall a b. (a -> b) -> a -> b
$ Attributes
-> Identifier -> TFBlockDecl t -> AttrIded (TFBlockDecl t)
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
a Identifier
s (TFBlockDecl t -> AttrIded (TFBlockDecl t))
-> TFBlockDecl t -> AttrIded (TFBlockDecl t)
forall a b. (a -> b) -> a -> b
$ t -> ComType Bool -> TFBlockDecl t
forall t. t -> ComType Bool -> TFBlockDecl t
TFBDPort t
dir ComType Bool
kind)

-- | Delay1/2/3
delayCom :: Parser NumIdent
delayCom :: Parser NumIdent
delayCom = (Token -> Maybe NumIdent) -> Parser NumIdent
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe NumIdent) -> Parser NumIdent)
-> (Token -> Maybe NumIdent) -> Parser NumIdent
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
  LitDecimal Natural
i -> NumIdent -> Maybe NumIdent
forall a. a -> Maybe a
Just (NumIdent -> Maybe NumIdent) -> NumIdent -> Maybe NumIdent
forall a b. (a -> b) -> a -> b
$ Natural -> NumIdent
NINumber Natural
i
  LitReal ByteString
s -> NumIdent -> Maybe NumIdent
forall a. a -> Maybe a
Just (NumIdent -> Maybe NumIdent) -> NumIdent -> Maybe NumIdent
forall a b. (a -> b) -> a -> b
$ ByteString -> NumIdent
NIReal ByteString
s
  IdSimple ByteString
s -> NumIdent -> Maybe NumIdent
forall a. a -> Maybe a
Just (NumIdent -> Maybe NumIdent) -> NumIdent -> Maybe NumIdent
forall a b. (a -> b) -> a -> b
$ Identifier -> NumIdent
NIIdent (Identifier -> NumIdent) -> Identifier -> NumIdent
forall a b. (a -> b) -> a -> b
$ ByteString -> Identifier
Identifier ByteString
s
  IdEscaped ByteString
s -> NumIdent -> Maybe NumIdent
forall a. a -> Maybe a
Just (NumIdent -> Maybe NumIdent) -> NumIdent -> Maybe NumIdent
forall a b. (a -> b) -> a -> b
$ Identifier -> NumIdent
NIIdent (Identifier -> NumIdent) -> Identifier -> NumIdent
forall a b. (a -> b) -> a -> b
$ ByteString -> Identifier
Identifier ByteString
s
  Token
_ -> Maybe NumIdent
forall a. Maybe a
Nothing

delay1 :: Parser Delay1
delay1 :: Parser Delay1
delay1 = NumIdent -> Delay1
D1Base (NumIdent -> Delay1) -> Parser NumIdent -> Parser Delay1
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NumIdent
delayCom Parser Delay1 -> Parser Delay1 -> Parser Delay1
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> GenMinTypMax Expr -> Delay1
D11 (GenMinTypMax Expr -> Delay1)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> Parser Delay1
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser a
parens (Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser Expr
expr)

delay2 :: Parser Delay2
delay2 :: Parser Delay2
delay2 = do
  Token -> Parser ()
consume Token
SymPound
  NumIdent -> Delay2
D2Base (NumIdent -> Delay2) -> Parser NumIdent -> Parser Delay2
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NumIdent
delayCom
    Parser Delay2 -> Parser Delay2 -> Parser Delay2
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser Delay2 -> Parser Delay2
forall a. Parser a -> Parser a
parens (Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser Expr
expr ParsecT
  [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> (GenMinTypMax Expr -> Parser Delay2) -> Parser Delay2
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \GenMinTypMax Expr
a -> Delay2 -> Parser Delay2 -> Parser Delay2
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option (GenMinTypMax Expr -> Delay2
D21 GenMinTypMax Expr
a) (Parser Delay2 -> Parser Delay2) -> Parser Delay2 -> Parser Delay2
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymComma Parser () -> Parser Delay2 -> Parser Delay2
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> GenMinTypMax Expr -> GenMinTypMax Expr -> Delay2
D22 GenMinTypMax Expr
a (GenMinTypMax Expr -> Delay2)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> Parser Delay2
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser Expr
expr)

delay3 :: Parser Delay3
delay3 :: Parser Delay3
delay3 = do
  Token -> Parser ()
consume Token
SymPound
  NumIdent -> Delay3
D3Base (NumIdent -> Delay3) -> Parser NumIdent -> Parser Delay3
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NumIdent
delayCom Parser Delay3 -> Parser Delay3 -> Parser Delay3
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
    NonEmpty (GenMinTypMax Expr)
l <- ParsecT
  [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> Parser (NonEmpty (GenMinTypMax Expr))
forall a. Parser a -> Parser (NonEmpty a)
pcsl1 (Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser Expr
expr)
    case NonEmpty (GenMinTypMax Expr)
l of
      [Item (NonEmpty (GenMinTypMax Expr))
a] -> Delay3 -> Parser Delay3
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Delay3 -> Parser Delay3) -> Delay3 -> Parser Delay3
forall a b. (a -> b) -> a -> b
$ GenMinTypMax Expr -> Delay3
D31 Item (NonEmpty (GenMinTypMax Expr))
GenMinTypMax Expr
a
      [Item (NonEmpty (GenMinTypMax Expr))
a, Item (NonEmpty (GenMinTypMax Expr))
b] -> Delay3 -> Parser Delay3
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Delay3 -> Parser Delay3) -> Delay3 -> Parser Delay3
forall a b. (a -> b) -> a -> b
$ GenMinTypMax Expr -> GenMinTypMax Expr -> Delay3
D32 Item (NonEmpty (GenMinTypMax Expr))
GenMinTypMax Expr
a Item (NonEmpty (GenMinTypMax Expr))
GenMinTypMax Expr
b
      [Item (NonEmpty (GenMinTypMax Expr))
a, Item (NonEmpty (GenMinTypMax Expr))
b, Item (NonEmpty (GenMinTypMax Expr))
c] -> Delay3 -> Parser Delay3
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Delay3 -> Parser Delay3) -> Delay3 -> Parser Delay3
forall a b. (a -> b) -> a -> b
$ GenMinTypMax Expr
-> GenMinTypMax Expr -> GenMinTypMax Expr -> Delay3
D33 Item (NonEmpty (GenMinTypMax Expr))
GenMinTypMax Expr
a Item (NonEmpty (GenMinTypMax Expr))
GenMinTypMax Expr
b Item (NonEmpty (GenMinTypMax Expr))
GenMinTypMax Expr
c
      NonEmpty (GenMinTypMax Expr)
_ -> String -> Parser Delay3
forall a. String -> Parser a
hardfail String
"A delay cannot have more than 3 elemets"

-- | Drive strength
strength :: Parser (Either Bool (Strength, Bool))
strength :: Parser (Either Bool (Strength, Bool))
strength = (Token -> Maybe (Either Bool (Strength, Bool)))
-> Parser (Either Bool (Strength, Bool))
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe (Either Bool (Strength, Bool)))
 -> Parser (Either Bool (Strength, Bool)))
-> (Token -> Maybe (Either Bool (Strength, Bool)))
-> Parser (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
  Token
KWSupply0 -> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a. a -> Maybe a
Just (Either Bool (Strength, Bool)
 -> Maybe (Either Bool (Strength, Bool)))
-> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ (Strength, Bool) -> Either Bool (Strength, Bool)
forall a b. b -> Either a b
Right (Strength
StrSupply, Bool
False)
  Token
KWSupply1 -> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a. a -> Maybe a
Just (Either Bool (Strength, Bool)
 -> Maybe (Either Bool (Strength, Bool)))
-> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ (Strength, Bool) -> Either Bool (Strength, Bool)
forall a b. b -> Either a b
Right (Strength
StrSupply, Bool
True)
  Token
KWStrong0 -> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a. a -> Maybe a
Just (Either Bool (Strength, Bool)
 -> Maybe (Either Bool (Strength, Bool)))
-> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ (Strength, Bool) -> Either Bool (Strength, Bool)
forall a b. b -> Either a b
Right (Strength
StrStrong, Bool
False)
  Token
KWStrong1 -> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a. a -> Maybe a
Just (Either Bool (Strength, Bool)
 -> Maybe (Either Bool (Strength, Bool)))
-> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ (Strength, Bool) -> Either Bool (Strength, Bool)
forall a b. b -> Either a b
Right (Strength
StrStrong, Bool
True)
  Token
KWPull0 -> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a. a -> Maybe a
Just (Either Bool (Strength, Bool)
 -> Maybe (Either Bool (Strength, Bool)))
-> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ (Strength, Bool) -> Either Bool (Strength, Bool)
forall a b. b -> Either a b
Right (Strength
StrPull, Bool
False)
  Token
KWPull1 -> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a. a -> Maybe a
Just (Either Bool (Strength, Bool)
 -> Maybe (Either Bool (Strength, Bool)))
-> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ (Strength, Bool) -> Either Bool (Strength, Bool)
forall a b. b -> Either a b
Right (Strength
StrPull, Bool
True)
  Token
KWWeak0 -> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a. a -> Maybe a
Just (Either Bool (Strength, Bool)
 -> Maybe (Either Bool (Strength, Bool)))
-> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ (Strength, Bool) -> Either Bool (Strength, Bool)
forall a b. b -> Either a b
Right (Strength
StrWeak, Bool
False)
  Token
KWWeak1 -> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a. a -> Maybe a
Just (Either Bool (Strength, Bool)
 -> Maybe (Either Bool (Strength, Bool)))
-> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ (Strength, Bool) -> Either Bool (Strength, Bool)
forall a b. b -> Either a b
Right (Strength
StrWeak, Bool
True)
  Token
KWHighz0 -> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a. a -> Maybe a
Just (Either Bool (Strength, Bool)
 -> Maybe (Either Bool (Strength, Bool)))
-> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ Bool -> Either Bool (Strength, Bool)
forall a b. a -> Either a b
Left Bool
False
  Token
KWHighz1 -> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a. a -> Maybe a
Just (Either Bool (Strength, Bool)
 -> Maybe (Either Bool (Strength, Bool)))
-> Either Bool (Strength, Bool)
-> Maybe (Either Bool (Strength, Bool))
forall a b. (a -> b) -> a -> b
$ Bool -> Either Bool (Strength, Bool)
forall a b. a -> Either a b
Left Bool
True
  Token
_ -> Maybe (Either Bool (Strength, Bool))
forall a. Maybe a
Nothing

comDriveStrength :: Parser DriveStrength
comDriveStrength :: Parser DriveStrength
comDriveStrength = do
  Either Bool (Strength, Bool)
s1 <- Parser (Either Bool (Strength, Bool))
strength
  Token -> Parser ()
consume Token
SymComma
  Either Bool (Strength, Bool)
s2 <- Parser (Either Bool (Strength, Bool))
strength
  case (Either Bool (Strength, Bool)
s1, Either Bool (Strength, Bool)
s2) of
    (Left Bool
_, Left Bool
_) -> String -> Parser DriveStrength
forall a. String -> Parser a
hardfail String
"Only one of the strength can be high impedence"
    (Left Bool
bl, Right (Strength
s, Bool
br)) ->
      if Bool
bl Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
br
        then String -> Parser DriveStrength
forall a. String -> Parser a
hardfail String
"Both strength must refer to a different value"
        else DriveStrength -> Parser DriveStrength
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return DSHighZ {_dsHZ :: Bool
_dsHZ = Bool
bl, _dsStr :: Strength
_dsStr = Strength
s}
    (Right (Strength
s, Bool
br), Left Bool
bl) ->
      if Bool
bl Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
br
        then String -> Parser DriveStrength
forall a. String -> Parser a
hardfail String
"Both strength must refer to a different value"
        else DriveStrength -> Parser DriveStrength
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return DSHighZ {_dsHZ :: Bool
_dsHZ = Bool
bl, _dsStr :: Strength
_dsStr = Strength
s}
    (Right (Strength
s1, Bool
b1), Right (Strength
s2, Bool
b2)) -> case (Bool
b1, Bool
b2) of
      (Bool
False, Bool
True) -> DriveStrength -> Parser DriveStrength
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return DSNormal {_ds0 :: Strength
_ds0 = Strength
s1, _ds1 :: Strength
_ds1 = Strength
s2}
      (Bool
True, Bool
False) -> DriveStrength -> Parser DriveStrength
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return DSNormal {_ds0 :: Strength
_ds0 = Strength
s2, _ds1 :: Strength
_ds1 = Strength
s1}
      (Bool, Bool)
_ -> String -> Parser DriveStrength
forall a. String -> Parser a
hardfail String
"Both strength must refer to a different value"

driveStrength :: Parser DriveStrength
driveStrength :: Parser DriveStrength
driveStrength = DriveStrength -> Parser DriveStrength -> Parser DriveStrength
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option DriveStrength
dsDefault (Parser DriveStrength -> Parser DriveStrength)
-> Parser DriveStrength -> Parser DriveStrength
forall a b. (a -> b) -> a -> b
$ Parser DriveStrength -> Parser DriveStrength
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Parser DriveStrength -> Parser DriveStrength)
-> Parser DriveStrength -> Parser DriveStrength
forall a b. (a -> b) -> a -> b
$ Parser DriveStrength -> Parser DriveStrength
forall a. Parser a -> Parser a
parens Parser DriveStrength
comDriveStrength

-- | Best effort PATHPULSE parser
pathpulse :: Parser SpecParamDecl
pathpulse :: Parser SpecParamDecl
pathpulse = do
  ByteString
imid <- (Token -> Maybe ByteString) -> Parser ByteString
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe ByteString) -> Parser ByteString)
-> (Token -> Maybe ByteString) -> Parser ByteString
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of TknPP ByteString
s -> ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
s; Token
_ -> Maybe ByteString
forall a. Maybe a
Nothing
  Maybe ByteString
miid <- if ByteString -> Bool
B.null ByteString
imid then Parser ByteString
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe ByteString)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser ByteString
parseBS else Maybe ByteString
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe ByteString)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe ByteString
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (Maybe ByteString))
-> Maybe ByteString
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe ByteString)
forall a b. (a -> b) -> a -> b
$ ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
imid
  Either (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)
c0 <- case Maybe ByteString
miid of
    Maybe ByteString
Nothing -> Either (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Either
         (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)))
-> Either
     (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr))
forall a b. (a -> b) -> a -> b
$ Maybe (SpecTerm, SpecTerm)
-> Either
     (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)
forall a b. a -> Either a b
Left Maybe (SpecTerm, SpecTerm)
forall a. Maybe a
Nothing
    Just ByteString
iid -> do
      Maybe CRangeExpr
irng <- ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
pMRE
      let ist :: SpecTerm
ist = Identifier -> Maybe CRangeExpr -> SpecTerm
SpecTerm (ByteString -> Identifier
Identifier ByteString
iid) Maybe CRangeExpr
irng
      Either (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr))
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option ((ByteString, Maybe CRangeExpr)
-> Either
     (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)
forall a b. b -> Either a b
Right (ByteString
iid, Maybe CRangeExpr
irng)) (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (Either
      (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr))
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Either
         (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr))
forall a b. (a -> b) -> a -> b
$ Maybe (SpecTerm, SpecTerm)
-> Either
     (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)
forall a b. a -> Either a b
Left (Maybe (SpecTerm, SpecTerm)
 -> Either
      (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr))
-> (SpecTerm -> Maybe (SpecTerm, SpecTerm))
-> SpecTerm
-> Either
     (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SpecTerm, SpecTerm) -> Maybe (SpecTerm, SpecTerm)
forall a. a -> Maybe a
Just ((SpecTerm, SpecTerm) -> Maybe (SpecTerm, SpecTerm))
-> (SpecTerm -> (SpecTerm, SpecTerm))
-> SpecTerm
-> Maybe (SpecTerm, SpecTerm)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) SpecTerm
ist (SpecTerm
 -> Either
      (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr))
-> Parser SpecTerm
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Token -> Maybe (Parser SpecTerm)) -> Parser SpecTerm
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch
        ( \Token
t -> case Token
t of
            Token
SymDollar -> Parser SpecTerm -> Maybe (Parser SpecTerm)
forall a. a -> Maybe a
Just (Parser SpecTerm -> Maybe (Parser SpecTerm))
-> Parser SpecTerm -> Maybe (Parser SpecTerm)
forall a b. (a -> b) -> a -> b
$ Parser SpecTerm
specTerm
            IdSystem ByteString
s -> Parser SpecTerm -> Maybe (Parser SpecTerm)
forall a. a -> Maybe a
Just (Parser SpecTerm -> Maybe (Parser SpecTerm))
-> Parser SpecTerm -> Maybe (Parser SpecTerm)
forall a b. (a -> b) -> a -> b
$ Identifier -> Maybe CRangeExpr -> SpecTerm
SpecTerm (ByteString -> Identifier
Identifier ByteString
s) (Maybe CRangeExpr -> SpecTerm)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
-> Parser SpecTerm
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
pMRE
            Token
_ -> Maybe (Parser SpecTerm)
forall a. Maybe a
Nothing
        )
  Either
  (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
c1 <- case Either (Maybe (SpecTerm, SpecTerm)) (ByteString, Maybe CRangeExpr)
c0 of
    Left Maybe (SpecTerm, SpecTerm)
x -> Either
  (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either
   (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Either
         (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])))
-> Either
     (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
forall a b. (a -> b) -> a -> b
$ Maybe (SpecTerm, SpecTerm)
-> Either
     (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
forall a b. a -> Either a b
Left Maybe (SpecTerm, SpecTerm)
x
    Right (ByteString
iid, Maybe CRangeExpr
irng) -> case [ByteString] -> [ByteString]
forall a. [a] -> [a]
reverse ([ByteString] -> [ByteString]) -> [ByteString] -> [ByteString]
forall a b. (a -> b) -> a -> b
$ Word8 -> ByteString -> [ByteString]
B.split (Char -> Word8
c2w Char
'$') ByteString
iid of
      [Item [ByteString]
_] -> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Either
     (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
forall {a}. ParsecT [PosToken] LocalCompDir (Writer [String]) a
failure
      ByteString
h : [ByteString]
t | ByteString -> Bool
B.null ByteString
h Bool -> Bool -> Bool
&& Maybe CRangeExpr
irng Maybe CRangeExpr -> Maybe CRangeExpr -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe CRangeExpr
forall a. Maybe a
Nothing ->
        Maybe (SpecTerm, SpecTerm)
-> Either
     (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
forall a b. a -> Either a b
Left (Maybe (SpecTerm, SpecTerm)
 -> Either
      (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
-> (SpecTerm -> Maybe (SpecTerm, SpecTerm))
-> SpecTerm
-> Either
     (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SpecTerm, SpecTerm) -> Maybe (SpecTerm, SpecTerm)
forall a. a -> Maybe a
Just ((SpecTerm, SpecTerm) -> Maybe (SpecTerm, SpecTerm))
-> (SpecTerm -> (SpecTerm, SpecTerm))
-> SpecTerm
-> Maybe (SpecTerm, SpecTerm)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) (Identifier -> Maybe CRangeExpr -> SpecTerm
SpecTerm (ByteString -> Identifier
Identifier (ByteString -> Identifier) -> ByteString -> Identifier
forall a b. (a -> b) -> a -> b
$ [ByteString] -> ByteString
restore_id [ByteString]
t) Maybe CRangeExpr
forall a. Maybe a
Nothing) (SpecTerm
 -> Either
      (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
-> Parser SpecTerm
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SpecTerm
specTerm
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Either
     (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Either
  (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Maybe CRangeExpr, [ByteString])
-> Either
     (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
forall a b. b -> Either a b
Right (Maybe CRangeExpr
irng, ByteString
h ByteString -> [ByteString] -> [ByteString]
forall a. a -> [a] -> [a]
: [ByteString]
t))
      [ByteString]
l -> Either
  (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either
   (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Either
         (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])))
-> Either
     (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either
        (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString]))
forall a b. (a -> b) -> a -> b
$ (Maybe CRangeExpr, [ByteString])
-> Either
     (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
forall a b. b -> Either a b
Right (Maybe CRangeExpr
irng, [ByteString]
l)
  Maybe (SpecTerm, SpecTerm)
iost <- case Either
  (Maybe (SpecTerm, SpecTerm)) (Maybe CRangeExpr, [ByteString])
c1 of
    Left Maybe (SpecTerm, SpecTerm)
x -> Maybe (SpecTerm, SpecTerm)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (SpecTerm, SpecTerm))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (SpecTerm, SpecTerm)
x
    Right (Maybe CRangeExpr
irng, [ByteString]
l) -> let ([ByteString]
dollar_suffix, [ByteString]
rest) = (ByteString -> Bool)
-> [ByteString] -> ([ByteString], [ByteString])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span ByteString -> Bool
B.null [ByteString]
l in case [ByteString]
rest of
      ByteString
not_dollar : x :: [ByteString]
x@(ByteString
_ : [ByteString]
_) ->
        Maybe (SpecTerm, SpecTerm)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (SpecTerm, SpecTerm))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (SpecTerm, SpecTerm)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe (SpecTerm, SpecTerm)))
-> Maybe (SpecTerm, SpecTerm)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (SpecTerm, SpecTerm))
forall a b. (a -> b) -> a -> b
$
          (SpecTerm, SpecTerm) -> Maybe (SpecTerm, SpecTerm)
forall a. a -> Maybe a
Just
            ( Identifier -> Maybe CRangeExpr -> SpecTerm
SpecTerm (ByteString -> Identifier
Identifier (ByteString -> Identifier) -> ByteString -> Identifier
forall a b. (a -> b) -> a -> b
$ [ByteString] -> ByteString
restore_id ([ByteString] -> ByteString) -> [ByteString] -> ByteString
forall a b. (a -> b) -> a -> b
$ [ByteString]
dollar_suffix [ByteString] -> [ByteString] -> [ByteString]
forall a. Semigroup a => a -> a -> a
<> [Item [ByteString]
ByteString
not_dollar]) Maybe CRangeExpr
forall a. Maybe a
Nothing,
              Identifier -> Maybe CRangeExpr -> SpecTerm
SpecTerm (ByteString -> Identifier
Identifier (ByteString -> Identifier) -> ByteString -> Identifier
forall a b. (a -> b) -> a -> b
$ [ByteString] -> ByteString
restore_id [ByteString]
x) Maybe CRangeExpr
irng
            )
      [ByteString]
_ -> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe (SpecTerm, SpecTerm))
forall {a}. ParsecT [PosToken] LocalCompDir (Writer [String]) a
failure
  Token -> Parser ()
consume Token
SymEq
  Parser SpecParamDecl -> Parser SpecParamDecl
forall a. Parser a -> Parser a
parens (Parser SpecParamDecl -> Parser SpecParamDecl)
-> Parser SpecParamDecl -> Parser SpecParamDecl
forall a b. (a -> b) -> a -> b
$ do
    GenMinTypMax CExpr
rej <- Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser CExpr
constExpr
    GenMinTypMax CExpr
err <- GenMinTypMax CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option GenMinTypMax CExpr
rej (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymComma Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser CExpr
constExpr
    SpecParamDecl -> Parser SpecParamDecl
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (SpecParamDecl -> Parser SpecParamDecl)
-> SpecParamDecl -> Parser SpecParamDecl
forall a b. (a -> b) -> a -> b
$ Maybe (SpecTerm, SpecTerm)
-> GenMinTypMax CExpr -> GenMinTypMax CExpr -> SpecParamDecl
SPDPathPulse Maybe (SpecTerm, SpecTerm)
iost GenMinTypMax CExpr
rej GenMinTypMax CExpr
err
  where
    pMRE :: ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
pMRE = ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
constRangeExpr
    restore_id :: [ByteString] -> ByteString
restore_id = ByteString -> [ByteString] -> ByteString
B.intercalate ByteString
"$" ([ByteString] -> ByteString)
-> ([ByteString] -> [ByteString]) -> [ByteString] -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [ByteString] -> [ByteString]
forall a. [a] -> [a]
reverse
    failure :: ParsecT [PosToken] LocalCompDir (Writer [String]) a
failure = String -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Pathpulse expects two dollar separated specify terminals"

-- | Specify parameter declaration
specParam :: Parser (Maybe Range2, NonEmpty SpecParamDecl)
specParam :: Parser (Maybe Range2, NonEmpty SpecParamDecl)
specParam = do
  ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Range2)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty SpecParamDecl)
-> Parser (Maybe Range2, NonEmpty SpecParamDecl)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f (a, b)
mkpair (Parser Range2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Range2)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Range2
range2) (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (NonEmpty SpecParamDecl)
 -> Parser (Maybe Range2, NonEmpty SpecParamDecl))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty SpecParamDecl)
-> Parser (Maybe Range2, NonEmpty SpecParamDecl)
forall a b. (a -> b) -> a -> b
$
    Parser SpecParamDecl
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty SpecParamDecl)
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Parser SpecParamDecl
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (NonEmpty SpecParamDecl))
-> Parser SpecParamDecl
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty SpecParamDecl)
forall a b. (a -> b) -> a -> b
$ Identifier -> GenMinTypMax CExpr -> SpecParamDecl
SPDAssign (Identifier -> GenMinTypMax CExpr -> SpecParamDecl)
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenMinTypMax CExpr -> SpecParamDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenMinTypMax CExpr -> SpecParamDecl)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenMinTypMax CExpr -> SpecParamDecl)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymEq ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenMinTypMax CExpr -> SpecParamDecl)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> Parser SpecParamDecl
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser CExpr
constExpr Parser SpecParamDecl
-> Parser SpecParamDecl -> Parser SpecParamDecl
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser SpecParamDecl
pathpulse

-- | Event control
eventControl :: Parser EventControl
eventControl :: Parser EventControl
eventControl = (SourcePos -> Token -> Maybe (Parser EventControl))
-> Parser EventControl
forall a. (SourcePos -> Token -> Maybe (Parser a)) -> Parser a
fpbranch ((SourcePos -> Token -> Maybe (Parser EventControl))
 -> Parser EventControl)
-> (SourcePos -> Token -> Maybe (Parser EventControl))
-> Parser EventControl
forall a b. (a -> b) -> a -> b
$ \SourcePos
p Token
t -> case Token
t of
  Token
SymAster -> Parser EventControl -> Maybe (Parser EventControl)
forall a. a -> Maybe a
Just (Parser EventControl -> Maybe (Parser EventControl))
-> Parser EventControl -> Maybe (Parser EventControl)
forall a b. (a -> b) -> a -> b
$ EventControl -> Parser EventControl
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return EventControl
ECDeps
  Token
SymParenAster -> Parser EventControl -> Maybe (Parser EventControl)
forall a. a -> Maybe a
Just (Parser EventControl -> Maybe (Parser EventControl))
-> Parser EventControl -> Maybe (Parser EventControl)
forall a b. (a -> b) -> a -> b
$ SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
SymParenAster Token
SymParenR Parser () -> Parser EventControl -> Parser EventControl
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> EventControl -> Parser EventControl
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EventControl
ECDeps -- yeah, f*** that
  IdSimple ByteString
s -> Parser EventControl -> Maybe (Parser EventControl)
forall a. a -> Maybe a
Just (Parser EventControl -> Maybe (Parser EventControl))
-> Parser EventControl -> Maybe (Parser EventControl)
forall a b. (a -> b) -> a -> b
$ HierIdent -> EventControl
ECIdent (HierIdent -> EventControl)
-> Parser HierIdent -> Parser EventControl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> ByteString -> Parser HierIdent
trHierIdent Bool
False ByteString
s
  IdEscaped ByteString
s -> Parser EventControl -> Maybe (Parser EventControl)
forall a. a -> Maybe a
Just (Parser EventControl -> Maybe (Parser EventControl))
-> Parser EventControl -> Maybe (Parser EventControl)
forall a b. (a -> b) -> a -> b
$ HierIdent -> EventControl
ECIdent (HierIdent -> EventControl)
-> Parser HierIdent -> Parser EventControl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> ByteString -> Parser HierIdent
trHierIdent Bool
False ByteString
s
  Token
SymParenL ->
    Parser EventControl -> Maybe (Parser EventControl)
forall a. a -> Maybe a
Just (Parser EventControl -> Maybe (Parser EventControl))
-> Parser EventControl -> Maybe (Parser EventControl)
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymAsterParen Parser () -> Parser EventControl -> Parser EventControl
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> EventControl -> Parser EventControl
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EventControl
ECDeps -- yeah, f*** that
      Parser EventControl -> Parser EventControl -> Parser EventControl
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Token -> Parser ()
consume Token
SymAster Parser () -> Parser EventControl -> Parser EventControl
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> EventControl -> Parser EventControl
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EventControl
ECDeps Parser EventControl -> Parser EventControl -> Parser EventControl
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> NonEmpty EventPrim -> EventControl
ECExpr (NonEmpty EventPrim -> EventControl)
-> ([EventPrim] -> NonEmpty EventPrim)
-> [EventPrim]
-> EventControl
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [EventPrim] -> NonEmpty EventPrim
forall a. HasCallStack => [a] -> NonEmpty a
NE.fromList ([EventPrim] -> EventControl)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [EventPrim]
-> Parser EventControl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [PosToken] LocalCompDir (Writer [String]) [EventPrim]
eventexpr)
        Parser EventControl -> Parser () -> Parser EventControl
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
SymParenL Token
SymParenR
  Token
_ -> Maybe (Parser EventControl)
forall a. Maybe a
Nothing
  where
    eventexpr :: ParsecT [PosToken] LocalCompDir (Writer [String]) [EventPrim]
eventexpr =
      ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrim
-> Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [EventPrim]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy1
        ( do
            EventPrefix
p <- EventPrefix
-> ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrefix
-> ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrefix
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option EventPrefix
EPAny (ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrefix
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrefix)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrefix
-> ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrefix
forall a b. (a -> b) -> a -> b
$
              (Token -> Maybe EventPrefix)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrefix
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe EventPrefix)
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrefix)
-> (Token -> Maybe EventPrefix)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrefix
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
                Token
KWPosedge -> EventPrefix -> Maybe EventPrefix
forall a. a -> Maybe a
Just EventPrefix
EPPos
                Token
KWNegedge -> EventPrefix -> Maybe EventPrefix
forall a. a -> Maybe a
Just EventPrefix
EPNeg
                Token
_ -> Maybe EventPrefix
forall a. Maybe a
Nothing
            EventPrefix -> Expr -> EventPrim
EventPrim EventPrefix
p (Expr -> EventPrim)
-> Parser Expr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) EventPrim
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
expr
        )
        ((Token -> Maybe ()) -> Parser ()
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe ()) -> Parser ())
-> (Token -> Maybe ()) -> Parser ()
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of Token
SymComma -> () -> Maybe ()
forall a. a -> Maybe a
Just (); Token
KWOr -> () -> Maybe ()
forall a. a -> Maybe a
Just (); Token
_ -> Maybe ()
forall a. Maybe a
Nothing)

-- | Statement blocks: begin/end and fork/join
stmtBlock :: Bool -> SourcePos -> Parser Statement
stmtBlock :: Bool -> SourcePos -> Parser Statement
stmtBlock Bool
kind SourcePos
pos = do
  Maybe Identifier
ms <- Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser Identifier
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier))
-> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymColon Parser () -> Parser Identifier -> Parser Identifier
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Identifier
ident
  ([[AttrIded StdBlockDecl]]
decl, [Attributed Statement]
body) <- Parser Attributes
-> (Attributes -> Parser [AttrIded StdBlockDecl])
-> (Attributes -> Parser (Attributed Statement))
-> Parser ([[AttrIded StdBlockDecl]], [Attributed Statement])
forall a b c.
Parser a -> (a -> Parser b) -> (a -> Parser c) -> Parser ([b], [c])
smanythen
    Parser Attributes
attributes
    (\Attributes
a -> LProduce (Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
-> Parser (Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
forall a. LProduce a -> Parser a
lproduce LProduce (Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
stdBlockDecl Parser (Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
-> ((Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
    -> Parser [AttrIded StdBlockDecl])
-> Parser [AttrIded StdBlockDecl]
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl))
p -> NonEmpty (AttrIded StdBlockDecl) -> [AttrIded StdBlockDecl]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty (AttrIded StdBlockDecl) -> [AttrIded StdBlockDecl])
-> Parser (NonEmpty (AttrIded StdBlockDecl))
-> Parser [AttrIded StdBlockDecl]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl))
p Attributes
a)
    (\Attributes
a -> Attributes -> Statement -> Attributed Statement
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a (Statement -> Attributed Statement)
-> Parser Statement -> Parser (Attributed Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Statement
statement)
  let d :: [AttrIded StdBlockDecl]
d = [[AttrIded StdBlockDecl]] -> [AttrIded StdBlockDecl]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[AttrIded StdBlockDecl]]
decl
  Maybe (Identifier, [AttrIded StdBlockDecl])
h <- case ([AttrIded StdBlockDecl]
d, Maybe Identifier
ms) of
    (AttrIded StdBlockDecl
_ : [AttrIded StdBlockDecl]
_, Maybe Identifier
Nothing) -> do
      SourcePos -> String -> Parser ()
warn SourcePos
pos String
"Declaration in an unnamed statement block is a SystemVerilog feature"
      Maybe (Identifier, [AttrIded StdBlockDecl])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Identifier, [AttrIded StdBlockDecl]))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Identifier, [AttrIded StdBlockDecl])
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe (Identifier, [AttrIded StdBlockDecl])))
-> Maybe (Identifier, [AttrIded StdBlockDecl])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Identifier, [AttrIded StdBlockDecl]))
forall a b. (a -> b) -> a -> b
$
        (Identifier, [AttrIded StdBlockDecl])
-> Maybe (Identifier, [AttrIded StdBlockDecl])
forall a. a -> Maybe a
Just (ByteString -> Identifier
Identifier (ByteString -> Identifier) -> ByteString -> Identifier
forall a b. (a -> b) -> a -> b
$ [Word8] -> ByteString
B.pack ([Word8] -> ByteString) -> [Word8] -> ByteString
forall a b. (a -> b) -> a -> b
$ (Char -> Word8) -> String -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Word8
c2w (String -> [Word8]) -> String -> [Word8]
forall a b. (a -> b) -> a -> b
$ String -> Line -> String
forall r. PrintfType r => String -> r
printf String
"__block_at_line_%d__" (SourcePos -> Line
sourceLine SourcePos
pos), [AttrIded StdBlockDecl]
d)
    ([AttrIded StdBlockDecl], Maybe Identifier)
_ -> Maybe (Identifier, [AttrIded StdBlockDecl])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Identifier, [AttrIded StdBlockDecl]))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Identifier, [AttrIded StdBlockDecl])
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe (Identifier, [AttrIded StdBlockDecl])))
-> Maybe (Identifier, [AttrIded StdBlockDecl])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Identifier, [AttrIded StdBlockDecl]))
forall a b. (a -> b) -> a -> b
$ (Identifier
 -> [AttrIded StdBlockDecl]
 -> (Identifier, [AttrIded StdBlockDecl]))
-> [AttrIded StdBlockDecl]
-> Identifier
-> (Identifier, [AttrIded StdBlockDecl])
forall a b c. (a -> b -> c) -> b -> a -> c
flip (,) [AttrIded StdBlockDecl]
d (Identifier -> (Identifier, [AttrIded StdBlockDecl]))
-> Maybe Identifier -> Maybe (Identifier, [AttrIded StdBlockDecl])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Identifier
ms
  SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
pos (if Bool
kind then Token
KWFork else Token
KWBegin) (if Bool
kind then Token
KWJoin else Token
KWEnd)
  Statement -> Parser Statement
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement -> Parser Statement) -> Statement -> Parser Statement
forall a b. (a -> b) -> a -> b
$ Maybe (Identifier, [AttrIded StdBlockDecl])
-> Bool -> [Attributed Statement] -> Statement
SBlock Maybe (Identifier, [AttrIded StdBlockDecl])
h Bool
kind [Attributed Statement]
body

-- | Statement case: case, casex and casez
caseX :: ZOX -> Parser Statement
caseX :: ZOX -> Parser Statement
caseX ZOX
zox = do
  Expr
cond <- Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
parens Parser Expr
expr
  [CaseItem]
l0 <- ParsecT [PosToken] LocalCompDir (Writer [String]) [CaseItem]
pci
  (MybStmt
d, [CaseItem]
l1) <- (if [CaseItem] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [CaseItem]
l0 then ParsecT
  [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem])
forall a. a -> a
id else (MybStmt, [CaseItem])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem])
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option (Attributes -> Maybe Statement -> MybStmt
forall t. Attributes -> t -> Attributed t
Attributed [] Maybe Statement
forall a. Maybe a
Nothing, [])) (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem])
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem]))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem])
forall a b. (a -> b) -> a -> b
$
    Token -> Parser ()
consume Token
KWDefault Parser () -> Parser () -> Parser ()
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser () -> Parser ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (Token -> Parser ()
consume Token
SymColon) Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem])
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [CaseItem]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt, [CaseItem])
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f (a, b)
mkpair ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
optStmt ParsecT [PosToken] LocalCompDir (Writer [String]) [CaseItem]
pci
  Statement -> Parser Statement
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement -> Parser Statement) -> Statement -> Parser Statement
forall a b. (a -> b) -> a -> b
$ ZOX -> Expr -> [CaseItem] -> MybStmt -> Statement
SCase ZOX
zox Expr
cond ([CaseItem]
l0 [CaseItem] -> [CaseItem] -> [CaseItem]
forall a. Semigroup a => a -> a -> a
<> [CaseItem]
l1) MybStmt
d
  where
    pci :: ParsecT [PosToken] LocalCompDir (Writer [String]) [CaseItem]
pci = ParsecT [PosToken] LocalCompDir (Writer [String]) CaseItem
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [CaseItem]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT [PosToken] LocalCompDir (Writer [String]) CaseItem
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) [CaseItem])
-> ParsecT [PosToken] LocalCompDir (Writer [String]) CaseItem
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [CaseItem]
forall a b. (a -> b) -> a -> b
$ NonEmpty Expr -> MybStmt -> CaseItem
CaseItem (NonEmpty Expr -> MybStmt -> CaseItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Expr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt -> CaseItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Expr)
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser Expr
expr ParsecT
  [PosToken] LocalCompDir (Writer [String]) (MybStmt -> CaseItem)
-> Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt -> CaseItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymColon ParsecT
  [PosToken] LocalCompDir (Writer [String]) (MybStmt -> CaseItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
-> ParsecT [PosToken] LocalCompDir (Writer [String]) CaseItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
optStmt

blockass :: VarLValue -> Parser Statement
blockass :: VarLValue -> Parser Statement
blockass VarLValue
lv = do
  Bool
bl <- (Token -> Maybe Bool) -> Parser Bool
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Bool) -> Parser Bool)
-> (Token -> Maybe Bool) -> Parser Bool
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of Token
SymEq -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True; Token
SymLtEq -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False; Token
_ -> Maybe Bool
forall a. Maybe a
Nothing
  Maybe DelayEventControl
delev <- ParsecT [PosToken] LocalCompDir (Writer [String]) DelayEventControl
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe DelayEventControl)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT
   [PosToken] LocalCompDir (Writer [String]) DelayEventControl
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe DelayEventControl))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) DelayEventControl
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe DelayEventControl)
forall a b. (a -> b) -> a -> b
$
    (Token
 -> Maybe
      (ParsecT
         [PosToken] LocalCompDir (Writer [String]) DelayEventControl))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) DelayEventControl
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token
  -> Maybe
       (ParsecT
          [PosToken] LocalCompDir (Writer [String]) DelayEventControl))
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) DelayEventControl)
-> (Token
    -> Maybe
         (ParsecT
            [PosToken] LocalCompDir (Writer [String]) DelayEventControl))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) DelayEventControl
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
      Token
SymPound -> ParsecT [PosToken] LocalCompDir (Writer [String]) DelayEventControl
-> Maybe
     (ParsecT
        [PosToken] LocalCompDir (Writer [String]) DelayEventControl)
forall a. a -> Maybe a
Just (ParsecT
   [PosToken] LocalCompDir (Writer [String]) DelayEventControl
 -> Maybe
      (ParsecT
         [PosToken] LocalCompDir (Writer [String]) DelayEventControl))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) DelayEventControl
-> Maybe
     (ParsecT
        [PosToken] LocalCompDir (Writer [String]) DelayEventControl)
forall a b. (a -> b) -> a -> b
$ Delay1 -> DelayEventControl
DECDelay (Delay1 -> DelayEventControl)
-> Parser Delay1
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) DelayEventControl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Delay1
delay1
      Token
SymAt -> ParsecT [PosToken] LocalCompDir (Writer [String]) DelayEventControl
-> Maybe
     (ParsecT
        [PosToken] LocalCompDir (Writer [String]) DelayEventControl)
forall a. a -> Maybe a
Just (ParsecT
   [PosToken] LocalCompDir (Writer [String]) DelayEventControl
 -> Maybe
      (ParsecT
         [PosToken] LocalCompDir (Writer [String]) DelayEventControl))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) DelayEventControl
-> Maybe
     (ParsecT
        [PosToken] LocalCompDir (Writer [String]) DelayEventControl)
forall a b. (a -> b) -> a -> b
$ EventControl -> DelayEventControl
DECEvent (EventControl -> DelayEventControl)
-> Parser EventControl
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) DelayEventControl
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser EventControl
eventControl
      Token
KWRepeat -> ParsecT [PosToken] LocalCompDir (Writer [String]) DelayEventControl
-> Maybe
     (ParsecT
        [PosToken] LocalCompDir (Writer [String]) DelayEventControl)
forall a. a -> Maybe a
Just (ParsecT
   [PosToken] LocalCompDir (Writer [String]) DelayEventControl
 -> Maybe
      (ParsecT
         [PosToken] LocalCompDir (Writer [String]) DelayEventControl))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) DelayEventControl
-> Maybe
     (ParsecT
        [PosToken] LocalCompDir (Writer [String]) DelayEventControl)
forall a b. (a -> b) -> a -> b
$ Expr -> EventControl -> DelayEventControl
DECRepeat (Expr -> EventControl -> DelayEventControl)
-> Parser Expr
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (EventControl -> DelayEventControl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
parens Parser Expr
expr ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (EventControl -> DelayEventControl)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (EventControl -> DelayEventControl)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymAt ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (EventControl -> DelayEventControl)
-> Parser EventControl
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) DelayEventControl
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser EventControl
eventControl
      Token
_ -> Maybe
  (ParsecT
     [PosToken] LocalCompDir (Writer [String]) DelayEventControl)
forall a. Maybe a
Nothing
  Expr
e <- Parser Expr
expr
  Token -> Parser ()
consume Token
SymSemi
  Statement -> Parser Statement
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement -> Parser Statement) -> Statement -> Parser Statement
forall a b. (a -> b) -> a -> b
$ Bool -> VarAssign -> Maybe DelayEventControl -> Statement
SBlockAssign Bool
bl (VarLValue -> Expr -> VarAssign
forall dr. LValue dr -> Expr -> Assign dr
Assign VarLValue
lv Expr
e) Maybe DelayEventControl
delev

-- | Statement
statement :: Parser Statement
statement :: Parser Statement
statement = (SourcePos -> Token -> Maybe (Parser Statement))
-> Parser Statement
forall a. (SourcePos -> Token -> Maybe (Parser a)) -> Parser a
fpbranch ((SourcePos -> Token -> Maybe (Parser Statement))
 -> Parser Statement)
-> (SourcePos -> Token -> Maybe (Parser Statement))
-> Parser Statement
forall a b. (a -> b) -> a -> b
$ \SourcePos
p Token
t -> case Token
t of
  Token
SymPound -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ Either Delay1 EventControl -> MybStmt -> Statement
SProcTimingControl (Either Delay1 EventControl -> MybStmt -> Statement)
-> (Delay1 -> Either Delay1 EventControl)
-> Delay1
-> MybStmt
-> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Delay1 -> Either Delay1 EventControl
forall a b. a -> Either a b
Left (Delay1 -> MybStmt -> Statement)
-> Parser Delay1
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt -> Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Delay1
delay1 ParsecT
  [PosToken] LocalCompDir (Writer [String]) (MybStmt -> Statement)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
-> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
optStmt
  Token
SymAt -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ Either Delay1 EventControl -> MybStmt -> Statement
SProcTimingControl (Either Delay1 EventControl -> MybStmt -> Statement)
-> (EventControl -> Either Delay1 EventControl)
-> EventControl
-> MybStmt
-> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EventControl -> Either Delay1 EventControl
forall a b. b -> Either a b
Right (EventControl -> MybStmt -> Statement)
-> Parser EventControl
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt -> Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser EventControl
eventControl ParsecT
  [PosToken] LocalCompDir (Writer [String]) (MybStmt -> Statement)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
-> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
optStmt
  Token
SymDashGt -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ HierIdent -> [Expr] -> Statement
SEventTrigger (HierIdent -> [Expr] -> Statement)
-> Parser HierIdent
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) ([Expr] -> Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Parser HierIdent
hierIdent Bool
True ParsecT
  [PosToken] LocalCompDir (Writer [String]) ([Expr] -> Statement)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
-> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
brackets Parser Expr
expr) Parser Statement -> Parser () -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi
  Token
KWFork -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ Bool -> SourcePos -> Parser Statement
stmtBlock Bool
True SourcePos
p
  Token
KWBegin -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ Bool -> SourcePos -> Parser Statement
stmtBlock Bool
False SourcePos
p
  Token
KWCase -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ ZOX -> Parser Statement
caseX ZOX
ZOXO Parser Statement -> Parser () -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
KWCase Token
KWEndcase
  Token
KWCasez -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ ZOX -> Parser Statement
caseX ZOX
ZOXZ Parser Statement -> Parser () -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
KWCasez Token
KWEndcase
  Token
KWCasex -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ ZOX -> Parser Statement
caseX ZOX
ZOXX Parser Statement -> Parser () -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
KWCasex Token
KWEndcase
  Token
KWDisable -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ HierIdent -> Statement
SDisable (HierIdent -> Statement) -> Parser HierIdent -> Parser Statement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Parser HierIdent
hierIdent Bool
False Parser Statement -> Parser () -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi
  Token
KWWait -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ Expr -> MybStmt -> Statement
SWait (Expr -> MybStmt -> Statement)
-> Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt -> Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
parens Parser Expr
expr ParsecT
  [PosToken] LocalCompDir (Writer [String]) (MybStmt -> Statement)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
-> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
optStmt
  Token
KWIf ->
    Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$
      Expr -> MybStmt -> MybStmt -> Statement
SIf (Expr -> MybStmt -> MybStmt -> Statement)
-> Parser Expr
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (MybStmt -> MybStmt -> Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
parens Parser Expr
expr ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (MybStmt -> MybStmt -> Statement)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (MybStmt -> Statement)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
optStmt ParsecT
  [PosToken] LocalCompDir (Writer [String]) (MybStmt -> Statement)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
-> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MybStmt
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option (Attributes -> Maybe Statement -> MybStmt
forall t. Attributes -> t -> Attributed t
Attributed [] Maybe Statement
forall a. Maybe a
Nothing) (Token -> Parser ()
consume Token
KWElse Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
optStmt)
  Token
KWAssign -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ ProcContAssign -> Statement
SProcContAssign (ProcContAssign -> Statement)
-> (VarAssign -> ProcContAssign) -> VarAssign -> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VarAssign -> ProcContAssign
PCAAssign (VarAssign -> Statement) -> Parser VarAssign -> Parser Statement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VarAssign
varAssign Parser Statement -> Parser () -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi
  Token
KWDeassign -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ ProcContAssign -> Statement
SProcContAssign (ProcContAssign -> Statement)
-> (VarLValue -> ProcContAssign) -> VarLValue -> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VarLValue -> ProcContAssign
PCADeassign (VarLValue -> Statement) -> Parser VarLValue -> Parser Statement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VarLValue
varLV Parser Statement -> Parser () -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi
  Token
KWForce -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ do
    VarAssign
va <- Parser VarAssign
varAssign
    Token -> Parser ()
consume Token
SymSemi
    Statement -> Parser Statement
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement -> Parser Statement) -> Statement -> Parser Statement
forall a b. (a -> b) -> a -> b
$
      ProcContAssign -> Statement
SProcContAssign (ProcContAssign -> Statement) -> ProcContAssign -> Statement
forall a b. (a -> b) -> a -> b
$
        Either VarAssign NetAssign -> ProcContAssign
PCAForce (Either VarAssign NetAssign -> ProcContAssign)
-> Either VarAssign NetAssign -> ProcContAssign
forall a b. (a -> b) -> a -> b
$
          Either VarAssign NetAssign
-> (NetLValue -> Either VarAssign NetAssign)
-> Maybe NetLValue
-> Either VarAssign NetAssign
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (VarAssign -> Either VarAssign NetAssign
forall a b. a -> Either a b
Left VarAssign
va) (\NetLValue
nl -> NetAssign -> Either VarAssign NetAssign
forall a b. b -> Either a b
Right (NetAssign -> Either VarAssign NetAssign)
-> NetAssign -> Either VarAssign NetAssign
forall a b. (a -> b) -> a -> b
$ NetLValue -> Expr -> NetAssign
forall dr. LValue dr -> Expr -> Assign dr
Assign NetLValue
nl (Expr -> NetAssign) -> Expr -> NetAssign
forall a b. (a -> b) -> a -> b
$ VarAssign -> Expr
forall dr. Assign dr -> Expr
_aValue VarAssign
va) (Maybe NetLValue -> Either VarAssign NetAssign)
-> Maybe NetLValue -> Either VarAssign NetAssign
forall a b. (a -> b) -> a -> b
$ VarLValue -> Maybe NetLValue
constifyLV (VarLValue -> Maybe NetLValue) -> VarLValue -> Maybe NetLValue
forall a b. (a -> b) -> a -> b
$ VarAssign -> VarLValue
forall dr. Assign dr -> LValue dr
_aLValue VarAssign
va
  Token
KWRelease -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ do
    VarLValue
vl <- Parser VarLValue
varLV
    Token -> Parser ()
consume Token
SymSemi
    Statement -> Parser Statement
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement -> Parser Statement) -> Statement -> Parser Statement
forall a b. (a -> b) -> a -> b
$ ProcContAssign -> Statement
SProcContAssign (ProcContAssign -> Statement) -> ProcContAssign -> Statement
forall a b. (a -> b) -> a -> b
$ Either VarLValue NetLValue -> ProcContAssign
PCARelease (Either VarLValue NetLValue -> ProcContAssign)
-> Either VarLValue NetLValue -> ProcContAssign
forall a b. (a -> b) -> a -> b
$ Either VarLValue NetLValue
-> (NetLValue -> Either VarLValue NetLValue)
-> Maybe NetLValue
-> Either VarLValue NetLValue
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (VarLValue -> Either VarLValue NetLValue
forall a b. a -> Either a b
Left VarLValue
vl) NetLValue -> Either VarLValue NetLValue
forall a b. b -> Either a b
Right (Maybe NetLValue -> Either VarLValue NetLValue)
-> Maybe NetLValue -> Either VarLValue NetLValue
forall a b. (a -> b) -> a -> b
$ VarLValue -> Maybe NetLValue
constifyLV VarLValue
vl
  Token
KWForever -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ LoopStatement -> Parser Statement
stmtLoop LoopStatement
LSForever
  Token
KWRepeat -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ Expr -> LoopStatement
LSRepeat (Expr -> LoopStatement)
-> Parser Expr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) LoopStatement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
parens Parser Expr
expr ParsecT [PosToken] LocalCompDir (Writer [String]) LoopStatement
-> (LoopStatement -> Parser Statement) -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= LoopStatement -> Parser Statement
stmtLoop
  Token
KWWhile -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ Expr -> LoopStatement
LSWhile (Expr -> LoopStatement)
-> Parser Expr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) LoopStatement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr -> Parser Expr
forall a. Parser a -> Parser a
parens Parser Expr
expr ParsecT [PosToken] LocalCompDir (Writer [String]) LoopStatement
-> (LoopStatement -> Parser Statement) -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= LoopStatement -> Parser Statement
stmtLoop
  Token
KWFor ->
    Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$
      ParsecT [PosToken] LocalCompDir (Writer [String]) LoopStatement
-> ParsecT [PosToken] LocalCompDir (Writer [String]) LoopStatement
forall a. Parser a -> Parser a
parens (VarAssign -> Expr -> VarAssign -> LoopStatement
LSFor (VarAssign -> Expr -> VarAssign -> LoopStatement)
-> Parser VarAssign
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Expr -> VarAssign -> LoopStatement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VarAssign
varAssign ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Expr -> VarAssign -> LoopStatement)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Expr -> VarAssign -> LoopStatement)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Expr -> VarAssign -> LoopStatement)
-> Parser Expr
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (VarAssign -> LoopStatement)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
expr ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (VarAssign -> LoopStatement)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (VarAssign -> LoopStatement)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (VarAssign -> LoopStatement)
-> Parser VarAssign
-> ParsecT [PosToken] LocalCompDir (Writer [String]) LoopStatement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser VarAssign
varAssign)
        ParsecT [PosToken] LocalCompDir (Writer [String]) LoopStatement
-> (LoopStatement -> Parser Statement) -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= LoopStatement -> Parser Statement
stmtLoop
  IdSystem ByteString
s ->
    Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$
      ByteString -> [Maybe Expr] -> Statement
SSysTaskEnable ByteString
s ([Maybe Expr] -> Statement)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Maybe Expr]
-> Parser Statement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Maybe Expr]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Maybe Expr]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Maybe Expr]
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (NonEmpty (Maybe Expr) -> [Maybe Expr]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty (Maybe Expr) -> [Maybe Expr])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty (Maybe Expr))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Maybe Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Maybe Expr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty (Maybe Expr))
forall a. Parser a -> Parser (NonEmpty a)
pcsl1 (Parser Expr -> Parser (Maybe Expr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Expr
expr)) Parser Statement -> Parser () -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi
  IdSimple ByteString
s -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ ByteString -> Parser Statement
blockassortask ByteString
s
  IdEscaped ByteString
s -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ ByteString -> Parser Statement
blockassortask ByteString
s
  Token
SymBraceL -> Parser Statement -> Maybe (Parser Statement)
forall a. a -> Maybe a
Just (Parser Statement -> Maybe (Parser Statement))
-> Parser Statement -> Maybe (Parser Statement)
forall a b. (a -> b) -> a -> b
$ (NonEmpty VarLValue -> VarLValue
forall dr. NonEmpty (LValue dr) -> LValue dr
LVConcat (NonEmpty VarLValue -> VarLValue)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty VarLValue)
-> Parser VarLValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser VarLValue
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty VarLValue)
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser VarLValue
varLV Parser VarLValue -> Parser () -> Parser VarLValue
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
SymBraceL Token
SymBraceR) Parser VarLValue
-> (VarLValue -> Parser Statement) -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= VarLValue -> Parser Statement
blockass
  Token
_ -> Maybe (Parser Statement)
forall a. Maybe a
Nothing
  where
    stmtLoop :: LoopStatement -> Parser Statement
stmtLoop LoopStatement
ls = LoopStatement -> Attributed Statement -> Statement
SLoop LoopStatement
ls (Attributed Statement -> Statement)
-> Parser (Attributed Statement) -> Parser Statement
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Attributed Statement)
attrStmt
    blockassortask :: ByteString -> Parser Statement
blockassortask ByteString
s = do
      HierIdent
hi <- Bool -> ByteString -> Parser HierIdent
trHierIdent Bool
True ByteString
s
      (Parser (Maybe DimRange)
dimRange Parser (Maybe DimRange)
-> (Maybe DimRange -> Parser Statement) -> Parser Statement
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= VarLValue -> Parser Statement
blockass (VarLValue -> Parser Statement)
-> (Maybe DimRange -> VarLValue)
-> Maybe DimRange
-> Parser Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HierIdent -> Maybe DimRange -> VarLValue
forall dr. HierIdent -> Maybe dr -> LValue dr
LVSingle HierIdent
hi)
        Parser Statement -> Parser Statement -> Parser Statement
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
          [Expr]
args <- [Expr]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr])
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
forall a b. (a -> b) -> a -> b
$ ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
forall a. Parser a -> Parser a
parens (ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr])
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
forall a b. (a -> b) -> a -> b
$ String
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
forall a. String -> Parser [a] -> Parser [a]
wempty String
"task argument" (ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr])
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
forall a b. (a -> b) -> a -> b
$ Parser Expr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Expr]
forall a. Parser a -> Parser [a]
csl Parser Expr
expr
          Token -> Parser ()
consume Token
SymSemi
          Statement -> Parser Statement
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Statement -> Parser Statement) -> Statement -> Parser Statement
forall a b. (a -> b) -> a -> b
$ HierIdent -> [Expr] -> Statement
STaskEnable HierIdent
hi [Expr]
args

attrStmt :: Parser AttrStmt
attrStmt :: Parser (Attributed Statement)
attrStmt = Attributes -> Statement -> Attributed Statement
forall t. Attributes -> t -> Attributed t
Attributed (Attributes -> Statement -> Attributed Statement)
-> Parser Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Statement -> Attributed Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Attributes
attributes ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Statement -> Attributed Statement)
-> Parser Statement -> Parser (Attributed Statement)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Statement
statement

trOptStmt :: Attributes -> Parser MybStmt
trOptStmt :: Attributes
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
trOptStmt Attributes
a = (Maybe Statement -> MybStmt)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Statement)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
forall a b.
(a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Attributes -> Maybe Statement -> MybStmt
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a) (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (Maybe Statement)
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Statement)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
forall a b. (a -> b) -> a -> b
$ Statement -> Maybe Statement
forall a. a -> Maybe a
Just (Statement -> Maybe Statement)
-> Parser Statement
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Statement)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Statement
statement ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Statement)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Statement)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Statement)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Token -> Parser ()
consume Token
SymSemi Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Statement)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Statement)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Maybe Statement
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Statement)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Statement
forall a. Maybe a
Nothing

optStmt :: Parser MybStmt
optStmt :: ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
optStmt = Parser Attributes
attributes Parser Attributes
-> (Attributes
    -> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Attributes
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
trOptStmt

-- | Block declarations except parameters, including local parameters
blockDecl :: Parser t -> LBranch (BlockDecl (Compose NonEmpty Identified) t)
blockDecl :: forall t.
Parser t -> LBranch (BlockDecl (Compose NonEmpty Identified) t)
blockDecl Parser t
p =
  [ (Token
KWReg, SignRange
-> Compose NonEmpty Identified t
-> BlockDecl (Compose NonEmpty Identified) t
forall (f :: * -> *) t. SignRange -> f t -> BlockDecl f t
BDReg (SignRange
 -> Compose NonEmpty Identified t
 -> BlockDecl (Compose NonEmpty Identified) t)
-> Parser SignRange
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t
      -> BlockDecl (Compose NonEmpty Identified) t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SignRange
signRange ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Compose NonEmpty Identified t
   -> BlockDecl (Compose NonEmpty Identified) t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (BlockDecl (Compose NonEmpty Identified) t)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser t
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t)
forall {a}.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified a)
ppl Parser t
p),
    (Token
KWInteger, Compose NonEmpty Identified t
-> BlockDecl (Compose NonEmpty Identified) t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDInt (Compose NonEmpty Identified t
 -> BlockDecl (Compose NonEmpty Identified) t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (BlockDecl (Compose NonEmpty Identified) t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser t
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t)
forall {a}.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified a)
ppl Parser t
p),
    (Token
KWReal, Compose NonEmpty Identified t
-> BlockDecl (Compose NonEmpty Identified) t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDReal (Compose NonEmpty Identified t
 -> BlockDecl (Compose NonEmpty Identified) t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (BlockDecl (Compose NonEmpty Identified) t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser t
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t)
forall {a}.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified a)
ppl Parser t
p),
    (Token
KWTime, Compose NonEmpty Identified t
-> BlockDecl (Compose NonEmpty Identified) t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDTime (Compose NonEmpty Identified t
 -> BlockDecl (Compose NonEmpty Identified) t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (BlockDecl (Compose NonEmpty Identified) t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser t
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t)
forall {a}.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified a)
ppl Parser t
p),
    (Token
KWRealtime, Compose NonEmpty Identified t
-> BlockDecl (Compose NonEmpty Identified) t
forall (f :: * -> *) t. f t -> BlockDecl f t
BDRealTime (Compose NonEmpty Identified t
 -> BlockDecl (Compose NonEmpty Identified) t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (BlockDecl (Compose NonEmpty Identified) t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser t
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified t)
forall {a}.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified a)
ppl Parser t
p),
    (Token
KWEvent, Compose NonEmpty Identified [Range2]
-> BlockDecl (Compose NonEmpty Identified) t
forall (f :: * -> *) t. f [Range2] -> BlockDecl f t
BDEvent (Compose NonEmpty Identified [Range2]
 -> BlockDecl (Compose NonEmpty Identified) t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified [Range2])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (BlockDecl (Compose NonEmpty Identified) t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified [Range2])
forall {a}.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified a)
ppl (Parser Range2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser Range2
range2)),
    (Token
KWLocalparam, ComType ()
-> Compose NonEmpty Identified (GenMinTypMax CExpr)
-> BlockDecl (Compose NonEmpty Identified) t
forall (f :: * -> *) t.
ComType () -> f (GenMinTypMax CExpr) -> BlockDecl f t
BDLocalParam (ComType ()
 -> Compose NonEmpty Identified (GenMinTypMax CExpr)
 -> BlockDecl (Compose NonEmpty Identified) t)
-> Parser (ComType ())
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified (GenMinTypMax CExpr)
      -> BlockDecl (Compose NonEmpty Identified) t)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser () -> Parser (ComType ())
forall t. Parser t -> Parser (ComType t)
comType (() -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()) ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Compose NonEmpty Identified (GenMinTypMax CExpr)
   -> BlockDecl (Compose NonEmpty Identified) t)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified (GenMinTypMax CExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (BlockDecl (Compose NonEmpty Identified) t)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT
  [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified (GenMinTypMax CExpr))
forall {a}.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified a)
ppl (Token -> Parser ()
consume Token
SymEq Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser CExpr
constExpr))
  ]
  where
    ppl :: ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified a)
ppl ParsecT [PosToken] LocalCompDir (Writer [String]) a
ps = NonEmpty (Identified a) -> Compose NonEmpty Identified a
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (NonEmpty (Identified a) -> Compose NonEmpty Identified a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty (Identified a))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Identified a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty (Identified a))
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Identifier -> a -> Identified a
forall t. Identifier -> t -> Identified t
Identified (Identifier -> a -> Identified a)
-> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (a -> Identified a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken] LocalCompDir (Writer [String]) (a -> Identified a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> Parser (Identified a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) a
ps) ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Compose NonEmpty Identified a)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Compose NonEmpty Identified a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi

-- | Standard block declarations
stdBlockDecl :: LABranch (NonEmpty (AttrIded StdBlockDecl))
stdBlockDecl :: LProduce (Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
stdBlockDecl =
  (Token
KWParameter, \Attributes
a -> (((Identifier, Parameter) -> AttrIded StdBlockDecl)
-> NonEmpty (Identifier, Parameter)
-> NonEmpty (AttrIded StdBlockDecl)
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (((Identifier, Parameter) -> AttrIded StdBlockDecl)
 -> NonEmpty (Identifier, Parameter)
 -> NonEmpty (AttrIded StdBlockDecl))
-> ((Identifier, Parameter) -> AttrIded StdBlockDecl)
-> NonEmpty (Identifier, Parameter)
-> NonEmpty (AttrIded StdBlockDecl)
forall a b. (a -> b) -> a -> b
$ \(Identifier
s, Parameter
p) -> Attributes -> Identifier -> StdBlockDecl -> AttrIded StdBlockDecl
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
a Identifier
s (StdBlockDecl -> AttrIded StdBlockDecl)
-> StdBlockDecl -> AttrIded StdBlockDecl
forall a b. (a -> b) -> a -> b
$ Parameter -> StdBlockDecl
SBDParameter Parameter
p) (NonEmpty (Identifier, Parameter)
 -> NonEmpty (AttrIded StdBlockDecl))
-> Parser (NonEmpty (Identifier, Parameter))
-> Parser (NonEmpty (AttrIded StdBlockDecl))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Parser (NonEmpty (Identifier, Parameter))
paramDecl Bool
False) ABranch (NonEmpty (AttrIded StdBlockDecl))
-> LProduce
     (Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
-> LProduce
     (Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
forall a. a -> [a] -> [a]
:
    (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (BD NonEmpty [Range2])
 -> Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
-> LProduce
     (ParsecT
        [PosToken] LocalCompDir (Writer [String]) (BD NonEmpty [Range2]))
-> LProduce
     (Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
forall a b. (a -> b) -> LProduce a -> LProduce b
maplproduce
      (\ParsecT
  [PosToken] LocalCompDir (Writer [String]) (BD NonEmpty [Range2])
p Attributes
a -> (Identified (BlockDecl Identity [Range2]) -> AttrIded StdBlockDecl)
-> NonEmpty (Identified (BlockDecl Identity [Range2]))
-> NonEmpty (AttrIded StdBlockDecl)
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Identified Identifier
i BlockDecl Identity [Range2]
x) -> Attributes -> Identifier -> StdBlockDecl -> AttrIded StdBlockDecl
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
a Identifier
i (StdBlockDecl -> AttrIded StdBlockDecl)
-> StdBlockDecl -> AttrIded StdBlockDecl
forall a b. (a -> b) -> a -> b
$ BlockDecl Identity [Range2] -> StdBlockDecl
SBDBlockDecl BlockDecl Identity [Range2]
x) (NonEmpty (Identified (BlockDecl Identity [Range2]))
 -> NonEmpty (AttrIded StdBlockDecl))
-> (BD NonEmpty [Range2]
    -> NonEmpty (Identified (BlockDecl Identity [Range2])))
-> BD NonEmpty [Range2]
-> NonEmpty (AttrIded StdBlockDecl)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BD NonEmpty [Range2]
-> NonEmpty (Identified (BlockDecl Identity [Range2]))
forall t.
BD NonEmpty t -> NonEmpty (Identified (BlockDecl Identity t))
toStdBlockDecl (BD NonEmpty [Range2] -> NonEmpty (AttrIded StdBlockDecl))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (BD NonEmpty [Range2])
-> Parser (NonEmpty (AttrIded StdBlockDecl))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken] LocalCompDir (Writer [String]) (BD NonEmpty [Range2])
p)
      (ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
-> LProduce
     (ParsecT
        [PosToken] LocalCompDir (Writer [String]) (BD NonEmpty [Range2]))
forall t.
Parser t -> LBranch (BlockDecl (Compose NonEmpty Identified) t)
blockDecl (ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
 -> LProduce
      (ParsecT
         [PosToken] LocalCompDir (Writer [String]) (BD NonEmpty [Range2])))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
-> LProduce
     (ParsecT
        [PosToken] LocalCompDir (Writer [String]) (BD NonEmpty [Range2]))
forall a b. (a -> b) -> a -> b
$ Parser Range2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser Range2
range2)

type GIF a = Maybe InstanceName -> NetLValue -> NonEmpty Expr -> Maybe a

-- | Gate instantiation utility functions
gateInst :: GIF a -> Parser (NonEmpty a)
gateInst :: forall a. GIF a -> Parser (NonEmpty a)
gateInst GIF a
f = do
  NonEmpty a
l <- Parser a -> Parser (NonEmpty a)
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Parser a -> Parser (NonEmpty a))
-> Parser a -> Parser (NonEmpty a)
forall a b. (a -> b) -> a -> b
$ do
    Maybe InstanceName
n <- Parser InstanceName
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe InstanceName)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser InstanceName
instName
    Maybe a
mgi <- Parser (Maybe a) -> Parser (Maybe a)
forall a. Parser a -> Parser a
parens (Parser (Maybe a) -> Parser (Maybe a))
-> Parser (Maybe a) -> Parser (Maybe a)
forall a b. (a -> b) -> a -> b
$
      GIF a
f Maybe InstanceName
n (NetLValue -> NonEmpty Expr -> Maybe a)
-> Parser NetLValue
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty Expr -> Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetLValue
netLV ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty Expr -> Maybe a)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty Expr -> Maybe a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymComma ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty Expr -> Maybe a)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Expr)
-> Parser (Maybe a)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Expr)
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser Expr
expr
    case Maybe a
mgi of Just a
gi -> a -> Parser a
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return a
gi; Maybe a
Nothing -> String -> Parser a
forall a. String -> Parser a
hardfail String
"Unexpected arguments"
  Token -> Parser ()
consume Token
SymSemi
  NonEmpty a -> Parser (NonEmpty a)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return NonEmpty a
l

-- | Strength for pullup/pulldown
pullStrength :: Bool -> Parser DriveStrength
pullStrength :: Bool -> Parser DriveStrength
pullStrength Bool
ud = do
  Either Bool (Strength, Bool)
e1 <- Parser (Either Bool (Strength, Bool))
strength
  Maybe (Either Bool (Strength, Bool))
e2 <- Parser (Either Bool (Strength, Bool))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Either Bool (Strength, Bool)))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser (Either Bool (Strength, Bool))
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe (Either Bool (Strength, Bool))))
-> Parser (Either Bool (Strength, Bool))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Either Bool (Strength, Bool)))
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymComma Parser ()
-> Parser (Either Bool (Strength, Bool))
-> Parser (Either Bool (Strength, Bool))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Either Bool (Strength, Bool))
strength
  case (Either Bool (Strength, Bool)
e1, Maybe (Either Bool (Strength, Bool))
e2) of
    (Left Bool
b, Maybe (Either Bool (Strength, Bool))
Nothing) | Bool
ud Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
b -> DriveStrength -> Parser DriveStrength
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return DSHighZ {_dsHZ :: Bool
_dsHZ = Bool
b, _dsStr :: Strength
_dsStr = Strength
StrStrong}
    (Left Bool
bl, Just (Right (Strength
s, Bool
br))) | Bool
bl Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
/= Bool
br -> DriveStrength -> Parser DriveStrength
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return DSHighZ {_dsHZ :: Bool
_dsHZ = Bool
bl, _dsStr :: Strength
_dsStr = Strength
s}
    (Right (Strength
s, Bool
br), Just (Left Bool
bl)) | Bool
bl Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
/= Bool
br -> DriveStrength -> Parser DriveStrength
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return DSHighZ {_dsHZ :: Bool
_dsHZ = Bool
bl, _dsStr :: Strength
_dsStr = Strength
s}
    (Right (Strength
s, Bool
b), Maybe (Either Bool (Strength, Bool))
Nothing) | Bool
ud Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
b ->
      DriveStrength -> Parser DriveStrength
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (DriveStrength -> Parser DriveStrength)
-> DriveStrength -> Parser DriveStrength
forall a b. (a -> b) -> a -> b
$
        if Bool
b then DSNormal {_ds0 :: Strength
_ds0 = Strength
StrStrong, _ds1 :: Strength
_ds1 = Strength
s} else DSNormal {_ds1 :: Strength
_ds1 = Strength
StrStrong, _ds0 :: Strength
_ds0 = Strength
s}
    (Right (Strength
s1, Bool
False), Just (Right (Strength
s2, Bool
True))) -> DriveStrength -> Parser DriveStrength
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return DSNormal {_ds0 :: Strength
_ds0 = Strength
s1, _ds1 :: Strength
_ds1 = Strength
s2}
    (Right (Strength
s1, Bool
True), Just (Right (Strength
s2, Bool
False))) -> DriveStrength -> Parser DriveStrength
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return DSNormal {_ds0 :: Strength
_ds0 = Strength
s2, _ds1 :: Strength
_ds1 = Strength
s1}
    (Either Bool (Strength, Bool),
 Maybe (Either Bool (Strength, Bool)))
_ -> String -> Parser DriveStrength
forall a. String -> Parser a
hardfail String
"Unexpected arguments"

-- | Task and function common parts
taskFun ::
  Bool ->
  (Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))) ->
  Parser ([AttrIded (TFBlockDecl a)], [MybStmt])
taskFun :: forall a.
Bool
-> (Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl a))))
-> Parser ([AttrIded (TFBlockDecl a)], [MybStmt])
taskFun Bool
zeroarg Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
arglb = do
  Maybe [AttrIded (TFBlockDecl a)]
l <- ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  [AttrIded (TFBlockDecl a)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [AttrIded (TFBlockDecl a)])
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   [AttrIded (TFBlockDecl a)]
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe [AttrIded (TFBlockDecl a)]))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [AttrIded (TFBlockDecl a)])
forall a b. (a -> b) -> a -> b
$
    ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  [AttrIded (TFBlockDecl a)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
forall a. Parser a -> Parser a
parens (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   [AttrIded (TFBlockDecl a)]
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      [AttrIded (TFBlockDecl a)])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
forall a b. (a -> b) -> a -> b
$ String
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
forall a. String -> Parser [a] -> Parser [a]
ww String
"function ports" (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   [AttrIded (TFBlockDecl a)]
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      [AttrIded (TFBlockDecl a)])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
forall a b. (a -> b) -> a -> b
$ [[AttrIded (TFBlockDecl a)]] -> [AttrIded (TFBlockDecl a)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[AttrIded (TFBlockDecl a)]] -> [AttrIded (TFBlockDecl a)])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[AttrIded (TFBlockDecl a)]]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  [AttrIded (TFBlockDecl a)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[AttrIded (TFBlockDecl a)]]
forall a. Parser a -> Parser [a]
csl (NonEmpty (AttrIded (TFBlockDecl a)) -> [AttrIded (TFBlockDecl a)]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty (AttrIded (TFBlockDecl a)) -> [AttrIded (TFBlockDecl a)])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl a)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl a)))
forall a. LABranch a -> Parser a
labranch (Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
arglb Bool
True))
  Token -> Parser ()
consume Token
SymSemi
  let dp :: LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
dp = case Maybe [AttrIded (TFBlockDecl a)]
l of
        Maybe [AttrIded (TFBlockDecl a)]
Nothing -> (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (NonEmpty (AttrIded (TFBlockDecl a)))
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (NonEmpty (AttrIded (TFBlockDecl a))))
-> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
-> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
forall a b. (a -> b) -> LAProduce a -> LAProduce b
maplaproduce (\ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty (AttrIded (TFBlockDecl a)))
p -> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty (AttrIded (TFBlockDecl a)))
p ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty (AttrIded (TFBlockDecl a)))
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl a)))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi) (Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
arglb Bool
False) LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
-> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
-> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
forall a. [a] -> [a] -> [a]
++ LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
forall {t}. LABranch (NonEmpty (AttrIded (TFBlockDecl t)))
sbd
        Just [AttrIded (TFBlockDecl a)]
_ -> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
forall {t}. LABranch (NonEmpty (AttrIded (TFBlockDecl t)))
sbd
  ([[AttrIded (TFBlockDecl a)]]
d, [MybStmt]
b) <- Parser Attributes
-> (Attributes
    -> ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         [AttrIded (TFBlockDecl a)])
-> (Attributes
    -> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt)
-> Parser ([[AttrIded (TFBlockDecl a)]], [MybStmt])
forall a b c.
Parser a -> (a -> Parser b) -> (a -> Parser c) -> Parser ([b], [c])
smanythen Parser Attributes
attributes (\Attributes
a -> LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
-> Parser
     (Attributes
      -> ParsecT
           [PosToken]
           LocalCompDir
           (Writer [String])
           (NonEmpty (AttrIded (TFBlockDecl a))))
forall a. LProduce a -> Parser a
lproduce LABranch (NonEmpty (AttrIded (TFBlockDecl a)))
dp Parser
  (Attributes
   -> ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (NonEmpty (AttrIded (TFBlockDecl a))))
-> ((Attributes
     -> ParsecT
          [PosToken]
          LocalCompDir
          (Writer [String])
          (NonEmpty (AttrIded (TFBlockDecl a))))
    -> ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         [AttrIded (TFBlockDecl a)])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl a)))
p -> NonEmpty (AttrIded (TFBlockDecl a)) -> [AttrIded (TFBlockDecl a)]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty (AttrIded (TFBlockDecl a)) -> [AttrIded (TFBlockDecl a)])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl a)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [AttrIded (TFBlockDecl a)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (AttrIded (TFBlockDecl a)))
p Attributes
a) Attributes
-> ParsecT [PosToken] LocalCompDir (Writer [String]) MybStmt
trOptStmt
  String
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[AttrIded (TFBlockDecl a)]]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[AttrIded (TFBlockDecl a)]]
forall a. String -> Parser [a] -> Parser [a]
ww String
"function declarations" (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   [[AttrIded (TFBlockDecl a)]]
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      [[AttrIded (TFBlockDecl a)]])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[AttrIded (TFBlockDecl a)]]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[AttrIded (TFBlockDecl a)]]
forall a b. (a -> b) -> a -> b
$ [[AttrIded (TFBlockDecl a)]]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[AttrIded (TFBlockDecl a)]]
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [[AttrIded (TFBlockDecl a)]]
d
  case [MybStmt]
b of
    [Item [MybStmt]
x] -> () -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
    [MybStmt]
_ -> do
      SourcePos
pos <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
      SourcePos -> String -> Parser ()
warn SourcePos
pos (String -> Parser ()) -> String -> Parser ()
forall a b. (a -> b) -> a -> b
$
        String -> String -> String
forall r. PrintfType r => String -> r
printf String
"No or multiple statements in a %s is a SystemVerilog feature" (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$
          if Bool
zeroarg then String
"function" else String
"task" :: String
  ([AttrIded (TFBlockDecl a)], [MybStmt])
-> Parser ([AttrIded (TFBlockDecl a)], [MybStmt])
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([[AttrIded (TFBlockDecl a)]] -> [AttrIded (TFBlockDecl a)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[AttrIded (TFBlockDecl a)]]
d, [MybStmt]
b)
  where
    sbd :: LABranch (NonEmpty (AttrIded (TFBlockDecl t)))
sbd = (NonEmpty (AttrIded StdBlockDecl)
 -> NonEmpty (AttrIded (TFBlockDecl t)))
-> LProduce
     (Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
-> LABranch (NonEmpty (AttrIded (TFBlockDecl t)))
forall a b. (a -> b) -> LABranch a -> LABranch b
maplabranch ((AttrIded StdBlockDecl -> AttrIded (TFBlockDecl t))
-> NonEmpty (AttrIded StdBlockDecl)
-> NonEmpty (AttrIded (TFBlockDecl t))
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((AttrIded StdBlockDecl -> AttrIded (TFBlockDecl t))
 -> NonEmpty (AttrIded StdBlockDecl)
 -> NonEmpty (AttrIded (TFBlockDecl t)))
-> (AttrIded StdBlockDecl -> AttrIded (TFBlockDecl t))
-> NonEmpty (AttrIded StdBlockDecl)
-> NonEmpty (AttrIded (TFBlockDecl t))
forall a b. (a -> b) -> a -> b
$ (StdBlockDecl -> TFBlockDecl t)
-> AttrIded StdBlockDecl -> AttrIded (TFBlockDecl t)
forall a b. (a -> b) -> AttrIded a -> AttrIded b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap StdBlockDecl -> TFBlockDecl t
forall t. StdBlockDecl -> TFBlockDecl t
TFBDStd) LProduce (Attributes -> Parser (NonEmpty (AttrIded StdBlockDecl)))
stdBlockDecl
    ww :: String -> Parser [a] -> Parser [a]
ww String
s = if Bool
zeroarg then Parser [a] -> Parser [a]
forall a. a -> a
id else String -> Parser [a] -> Parser [a]
forall a. String -> Parser [a] -> Parser [a]
wempty String
s

-- | Trireg and net common properties
netProp :: Parser NetProp
netProp :: Parser NetProp
netProp = do
  Maybe Bool
vs <- Parser Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser Bool
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
-> Parser Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a b. (a -> b) -> a -> b
$
    (Token -> Maybe Bool) -> Parser Bool
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Bool) -> Parser Bool)
-> (Token -> Maybe Bool) -> Parser Bool
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
      Token
KWVectored -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
      Token
KWScalared -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
      Token
_ -> Maybe Bool
forall a. Maybe a
Nothing
  Bool
sn <- Token -> Parser Bool
optConsume Token
KWSigned
  Maybe (Maybe Bool, Range2)
vec <- if Maybe Bool -> Bool
forall a. Maybe a -> Bool
isJust Maybe Bool
vs then (Maybe Bool, Range2) -> Maybe (Maybe Bool, Range2)
forall a. a -> Maybe a
Just ((Maybe Bool, Range2) -> Maybe (Maybe Bool, Range2))
-> (Range2 -> (Maybe Bool, Range2))
-> Range2
-> Maybe (Maybe Bool, Range2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) Maybe Bool
vs (Range2 -> Maybe (Maybe Bool, Range2))
-> Parser Range2
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Maybe Bool, Range2))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Range2
range2 else ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Maybe Bool, Range2)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Maybe Bool, Range2))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (Maybe Bool, Range2)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe (Maybe Bool, Range2)))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Bool, Range2)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Maybe Bool, Range2))
forall a b. (a -> b) -> a -> b
$ (,) Maybe Bool
vs (Range2 -> (Maybe Bool, Range2))
-> Parser Range2
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Bool, Range2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Range2
range2
  Maybe Delay3
d3 <- Parser Delay3
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay3)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Delay3
delay3
  NetProp -> Parser NetProp
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (NetProp -> Parser NetProp) -> NetProp -> Parser NetProp
forall a b. (a -> b) -> a -> b
$ Bool -> Maybe (Maybe Bool, Range2) -> Maybe Delay3 -> NetProp
NetProp Bool
sn Maybe (Maybe Bool, Range2)
vec Maybe Delay3
d3

-- | Uniform list of either initialisation or dimension
ediList :: Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl))
ediList :: Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl))
ediList = do
  Identifier
hdid <- Parser Identifier
ident
  Either Expr [Range2]
hddi <- (Token -> Parser ()
consume Token
SymEq Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Either Expr [Range2])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Either Expr [Range2])
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Expr -> Either Expr [Range2]
forall a b. a -> Either a b
Left (Expr -> Either Expr [Range2])
-> Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Either Expr [Range2])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
expr) ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Either Expr [Range2])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Either Expr [Range2])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Either Expr [Range2])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> [Range2] -> Either Expr [Range2]
forall a b. b -> Either a b
Right ([Range2] -> Either Expr [Range2])
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Either Expr [Range2])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Range2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser Range2
range2
  Bool
b <- Token -> Parser Bool
optConsume Token
SymComma
  if Bool
b
    then case Either Expr [Range2]
hddi of
      Left Expr
hdi -> NonEmpty NetInit -> Either (NonEmpty NetInit) (NonEmpty NetDecl)
forall a b. a -> Either a b
Left (NonEmpty NetInit -> Either (NonEmpty NetInit) (NonEmpty NetDecl))
-> ([NetInit] -> NonEmpty NetInit)
-> [NetInit]
-> Either (NonEmpty NetInit) (NonEmpty NetDecl)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Expr -> NetInit
NetInit Identifier
hdid Expr
hdi NetInit -> [NetInit] -> NonEmpty NetInit
forall a. a -> [a] -> NonEmpty a
:|) ([NetInit] -> Either (NonEmpty NetInit) (NonEmpty NetDecl))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [NetInit]
-> Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetInit
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [NetInit]
forall a. Parser a -> Parser [a]
csl (Identifier -> Expr -> NetInit
NetInit (Identifier -> Expr -> NetInit)
-> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
-> Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymEq ParsecT [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
-> Parser Expr -> Parser NetInit
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
expr)
      Right [Range2]
hdd -> NonEmpty NetDecl -> Either (NonEmpty NetInit) (NonEmpty NetDecl)
forall a b. b -> Either a b
Right (NonEmpty NetDecl -> Either (NonEmpty NetInit) (NonEmpty NetDecl))
-> ([NetDecl] -> NonEmpty NetDecl)
-> [NetDecl]
-> Either (NonEmpty NetInit) (NonEmpty NetDecl)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> [Range2] -> NetDecl
NetDecl Identifier
hdid [Range2]
hdd NetDecl -> [NetDecl] -> NonEmpty NetDecl
forall a. a -> [a] -> NonEmpty a
:|) ([NetDecl] -> Either (NonEmpty NetInit) (NonEmpty NetDecl))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [NetDecl]
-> Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetDecl
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [NetDecl]
forall a. Parser a -> Parser [a]
csl (Identifier -> [Range2] -> NetDecl
NetDecl (Identifier -> [Range2] -> NetDecl)
-> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) ([Range2] -> NetDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken] LocalCompDir (Writer [String]) ([Range2] -> NetDecl)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
-> Parser NetDecl
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Range2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser Range2
range2)
    else Either (NonEmpty NetInit) (NonEmpty NetDecl)
-> Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either (NonEmpty NetInit) (NonEmpty NetDecl)
 -> Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl)))
-> Either (NonEmpty NetInit) (NonEmpty NetDecl)
-> Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl))
forall a b. (a -> b) -> a -> b
$ (Expr -> NonEmpty NetInit)
-> ([Range2] -> NonEmpty NetDecl)
-> Either Expr [Range2]
-> Either (NonEmpty NetInit) (NonEmpty NetDecl)
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap ((NetInit -> [NetInit] -> NonEmpty NetInit
forall a. a -> [a] -> NonEmpty a
:|[]) (NetInit -> NonEmpty NetInit)
-> (Expr -> NetInit) -> Expr -> NonEmpty NetInit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Expr -> NetInit
NetInit Identifier
hdid) ((NetDecl -> [NetDecl] -> NonEmpty NetDecl
forall a. a -> [a] -> NonEmpty a
:|[]) (NetDecl -> NonEmpty NetDecl)
-> ([Range2] -> NetDecl) -> [Range2] -> NonEmpty NetDecl
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> [Range2] -> NetDecl
NetDecl Identifier
hdid) Either Expr [Range2]
hddi

-- | Net declaration
netDecl :: NetType -> Parser ModGenSingleItem
netDecl :: NetType -> Parser ModGenSingleItem
netDecl NetType
nt = do
  Maybe DriveStrength
ods <- Parser DriveStrength
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe DriveStrength)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser DriveStrength
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (Maybe DriveStrength))
-> Parser DriveStrength
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe DriveStrength)
forall a b. (a -> b) -> a -> b
$ Parser DriveStrength -> Parser DriveStrength
forall a. Parser a -> Parser a
parens Parser DriveStrength
comDriveStrength
  NetProp
np <- Parser NetProp
netProp
  ModGenSingleItem
x <- case Maybe DriveStrength
ods of
    Just DriveStrength
ds -> NetType
-> DriveStrength -> NetProp -> NonEmpty NetInit -> ModGenSingleItem
forall (f :: * -> *).
NetType -> DriveStrength -> NetProp -> f NetInit -> ModGenItem f
MGINetInit NetType
nt DriveStrength
ds NetProp
np (NonEmpty NetInit -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty NetInit)
-> Parser ModGenSingleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetInit
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty NetInit)
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Identifier -> Expr -> NetInit
NetInit (Identifier -> Expr -> NetInit)
-> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
-> Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymEq ParsecT [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
-> Parser Expr -> Parser NetInit
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
expr)
    Maybe DriveStrength
Nothing -> (NonEmpty NetInit -> ModGenSingleItem)
-> (NonEmpty NetDecl -> ModGenSingleItem)
-> Either (NonEmpty NetInit) (NonEmpty NetDecl)
-> ModGenSingleItem
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (NetType
-> DriveStrength -> NetProp -> NonEmpty NetInit -> ModGenSingleItem
forall (f :: * -> *).
NetType -> DriveStrength -> NetProp -> f NetInit -> ModGenItem f
MGINetInit NetType
nt DriveStrength
dsDefault NetProp
np) (NetType -> NetProp -> NonEmpty NetDecl -> ModGenSingleItem
forall (f :: * -> *).
NetType -> NetProp -> f NetDecl -> ModGenItem f
MGINetDecl NetType
nt NetProp
np) (Either (NonEmpty NetInit) (NonEmpty NetDecl) -> ModGenSingleItem)
-> Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl))
-> Parser ModGenSingleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl))
ediList
  Token -> Parser ()
consume Token
SymSemi
  ModGenSingleItem -> Parser ModGenSingleItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ModGenSingleItem
x

-- | Trireg declaration
triregDecl :: Parser ModGenSingleItem
triregDecl :: Parser ModGenSingleItem
triregDecl = do
  Maybe (Either DriveStrength ChargeStrength)
ods_cs <- ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Either DriveStrength ChargeStrength)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Either DriveStrength ChargeStrength))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (Either DriveStrength ChargeStrength)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe (Either DriveStrength ChargeStrength)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either DriveStrength ChargeStrength)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Either DriveStrength ChargeStrength))
forall a b. (a -> b) -> a -> b
$
    ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Either DriveStrength ChargeStrength)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either DriveStrength ChargeStrength)
forall a. Parser a -> Parser a
parens (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (Either DriveStrength ChargeStrength)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Either DriveStrength ChargeStrength))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either DriveStrength ChargeStrength)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either DriveStrength ChargeStrength)
forall a b. (a -> b) -> a -> b
$
      ChargeStrength -> Either DriveStrength ChargeStrength
forall a b. b -> Either a b
Right (ChargeStrength -> Either DriveStrength ChargeStrength)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) ChargeStrength
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either DriveStrength ChargeStrength)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Token -> Maybe ChargeStrength)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) ChargeStrength
forall a. (Token -> Maybe a) -> Parser a
fproduce
        ( \Token
t -> case Token
t of
          Token
KWSmall -> ChargeStrength -> Maybe ChargeStrength
forall a. a -> Maybe a
Just ChargeStrength
CSSmall
          Token
KWMedium -> ChargeStrength -> Maybe ChargeStrength
forall a. a -> Maybe a
Just ChargeStrength
CSMedium
          Token
KWLarge -> ChargeStrength -> Maybe ChargeStrength
forall a. a -> Maybe a
Just ChargeStrength
CSLarge
          Token
_ -> Maybe ChargeStrength
forall a. Maybe a
Nothing
        )
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Either DriveStrength ChargeStrength)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either DriveStrength ChargeStrength)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either DriveStrength ChargeStrength)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> DriveStrength -> Either DriveStrength ChargeStrength
forall a b. a -> Either a b
Left (DriveStrength -> Either DriveStrength ChargeStrength)
-> Parser DriveStrength
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Either DriveStrength ChargeStrength)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser DriveStrength
comDriveStrength
  NetProp
np <- Parser NetProp
netProp
  ModGenSingleItem
x <- case Maybe (Either DriveStrength ChargeStrength)
ods_cs of
    Just (Left DriveStrength
ds) -> DriveStrength -> NetProp -> NonEmpty NetInit -> ModGenSingleItem
forall (f :: * -> *).
DriveStrength -> NetProp -> f NetInit -> ModGenItem f
MGITriD DriveStrength
ds NetProp
np (NonEmpty NetInit -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty NetInit)
-> Parser ModGenSingleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetInit
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty NetInit)
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Identifier -> Expr -> NetInit
NetInit (Identifier -> Expr -> NetInit)
-> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
-> Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymEq ParsecT [PosToken] LocalCompDir (Writer [String]) (Expr -> NetInit)
-> Parser Expr -> Parser NetInit
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
expr)
    Just (Right ChargeStrength
cs) -> ChargeStrength -> NetProp -> NonEmpty NetDecl -> ModGenSingleItem
forall (f :: * -> *).
ChargeStrength -> NetProp -> f NetDecl -> ModGenItem f
MGITriC ChargeStrength
cs NetProp
np (NonEmpty NetDecl -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty NetDecl)
-> Parser ModGenSingleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetDecl
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty NetDecl)
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Identifier -> [Range2] -> NetDecl
NetDecl (Identifier -> [Range2] -> NetDecl)
-> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) ([Range2] -> NetDecl)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken] LocalCompDir (Writer [String]) ([Range2] -> NetDecl)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
-> Parser NetDecl
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Range2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser Range2
range2)
    Maybe (Either DriveStrength ChargeStrength)
Nothing -> (NonEmpty NetInit -> ModGenSingleItem)
-> (NonEmpty NetDecl -> ModGenSingleItem)
-> Either (NonEmpty NetInit) (NonEmpty NetDecl)
-> ModGenSingleItem
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (DriveStrength -> NetProp -> NonEmpty NetInit -> ModGenSingleItem
forall (f :: * -> *).
DriveStrength -> NetProp -> f NetInit -> ModGenItem f
MGITriD DriveStrength
dsDefault NetProp
np) (ChargeStrength -> NetProp -> NonEmpty NetDecl -> ModGenSingleItem
forall (f :: * -> *).
ChargeStrength -> NetProp -> f NetDecl -> ModGenItem f
MGITriC ChargeStrength
CSMedium NetProp
np) (Either (NonEmpty NetInit) (NonEmpty NetDecl) -> ModGenSingleItem)
-> Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl))
-> Parser ModGenSingleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Either (NonEmpty NetInit) (NonEmpty NetDecl))
ediList
  Token -> Parser ()
consume Token
SymSemi
  ModGenSingleItem -> Parser ModGenSingleItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ModGenSingleItem
x

-- | Module or Generate region statement
comModGenItem :: LProduce (SourcePos -> Parser ModGenSingleItem)
comModGenItem :: [Produce (SourcePos -> Parser ModGenSingleItem)]
comModGenItem =
  ( (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr))
 -> SourcePos -> Parser ModGenSingleItem)
-> LProduce
     (ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)))
-> [Produce (SourcePos -> Parser ModGenSingleItem)]
forall a b. (a -> b) -> LProduce a -> LProduce b
maplproduce (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. a -> b -> a
const (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem)
-> (ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr))
    -> Parser ModGenSingleItem)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr))
-> SourcePos
-> Parser ModGenSingleItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
 -> ModGenSingleItem)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr))
-> Parser ModGenSingleItem
forall a b.
(a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)
-> ModGenSingleItem
forall (f :: * -> *).
BlockDecl (Compose f Identified) (Either [Range2] CExpr)
-> ModGenItem f
MGIBlockDecl) (LProduce
   (ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)))
 -> [Produce (SourcePos -> Parser ModGenSingleItem)])
-> LProduce
     (ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)))
-> [Produce (SourcePos -> Parser ModGenSingleItem)]
forall a b. (a -> b) -> a -> b
$
      Parser (Either [Range2] CExpr)
-> LProduce
     (ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)))
forall t.
Parser t -> LBranch (BlockDecl (Compose NonEmpty Identified) t)
blockDecl (Parser (Either [Range2] CExpr)
 -> LProduce
      (ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr))))
-> Parser (Either [Range2] CExpr)
-> LProduce
     (ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (BlockDecl (Compose NonEmpty Identified) (Either [Range2] CExpr)))
forall a b. (a -> b) -> a -> b
$ (Token -> Parser ()
consume Token
SymEq Parser ()
-> Parser (Either [Range2] CExpr) -> Parser (Either [Range2] CExpr)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CExpr -> Either [Range2] CExpr
forall a b. b -> Either a b
Right (CExpr -> Either [Range2] CExpr)
-> Parser CExpr -> Parser (Either [Range2] CExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser CExpr
constExpr) Parser (Either [Range2] CExpr)
-> Parser (Either [Range2] CExpr) -> Parser (Either [Range2] CExpr)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> [Range2] -> Either [Range2] CExpr
forall a b. a -> Either a b
Left ([Range2] -> Either [Range2] CExpr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
-> Parser (Either [Range2] CExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Range2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Range2]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser Range2
range2
  )
  [Produce (SourcePos -> Parser ModGenSingleItem)]
-> [Produce (SourcePos -> Parser ModGenSingleItem)]
-> [Produce (SourcePos -> Parser ModGenSingleItem)]
forall a. [a] -> [a] -> [a]
++ (NetType -> SourcePos -> Parser ModGenSingleItem)
-> LProduce NetType
-> [Produce (SourcePos -> Parser ModGenSingleItem)]
forall a b. (a -> b) -> LProduce a -> LProduce b
maplproduce (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. a -> b -> a
const (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem)
-> (NetType -> Parser ModGenSingleItem)
-> NetType
-> SourcePos
-> Parser ModGenSingleItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NetType -> Parser ModGenSingleItem
netDecl) LProduce NetType
netType
  [Produce (SourcePos -> Parser ModGenSingleItem)]
-> [Produce (SourcePos -> Parser ModGenSingleItem)]
-> [Produce (SourcePos -> Parser ModGenSingleItem)]
forall a. [a] -> [a] -> [a]
++ [ (Token
KWCmos, Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> p -> Parser ModGenSingleItem
gateCmos Bool
False),
       (Token
KWRcmos, Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> p -> Parser ModGenSingleItem
gateCmos Bool
True),
       (Token
KWBufif0, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gateEnable Bool
False Bool
False),
       (Token
KWBufif1, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gateEnable Bool
False Bool
True),
       (Token
KWNotif0, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gateEnable Bool
True Bool
False),
       (Token
KWNotif1, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gateEnable Bool
True Bool
True),
       (Token
KWNmos, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gateMos Bool
False Bool
True),
       (Token
KWPmos, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gateMos Bool
False Bool
False),
       (Token
KWRnmos, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gateMos Bool
True Bool
True),
       (Token
KWRpmos, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gateMos Bool
True Bool
False),
       (Token
KWAnd, NInputType -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. NInputType -> Bool -> p -> Parser ModGenSingleItem
gateNinp NInputType
NITAnd Bool
False),
       (Token
KWNand, NInputType -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. NInputType -> Bool -> p -> Parser ModGenSingleItem
gateNinp NInputType
NITAnd Bool
True),
       (Token
KWOr, NInputType -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. NInputType -> Bool -> p -> Parser ModGenSingleItem
gateNinp NInputType
NITOr Bool
False),
       (Token
KWNor, NInputType -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. NInputType -> Bool -> p -> Parser ModGenSingleItem
gateNinp NInputType
NITOr Bool
True),
       (Token
KWXor, NInputType -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. NInputType -> Bool -> p -> Parser ModGenSingleItem
gateNinp NInputType
NITXor Bool
False),
       (Token
KWXnor, NInputType -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. NInputType -> Bool -> p -> Parser ModGenSingleItem
gateNinp NInputType
NITXor Bool
True),
       (Token
KWBuf, Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> p -> Parser ModGenSingleItem
gateNout Bool
False),
       (Token
KWNot, Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> p -> Parser ModGenSingleItem
gateNout Bool
True),
       (Token
KWTranif0, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gatePassen Bool
False Bool
False),
       (Token
KWTranif1, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gatePassen Bool
False Bool
True),
       (Token
KWRtranif0, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gatePassen Bool
True Bool
False),
       (Token
KWRtranif1, Bool -> Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> Bool -> p -> Parser ModGenSingleItem
gatePassen Bool
True Bool
True),
       (Token
KWTran, Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> p -> Parser ModGenSingleItem
gatePass Bool
False),
       (Token
KWRtran, Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> p -> Parser ModGenSingleItem
gatePass Bool
True),
       (Token
KWPulldown, Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> p -> Parser ModGenSingleItem
gatePull Bool
False),
       (Token
KWPullup, Bool -> SourcePos -> Parser ModGenSingleItem
forall {p}. Bool -> p -> Parser ModGenSingleItem
gatePull Bool
True),
       (Token
KWInitial, Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. a -> b -> a
const (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem)
-> Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ Attributed Statement -> ModGenSingleItem
forall (f :: * -> *). Attributed Statement -> ModGenItem f
MGIInitial (Attributed Statement -> ModGenSingleItem)
-> Parser (Attributed Statement) -> Parser ModGenSingleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Attributed Statement)
attrStmt),
       (Token
KWAlways, Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. a -> b -> a
const (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem)
-> Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ Attributed Statement -> ModGenSingleItem
forall (f :: * -> *). Attributed Statement -> ModGenItem f
MGIAlways (Attributed Statement -> ModGenSingleItem)
-> Parser (Attributed Statement) -> Parser ModGenSingleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Attributed Statement)
attrStmt),
       (Token
KWTrireg, Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. a -> b -> a
const Parser ModGenSingleItem
triregDecl),
       (Token
KWGenvar, Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. a -> b -> a
const (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem)
-> Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ NonEmpty Identifier -> ModGenSingleItem
forall (f :: * -> *). f Identifier -> ModGenItem f
MGIGenVar (NonEmpty Identifier -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Identifier)
-> Parser ModGenSingleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Identifier)
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser Identifier
ident Parser ModGenSingleItem -> Parser () -> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi),
       ( Token
KWIf,
         Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. a -> b -> a
const (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem)
-> Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$
           (ModGenCondItem -> ModGenSingleItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) ModGenCondItem
-> Parser ModGenSingleItem
forall a b.
(a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ModGenCondItem -> ModGenSingleItem
forall (f :: * -> *). ModGenCondItem -> ModGenItem f
MGICondItem (ParsecT [PosToken] LocalCompDir (Writer [String]) ModGenCondItem
 -> Parser ModGenSingleItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) ModGenCondItem
-> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$
             CExpr -> GenerateCondBlock -> GenerateCondBlock -> ModGenCondItem
MGCIIf (CExpr -> GenerateCondBlock -> GenerateCondBlock -> ModGenCondItem)
-> Parser CExpr
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock -> GenerateCondBlock -> ModGenCondItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser CExpr -> Parser CExpr
forall a. Parser a -> Parser a
parens Parser CExpr
constExpr
               ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenerateCondBlock -> GenerateCondBlock -> ModGenCondItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock -> ModGenCondItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
genCondBlock
               ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenerateCondBlock -> ModGenCondItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT [PosToken] LocalCompDir (Writer [String]) ModGenCondItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option GenerateCondBlock
GCBEmpty (Token -> Parser ()
consume Token
KWElse Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
genCondBlock)
       ),
       ( Token
KWBegin,
         \SourcePos
pos -> do
           SourcePos -> String -> Parser ()
warn SourcePos
pos String
"Generate blocks outside of for/if/case is a Verilog 2001 feature disallowed by later standards"
           Identifier
s <- Identifier -> Parser Identifier -> Parser Identifier
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Identifier
"" (Parser Identifier -> Parser Identifier)
-> Parser Identifier -> Parser Identifier
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymColon Parser () -> Parser Identifier -> Parser Identifier
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Identifier
ident
           [[Attributed ModGenBlockedItem]]
gr <- ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  [Attributed ModGenBlockedItem]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[Attributed ModGenBlockedItem]]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   [Attributed ModGenBlockedItem]
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      [[Attributed ModGenBlockedItem]])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [Attributed ModGenBlockedItem]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[Attributed ModGenBlockedItem]]
forall a b. (a -> b) -> a -> b
$ (Attributed ModGenBlockedItem -> Attributed ModGenBlockedItem)
-> LAPBranch (NonEmpty (Attributed ModGenBlockedItem))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [Attributed ModGenBlockedItem]
forall a.
(Attributed ModGenBlockedItem -> a)
-> LAPBranch (NonEmpty a) -> Parser [a]
parseItem Attributed ModGenBlockedItem -> Attributed ModGenBlockedItem
forall a. a -> a
id []
           SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
pos Token
KWBegin Token
KWEnd
           ModGenSingleItem -> Parser ModGenSingleItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModGenSingleItem -> Parser ModGenSingleItem)
-> ModGenSingleItem -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$
             ModGenCondItem -> ModGenSingleItem
forall (f :: * -> *). ModGenCondItem -> ModGenItem f
MGICondItem (ModGenCondItem -> ModGenSingleItem)
-> ModGenCondItem -> ModGenSingleItem
forall a b. (a -> b) -> a -> b
$
               CExpr -> GenerateCondBlock -> GenerateCondBlock -> ModGenCondItem
MGCIIf (GenExpr Identifier (Maybe CRangeExpr) Attributes -> CExpr
CExpr (GenExpr Identifier (Maybe CRangeExpr) Attributes -> CExpr)
-> GenExpr Identifier (Maybe CRangeExpr) Attributes -> CExpr
forall a b. (a -> b) -> a -> b
$ Natural -> GenExpr Identifier (Maybe CRangeExpr) Attributes
forall i r a. Natural -> GenExpr i r a
genexprnumber Natural
1) (GenerateBlock -> GenerateCondBlock
GCBBlock (GenerateBlock -> GenerateCondBlock)
-> GenerateBlock -> GenerateCondBlock
forall a b. (a -> b) -> a -> b
$ Identifier -> [Attributed ModGenBlockedItem] -> GenerateBlock
forall t. Identifier -> t -> Identified t
Identified Identifier
s ([Attributed ModGenBlockedItem] -> GenerateBlock)
-> [Attributed ModGenBlockedItem] -> GenerateBlock
forall a b. (a -> b) -> a -> b
$ [[Attributed ModGenBlockedItem]] -> [Attributed ModGenBlockedItem]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Attributed ModGenBlockedItem]]
gr) GenerateCondBlock
GCBEmpty
       ),
       ( Token
KWAssign,
         Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. a -> b -> a
const (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem)
-> Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$
           DriveStrength
-> Maybe Delay3 -> NonEmpty NetAssign -> ModGenSingleItem
forall (f :: * -> *).
DriveStrength -> Maybe Delay3 -> f NetAssign -> ModGenItem f
MGIContAss (DriveStrength
 -> Maybe Delay3 -> NonEmpty NetAssign -> ModGenSingleItem)
-> Parser DriveStrength
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe Delay3 -> NonEmpty NetAssign -> ModGenSingleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser DriveStrength
driveStrength
             ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe Delay3 -> NonEmpty NetAssign -> ModGenSingleItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay3)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty NetAssign -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Delay3
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay3)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Delay3
delay3
             ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty NetAssign -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty NetAssign)
-> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser NetAssign
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty NetAssign)
forall a. Parser a -> Parser (NonEmpty a)
csl1 (NetLValue -> Expr -> NetAssign
forall dr. LValue dr -> Expr -> Assign dr
Assign (NetLValue -> Expr -> NetAssign)
-> Parser NetLValue
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Expr -> NetAssign)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NetLValue
netLV ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Expr -> NetAssign)
-> Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Expr -> NetAssign)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymEq ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Expr -> NetAssign)
-> Parser Expr -> Parser NetAssign
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
expr)
             Parser ModGenSingleItem -> Parser () -> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi
       ),
       ( Token
KWDefparam,
         Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. a -> b -> a
const (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem)
-> Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$
           NonEmpty ParamOver -> ModGenSingleItem
forall (f :: * -> *). f ParamOver -> ModGenItem f
MGIDefParam (NonEmpty ParamOver -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty ParamOver)
-> Parser ModGenSingleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ParamOver
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty ParamOver)
forall a. Parser a -> Parser (NonEmpty a)
csl1 (HierIdent -> GenMinTypMax CExpr -> ParamOver
ParamOver (HierIdent -> GenMinTypMax CExpr -> ParamOver)
-> Parser HierIdent
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenMinTypMax CExpr -> ParamOver)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Parser HierIdent
hierIdent Bool
False ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenMinTypMax CExpr -> ParamOver)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenMinTypMax CExpr -> ParamOver)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymEq ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenMinTypMax CExpr -> ParamOver)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> Parser ParamOver
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser CExpr
constExpr)
             Parser ModGenSingleItem -> Parser () -> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi
       ),
       ( Token
KWCase,
         \SourcePos
pos -> do
           CExpr
cond <- Parser CExpr -> Parser CExpr
forall a. Parser a -> Parser a
parens Parser CExpr
constExpr
           (GenerateCondBlock
d, [GenCaseItem]
b) <- do
             [GenCaseItem]
cb <- ParsecT [PosToken] LocalCompDir (Writer [String]) GenCaseItem
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [GenCaseItem]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT [PosToken] LocalCompDir (Writer [String]) GenCaseItem
cbranch
             (if [GenCaseItem] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [GenCaseItem]
cb then ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenerateCondBlock, [GenCaseItem])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock, [GenCaseItem])
forall a. a -> a
id else (GenerateCondBlock, [GenCaseItem])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock, [GenCaseItem])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock, [GenCaseItem])
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option (GenerateCondBlock
GCBEmpty, [GenCaseItem]
cb)) (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (GenerateCondBlock, [GenCaseItem])
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (GenerateCondBlock, [GenCaseItem]))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock, [GenCaseItem])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock, [GenCaseItem])
forall a b. (a -> b) -> a -> b
$ do
               Token -> Parser ()
consume Token
KWDefault
               () -> Parser () -> Parser ()
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option () (Parser () -> Parser ()) -> Parser () -> Parser ()
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymColon
               ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [GenCaseItem]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock, [GenCaseItem])
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f (a, b)
mkpair ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
genCondBlock (ParsecT [PosToken] LocalCompDir (Writer [String]) [GenCaseItem]
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (GenerateCondBlock, [GenCaseItem]))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [GenCaseItem]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock, [GenCaseItem])
forall a b. (a -> b) -> a -> b
$ ([GenCaseItem]
cb [GenCaseItem] -> [GenCaseItem] -> [GenCaseItem]
forall a. Semigroup a => a -> a -> a
<>) ([GenCaseItem] -> [GenCaseItem])
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [GenCaseItem]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [GenCaseItem]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [PosToken] LocalCompDir (Writer [String]) GenCaseItem
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [GenCaseItem]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT [PosToken] LocalCompDir (Writer [String]) GenCaseItem
cbranch
           SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
pos Token
KWCase Token
KWEndcase
           ModGenSingleItem -> Parser ModGenSingleItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModGenSingleItem -> Parser ModGenSingleItem)
-> ModGenSingleItem -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ ModGenCondItem -> ModGenSingleItem
forall (f :: * -> *). ModGenCondItem -> ModGenItem f
MGICondItem (ModGenCondItem -> ModGenSingleItem)
-> ModGenCondItem -> ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ CExpr -> [GenCaseItem] -> GenerateCondBlock -> ModGenCondItem
MGCICase CExpr
cond [GenCaseItem]
b GenerateCondBlock
d
       ),
       ( Token
KWFor,
         Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. a -> b -> a
const (Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem)
-> Parser ModGenSingleItem -> SourcePos -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$
           Parser (GenerateBlock -> ModGenSingleItem)
-> Parser (GenerateBlock -> ModGenSingleItem)
forall a. Parser a -> Parser a
parens
             ( Identifier
-> CExpr
-> CExpr
-> Identifier
-> CExpr
-> GenerateBlock
-> ModGenSingleItem
forall (f :: * -> *).
Identifier
-> CExpr
-> CExpr
-> Identifier
-> CExpr
-> GenerateBlock
-> ModGenItem f
MGILoopGen (Identifier
 -> CExpr
 -> CExpr
 -> Identifier
 -> CExpr
 -> GenerateBlock
 -> ModGenSingleItem)
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (CExpr
      -> CExpr
      -> Identifier
      -> CExpr
      -> GenerateBlock
      -> ModGenSingleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident
                 ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (CExpr
   -> CExpr
   -> Identifier
   -> CExpr
   -> GenerateBlock
   -> ModGenSingleItem)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (CExpr
      -> CExpr
      -> Identifier
      -> CExpr
      -> GenerateBlock
      -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymEq
                 ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (CExpr
   -> CExpr
   -> Identifier
   -> CExpr
   -> GenerateBlock
   -> ModGenSingleItem)
-> Parser CExpr
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (CExpr -> Identifier -> CExpr -> GenerateBlock -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser CExpr
constExpr
                 ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (CExpr -> Identifier -> CExpr -> GenerateBlock -> ModGenSingleItem)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (CExpr -> Identifier -> CExpr -> GenerateBlock -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi
                 ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (CExpr -> Identifier -> CExpr -> GenerateBlock -> ModGenSingleItem)
-> Parser CExpr
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Identifier -> CExpr -> GenerateBlock -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser CExpr
constExpr
                 ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Identifier -> CExpr -> GenerateBlock -> ModGenSingleItem)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Identifier -> CExpr -> GenerateBlock -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi
                 ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Identifier -> CExpr -> GenerateBlock -> ModGenSingleItem)
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (CExpr -> GenerateBlock -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Identifier
ident
                 ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (CExpr -> GenerateBlock -> ModGenSingleItem)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (CExpr -> GenerateBlock -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymEq
                 ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (CExpr -> GenerateBlock -> ModGenSingleItem)
-> Parser CExpr -> Parser (GenerateBlock -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser CExpr
constExpr
             )
             Parser (GenerateBlock -> ModGenSingleItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
-> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
genBlock ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
-> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
-> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Identifier -> [Attributed ModGenBlockedItem] -> GenerateBlock
forall t. Identifier -> t -> Identified t
Identified Identifier
"" ([Attributed ModGenBlockedItem] -> GenerateBlock)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [Attributed ModGenBlockedItem]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  [Attributed ModGenBlockedItem]
genSingle)
       ),
       ( Token
KWTask,
         \SourcePos
pos -> do
           Bool
auto <- Token -> Parser Bool
optConsume Token
KWAutomatic
           Identifier
name <- Parser Identifier
ident
           ([AttrIded (TFBlockDecl Dir)]
decl, [MybStmt]
body) <- Bool
-> (Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl Dir))))
-> Parser ([AttrIded (TFBlockDecl Dir)], [MybStmt])
forall a.
Bool
-> (Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl a))))
-> Parser ([AttrIded (TFBlockDecl a)], [MybStmt])
taskFun Bool
True Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl Dir)))
taskArgDecl
           SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
pos Token
KWTask Token
KWEndtask
           ModGenSingleItem -> Parser ModGenSingleItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModGenSingleItem -> Parser ModGenSingleItem)
-> ModGenSingleItem -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$
             Bool
-> Identifier
-> [AttrIded (TFBlockDecl Dir)]
-> MybStmt
-> ModGenSingleItem
forall (f :: * -> *).
Bool
-> Identifier
-> [AttrIded (TFBlockDecl Dir)]
-> MybStmt
-> ModGenItem f
MGITask Bool
auto Identifier
name [AttrIded (TFBlockDecl Dir)]
decl (MybStmt -> ModGenSingleItem) -> MybStmt -> ModGenSingleItem
forall a b. (a -> b) -> a -> b
$
               case [MybStmt]
body of
                 [Item [MybStmt]
x] -> Item [MybStmt]
MybStmt
x
                 [MybStmt]
_ -> Attributes -> Maybe Statement -> MybStmt
forall t. Attributes -> t -> Attributed t
Attributed [] (Maybe Statement -> MybStmt) -> Maybe Statement -> MybStmt
forall a b. (a -> b) -> a -> b
$ Statement -> Maybe Statement
forall a. a -> Maybe a
Just (Statement -> Maybe Statement) -> Statement -> Maybe Statement
forall a b. (a -> b) -> a -> b
$ Maybe (Identifier, [AttrIded StdBlockDecl])
-> Bool -> [Attributed Statement] -> Statement
SBlock Maybe (Identifier, [AttrIded StdBlockDecl])
forall a. Maybe a
Nothing Bool
False ([Attributed Statement] -> Statement)
-> [Attributed Statement] -> Statement
forall a b. (a -> b) -> a -> b
$ (MybStmt -> Attributed Statement)
-> [MybStmt] -> [Attributed Statement]
forall a b. (a -> b) -> [a] -> [b]
map MybStmt -> Attributed Statement
fromMybStmt [MybStmt]
body
       ),
       ( Token
KWFunction,
         \SourcePos
pos -> do
           Bool
auto <- Token -> Parser Bool
optConsume Token
KWAutomatic
           Maybe (ComType ())
t <- Parser (ComType ())
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe (ComType ()))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser () -> Parser (ComType ())
forall t. Parser t -> Parser (ComType t)
comType (Parser () -> Parser (ComType ()))
-> Parser () -> Parser (ComType ())
forall a b. (a -> b) -> a -> b
$ () -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ())
           Identifier
name <- Parser Identifier
ident
           ([AttrIded (TFBlockDecl ())]
decl, [MybStmt]
body) <- Bool
-> (Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl ()))))
-> Parser ([AttrIded (TFBlockDecl ())], [MybStmt])
forall a.
Bool
-> (Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl a))))
-> Parser ([AttrIded (TFBlockDecl a)], [MybStmt])
taskFun Bool
False Bool -> LABranch (NonEmpty (AttrIded (TFBlockDecl ())))
funArgDecl
           FunctionStatement
b <- case (MybStmt -> Maybe (Attributed FunctionStatement))
-> [MybStmt] -> Maybe [Attributed FunctionStatement]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Statement -> Maybe FunctionStatement)
-> Attributed Statement -> Maybe (Attributed FunctionStatement)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Attributed a -> f (Attributed b)
traverse Statement -> Maybe FunctionStatement
fromStatement (Attributed Statement -> Maybe (Attributed FunctionStatement))
-> (MybStmt -> Attributed Statement)
-> MybStmt
-> Maybe (Attributed FunctionStatement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MybStmt -> Attributed Statement
fromMybStmt) [MybStmt]
body of
             Maybe [Attributed FunctionStatement]
Nothing ->
              String
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) FunctionStatement
forall a. String -> Parser a
hardfail
                String
"Events, delays, continuous assignments and tasks are forbidden in function statements"
             Just [Attributed [] FunctionStatement
x] -> FunctionStatement
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) FunctionStatement
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return FunctionStatement
x
             Just [Attributed FunctionStatement]
l -> FunctionStatement
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) FunctionStatement
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (FunctionStatement
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) FunctionStatement)
-> FunctionStatement
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) FunctionStatement
forall a b. (a -> b) -> a -> b
$ Maybe (Identifier, [AttrIded StdBlockDecl])
-> Bool -> [Attributed FunctionStatement] -> FunctionStatement
FSBlock Maybe (Identifier, [AttrIded StdBlockDecl])
forall a. Maybe a
Nothing Bool
False [Attributed FunctionStatement]
l
           SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
pos Token
KWFunction Token
KWEndfunction
           ModGenSingleItem -> Parser ModGenSingleItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModGenSingleItem -> Parser ModGenSingleItem)
-> ModGenSingleItem -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ Bool
-> Maybe (ComType ())
-> Identifier
-> [AttrIded (TFBlockDecl ())]
-> FunctionStatement
-> ModGenSingleItem
forall (f :: * -> *).
Bool
-> Maybe (ComType ())
-> Identifier
-> [AttrIded (TFBlockDecl ())]
-> FunctionStatement
-> ModGenItem f
MGIFunc Bool
auto Maybe (ComType ())
t Identifier
name [AttrIded (TFBlockDecl ())]
decl FunctionStatement
b
       )
     ]
  where
    cbranch :: ParsecT [PosToken] LocalCompDir (Writer [String]) GenCaseItem
cbranch = NonEmpty CExpr -> GenerateCondBlock -> GenCaseItem
GenCaseItem (NonEmpty CExpr -> GenerateCondBlock -> GenCaseItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty CExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock -> GenCaseItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty CExpr)
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser CExpr
constExpr ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenerateCondBlock -> GenCaseItem)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenerateCondBlock -> GenCaseItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymColon ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenerateCondBlock -> GenCaseItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT [PosToken] LocalCompDir (Writer [String]) GenCaseItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
genCondBlock
    gateCmos :: Bool -> p -> Parser ModGenSingleItem
gateCmos Bool
r p
_ =
      Bool -> Maybe Delay3 -> NonEmpty GICMos -> ModGenSingleItem
forall (f :: * -> *).
Bool -> Maybe Delay3 -> f GICMos -> ModGenItem f
MGICMos Bool
r (Maybe Delay3 -> NonEmpty GICMos -> ModGenSingleItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay3)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty GICMos -> ModGenSingleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Delay3
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay3)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Delay3
delay3
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty GICMos -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GICMos)
-> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GIF GICMos
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GICMos)
forall a. GIF a -> Parser (NonEmpty a)
gateInst
          (\Maybe InstanceName
mn NetLValue
lv NonEmpty Expr
args -> case NonEmpty Expr
args of [Item (NonEmpty Expr)
i, Item (NonEmpty Expr)
n, Item (NonEmpty Expr)
p] -> GICMos -> Maybe GICMos
forall a. a -> Maybe a
Just (GICMos -> Maybe GICMos) -> GICMos -> Maybe GICMos
forall a b. (a -> b) -> a -> b
$ Maybe InstanceName -> NetLValue -> Expr -> Expr -> Expr -> GICMos
GICMos Maybe InstanceName
mn NetLValue
lv Item (NonEmpty Expr)
Expr
i Item (NonEmpty Expr)
Expr
n Item (NonEmpty Expr)
Expr
p; NonEmpty Expr
_ -> Maybe GICMos
forall a. Maybe a
Nothing)
    gateEnable :: Bool -> Bool -> p -> Parser ModGenSingleItem
gateEnable Bool
r Bool
b p
_ =
      Bool
-> Bool
-> DriveStrength
-> Maybe Delay3
-> NonEmpty GIEnable
-> ModGenSingleItem
forall (f :: * -> *).
Bool
-> Bool
-> DriveStrength
-> Maybe Delay3
-> f GIEnable
-> ModGenItem f
MGIEnable Bool
r Bool
b (DriveStrength
 -> Maybe Delay3 -> NonEmpty GIEnable -> ModGenSingleItem)
-> Parser DriveStrength
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe Delay3 -> NonEmpty GIEnable -> ModGenSingleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser DriveStrength
driveStrength
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe Delay3 -> NonEmpty GIEnable -> ModGenSingleItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay3)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty GIEnable -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Delay3
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay3)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Delay3
delay3
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty GIEnable -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIEnable)
-> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GIF GIEnable
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIEnable)
forall a. GIF a -> Parser (NonEmpty a)
gateInst
          (\Maybe InstanceName
n NetLValue
lv NonEmpty Expr
args -> case NonEmpty Expr
args of [Item (NonEmpty Expr)
inp, Item (NonEmpty Expr)
en] -> GIEnable -> Maybe GIEnable
forall a. a -> Maybe a
Just (GIEnable -> Maybe GIEnable) -> GIEnable -> Maybe GIEnable
forall a b. (a -> b) -> a -> b
$ Maybe InstanceName -> NetLValue -> Expr -> Expr -> GIEnable
GIEnable Maybe InstanceName
n NetLValue
lv Item (NonEmpty Expr)
Expr
inp Item (NonEmpty Expr)
Expr
en; NonEmpty Expr
_ -> Maybe GIEnable
forall a. Maybe a
Nothing)
    gateMos :: Bool -> Bool -> p -> Parser ModGenSingleItem
gateMos Bool
r Bool
np p
_ =
      Bool -> Bool -> Maybe Delay3 -> NonEmpty GIMos -> ModGenSingleItem
forall (f :: * -> *).
Bool -> Bool -> Maybe Delay3 -> f GIMos -> ModGenItem f
MGIMos Bool
r Bool
np (Maybe Delay3 -> NonEmpty GIMos -> ModGenSingleItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay3)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty GIMos -> ModGenSingleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Delay3
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay3)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Delay3
delay3
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty GIMos -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIMos)
-> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GIF GIMos
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIMos)
forall a. GIF a -> Parser (NonEmpty a)
gateInst
          (\Maybe InstanceName
n NetLValue
lv NonEmpty Expr
args -> case NonEmpty Expr
args of [Item (NonEmpty Expr)
inp, Item (NonEmpty Expr)
en] -> GIMos -> Maybe GIMos
forall a. a -> Maybe a
Just (GIMos -> Maybe GIMos) -> GIMos -> Maybe GIMos
forall a b. (a -> b) -> a -> b
$ Maybe InstanceName -> NetLValue -> Expr -> Expr -> GIMos
GIMos Maybe InstanceName
n NetLValue
lv Item (NonEmpty Expr)
Expr
inp Item (NonEmpty Expr)
Expr
en; NonEmpty Expr
_ -> Maybe GIMos
forall a. Maybe a
Nothing)
    gateNinp :: NInputType -> Bool -> p -> Parser ModGenSingleItem
gateNinp NInputType
t Bool
n p
_ =
      NInputType
-> Bool
-> DriveStrength
-> Maybe Delay2
-> NonEmpty GINIn
-> ModGenSingleItem
forall (f :: * -> *).
NInputType
-> Bool -> DriveStrength -> Maybe Delay2 -> f GINIn -> ModGenItem f
MGINIn NInputType
t Bool
n (DriveStrength
 -> Maybe Delay2 -> NonEmpty GINIn -> ModGenSingleItem)
-> Parser DriveStrength
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe Delay2 -> NonEmpty GINIn -> ModGenSingleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser DriveStrength
driveStrength
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe Delay2 -> NonEmpty GINIn -> ModGenSingleItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay2)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty GINIn -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Delay2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay2)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Delay2
delay2
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty GINIn -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GINIn)
-> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GIF GINIn
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GINIn)
forall a. GIF a -> Parser (NonEmpty a)
gateInst (\Maybe InstanceName
n NetLValue
o NonEmpty Expr
i -> GINIn -> Maybe GINIn
forall a. a -> Maybe a
Just (GINIn -> Maybe GINIn) -> GINIn -> Maybe GINIn
forall a b. (a -> b) -> a -> b
$ Maybe InstanceName -> NetLValue -> NonEmpty Expr -> GINIn
GINIn Maybe InstanceName
n NetLValue
o NonEmpty Expr
i)
    gateNout :: Bool -> p -> Parser ModGenSingleItem
gateNout Bool
r p
_ =
      Bool
-> DriveStrength
-> Maybe Delay2
-> NonEmpty GINOut
-> ModGenSingleItem
forall (f :: * -> *).
Bool -> DriveStrength -> Maybe Delay2 -> f GINOut -> ModGenItem f
MGINOut Bool
r (DriveStrength
 -> Maybe Delay2 -> NonEmpty GINOut -> ModGenSingleItem)
-> Parser DriveStrength
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe Delay2 -> NonEmpty GINOut -> ModGenSingleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser DriveStrength
driveStrength
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe Delay2 -> NonEmpty GINOut -> ModGenSingleItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay2)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty GINOut -> ModGenSingleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Delay2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay2)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Delay2
delay2
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty GINOut -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GINOut)
-> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GIF GINOut
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GINOut)
forall a. GIF a -> Parser (NonEmpty a)
gateInst
          ( \Maybe InstanceName
n NetLValue
lv NonEmpty Expr
args ->
              ((Expr, [NetLValue]) -> GINOut)
-> Maybe (Expr, [NetLValue]) -> Maybe GINOut
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Expr
e, [NetLValue]
t) -> Maybe InstanceName -> NonEmpty NetLValue -> Expr -> GINOut
GINOut Maybe InstanceName
n (NetLValue
lv NetLValue -> [NetLValue] -> NonEmpty NetLValue
forall a. a -> [a] -> NonEmpty a
:| [NetLValue]
t) Expr
e) (Maybe (Expr, [NetLValue]) -> Maybe GINOut)
-> Maybe (Expr, [NetLValue]) -> Maybe GINOut
forall a b. (a -> b) -> a -> b
$
                (Expr -> Maybe (Expr, [NetLValue]))
-> (Expr -> (Expr, [NetLValue]) -> Maybe (Expr, [NetLValue]))
-> NonEmpty Expr
-> Maybe (Expr, [NetLValue])
forall (m :: * -> *) a b.
(Applicative m, Monad m) =>
(a -> m b) -> (a -> b -> m b) -> NonEmpty a -> m b
foldrMapM1 (\Expr
x -> (Expr, [NetLValue]) -> Maybe (Expr, [NetLValue])
forall a. a -> Maybe a
Just (Expr
x, [])) (\Expr
x (Expr
y, [NetLValue]
t) -> (,) Expr
y ([NetLValue] -> (Expr, [NetLValue]))
-> (NetLValue -> [NetLValue]) -> NetLValue -> (Expr, [NetLValue])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NetLValue -> [NetLValue] -> [NetLValue]
forall a. a -> [a] -> [a]
: [NetLValue]
t) (NetLValue -> (Expr, [NetLValue]))
-> Maybe NetLValue -> Maybe (Expr, [NetLValue])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> Maybe NetLValue
expr2netlv Expr
x) NonEmpty Expr
args
          )
    gatePassen :: Bool -> Bool -> p -> Parser ModGenSingleItem
gatePassen Bool
r Bool
b p
_ =
      Bool
-> Bool -> Maybe Delay2 -> NonEmpty GIPassEn -> ModGenSingleItem
forall (f :: * -> *).
Bool -> Bool -> Maybe Delay2 -> f GIPassEn -> ModGenItem f
MGIPassEn Bool
r Bool
b (Maybe Delay2 -> NonEmpty GIPassEn -> ModGenSingleItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay2)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty GIPassEn -> ModGenSingleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Delay2
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Delay2)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Delay2
delay2
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty GIPassEn -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIPassEn)
-> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> GIF GIPassEn
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIPassEn)
forall a. GIF a -> Parser (NonEmpty a)
gateInst
          ( \Maybe InstanceName
n NetLValue
lv NonEmpty Expr
args -> case NonEmpty Expr
args of
              [Item (NonEmpty Expr)
x, Item (NonEmpty Expr)
y] -> ((NetLValue -> Expr -> GIPassEn) -> Expr -> NetLValue -> GIPassEn
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Maybe InstanceName -> NetLValue -> NetLValue -> Expr -> GIPassEn
GIPassEn Maybe InstanceName
n NetLValue
lv) Item (NonEmpty Expr)
Expr
y) (NetLValue -> GIPassEn) -> Maybe NetLValue -> Maybe GIPassEn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> Maybe NetLValue
expr2netlv Item (NonEmpty Expr)
Expr
x
              NonEmpty Expr
_ -> Maybe GIPassEn
forall a. Maybe a
Nothing
          )
    gatePass :: Bool -> p -> Parser ModGenSingleItem
gatePass Bool
r p
_ =
      (NonEmpty GIPass -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIPass)
-> Parser ModGenSingleItem
forall a b.
(a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Bool -> NonEmpty GIPass -> ModGenSingleItem
forall (f :: * -> *). Bool -> f GIPass -> ModGenItem f
MGIPass Bool
r) (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIPass)
 -> Parser ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIPass)
-> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$
        GIF GIPass
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIPass)
forall a. GIF a -> Parser (NonEmpty a)
gateInst (GIF GIPass
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIPass))
-> GIF GIPass
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIPass)
forall a b. (a -> b) -> a -> b
$ \Maybe InstanceName
n NetLValue
lv NonEmpty Expr
args -> case NonEmpty Expr
args of [Item (NonEmpty Expr)
x] -> Maybe InstanceName -> NetLValue -> NetLValue -> GIPass
GIPass Maybe InstanceName
n NetLValue
lv (NetLValue -> GIPass) -> Maybe NetLValue -> Maybe GIPass
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> Maybe NetLValue
expr2netlv Item (NonEmpty Expr)
Expr
x; NonEmpty Expr
_ -> Maybe GIPass
forall a. Maybe a
Nothing
    gatePull :: Bool -> p -> Parser ModGenSingleItem
gatePull Bool
ud p
_ =
      Bool -> DriveStrength -> NonEmpty GIPull -> ModGenSingleItem
forall (f :: * -> *).
Bool -> DriveStrength -> f GIPull -> ModGenItem f
MGIPull Bool
ud (DriveStrength -> NonEmpty GIPull -> ModGenSingleItem)
-> Parser DriveStrength
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty GIPull -> ModGenSingleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DriveStrength -> Parser DriveStrength -> Parser DriveStrength
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option DriveStrength
dsDefault (Parser DriveStrength -> Parser DriveStrength
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Parser DriveStrength -> Parser DriveStrength)
-> Parser DriveStrength -> Parser DriveStrength
forall a b. (a -> b) -> a -> b
$ Parser DriveStrength -> Parser DriveStrength
forall a. Parser a -> Parser a
parens (Parser DriveStrength -> Parser DriveStrength)
-> Parser DriveStrength -> Parser DriveStrength
forall a b. (a -> b) -> a -> b
$ Bool -> Parser DriveStrength
pullStrength Bool
ud)
        ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty GIPull -> ModGenSingleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIPull)
-> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser GIPull
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty GIPull)
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Maybe InstanceName -> NetLValue -> GIPull
GIPull (Maybe InstanceName -> NetLValue -> GIPull)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe InstanceName)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NetLValue -> GIPull)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser InstanceName
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe InstanceName)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser InstanceName
instName ParsecT
  [PosToken] LocalCompDir (Writer [String]) (NetLValue -> GIPull)
-> Parser NetLValue -> Parser GIPull
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser NetLValue -> Parser NetLValue
forall a. Parser a -> Parser a
parens Parser NetLValue
netLV)
        Parser ModGenSingleItem -> Parser () -> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi

data MPUD
  = MPUDUDPDelay (Maybe Delay2)
  | MPUDModParam ParamAssign
  | MPUDUknNone
  | MPUDUknSingle Expr
  | MPUDUknDouble Expr Expr

ismod :: MPUD -> Bool
ismod :: MPUD -> Bool
ismod MPUD
x = case MPUD
x of MPUDModParam ParamAssign
_ -> Bool
True; MPUD
_ -> Bool
False

isukn :: MPUD -> Bool
isukn :: MPUD -> Bool
isukn MPUD
x = case MPUD
x of MPUDModParam ParamAssign
_ -> Bool
False; MPUDUDPDelay Maybe Delay2
_ -> Bool
False; MPUD
_ -> Bool
True

-- | Module parameters or udp delay
modparamudpdelay :: Parser MPUD
modparamudpdelay :: Parser MPUD
modparamudpdelay =
  Maybe Delay2 -> MPUD
MPUDUDPDelay (Maybe Delay2 -> MPUD)
-> (NumIdent -> Maybe Delay2) -> NumIdent -> MPUD
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Delay2 -> Maybe Delay2
forall a. a -> Maybe a
Just (Delay2 -> Maybe Delay2)
-> (NumIdent -> Delay2) -> NumIdent -> Maybe Delay2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NumIdent -> Delay2
D2Base (NumIdent -> MPUD) -> Parser NumIdent -> Parser MPUD
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser NumIdent
delayCom
    Parser MPUD -> Parser MPUD -> Parser MPUD
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser MPUD -> Parser MPUD
forall a. Parser a -> Parser a
parens (ParamAssign -> MPUD
MPUDModParam (ParamAssign -> MPUD)
-> (NonEmpty (Identified (Maybe (GenMinTypMax Expr)))
    -> ParamAssign)
-> NonEmpty (Identified (Maybe (GenMinTypMax Expr)))
-> MPUD
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Identified (Maybe (GenMinTypMax Expr))] -> ParamAssign
ParamNamed ([Identified (Maybe (GenMinTypMax Expr))] -> ParamAssign)
-> (NonEmpty (Identified (Maybe (GenMinTypMax Expr)))
    -> [Identified (Maybe (GenMinTypMax Expr))])
-> NonEmpty (Identified (Maybe (GenMinTypMax Expr)))
-> ParamAssign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (Identified (Maybe (GenMinTypMax Expr)))
-> [Identified (Maybe (GenMinTypMax Expr))]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty (Identified (Maybe (GenMinTypMax Expr))) -> MPUD)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (Identified (Maybe (GenMinTypMax Expr))))
-> Parser MPUD
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty (Identified (Maybe (GenMinTypMax Expr))))
namedparam Parser MPUD -> Parser MPUD -> Parser MPUD
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser MPUD
mpud)
  where
    namedparam :: ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty (Identified (Maybe (GenMinTypMax Expr))))
namedparam =
      String
-> Parser (Identified (Maybe (GenMinTypMax Expr)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (Identified (Maybe (GenMinTypMax Expr))))
forall a. String -> Parser a -> Parser (NonEmpty a)
xcsl1 String
"parameter instantiation" (Parser (Identified (Maybe (GenMinTypMax Expr)))
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (NonEmpty (Identified (Maybe (GenMinTypMax Expr)))))
-> Parser (Identified (Maybe (GenMinTypMax Expr)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (Identified (Maybe (GenMinTypMax Expr))))
forall a b. (a -> b) -> a -> b
$
        Token -> Parser ()
consume Token
SymDot Parser ()
-> Parser (Identified (Maybe (GenMinTypMax Expr)))
-> Parser (Identified (Maybe (GenMinTypMax Expr)))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Identifier
-> Maybe (GenMinTypMax Expr)
-> Identified (Maybe (GenMinTypMax Expr))
forall t. Identifier -> t -> Identified t
Identified (Identifier
 -> Maybe (GenMinTypMax Expr)
 -> Identified (Maybe (GenMinTypMax Expr)))
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (GenMinTypMax Expr)
      -> Identified (Maybe (GenMinTypMax Expr)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe (GenMinTypMax Expr)
   -> Identified (Maybe (GenMinTypMax Expr)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (GenMinTypMax Expr))
-> Parser (Identified (Maybe (GenMinTypMax Expr)))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe (GenMinTypMax Expr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (GenMinTypMax Expr))
forall a. Parser a -> Parser a
parens (ParsecT
  [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (GenMinTypMax Expr))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe (GenMinTypMax Expr)))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (GenMinTypMax Expr))
forall a b. (a -> b) -> a -> b
$ Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser Expr
expr)
    mpud :: Parser MPUD
mpud = do
      [GenMinTypMax Expr]
l <- String
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> Parser [GenMinTypMax Expr]
forall a. String -> Parser a -> Parser [a]
wxcsl String
"parameter instantiation or delay specification" (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
 -> Parser [GenMinTypMax Expr])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> Parser [GenMinTypMax Expr]
forall a b. (a -> b) -> a -> b
$ Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser Expr
expr
      case (GenMinTypMax Expr -> Maybe Expr)
-> [GenMinTypMax Expr] -> Maybe [Expr]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (\GenMinTypMax Expr
p -> case GenMinTypMax Expr
p of MTMSingle Expr
e -> Expr -> Maybe Expr
forall a. a -> Maybe a
Just Expr
e; GenMinTypMax Expr
_ -> Maybe Expr
forall a. Maybe a
Nothing) [GenMinTypMax Expr]
l of
        Maybe [Expr]
Nothing -> case [GenMinTypMax Expr]
l of
          [Item [GenMinTypMax Expr]
x] -> MPUD -> Parser MPUD
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MPUD -> Parser MPUD) -> MPUD -> Parser MPUD
forall a b. (a -> b) -> a -> b
$ Maybe Delay2 -> MPUD
MPUDUDPDelay (Maybe Delay2 -> MPUD) -> Maybe Delay2 -> MPUD
forall a b. (a -> b) -> a -> b
$ Delay2 -> Maybe Delay2
forall a. a -> Maybe a
Just (Delay2 -> Maybe Delay2) -> Delay2 -> Maybe Delay2
forall a b. (a -> b) -> a -> b
$ GenMinTypMax Expr -> Delay2
D21 Item [GenMinTypMax Expr]
GenMinTypMax Expr
x
          [Item [GenMinTypMax Expr]
x, Item [GenMinTypMax Expr]
y] -> MPUD -> Parser MPUD
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MPUD -> Parser MPUD) -> MPUD -> Parser MPUD
forall a b. (a -> b) -> a -> b
$ Maybe Delay2 -> MPUD
MPUDUDPDelay (Maybe Delay2 -> MPUD) -> Maybe Delay2 -> MPUD
forall a b. (a -> b) -> a -> b
$ Delay2 -> Maybe Delay2
forall a. a -> Maybe a
Just (Delay2 -> Maybe Delay2) -> Delay2 -> Maybe Delay2
forall a b. (a -> b) -> a -> b
$ GenMinTypMax Expr -> GenMinTypMax Expr -> Delay2
D22 Item [GenMinTypMax Expr]
GenMinTypMax Expr
x Item [GenMinTypMax Expr]
GenMinTypMax Expr
y
          [GenMinTypMax Expr]
_ -> String -> Parser MPUD
forall a. String -> Parser a
hardfail String
"Delay expression cannot have more than 2 elements"
        Just [Item [Expr]
x] -> MPUD -> Parser MPUD
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MPUD -> Parser MPUD) -> MPUD -> Parser MPUD
forall a b. (a -> b) -> a -> b
$ Expr -> MPUD
MPUDUknSingle Item [Expr]
Expr
x
        Just [Item [Expr]
x, Item [Expr]
y] -> MPUD -> Parser MPUD
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MPUD -> Parser MPUD) -> MPUD -> Parser MPUD
forall a b. (a -> b) -> a -> b
$ Expr -> Expr -> MPUD
MPUDUknDouble Item [Expr]
Expr
x Item [Expr]
Expr
y
        Just [Expr]
l -> MPUD -> Parser MPUD
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MPUD -> Parser MPUD) -> MPUD -> Parser MPUD
forall a b. (a -> b) -> a -> b
$ ParamAssign -> MPUD
MPUDModParam (ParamAssign -> MPUD) -> ParamAssign -> MPUD
forall a b. (a -> b) -> a -> b
$ [Expr] -> ParamAssign
ParamPositional [Expr]
l

data MUUPayload
  = MUUPMod ModInst
  | MUUPUDP UDPInst
  | MUUPUkn UknInst

-- | The actual instance of a module or user defined primive
modudpinstance :: MPUD -> Parser MUUPayload
modudpinstance :: MPUD -> Parser MUUPayload
modudpinstance MPUD
what = do
  Maybe InstanceName
mn <- Parser InstanceName
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe InstanceName)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser InstanceName
instName
  PortAssign
args <- Parser PortAssign -> Parser PortAssign
forall a. Parser a -> Parser a
parens (Parser PortAssign -> Parser PortAssign)
-> Parser PortAssign -> Parser PortAssign
forall a b. (a -> b) -> a -> b
$ do
    Attributes
a <- Parser Attributes
attributes
    do {
        AttrIded (Maybe Expr)
x <- Attributes
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr))
namePort Attributes
a;
        [AttrIded (Maybe Expr)] -> PortAssign
PortNamed ([AttrIded (Maybe Expr)] -> PortAssign)
-> ([AttrIded (Maybe Expr)] -> [AttrIded (Maybe Expr)])
-> [AttrIded (Maybe Expr)]
-> PortAssign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AttrIded (Maybe Expr)
x AttrIded (Maybe Expr)
-> [AttrIded (Maybe Expr)] -> [AttrIded (Maybe Expr)]
forall a. a -> [a] -> [a]
:) ([AttrIded (Maybe Expr)] -> PortAssign)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [AttrIded (Maybe Expr)]
-> Parser PortAssign
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken] LocalCompDir (Writer [String]) [AttrIded (Maybe Expr)]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [AttrIded (Maybe Expr)]
forall {a}.
IsList a =>
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
commathen (String
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [AttrIded (Maybe Expr)]
forall a. String -> Parser a -> Parser [a]
xcsl String
"port connections" (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr))
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) [AttrIded (Maybe Expr)])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [AttrIded (Maybe Expr)]
forall a b. (a -> b) -> a -> b
$ Parser Attributes
attributes Parser Attributes
-> (Attributes
    -> ParsecT
         [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr)))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Attributes
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr))
namePort)
    }
      Parser PortAssign -> Parser PortAssign -> Parser PortAssign
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Attributes
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Attributed (Maybe Expr))
ordPort Attributes
a ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Attributed (Maybe Expr))
-> (Attributed (Maybe Expr) -> Parser PortAssign)
-> Parser PortAssign
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Attributed (Maybe Expr)
x -> [Attributed (Maybe Expr)] -> PortAssign
PortPositional ([Attributed (Maybe Expr)] -> PortAssign)
-> ([Attributed (Maybe Expr)] -> [Attributed (Maybe Expr)])
-> [Attributed (Maybe Expr)]
-> PortAssign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Attributed (Maybe Expr)
x Attributed (Maybe Expr)
-> [Attributed (Maybe Expr)] -> [Attributed (Maybe Expr)]
forall a. a -> [a] -> [a]
:) ([Attributed (Maybe Expr)] -> PortAssign)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [Attributed (Maybe Expr)]
-> Parser PortAssign
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken] LocalCompDir (Writer [String]) [Attributed (Maybe Expr)]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [Attributed (Maybe Expr)]
forall {a}.
IsList a =>
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
commathen (ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Attributed (Maybe Expr))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [Attributed (Maybe Expr)]
forall a. Parser a -> Parser [a]
csl (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (Attributed (Maybe Expr))
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      [Attributed (Maybe Expr)])
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Attributed (Maybe Expr))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [Attributed (Maybe Expr)]
forall a b. (a -> b) -> a -> b
$ Parser Attributes
attributes Parser Attributes
-> (Attributes
    -> ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         (Attributed (Maybe Expr)))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Attributed (Maybe Expr))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Attributes
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Attributed (Maybe Expr))
ordPort))
  let argl :: Maybe [Expr]
argl = case PortAssign
args of
        PortPositional l :: [Attributed (Maybe Expr)]
l@(Attributed (Maybe Expr)
_ : Attributed (Maybe Expr)
_ : [Attributed (Maybe Expr)]
_) ->
          (Attributed (Maybe Expr) -> Maybe Expr)
-> [Attributed (Maybe Expr)] -> Maybe [Expr]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (\Attributed (Maybe Expr)
x -> case Attributed (Maybe Expr)
x of Attributed [] Maybe Expr
y -> Maybe Expr
y; Attributed (Maybe Expr)
_ -> Maybe Expr
forall a. Maybe a
Nothing) [Attributed (Maybe Expr)]
l
        PortAssign
_ -> Maybe [Expr]
forall a. Maybe a
Nothing
  case (Maybe InstanceName
mn, Maybe [Expr]
argl) of
    (Just InstanceName
n, Just (Expr
l : Expr
h : [Expr]
t)) | MPUD -> Bool
isukn MPUD
what -> case Expr -> Maybe NetLValue
expr2netlv Expr
l of
      Just NetLValue
lv -> MUUPayload -> Parser MUUPayload
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MUUPayload -> Parser MUUPayload)
-> MUUPayload -> Parser MUUPayload
forall a b. (a -> b) -> a -> b
$ UknInst -> MUUPayload
MUUPUkn (UknInst -> MUUPayload) -> UknInst -> MUUPayload
forall a b. (a -> b) -> a -> b
$ InstanceName -> NetLValue -> NonEmpty Expr -> UknInst
UknInst InstanceName
n NetLValue
lv (NonEmpty Expr -> UknInst) -> NonEmpty Expr -> UknInst
forall a b. (a -> b) -> a -> b
$ Expr
h Expr -> [Expr] -> NonEmpty Expr
forall a. a -> [a] -> NonEmpty a
:| [Expr]
t
      Maybe NetLValue
Nothing -> MUUPayload -> Parser MUUPayload
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MUUPayload -> Parser MUUPayload)
-> MUUPayload -> Parser MUUPayload
forall a b. (a -> b) -> a -> b
$ ModInst -> MUUPayload
MUUPMod (ModInst -> MUUPayload) -> ModInst -> MUUPayload
forall a b. (a -> b) -> a -> b
$ InstanceName -> PortAssign -> ModInst
ModInst InstanceName
n PortAssign
args
    (Maybe InstanceName
_, Just (Expr
l : Expr
h : [Expr]
t)) | Bool -> Bool
not (MPUD -> Bool
ismod MPUD
what) -> case Expr -> Maybe NetLValue
expr2netlv Expr
l of
      Just NetLValue
lv -> MUUPayload -> Parser MUUPayload
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MUUPayload -> Parser MUUPayload)
-> MUUPayload -> Parser MUUPayload
forall a b. (a -> b) -> a -> b
$ UDPInst -> MUUPayload
MUUPUDP (UDPInst -> MUUPayload) -> UDPInst -> MUUPayload
forall a b. (a -> b) -> a -> b
$ Maybe InstanceName -> NetLValue -> NonEmpty Expr -> UDPInst
UDPInst Maybe InstanceName
mn NetLValue
lv (NonEmpty Expr -> UDPInst) -> NonEmpty Expr -> UDPInst
forall a b. (a -> b) -> a -> b
$ Expr
h Expr -> [Expr] -> NonEmpty Expr
forall a. a -> [a] -> NonEmpty a
:| [Expr]
t
      Maybe NetLValue
Nothing -> Parser MUUPayload
forall {a}. ParsecT [PosToken] LocalCompDir (Writer [String]) a
failure
    (Just InstanceName
n, Maybe [Expr]
Nothing) | MPUD -> Bool
isukn MPUD
what -> MUUPayload -> Parser MUUPayload
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MUUPayload -> Parser MUUPayload)
-> MUUPayload -> Parser MUUPayload
forall a b. (a -> b) -> a -> b
$ ModInst -> MUUPayload
MUUPMod (ModInst -> MUUPayload) -> ModInst -> MUUPayload
forall a b. (a -> b) -> a -> b
$ InstanceName -> PortAssign -> ModInst
ModInst InstanceName
n PortAssign
args
    (Just InstanceName
n, Maybe [Expr]
_) | MPUD -> Bool
ismod MPUD
what -> MUUPayload -> Parser MUUPayload
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (MUUPayload -> Parser MUUPayload)
-> MUUPayload -> Parser MUUPayload
forall a b. (a -> b) -> a -> b
$ ModInst -> MUUPayload
MUUPMod (ModInst -> MUUPayload) -> ModInst -> MUUPayload
forall a b. (a -> b) -> a -> b
$ InstanceName -> PortAssign -> ModInst
ModInst InstanceName
n PortAssign
args
    (Maybe InstanceName, Maybe [Expr])
_ -> Parser MUUPayload
forall {a}. ParsecT [PosToken] LocalCompDir (Writer [String]) a
failure
  where
    failure :: Parser a
failure = String -> Parser a
forall a. String -> Parser a
hardfail String
"Got mixed elements of module and udp instatiation"
    commathen :: ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
commathen ParsecT [PosToken] LocalCompDir (Writer [String]) a
p = a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (ParsecT [PosToken] LocalCompDir (Writer [String]) a
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymComma Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT [PosToken] LocalCompDir (Writer [String]) a
p
    -- Port instantiation relying on order
    ordPort :: Attributes
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Attributed (Maybe Expr))
ordPort Attributes
a = Attributes -> Maybe Expr -> Attributed (Maybe Expr)
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a (Maybe Expr -> Attributed (Maybe Expr))
-> Parser (Maybe Expr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Attributed (Maybe Expr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr -> Parser (Maybe Expr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Expr
expr
    -- Port instantiation relying on name
    namePort :: Attributes
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr))
namePort Attributes
a = Token -> Parser ()
consume Token
SymDot Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Attributes -> Identifier -> Maybe Expr -> AttrIded (Maybe Expr)
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
a (Identifier -> Maybe Expr -> AttrIded (Maybe Expr))
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe Expr -> AttrIded (Maybe Expr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe Expr -> AttrIded (Maybe Expr))
-> Parser (Maybe Expr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (AttrIded (Maybe Expr))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe Expr) -> Parser (Maybe Expr)
forall a. Parser a -> Parser a
parens (Parser Expr -> Parser (Maybe Expr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Expr
expr)

-- | Module or udp instantiation, they are tricky to differentiate (if not impossible sometimes)
modudpInst :: Parser ModGenSingleItem
modudpInst :: Parser ModGenSingleItem
modudpInst = do
  Identifier
kind <- Parser Identifier
lenientIdent
  Maybe DriveStrength
ds <- Parser DriveStrength
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe DriveStrength)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser DriveStrength
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (Maybe DriveStrength))
-> Parser DriveStrength
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe DriveStrength)
forall a b. (a -> b) -> a -> b
$ Parser DriveStrength -> Parser DriveStrength
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Parser DriveStrength -> Parser DriveStrength)
-> Parser DriveStrength -> Parser DriveStrength
forall a b. (a -> b) -> a -> b
$ Parser DriveStrength -> Parser DriveStrength
forall a. Parser a -> Parser a
parens Parser DriveStrength
comDriveStrength
  MPUD
del_par <- MPUD -> Parser MPUD -> Parser MPUD
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option MPUD
MPUDUknNone (Parser MPUD -> Parser MPUD) -> Parser MPUD -> Parser MPUD
forall a b. (a -> b) -> a -> b
$
    if Maybe DriveStrength -> Bool
forall a. Maybe a -> Bool
isJust Maybe DriveStrength
ds then Maybe Delay2 -> MPUD
MPUDUDPDelay (Maybe Delay2 -> MPUD)
-> (Delay2 -> Maybe Delay2) -> Delay2 -> MPUD
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Delay2 -> Maybe Delay2
forall a. a -> Maybe a
Just (Delay2 -> MPUD) -> Parser Delay2 -> Parser MPUD
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Delay2
delay2 else Token -> Parser ()
consume Token
SymPound Parser () -> Parser MPUD -> Parser MPUD
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser MPUD
modparamudpdelay
  NonEmpty MUUPayload
insts <- Parser MUUPayload -> Parser (NonEmpty MUUPayload)
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Parser MUUPayload -> Parser (NonEmpty MUUPayload))
-> Parser MUUPayload -> Parser (NonEmpty MUUPayload)
forall a b. (a -> b) -> a -> b
$ MPUD -> Parser MUUPayload
modudpinstance MPUD
del_par
  MPUD
del_par <- if MPUD -> Bool
isukn MPUD
del_par
    then Parser MPUD -> (MPUD -> Parser MPUD) -> Maybe MPUD -> Parser MPUD
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Parser MPUD
forall {a}. ParsecT [PosToken] LocalCompDir (Writer [String]) a
failure MPUD -> Parser MPUD
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe MPUD -> Parser MPUD) -> Maybe MPUD -> Parser MPUD
forall a b. (a -> b) -> a -> b
$ (MUUPayload -> MPUD -> Maybe MPUD)
-> MPUD -> NonEmpty MUUPayload -> Maybe MPUD
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> b -> m b) -> b -> t a -> m b
foldrM MUUPayload -> MPUD -> Maybe MPUD
reduce_unknown MPUD
del_par NonEmpty MUUPayload
insts
    else MPUD -> Parser MPUD
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MPUD
del_par
  Token -> Parser ()
consume Token
SymSemi
  ModGenSingleItem -> Parser ModGenSingleItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModGenSingleItem -> Parser ModGenSingleItem)
-> ModGenSingleItem -> Parser ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ case MPUD
del_par of
    MPUDUDPDelay Maybe Delay2
d2 -> Identifier
-> DriveStrength
-> Maybe Delay2
-> NonEmpty UDPInst
-> ModGenSingleItem
forall (f :: * -> *).
Identifier
-> DriveStrength -> Maybe Delay2 -> f UDPInst -> ModGenItem f
MGIUDPInst Identifier
kind (DriveStrength
-> (DriveStrength -> DriveStrength)
-> Maybe DriveStrength
-> DriveStrength
forall b a. b -> (a -> b) -> Maybe a -> b
maybe DriveStrength
dsDefault DriveStrength -> DriveStrength
forall a. a -> a
id Maybe DriveStrength
ds) Maybe Delay2
d2 (NonEmpty UDPInst -> ModGenSingleItem)
-> NonEmpty UDPInst -> ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ MUUPayload -> UDPInst
mkudp (MUUPayload -> UDPInst) -> NonEmpty MUUPayload -> NonEmpty UDPInst
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty MUUPayload
insts
    MPUDModParam ParamAssign
pa -> Identifier -> ParamAssign -> NonEmpty ModInst -> ModGenSingleItem
forall (f :: * -> *).
Identifier -> ParamAssign -> f ModInst -> ModGenItem f
MGIModInst Identifier
kind ParamAssign
pa (NonEmpty ModInst -> ModGenSingleItem)
-> NonEmpty ModInst -> ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ MUUPayload -> ModInst
mkmod (MUUPayload -> ModInst) -> NonEmpty MUUPayload -> NonEmpty ModInst
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty MUUPayload
insts
    MPUD
MPUDUknNone -> Identifier
-> Maybe (Either Expr (Expr, Expr))
-> NonEmpty UknInst
-> ModGenSingleItem
forall (f :: * -> *).
Identifier
-> Maybe (Either Expr (Expr, Expr)) -> f UknInst -> ModGenItem f
MGIUnknownInst Identifier
kind Maybe (Either Expr (Expr, Expr))
forall a. Maybe a
Nothing (NonEmpty UknInst -> ModGenSingleItem)
-> NonEmpty UknInst -> ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ MUUPayload -> UknInst
mkukn (MUUPayload -> UknInst) -> NonEmpty MUUPayload -> NonEmpty UknInst
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty MUUPayload
insts
    MPUDUknSingle Expr
x -> Identifier
-> Maybe (Either Expr (Expr, Expr))
-> NonEmpty UknInst
-> ModGenSingleItem
forall (f :: * -> *).
Identifier
-> Maybe (Either Expr (Expr, Expr)) -> f UknInst -> ModGenItem f
MGIUnknownInst Identifier
kind (Either Expr (Expr, Expr) -> Maybe (Either Expr (Expr, Expr))
forall a. a -> Maybe a
Just (Either Expr (Expr, Expr) -> Maybe (Either Expr (Expr, Expr)))
-> Either Expr (Expr, Expr) -> Maybe (Either Expr (Expr, Expr))
forall a b. (a -> b) -> a -> b
$ Expr -> Either Expr (Expr, Expr)
forall a b. a -> Either a b
Left Expr
x) (NonEmpty UknInst -> ModGenSingleItem)
-> NonEmpty UknInst -> ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ MUUPayload -> UknInst
mkukn (MUUPayload -> UknInst) -> NonEmpty MUUPayload -> NonEmpty UknInst
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty MUUPayload
insts
    MPUDUknDouble Expr
x Expr
y -> Identifier
-> Maybe (Either Expr (Expr, Expr))
-> NonEmpty UknInst
-> ModGenSingleItem
forall (f :: * -> *).
Identifier
-> Maybe (Either Expr (Expr, Expr)) -> f UknInst -> ModGenItem f
MGIUnknownInst Identifier
kind (Either Expr (Expr, Expr) -> Maybe (Either Expr (Expr, Expr))
forall a. a -> Maybe a
Just (Either Expr (Expr, Expr) -> Maybe (Either Expr (Expr, Expr)))
-> Either Expr (Expr, Expr) -> Maybe (Either Expr (Expr, Expr))
forall a b. (a -> b) -> a -> b
$ (Expr, Expr) -> Either Expr (Expr, Expr)
forall a b. b -> Either a b
Right (Expr
x, Expr
y)) (NonEmpty UknInst -> ModGenSingleItem)
-> NonEmpty UknInst -> ModGenSingleItem
forall a b. (a -> b) -> a -> b
$ MUUPayload -> UknInst
mkukn (MUUPayload -> UknInst) -> NonEmpty MUUPayload -> NonEmpty UknInst
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty MUUPayload
insts
  where
    failure :: Parser a
failure = String -> Parser a
forall a. String -> Parser a
hardfail String
"Got mixed elements of module and udp instatiation"
    unreachable :: a
unreachable = String -> a
forall a. HasCallStack => String -> a
error String
"Internal error, unreachable case reached"
    reduce_unknown :: MUUPayload -> MPUD -> Maybe MPUD
reduce_unknown MUUPayload
i MPUD
a = case MUUPayload
i of
      MUUPUkn UknInst
_ -> MPUD -> Maybe MPUD
forall a. a -> Maybe a
Just MPUD
a
      MUUPMod ModInst
_ -> case MPUD
a of
        MPUDUDPDelay Maybe Delay2
_ -> Maybe MPUD
forall a. Maybe a
Nothing
        MPUDModParam ParamAssign
_ -> MPUD -> Maybe MPUD
forall a. a -> Maybe a
Just MPUD
a
        MPUD
MPUDUknNone -> MPUD -> Maybe MPUD
forall a. a -> Maybe a
Just (MPUD -> Maybe MPUD) -> MPUD -> Maybe MPUD
forall a b. (a -> b) -> a -> b
$ ParamAssign -> MPUD
MPUDModParam (ParamAssign -> MPUD) -> ParamAssign -> MPUD
forall a b. (a -> b) -> a -> b
$ [Expr] -> ParamAssign
ParamPositional []
        MPUDUknSingle Expr
x -> MPUD -> Maybe MPUD
forall a. a -> Maybe a
Just (MPUD -> Maybe MPUD) -> MPUD -> Maybe MPUD
forall a b. (a -> b) -> a -> b
$ ParamAssign -> MPUD
MPUDModParam (ParamAssign -> MPUD) -> ParamAssign -> MPUD
forall a b. (a -> b) -> a -> b
$ [Expr] -> ParamAssign
ParamPositional [Item [Expr]
Expr
x]
        MPUDUknDouble Expr
x Expr
y -> MPUD -> Maybe MPUD
forall a. a -> Maybe a
Just (MPUD -> Maybe MPUD) -> MPUD -> Maybe MPUD
forall a b. (a -> b) -> a -> b
$ ParamAssign -> MPUD
MPUDModParam (ParamAssign -> MPUD) -> ParamAssign -> MPUD
forall a b. (a -> b) -> a -> b
$ [Expr] -> ParamAssign
ParamPositional [Item [Expr]
Expr
x, Item [Expr]
Expr
y]
      MUUPUDP UDPInst
_ -> case MPUD
a of
        MPUDModParam ParamAssign
_ -> Maybe MPUD
forall a. Maybe a
Nothing
        MPUDUDPDelay Maybe Delay2
_ -> MPUD -> Maybe MPUD
forall a. a -> Maybe a
Just MPUD
a
        MPUD
MPUDUknNone -> MPUD -> Maybe MPUD
forall a. a -> Maybe a
Just (MPUD -> Maybe MPUD) -> MPUD -> Maybe MPUD
forall a b. (a -> b) -> a -> b
$ Maybe Delay2 -> MPUD
MPUDUDPDelay (Maybe Delay2 -> MPUD) -> Maybe Delay2 -> MPUD
forall a b. (a -> b) -> a -> b
$ Maybe Delay2
forall a. Maybe a
Nothing
        MPUDUknSingle Expr
x -> MPUD -> Maybe MPUD
forall a. a -> Maybe a
Just (MPUD -> Maybe MPUD) -> MPUD -> Maybe MPUD
forall a b. (a -> b) -> a -> b
$ Maybe Delay2 -> MPUD
MPUDUDPDelay (Maybe Delay2 -> MPUD) -> Maybe Delay2 -> MPUD
forall a b. (a -> b) -> a -> b
$ Delay2 -> Maybe Delay2
forall a. a -> Maybe a
Just (Delay2 -> Maybe Delay2) -> Delay2 -> Maybe Delay2
forall a b. (a -> b) -> a -> b
$ GenMinTypMax Expr -> Delay2
D21 (GenMinTypMax Expr -> Delay2) -> GenMinTypMax Expr -> Delay2
forall a b. (a -> b) -> a -> b
$ Expr -> GenMinTypMax Expr
forall et. et -> GenMinTypMax et
MTMSingle Expr
x
        MPUDUknDouble Expr
x Expr
y -> MPUD -> Maybe MPUD
forall a. a -> Maybe a
Just (MPUD -> Maybe MPUD) -> MPUD -> Maybe MPUD
forall a b. (a -> b) -> a -> b
$ Maybe Delay2 -> MPUD
MPUDUDPDelay (Maybe Delay2 -> MPUD) -> Maybe Delay2 -> MPUD
forall a b. (a -> b) -> a -> b
$ Delay2 -> Maybe Delay2
forall a. a -> Maybe a
Just (Delay2 -> Maybe Delay2) -> Delay2 -> Maybe Delay2
forall a b. (a -> b) -> a -> b
$ GenMinTypMax Expr -> GenMinTypMax Expr -> Delay2
D22 (Expr -> GenMinTypMax Expr
forall et. et -> GenMinTypMax et
MTMSingle Expr
x) (Expr -> GenMinTypMax Expr
forall et. et -> GenMinTypMax et
MTMSingle Expr
y)
    mkmod :: MUUPayload -> ModInst
mkmod MUUPayload
i = case MUUPayload
i of
      MUUPMod ModInst
i -> ModInst
i
      MUUPUDP UDPInst
_ -> ModInst
forall {a}. a
unreachable
      MUUPUkn (UknInst InstanceName
n NetLValue
lv NonEmpty Expr
args) ->
        InstanceName -> PortAssign -> ModInst
ModInst InstanceName
n (PortAssign -> ModInst) -> PortAssign -> ModInst
forall a b. (a -> b) -> a -> b
$ [Attributed (Maybe Expr)] -> PortAssign
PortPositional ([Attributed (Maybe Expr)] -> PortAssign)
-> [Attributed (Maybe Expr)] -> PortAssign
forall a b. (a -> b) -> a -> b
$ (Expr -> Attributed (Maybe Expr))
-> [Expr] -> [Attributed (Maybe Expr)]
forall a b. (a -> b) -> [a] -> [b]
map (Attributes -> Maybe Expr -> Attributed (Maybe Expr)
forall t. Attributes -> t -> Attributed t
Attributed [] (Maybe Expr -> Attributed (Maybe Expr))
-> (Expr -> Maybe Expr) -> Expr -> Attributed (Maybe Expr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr -> Maybe Expr
forall a. a -> Maybe a
Just) ([Expr] -> [Attributed (Maybe Expr)])
-> [Expr] -> [Attributed (Maybe Expr)]
forall a b. (a -> b) -> a -> b
$ NetLValue -> Expr
netlv2expr NetLValue
lv Expr -> [Expr] -> [Expr]
forall a. a -> [a] -> [a]
: NonEmpty Expr -> [Expr]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty Expr
args
    mkudp :: MUUPayload -> UDPInst
mkudp MUUPayload
i = case MUUPayload
i of
      MUUPMod ModInst
_ -> UDPInst
forall {a}. a
unreachable
      MUUPUDP UDPInst
i -> UDPInst
i
      MUUPUkn (UknInst InstanceName
n NetLValue
lv NonEmpty Expr
args) -> Maybe InstanceName -> NetLValue -> NonEmpty Expr -> UDPInst
UDPInst (InstanceName -> Maybe InstanceName
forall a. a -> Maybe a
Just InstanceName
n) NetLValue
lv NonEmpty Expr
args
    mkukn :: MUUPayload -> UknInst
mkukn MUUPayload
i = case MUUPayload
i of
      MUUPMod ModInst
_ -> UknInst
forall {a}. a
unreachable
      MUUPUDP UDPInst
_ -> UknInst
forall {a}. a
unreachable
      MUUPUkn UknInst
i -> UknInst
i

-- | Parse a module or generate region item along other given possibilities
-- | and converts it to the right type using the provided conversion function
parseItem :: (Attributed ModGenBlockedItem -> a) -> LAPBranch (NonEmpty a) -> Parser [a]
parseItem :: forall a.
(Attributed ModGenBlockedItem -> a)
-> LAPBranch (NonEmpty a) -> Parser [a]
parseItem Attributed ModGenBlockedItem -> a
f LAPBranch (NonEmpty a)
lb = do
  Attributes
a <- Parser Attributes
attributes
  SourcePos
pos <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  (NonEmpty a -> [a])
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
-> Parser [a]
forall a b.
(a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NE.toList (ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
 -> Parser [a])
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
-> Parser [a]
forall a b. (a -> b) -> a -> b
$
    do {
      Attributes
-> SourcePos
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
p <- LAPBranch (NonEmpty a)
-> Parser
     (Attributes
      -> SourcePos
      -> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a))
forall a. LProduce a -> Parser a
lproduce (LAPBranch (NonEmpty a)
 -> Parser
      (Attributes
       -> SourcePos
       -> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)))
-> LAPBranch (NonEmpty a)
-> Parser
     (Attributes
      -> SourcePos
      -> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a))
forall a b. (a -> b) -> a -> b
$
        LAPBranch (NonEmpty a)
lb LAPBranch (NonEmpty a)
-> LAPBranch (NonEmpty a) -> LAPBranch (NonEmpty a)
forall a. [a] -> [a] -> [a]
++ ((SourcePos -> Parser ModGenSingleItem)
 -> Attributes
 -> SourcePos
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a))
-> [Produce (SourcePos -> Parser ModGenSingleItem)]
-> LAPBranch (NonEmpty a)
forall a b. (a -> b) -> LProduce a -> LProduce b
maplproduce
          (\SourcePos -> Parser ModGenSingleItem
p Attributes
a SourcePos
pos -> (ModGenBlockedItem -> a)
-> NonEmpty ModGenBlockedItem -> NonEmpty a
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Attributed ModGenBlockedItem -> a
f (Attributed ModGenBlockedItem -> a)
-> (ModGenBlockedItem -> Attributed ModGenBlockedItem)
-> ModGenBlockedItem
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Attributes -> ModGenBlockedItem -> Attributed ModGenBlockedItem
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a) (NonEmpty ModGenBlockedItem -> NonEmpty a)
-> (ModGenSingleItem -> NonEmpty ModGenBlockedItem)
-> ModGenSingleItem
-> NonEmpty a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModGenSingleItem -> NonEmpty ModGenBlockedItem
toMGBlockedItem (ModGenSingleItem -> NonEmpty a)
-> Parser ModGenSingleItem
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SourcePos -> Parser ModGenSingleItem
p SourcePos
pos)
          [Produce (SourcePos -> Parser ModGenSingleItem)]
comModGenItem;
      Attributes
-> SourcePos
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
p Attributes
a SourcePos
pos
    }
      ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (\Parser ModGenSingleItem
p Attributes
a -> (ModGenBlockedItem -> a)
-> NonEmpty ModGenBlockedItem -> NonEmpty a
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Attributed ModGenBlockedItem -> a
f (Attributed ModGenBlockedItem -> a)
-> (ModGenBlockedItem -> Attributed ModGenBlockedItem)
-> ModGenBlockedItem
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Attributes -> ModGenBlockedItem -> Attributed ModGenBlockedItem
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a) (NonEmpty ModGenBlockedItem -> NonEmpty a)
-> (ModGenSingleItem -> NonEmpty ModGenBlockedItem)
-> ModGenSingleItem
-> NonEmpty a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModGenSingleItem -> NonEmpty ModGenBlockedItem
toMGBlockedItem (ModGenSingleItem -> NonEmpty a)
-> Parser ModGenSingleItem
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (NonEmpty a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ModGenSingleItem
p) Parser ModGenSingleItem
modudpInst Attributes
a

-- | Generate block
genBlock :: Parser GenerateBlock
genBlock :: ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
genBlock = do
  SourcePos
pos <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  Token -> Parser ()
consume Token
KWBegin
  Identifier
i <- Identifier -> Parser Identifier -> Parser Identifier
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Identifier
"" (Parser Identifier -> Parser Identifier)
-> Parser Identifier -> Parser Identifier
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymColon Parser () -> Parser Identifier -> Parser Identifier
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Identifier
ident
  [[Attributed ModGenBlockedItem]]
b <- ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  [Attributed ModGenBlockedItem]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[Attributed ModGenBlockedItem]]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   [Attributed ModGenBlockedItem]
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      [[Attributed ModGenBlockedItem]])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [Attributed ModGenBlockedItem]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[Attributed ModGenBlockedItem]]
forall a b. (a -> b) -> a -> b
$ (Attributed ModGenBlockedItem -> Attributed ModGenBlockedItem)
-> LAPBranch (NonEmpty (Attributed ModGenBlockedItem))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [Attributed ModGenBlockedItem]
forall a.
(Attributed ModGenBlockedItem -> a)
-> LAPBranch (NonEmpty a) -> Parser [a]
parseItem Attributed ModGenBlockedItem -> Attributed ModGenBlockedItem
forall a. a -> a
id []
  SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
pos Token
KWBegin Token
KWEnd
  GenerateBlock
-> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (GenerateBlock
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock)
-> GenerateBlock
-> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
forall a b. (a -> b) -> a -> b
$ Identifier -> [Attributed ModGenBlockedItem] -> GenerateBlock
forall t. Identifier -> t -> Identified t
Identified Identifier
i ([Attributed ModGenBlockedItem] -> GenerateBlock)
-> [Attributed ModGenBlockedItem] -> GenerateBlock
forall a b. (a -> b) -> a -> b
$ [[Attributed ModGenBlockedItem]] -> [Attributed ModGenBlockedItem]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Attributed ModGenBlockedItem]]
b

genSingle ::  Parser [Attributed ModGenBlockedItem]
genSingle :: ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  [Attributed ModGenBlockedItem]
genSingle = do
  Attributes
a <- Parser Attributes
attributes
  SourcePos
pos <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  ModGenSingleItem
b <- ([Produce (SourcePos -> Parser ModGenSingleItem)]
-> Parser (SourcePos -> Parser ModGenSingleItem)
forall a. LProduce a -> Parser a
lproduce [Produce (SourcePos -> Parser ModGenSingleItem)]
comModGenItem Parser (SourcePos -> Parser ModGenSingleItem)
-> ((SourcePos -> Parser ModGenSingleItem)
    -> Parser ModGenSingleItem)
-> Parser ModGenSingleItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \SourcePos -> Parser ModGenSingleItem
p -> SourcePos -> Parser ModGenSingleItem
p SourcePos
pos) Parser ModGenSingleItem
-> Parser ModGenSingleItem -> Parser ModGenSingleItem
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Parser ModGenSingleItem
modudpInst
  [Attributed ModGenBlockedItem]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [Attributed ModGenBlockedItem]
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attributed ModGenBlockedItem]
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      [Attributed ModGenBlockedItem])
-> [Attributed ModGenBlockedItem]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [Attributed ModGenBlockedItem]
forall a b. (a -> b) -> a -> b
$ Attributes -> ModGenBlockedItem -> Attributed ModGenBlockedItem
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a (ModGenBlockedItem -> Attributed ModGenBlockedItem)
-> [ModGenBlockedItem] -> [Attributed ModGenBlockedItem]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty ModGenBlockedItem -> [ModGenBlockedItem]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (ModGenSingleItem -> NonEmpty ModGenBlockedItem
toMGBlockedItem ModGenSingleItem
b)

genCondBlock :: Parser GenerateCondBlock
genCondBlock :: ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
genCondBlock = Token -> Parser ()
consume Token
SymSemi Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return GenerateCondBlock
GCBEmpty ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> GenerateBlock -> GenerateCondBlock
GCBBlock (GenerateBlock -> GenerateCondBlock)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateBlock
genBlock ParsecT [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
  [Attributed ModGenBlockedItem]
gb <- ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  [Attributed ModGenBlockedItem]
genSingle
  GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (GenerateCondBlock
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock)
-> GenerateCondBlock
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) GenerateCondBlock
forall a b. (a -> b) -> a -> b
$ case [Attributed ModGenBlockedItem]
gb of
    [Attributed Attributes
a (MGICondItem ModGenCondItem
ci)] -> Attributed ModGenCondItem -> GenerateCondBlock
GCBConditional (Attributed ModGenCondItem -> GenerateCondBlock)
-> Attributed ModGenCondItem -> GenerateCondBlock
forall a b. (a -> b) -> a -> b
$ Attributes -> ModGenCondItem -> Attributed ModGenCondItem
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a ModGenCondItem
ci
    [Attributed ModGenBlockedItem]
_ -> GenerateBlock -> GenerateCondBlock
GCBBlock (GenerateBlock -> GenerateCondBlock)
-> GenerateBlock -> GenerateCondBlock
forall a b. (a -> b) -> a -> b
$ Identifier -> [Attributed ModGenBlockedItem] -> GenerateBlock
forall t. Identifier -> t -> Identified t
Identified Identifier
"" [Attributed ModGenBlockedItem]
gb

type PortInterface = Identified [Identified (Maybe CRangeExpr)]

-- | Simple port declaration (Input, Output, InOut)
portsimple ::
  Maybe NetType ->
  Bool ->
  Dir ->
  Attributes ->
  Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
portsimple :: Maybe NetType
-> Bool
-> Dir
-> Attributes
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
portsimple Maybe NetType
dnt Bool
fullspec Dir
d Attributes
a = do
  Maybe NetType
nt <- ParsecT [PosToken] LocalCompDir (Writer [String]) NetType
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe NetType)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (ParsecT [PosToken] LocalCompDir (Writer [String]) NetType
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (Maybe NetType))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) NetType
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe NetType)
forall a b. (a -> b) -> a -> b
$ LProduce NetType
-> ParsecT [PosToken] LocalCompDir (Writer [String]) NetType
forall a. LProduce a -> Parser a
lproduce LProduce NetType
netType
  SignRange
sr <- Parser SignRange
signRange
  NonEmpty Identifier
sl <- Bool
-> Parser Identifier
-> (Identifier -> Parser Identifier)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Identifier)
forall a b.
Bool -> Parser a -> (a -> Parser b) -> Parser (NonEmpty b)
scsl1 Bool
fullspec Parser Identifier
ident Identifier -> Parser Identifier
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  let pd :: Identifier -> ModuleItem
pd Identifier
i = AttrIded (Dir, SignRange) -> ModuleItem
MIPort (AttrIded (Dir, SignRange) -> ModuleItem)
-> AttrIded (Dir, SignRange) -> ModuleItem
forall a b. (a -> b) -> a -> b
$ Attributes
-> Identifier -> (Dir, SignRange) -> AttrIded (Dir, SignRange)
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
a Identifier
i (Dir
d, SignRange
sr)
      nd :: NetType -> Identifier -> Attributed ModGenBlockedItem
nd NetType
t Identifier
i =
        Attributes -> ModGenBlockedItem -> Attributed ModGenBlockedItem
forall t. Attributes -> t -> Attributed t
Attributed [] (ModGenBlockedItem -> Attributed ModGenBlockedItem)
-> ModGenBlockedItem -> Attributed ModGenBlockedItem
forall a b. (a -> b) -> a -> b
$
          NetType -> NetProp -> Identity NetDecl -> ModGenBlockedItem
forall (f :: * -> *).
NetType -> NetProp -> f NetDecl -> ModGenItem f
MGINetDecl
            NetType
t
            (Bool -> Maybe (Maybe Bool, Range2) -> Maybe Delay3 -> NetProp
NetProp (SignRange -> Bool
_srSign SignRange
sr) ((,) Maybe Bool
forall a. Maybe a
Nothing (Range2 -> (Maybe Bool, Range2))
-> Maybe Range2 -> Maybe (Maybe Bool, Range2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SignRange -> Maybe Range2
_srRange SignRange
sr) Maybe Delay3
forall a. Maybe a
Nothing)
            (NetDecl -> Identity NetDecl
forall a. a -> Identity a
Identity (NetDecl -> Identity NetDecl) -> NetDecl -> Identity NetDecl
forall a b. (a -> b) -> a -> b
$ Identifier -> [Range2] -> NetDecl
NetDecl Identifier
i [])
      pi :: Identifier -> Identified t
pi Identifier
i = Identifier -> t -> Identified t
forall t. Identifier -> t -> Identified t
Identified Identifier
i [Identifier -> Maybe a -> Identified (Maybe a)
forall t. Identifier -> t -> Identified t
Identified Identifier
i Maybe a
forall a. Maybe a
Nothing]
  case Maybe NetType
nt of
    Just NetType
nt -> NonEmpty (NonEmpty ModuleItem, PortInterface)
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty (NonEmpty ModuleItem, PortInterface)
 -> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface)))
-> NonEmpty (NonEmpty ModuleItem, PortInterface)
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
forall a b. (a -> b) -> a -> b
$ (\Identifier
i -> ([Identifier -> ModuleItem
pd Identifier
i, Attributed ModGenBlockedItem -> ModuleItem
MIMGI (Attributed ModGenBlockedItem -> ModuleItem)
-> Attributed ModGenBlockedItem -> ModuleItem
forall a b. (a -> b) -> a -> b
$ NetType -> Identifier -> Attributed ModGenBlockedItem
nd NetType
nt Identifier
i], Identifier -> PortInterface
forall {t} {a}.
(Item t ~ Identified (Maybe a), IsList t) =>
Identifier -> Identified t
pi Identifier
i)) (Identifier -> (NonEmpty ModuleItem, PortInterface))
-> NonEmpty Identifier
-> NonEmpty (NonEmpty ModuleItem, PortInterface)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty Identifier
sl
    Maybe NetType
Nothing | Bool
fullspec -> case Maybe NetType
dnt of
      Just NetType
nt -> NonEmpty (NonEmpty ModuleItem, PortInterface)
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty (NonEmpty ModuleItem, PortInterface)
 -> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface)))
-> NonEmpty (NonEmpty ModuleItem, PortInterface)
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
forall a b. (a -> b) -> a -> b
$ (\Identifier
i -> ([Identifier -> ModuleItem
pd Identifier
i, Attributed ModGenBlockedItem -> ModuleItem
MIMGI (Attributed ModGenBlockedItem -> ModuleItem)
-> Attributed ModGenBlockedItem -> ModuleItem
forall a b. (a -> b) -> a -> b
$ NetType -> Identifier -> Attributed ModGenBlockedItem
nd NetType
nt Identifier
i], Identifier -> PortInterface
forall {t} {a}.
(Item t ~ Identified (Maybe a), IsList t) =>
Identifier -> Identified t
pi Identifier
i)) (Identifier -> (NonEmpty ModuleItem, PortInterface))
-> NonEmpty Identifier
-> NonEmpty (NonEmpty ModuleItem, PortInterface)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty Identifier
sl
      Maybe NetType
Nothing ->
        String -> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
forall a. String -> Parser a
hardfail String
"Ports declared in a module header must be typed when default_nettype is none"
    Maybe NetType
Nothing -> NonEmpty (NonEmpty ModuleItem, PortInterface)
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty (NonEmpty ModuleItem, PortInterface)
 -> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface)))
-> NonEmpty (NonEmpty ModuleItem, PortInterface)
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
forall a b. (a -> b) -> a -> b
$ (\Identifier
i -> ([Identifier -> ModuleItem
pd Identifier
i], Identifier -> PortInterface
forall {t} {a}.
(Item t ~ Identified (Maybe a), IsList t) =>
Identifier -> Identified t
pi Identifier
i)) (Identifier -> (NonEmpty ModuleItem, PortInterface))
-> NonEmpty Identifier
-> NonEmpty (NonEmpty ModuleItem, PortInterface)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty Identifier
sl

-- | Declaration of a port with a variable type
portvariable ::
  Bool ->
  Attributes ->
  ( Compose Identity Identified (Either [Range2] CExpr) ->
    BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
  ) ->
  Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
portvariable :: Bool
-> Attributes
-> (Compose Identity Identified (Either [Range2] CExpr)
    -> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
portvariable Bool
fullspec Attributes
a Compose Identity Identified (Either [Range2] CExpr)
-> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
f =
  Bool
-> Parser Identifier
-> (Identifier -> Parser (NonEmpty ModuleItem, PortInterface))
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
forall a b.
Bool -> Parser a -> (a -> Parser b) -> Parser (NonEmpty b)
scsl1 Bool
fullspec Parser Identifier
ident ((Identifier -> Parser (NonEmpty ModuleItem, PortInterface))
 -> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface)))
-> (Identifier -> Parser (NonEmpty ModuleItem, PortInterface))
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
forall a b. (a -> b) -> a -> b
$
    \Identifier
s -> do
      Maybe CExpr
e <- Parser CExpr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser CExpr
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr))
-> Parser CExpr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymEq Parser () -> Parser CExpr -> Parser CExpr
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser CExpr
constExpr
      (NonEmpty ModuleItem, PortInterface)
-> Parser (NonEmpty ModuleItem, PortInterface)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return
        ( [ AttrIded (Dir, SignRange) -> ModuleItem
MIPort (AttrIded (Dir, SignRange) -> ModuleItem)
-> AttrIded (Dir, SignRange) -> ModuleItem
forall a b. (a -> b) -> a -> b
$ Attributes
-> Identifier -> (Dir, SignRange) -> AttrIded (Dir, SignRange)
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
a Identifier
s (Dir
DirOut, Bool -> Maybe Range2 -> SignRange
SignRange Bool
False Maybe Range2
forall a. Maybe a
Nothing),
            Attributed ModGenBlockedItem -> ModuleItem
MIMGI (Attributed ModGenBlockedItem -> ModuleItem)
-> Attributed ModGenBlockedItem -> ModuleItem
forall a b. (a -> b) -> a -> b
$
              Attributes -> ModGenBlockedItem -> Attributed ModGenBlockedItem
forall t. Attributes -> t -> Attributed t
Attributed Attributes
a (ModGenBlockedItem -> Attributed ModGenBlockedItem)
-> ModGenBlockedItem -> Attributed ModGenBlockedItem
forall a b. (a -> b) -> a -> b
$
                BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
-> ModGenBlockedItem
forall (f :: * -> *).
BlockDecl (Compose f Identified) (Either [Range2] CExpr)
-> ModGenItem f
MGIBlockDecl (BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
 -> ModGenBlockedItem)
-> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
-> ModGenBlockedItem
forall a b. (a -> b) -> a -> b
$ Compose Identity Identified (Either [Range2] CExpr)
-> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
f (Compose Identity Identified (Either [Range2] CExpr)
 -> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
-> Compose Identity Identified (Either [Range2] CExpr)
-> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
forall a b. (a -> b) -> a -> b
$ Identity (Identified (Either [Range2] CExpr))
-> Compose Identity Identified (Either [Range2] CExpr)
forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Identity (Identified (Either [Range2] CExpr))
 -> Compose Identity Identified (Either [Range2] CExpr))
-> Identity (Identified (Either [Range2] CExpr))
-> Compose Identity Identified (Either [Range2] CExpr)
forall a b. (a -> b) -> a -> b
$ Identified (Either [Range2] CExpr)
-> Identity (Identified (Either [Range2] CExpr))
forall a. a -> Identity a
Identity (Identified (Either [Range2] CExpr)
 -> Identity (Identified (Either [Range2] CExpr)))
-> Identified (Either [Range2] CExpr)
-> Identity (Identified (Either [Range2] CExpr))
forall a b. (a -> b) -> a -> b
$ Identifier
-> Either [Range2] CExpr -> Identified (Either [Range2] CExpr)
forall t. Identifier -> t -> Identified t
Identified Identifier
s (Either [Range2] CExpr -> Identified (Either [Range2] CExpr))
-> Either [Range2] CExpr -> Identified (Either [Range2] CExpr)
forall a b. (a -> b) -> a -> b
$ Either [Range2] CExpr
-> (CExpr -> Either [Range2] CExpr)
-> Maybe CExpr
-> Either [Range2] CExpr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Range2] -> Either [Range2] CExpr
forall a b. a -> Either a b
Left []) CExpr -> Either [Range2] CExpr
forall a b. b -> Either a b
Right Maybe CExpr
e
          ],
          Identifier -> [Identified (Maybe CRangeExpr)] -> PortInterface
forall t. Identifier -> t -> Identified t
Identified Identifier
s [Identifier -> Maybe CRangeExpr -> Identified (Maybe CRangeExpr)
forall t. Identifier -> t -> Identified t
Identified Identifier
s Maybe CRangeExpr
forall a. Maybe a
Nothing]
        )

-- | Port declaration
portDecl :: Maybe NetType -> Bool -> LABranch (NonEmpty ModuleItem, NonEmpty PortInterface)
portDecl :: Maybe NetType
-> Bool -> LABranch (NonEmpty ModuleItem, NonEmpty PortInterface)
portDecl Maybe NetType
dnt Bool
fullspec =
  [ (Token
KWInput, Dir
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
ps Dir
DirIn),
    (Token
KWInout, Dir
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
ps Dir
DirInOut),
    ( Token
KWOutput,
      \Attributes
a ->
        (Token
 -> Maybe
      (ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         (NonEmpty ModuleItem, NonEmpty PortInterface)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch
          ( \Token
t -> case Token
t of
              Token
KWReg -> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty ModuleItem, NonEmpty PortInterface)
-> Maybe
     (ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (NonEmpty ModuleItem, NonEmpty PortInterface))
forall a. a -> Maybe a
Just (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (NonEmpty ModuleItem, NonEmpty PortInterface)
 -> Maybe
      (ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         (NonEmpty ModuleItem, NonEmpty PortInterface)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
-> Maybe
     (ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (NonEmpty ModuleItem, NonEmpty PortInterface))
forall a b. (a -> b) -> a -> b
$ Parser SignRange
signRange Parser SignRange
-> (SignRange
    -> ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         (NonEmpty ModuleItem, NonEmpty PortInterface))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Attributes
-> (Compose Identity Identified (Either [Range2] CExpr)
    -> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
pv Attributes
a ((Compose Identity Identified (Either [Range2] CExpr)
  -> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (NonEmpty ModuleItem, NonEmpty PortInterface))
-> (SignRange
    -> Compose Identity Identified (Either [Range2] CExpr)
    -> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
-> SignRange
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SignRange
-> Compose Identity Identified (Either [Range2] CExpr)
-> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
forall (f :: * -> *) t. SignRange -> f t -> BlockDecl f t
BDReg
              Token
KWInteger -> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty ModuleItem, NonEmpty PortInterface)
-> Maybe
     (ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (NonEmpty ModuleItem, NonEmpty PortInterface))
forall a. a -> Maybe a
Just (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (NonEmpty ModuleItem, NonEmpty PortInterface)
 -> Maybe
      (ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         (NonEmpty ModuleItem, NonEmpty PortInterface)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
-> Maybe
     (ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (NonEmpty ModuleItem, NonEmpty PortInterface))
forall a b. (a -> b) -> a -> b
$ Attributes
-> (Compose Identity Identified (Either [Range2] CExpr)
    -> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
pv Attributes
a Compose Identity Identified (Either [Range2] CExpr)
-> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
forall (f :: * -> *) t. f t -> BlockDecl f t
BDInt
              Token
KWTime -> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty ModuleItem, NonEmpty PortInterface)
-> Maybe
     (ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (NonEmpty ModuleItem, NonEmpty PortInterface))
forall a. a -> Maybe a
Just (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (NonEmpty ModuleItem, NonEmpty PortInterface)
 -> Maybe
      (ParsecT
         [PosToken]
         LocalCompDir
         (Writer [String])
         (NonEmpty ModuleItem, NonEmpty PortInterface)))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
-> Maybe
     (ParsecT
        [PosToken]
        LocalCompDir
        (Writer [String])
        (NonEmpty ModuleItem, NonEmpty PortInterface))
forall a b. (a -> b) -> a -> b
$ Attributes
-> (Compose Identity Identified (Either [Range2] CExpr)
    -> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
pv Attributes
a Compose Identity Identified (Either [Range2] CExpr)
-> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
forall (f :: * -> *) t. f t -> BlockDecl f t
BDTime
              Token
_ -> Maybe
  (ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface))
forall a. Maybe a
Nothing
          )
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty ModuleItem, NonEmpty PortInterface)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Dir
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
ps Dir
DirOut Attributes
a
    )
  ]
  where
    mk :: ParsecT [PosToken] LocalCompDir (Writer [String]) (m (m a, b))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (m a, m b)
mk ParsecT [PosToken] LocalCompDir (Writer [String]) (m (m a, b))
p = (m (m a) -> m a) -> (m (m a), m b) -> (m a, m b)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first m (m a) -> m a
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join ((m (m a), m b) -> (m a, m b))
-> (m (m a, b) -> (m (m a), m b)) -> m (m a, b) -> (m a, m b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (m a, b) -> (m (m a), m b)
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
DF.unzip (m (m a, b) -> (m a, m b))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (m (m a, b))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (m a, m b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [PosToken] LocalCompDir (Writer [String]) (m (m a, b))
p ParsecT [PosToken] LocalCompDir (Writer [String]) (m a, m b)
-> Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (m a, m b)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* if Bool
fullspec then () -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure () else Token -> Parser ()
consume Token
SymSemi
    ps :: Dir
-> Attributes
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
ps Dir
d Attributes
a = Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
forall {m :: * -> *} {a} {b}.
Monad m =>
ParsecT [PosToken] LocalCompDir (Writer [String]) (m (m a, b))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (m a, m b)
mk (Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (NonEmpty ModuleItem, NonEmpty PortInterface))
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
forall a b. (a -> b) -> a -> b
$ Maybe NetType
-> Bool
-> Dir
-> Attributes
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
portsimple Maybe NetType
dnt Bool
fullspec Dir
d Attributes
a
    pv :: Attributes
-> (Compose Identity Identified (Either [Range2] CExpr)
    -> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
pv Attributes
a Compose Identity Identified (Either [Range2] CExpr)
-> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
f = Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
forall {m :: * -> *} {a} {b}.
Monad m =>
ParsecT [PosToken] LocalCompDir (Writer [String]) (m (m a, b))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (m a, m b)
mk (Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (NonEmpty ModuleItem, NonEmpty PortInterface))
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
forall a b. (a -> b) -> a -> b
$ Bool
-> Attributes
-> (Compose Identity Identified (Either [Range2] CExpr)
    -> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr))
-> Parser (NonEmpty (NonEmpty ModuleItem, PortInterface))
portvariable Bool
fullspec Attributes
a Compose Identity Identified (Either [Range2] CExpr)
-> BlockDecl (Compose Identity Identified) (Either [Range2] CExpr)
f

-- | Port expression
portExpr :: Parser [Identified (Maybe CRangeExpr)]
portExpr :: Parser [Identified (Maybe CRangeExpr)]
portExpr = [Identified (Maybe CRangeExpr)]
-> Parser [Identified (Maybe CRangeExpr)]
-> Parser [Identified (Maybe CRangeExpr)]
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (Parser [Identified (Maybe CRangeExpr)]
 -> Parser [Identified (Maybe CRangeExpr)])
-> Parser [Identified (Maybe CRangeExpr)]
-> Parser [Identified (Maybe CRangeExpr)]
forall a b. (a -> b) -> a -> b
$ (Identified (Maybe CRangeExpr)
-> [Identified (Maybe CRangeExpr)]
-> [Identified (Maybe CRangeExpr)]
forall a. a -> [a] -> [a]
: []) (Identified (Maybe CRangeExpr) -> [Identified (Maybe CRangeExpr)])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Identified (Maybe CRangeExpr))
-> Parser [Identified (Maybe CRangeExpr)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Identified (Maybe CRangeExpr))
pp Parser [Identified (Maybe CRangeExpr)]
-> Parser [Identified (Maybe CRangeExpr)]
-> Parser [Identified (Maybe CRangeExpr)]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> NonEmpty (Identified (Maybe CRangeExpr))
-> [Identified (Maybe CRangeExpr)]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty (Identified (Maybe CRangeExpr))
 -> [Identified (Maybe CRangeExpr)])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (Identified (Maybe CRangeExpr)))
-> Parser [Identified (Maybe CRangeExpr)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Identified (Maybe CRangeExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (Identified (Maybe CRangeExpr)))
forall a. Parser a -> Parser (NonEmpty a)
bcsl1 ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Identified (Maybe CRangeExpr))
pp
  where
    pp :: ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Identified (Maybe CRangeExpr))
pp = Identifier -> Maybe CRangeExpr -> Identified (Maybe CRangeExpr)
forall t. Identifier -> t -> Identified t
Identified (Identifier -> Maybe CRangeExpr -> Identified (Maybe CRangeExpr))
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe CRangeExpr -> Identified (Maybe CRangeExpr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe CRangeExpr -> Identified (Maybe CRangeExpr))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Identified (Maybe CRangeExpr))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe CRangeExpr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe ParsecT [PosToken] LocalCompDir (Writer [String]) CRangeExpr
constRangeExpr

-- | Path declaration
trPathDecl :: SourcePos -> ModulePathCondition -> Parser (NonEmpty SpecifyBlockedItem)
trPathDecl :: SourcePos
-> ModulePathCondition -> Parser (NonEmpty SpecifyBlockedItem)
trPathDecl SourcePos
pos ModulePathCondition
cond = do
  Maybe Bool
edge <- Parser Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser Bool
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
-> Parser Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a b. (a -> b) -> a -> b
$
    (Token -> Maybe Bool) -> Parser Bool
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Bool) -> Parser Bool)
-> (Token -> Maybe Bool) -> Parser Bool
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
      Token
KWPosedge -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
      Token
KWNegedge -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
      Token
_ -> Maybe Bool
forall a. Maybe a
Nothing
  NonEmpty SpecTerm
inp <- Parser SpecTerm -> Parser (NonEmpty SpecTerm)
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser SpecTerm
specTerm
  Maybe Bool
po <- Parser Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser Bool
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
-> Parser Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a b. (a -> b) -> a -> b
$
    (Token -> Maybe Bool) -> Parser Bool
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Bool) -> Parser Bool)
-> (Token -> Maybe Bool) -> Parser Bool
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
      Token
SymPlus -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
      Token
SymDash -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
      Token
_ -> Maybe Bool
forall a. Maybe a
Nothing
  Bool
pf <- (Token -> Maybe Bool) -> Parser Bool
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Bool) -> Parser Bool)
-> (Token -> Maybe Bool) -> Parser Bool
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
    Token
SymAsterGt -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
    Token
SymEqGt -> Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
    Token
_ -> Maybe Bool
forall a. Maybe a
Nothing
  (NonEmpty SpecTerm
out, Maybe Bool
pol, Maybe (Expr, Maybe Bool)
eds) <-
    Parser (NonEmpty SpecTerm, Maybe Bool, Maybe (Expr, Maybe Bool))
-> Parser (NonEmpty SpecTerm, Maybe Bool, Maybe (Expr, Maybe Bool))
forall a. Parser a -> Parser a
parens
      ( do
          NonEmpty SpecTerm
outp <- Parser SpecTerm -> Parser (NonEmpty SpecTerm)
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser SpecTerm
specTerm
          Maybe Bool
po <- (Token
 -> Maybe
      (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token
  -> Maybe
       (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)))
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
-> (Token
    -> Maybe
         (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
            Token
SymPlus -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> Maybe
     (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a. a -> Maybe a
Just (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
 -> Maybe
      (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> Maybe
     (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymColon Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Maybe Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True)
            Token
SymDash -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> Maybe
     (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a. a -> Maybe a
Just (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
 -> Maybe
      (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> Maybe
     (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymColon Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Maybe Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False)
            Token
SymColon -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> Maybe
     (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a. a -> Maybe a
Just (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
 -> Maybe
      (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> Maybe
     (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a b. (a -> b) -> a -> b
$ Maybe Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Bool
forall a. Maybe a
Nothing
            Token
SymPlusColon -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> Maybe
     (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a. a -> Maybe a
Just (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
 -> Maybe
      (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> Maybe
     (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a b. (a -> b) -> a -> b
$ Maybe Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Bool
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
-> Maybe Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a b. (a -> b) -> a -> b
$ Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
            Token
SymDashColon -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> Maybe
     (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a. a -> Maybe a
Just (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
 -> Maybe
      (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
-> Maybe
     (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a b. (a -> b) -> a -> b
$ Maybe Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Bool
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
-> Maybe Bool
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool)
forall a b. (a -> b) -> a -> b
$ Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
            Token
_ -> Maybe
  (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe Bool))
forall a. Maybe a
Nothing
          Expr
e <- Parser Expr
expr
          (NonEmpty SpecTerm, Maybe Bool, Maybe (Expr, Maybe Bool))
-> Parser (NonEmpty SpecTerm, Maybe Bool, Maybe (Expr, Maybe Bool))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty SpecTerm
outp, Maybe Bool
po, (Expr, Maybe Bool) -> Maybe (Expr, Maybe Bool)
forall a. a -> Maybe a
Just (Expr
e, Maybe Bool
edge))
      )
      Parser (NonEmpty SpecTerm, Maybe Bool, Maybe (Expr, Maybe Bool))
-> Parser (NonEmpty SpecTerm, Maybe Bool, Maybe (Expr, Maybe Bool))
-> Parser (NonEmpty SpecTerm, Maybe Bool, Maybe (Expr, Maybe Bool))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (\NonEmpty SpecTerm
outp -> (NonEmpty SpecTerm
outp, Maybe Bool
po, Maybe (Expr, Maybe Bool)
forall a. Maybe a
Nothing)) (NonEmpty SpecTerm
 -> (NonEmpty SpecTerm, Maybe Bool, Maybe (Expr, Maybe Bool)))
-> Parser (NonEmpty SpecTerm)
-> Parser (NonEmpty SpecTerm, Maybe Bool, Maybe (Expr, Maybe Bool))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SpecTerm -> Parser (NonEmpty SpecTerm)
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser SpecTerm
specTerm
  SpecPath
co <- if Bool
pf
    then case (NonEmpty SpecTerm
inp, NonEmpty SpecTerm
out) of
      (SpecTerm
i :| [], SpecTerm
o :| []) -> SpecPath
-> ParsecT [PosToken] LocalCompDir (Writer [String]) SpecPath
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (SpecPath
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) SpecPath)
-> SpecPath
-> ParsecT [PosToken] LocalCompDir (Writer [String]) SpecPath
forall a b. (a -> b) -> a -> b
$ SpecTerm -> SpecTerm -> SpecPath
SPParallel SpecTerm
i SpecTerm
o
      (NonEmpty SpecTerm, NonEmpty SpecTerm)
_ -> String
-> ParsecT [PosToken] LocalCompDir (Writer [String]) SpecPath
forall a. String -> Parser a
hardfail String
"Parallel delay only accept single nets as source and destination"
    else SpecPath
-> ParsecT [PosToken] LocalCompDir (Writer [String]) SpecPath
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty SpecTerm -> NonEmpty SpecTerm -> SpecPath
SPFull NonEmpty SpecTerm
inp NonEmpty SpecTerm
out)
  case () of
    () | Maybe Bool -> Bool
forall a. Maybe a -> Bool
isJust Maybe Bool
po Bool -> Bool -> Bool
&& Maybe (Expr, Maybe Bool) -> Bool
forall a. Maybe a -> Bool
isJust Maybe (Expr, Maybe Bool)
eds -> String -> Parser ()
forall a. String -> Parser a
hardfail String
"Edge sensitive path with misplaced polarity operator"
    () | Maybe Bool -> Bool
forall a. Maybe a -> Bool
isJust Maybe Bool
edge Bool -> Bool -> Bool
&& Maybe (Expr, Maybe Bool)
eds Maybe (Expr, Maybe Bool) -> Maybe (Expr, Maybe Bool) -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe (Expr, Maybe Bool)
forall a. Maybe a
Nothing ->
      String -> Parser ()
forall a. String -> Parser a
hardfail String
"Mixed edge and non edge sensitive delay path elements"
    () -> () -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
pos Token
SymParenL Token
SymParenR
  Token -> Parser ()
consume Token
SymEq
  NonEmpty (GenMinTypMax CExpr)
vals <- ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty (GenMinTypMax CExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (GenMinTypMax CExpr))
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT
  [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (GenMinTypMax CExpr))
forall a. Parser a -> Parser (NonEmpty a)
csl1 (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (NonEmpty (GenMinTypMax CExpr)))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (GenMinTypMax CExpr))
forall a b. (a -> b) -> a -> b
$ Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser CExpr
constExpr) ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty (GenMinTypMax CExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (GenMinTypMax CExpr))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (GenMinTypMax CExpr))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT
  [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (GenMinTypMax CExpr))
forall a. Parser a -> Parser (NonEmpty a)
pcsl1 (Parser CExpr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax CExpr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser CExpr
constExpr) -- cancer optional parentheses
  (SpecifyBlockedItem
-> [SpecifyBlockedItem] -> NonEmpty SpecifyBlockedItem
forall a. a -> [a] -> NonEmpty a
:|[]) (SpecifyBlockedItem -> NonEmpty SpecifyBlockedItem)
-> (PathDelayValue -> SpecifyBlockedItem)
-> PathDelayValue
-> NonEmpty SpecifyBlockedItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModulePathCondition
-> SpecPath
-> Maybe Bool
-> Maybe (Expr, Maybe Bool)
-> PathDelayValue
-> SpecifyBlockedItem
forall (f :: * -> *).
ModulePathCondition
-> SpecPath
-> Maybe Bool
-> Maybe (Expr, Maybe Bool)
-> PathDelayValue
-> SpecifyItem f
SIPathDeclaration ModulePathCondition
cond SpecPath
co Maybe Bool
pol Maybe (Expr, Maybe Bool)
eds (PathDelayValue -> NonEmpty SpecifyBlockedItem)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
-> Parser (NonEmpty SpecifyBlockedItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> case NonEmpty (GenMinTypMax CExpr)
vals of
    [Item (NonEmpty (GenMinTypMax CExpr))
e] -> PathDelayValue
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (PathDelayValue
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) PathDelayValue)
-> PathDelayValue
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a b. (a -> b) -> a -> b
$ GenMinTypMax CExpr -> PathDelayValue
PDV1 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e
    [Item (NonEmpty (GenMinTypMax CExpr))
e1, Item (NonEmpty (GenMinTypMax CExpr))
e2] -> PathDelayValue
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (PathDelayValue
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) PathDelayValue)
-> PathDelayValue
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a b. (a -> b) -> a -> b
$ GenMinTypMax CExpr -> GenMinTypMax CExpr -> PathDelayValue
PDV2 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e1 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e2
    [Item (NonEmpty (GenMinTypMax CExpr))
e1, Item (NonEmpty (GenMinTypMax CExpr))
e2, Item (NonEmpty (GenMinTypMax CExpr))
e3] -> PathDelayValue
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (PathDelayValue
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) PathDelayValue)
-> PathDelayValue
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a b. (a -> b) -> a -> b
$ GenMinTypMax CExpr
-> GenMinTypMax CExpr -> GenMinTypMax CExpr -> PathDelayValue
PDV3 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e1 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e2 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e3
    [Item (NonEmpty (GenMinTypMax CExpr))
e1, Item (NonEmpty (GenMinTypMax CExpr))
e2, Item (NonEmpty (GenMinTypMax CExpr))
e3, Item (NonEmpty (GenMinTypMax CExpr))
e4, Item (NonEmpty (GenMinTypMax CExpr))
e5, Item (NonEmpty (GenMinTypMax CExpr))
e6] -> PathDelayValue
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (PathDelayValue
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) PathDelayValue)
-> PathDelayValue
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a b. (a -> b) -> a -> b
$ GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> PathDelayValue
PDV6 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e1 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e2 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e3 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e4 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e5 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e6
    [Item (NonEmpty (GenMinTypMax CExpr))
e1, Item (NonEmpty (GenMinTypMax CExpr))
e2, Item (NonEmpty (GenMinTypMax CExpr))
e3, Item (NonEmpty (GenMinTypMax CExpr))
e4, Item (NonEmpty (GenMinTypMax CExpr))
e5, Item (NonEmpty (GenMinTypMax CExpr))
e6, Item (NonEmpty (GenMinTypMax CExpr))
e7, Item (NonEmpty (GenMinTypMax CExpr))
e8, Item (NonEmpty (GenMinTypMax CExpr))
e9, Item (NonEmpty (GenMinTypMax CExpr))
e10, Item (NonEmpty (GenMinTypMax CExpr))
e11, Item (NonEmpty (GenMinTypMax CExpr))
e12] ->
      PathDelayValue
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (PathDelayValue
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) PathDelayValue)
-> PathDelayValue
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a b. (a -> b) -> a -> b
$ GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> GenMinTypMax CExpr
-> PathDelayValue
PDV12 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e1 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e2 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e3 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e4 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e5 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e6 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e7 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e8 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e9 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e10 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e11 Item (NonEmpty (GenMinTypMax CExpr))
GenMinTypMax CExpr
e12
    NonEmpty (GenMinTypMax CExpr)
_ -> String
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PathDelayValue
forall a. String -> Parser a
hardfail String
"Wrong number of argument"

pathDecl :: ModulePathCondition -> Parser (NonEmpty SpecifyBlockedItem)
pathDecl :: ModulePathCondition -> Parser (NonEmpty SpecifyBlockedItem)
pathDecl ModulePathCondition
mpc = ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
-> (SourcePos -> Parser (NonEmpty SpecifyBlockedItem))
-> Parser (NonEmpty SpecifyBlockedItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \SourcePos
p -> Token -> Parser ()
consume Token
SymParenL Parser ()
-> Parser (NonEmpty SpecifyBlockedItem)
-> Parser (NonEmpty SpecifyBlockedItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> SourcePos
-> ModulePathCondition -> Parser (NonEmpty SpecifyBlockedItem)
trPathDecl SourcePos
p ModulePathCondition
mpc

-- | Timing check event
edgeDesc :: Parser EdgeDesc
edgeDesc :: Parser EdgeDesc
edgeDesc = (Token -> Maybe (Parser EdgeDesc)) -> Parser EdgeDesc
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token -> Maybe (Parser EdgeDesc)) -> Parser EdgeDesc)
-> (Token -> Maybe (Parser EdgeDesc)) -> Parser EdgeDesc
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
  Token
KWPosedge -> Parser EdgeDesc -> Maybe (Parser EdgeDesc)
forall a. a -> Maybe a
Just (Parser EdgeDesc -> Maybe (Parser EdgeDesc))
-> Parser EdgeDesc -> Maybe (Parser EdgeDesc)
forall a b. (a -> b) -> a -> b
$ EdgeDesc -> Parser EdgeDesc
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (EdgeDesc -> Parser EdgeDesc) -> EdgeDesc -> Parser EdgeDesc
forall a b. (a -> b) -> a -> b
$ [Bool] -> EdgeDesc
forall a. Unbox a => [a] -> Vector a
V.fromList [Bool
Item [Bool]
True, Bool
Item [Bool]
True, Bool
Item [Bool]
False, Bool
Item [Bool]
False, Bool
Item [Bool]
False, Bool
Item [Bool]
True]
  Token
KWNegedge -> Parser EdgeDesc -> Maybe (Parser EdgeDesc)
forall a. a -> Maybe a
Just (Parser EdgeDesc -> Maybe (Parser EdgeDesc))
-> Parser EdgeDesc -> Maybe (Parser EdgeDesc)
forall a b. (a -> b) -> a -> b
$ EdgeDesc -> Parser EdgeDesc
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (EdgeDesc -> Parser EdgeDesc) -> EdgeDesc -> Parser EdgeDesc
forall a b. (a -> b) -> a -> b
$ [Bool] -> EdgeDesc
forall a. Unbox a => [a] -> Vector a
V.fromList [Bool
Item [Bool]
False, Bool
Item [Bool]
False, Bool
Item [Bool]
True, Bool
Item [Bool]
True, Bool
Item [Bool]
True, Bool
Item [Bool]
False]
  Token
KWEdge ->
    Parser EdgeDesc -> Maybe (Parser EdgeDesc)
forall a. a -> Maybe a
Just (Parser EdgeDesc -> Maybe (Parser EdgeDesc))
-> Parser EdgeDesc -> Maybe (Parser EdgeDesc)
forall a b. (a -> b) -> a -> b
$
      (Line -> Bool -> EdgeDesc
forall a. Unbox a => Line -> a -> Vector a
V.replicate Line
6 Bool
False EdgeDesc -> [(Line, Bool)] -> EdgeDesc
forall a. Unbox a => Vector a -> [(Line, a)] -> Vector a
V.//) ([(Line, Bool)] -> EdgeDesc)
-> (NonEmpty (Line, Bool) -> [(Line, Bool)])
-> NonEmpty (Line, Bool)
-> EdgeDesc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (Line, Bool) -> [(Line, Bool)]
forall a. NonEmpty a -> [a]
NE.toList
        (NonEmpty (Line, Bool) -> EdgeDesc)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty (Line, Bool))
-> Parser EdgeDesc
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken] LocalCompDir (Writer [String]) (NonEmpty (Line, Bool))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty (Line, Bool))
forall a. Parser a -> Parser a
brackets
          ( Parser (Line, Bool)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty (Line, Bool))
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Parser (Line, Bool)
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (NonEmpty (Line, Bool)))
-> Parser (Line, Bool)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty (Line, Bool))
forall a b. (a -> b) -> a -> b
$
              (Token -> Maybe (Line, Bool)) -> Parser (Line, Bool)
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe (Line, Bool)) -> Parser (Line, Bool))
-> (Token -> Maybe (Line, Bool)) -> Parser (Line, Bool)
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
                EdgeEdge BXZ
BXZ0 BXZ
BXZ1 -> (Line, Bool) -> Maybe (Line, Bool)
forall a. a -> Maybe a
Just (Line
0, Bool
True)
                EdgeEdge BXZ
BXZ0 BXZ
BXZX -> (Line, Bool) -> Maybe (Line, Bool)
forall a. a -> Maybe a
Just (Line
1, Bool
True)
                EdgeEdge BXZ
BXZ0 BXZ
BXZZ -> (Line, Bool) -> Maybe (Line, Bool)
forall a. a -> Maybe a
Just (Line
1, Bool
True)
                EdgeEdge BXZ
BXZ1 BXZ
BXZ0 -> (Line, Bool) -> Maybe (Line, Bool)
forall a. a -> Maybe a
Just (Line
2, Bool
True)
                EdgeEdge BXZ
BXZ1 BXZ
BXZX -> (Line, Bool) -> Maybe (Line, Bool)
forall a. a -> Maybe a
Just (Line
3, Bool
True)
                EdgeEdge BXZ
BXZ1 BXZ
BXZZ -> (Line, Bool) -> Maybe (Line, Bool)
forall a. a -> Maybe a
Just (Line
3, Bool
True)
                EdgeEdge BXZ
BXZX BXZ
BXZ0 -> (Line, Bool) -> Maybe (Line, Bool)
forall a. a -> Maybe a
Just (Line
4, Bool
True)
                EdgeEdge BXZ
BXZX BXZ
BXZ1 -> (Line, Bool) -> Maybe (Line, Bool)
forall a. a -> Maybe a
Just (Line
5, Bool
True)
                EdgeEdge BXZ
BXZZ BXZ
BXZ0 -> (Line, Bool) -> Maybe (Line, Bool)
forall a. a -> Maybe a
Just (Line
4, Bool
True)
                EdgeEdge BXZ
BXZZ BXZ
BXZ1 -> (Line, Bool) -> Maybe (Line, Bool)
forall a. a -> Maybe a
Just (Line
5, Bool
True)
                Token
_ -> Maybe (Line, Bool)
forall a. Maybe a
Nothing
          )
  Token
_ -> Maybe (Parser EdgeDesc)
forall a. Maybe a
Nothing

-- | Timing check condition after &&&
-- | This thing is cancer because of ambiguous parens, tilde, and comparisons
-- | Especially parens and comparison because it requires early exit in expression
-- | And that is PANTS: Pure Absurdity Nobody Truly Supports
-- | So I decided to NOT parse it correctly.
-- | If you think you have a simple parser, your parser idea is likely wrong
-- | If you think it's complicated parser, your parser idea is likely wrong
-- | If you think it's absurd and you have a parser the size of this file,
-- | you're right but your parser idea is still likely wrong
timingCheckCond :: Parser (Bool, Expr)
timingCheckCond :: Parser (Bool, Expr)
timingCheckCond = do
  Token -> Parser ()
consume Token
SymAmpAmpAmp
  Parser (Bool, Expr) -> Parser (Bool, Expr)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ((Token -> Parser ()
consume Token
UnTilde Parser () -> Parser (Bool, Expr) -> Parser (Bool, Expr)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (,) Bool
True (Expr -> (Bool, Expr)) -> Parser Expr -> Parser (Bool, Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
expr) Parser (Bool, Expr) -> Parser (Bool, Expr) -> Parser (Bool, Expr)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (,) Bool
False (Expr -> (Bool, Expr)) -> Parser Expr -> Parser (Bool, Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
expr)
    Parser (Bool, Expr) -> Parser (Bool, Expr) -> Parser (Bool, Expr)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Token -> Parser ()
consume Token
UnTilde Parser () -> Parser (Bool, Expr) -> Parser (Bool, Expr)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (,) Bool
True (Expr -> (Bool, Expr)) -> Parser Expr -> Parser (Bool, Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Expr
expr)

timingCheckEvent :: Parser TimingCheckEvent
timingCheckEvent :: Parser TimingCheckEvent
timingCheckEvent =
  Maybe EdgeDesc
-> SpecTerm -> Maybe (Bool, Expr) -> TimingCheckEvent
TimingCheckEvent (Maybe EdgeDesc
 -> SpecTerm -> Maybe (Bool, Expr) -> TimingCheckEvent)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe EdgeDesc)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (SpecTerm -> Maybe (Bool, Expr) -> TimingCheckEvent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser EdgeDesc
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe EdgeDesc)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser EdgeDesc
edgeDesc ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (SpecTerm -> Maybe (Bool, Expr) -> TimingCheckEvent)
-> Parser SpecTerm
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Bool, Expr) -> TimingCheckEvent)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SpecTerm
specTerm ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe (Bool, Expr) -> TimingCheckEvent)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe (Bool, Expr))
-> Parser TimingCheckEvent
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Bool, Expr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe (Bool, Expr))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser (Bool, Expr)
timingCheckCond

controlledTimingCheckEvent :: Parser ControlledTimingCheckEvent
controlledTimingCheckEvent :: Parser ControlledTimingCheckEvent
controlledTimingCheckEvent =
  EdgeDesc
-> SpecTerm -> Maybe (Bool, Expr) -> ControlledTimingCheckEvent
ControlledTimingCheckEvent (EdgeDesc
 -> SpecTerm -> Maybe (Bool, Expr) -> ControlledTimingCheckEvent)
-> Parser EdgeDesc
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (SpecTerm -> Maybe (Bool, Expr) -> ControlledTimingCheckEvent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser EdgeDesc
edgeDesc ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (SpecTerm -> Maybe (Bool, Expr) -> ControlledTimingCheckEvent)
-> Parser SpecTerm
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (Bool, Expr) -> ControlledTimingCheckEvent)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SpecTerm
specTerm ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe (Bool, Expr) -> ControlledTimingCheckEvent)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe (Bool, Expr))
-> Parser ControlledTimingCheckEvent
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Bool, Expr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe (Bool, Expr))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser (Bool, Expr)
timingCheckCond

-- | Standard system timing check arguments
optoptChain :: b -> Parser a -> Parser b -> Parser (Maybe a, b)
optoptChain :: forall b a. b -> Parser a -> Parser b -> Parser (Maybe a, b)
optoptChain b
dn Parser a
px Parser b
pn =
  Token -> Parser Bool
optConsume Token
SymComma Parser Bool
-> (Bool
    -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe a, b))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe a, b)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> (a -> ParsecT [PosToken] LocalCompDir (Writer [String]) b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
b -> if Bool
b then ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe a)
-> Parser b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe a, b)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f (a, b)
mkpair (Parser a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe a)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser a
px) Parser b
pn else (Maybe a, b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe a, b)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe a
forall a. Maybe a
Nothing, b
dn)

comStcArgs :: Parser (TimingCheckEvent, TimingCheckEvent, Expr)
comStcArgs :: Parser (TimingCheckEvent, TimingCheckEvent, Expr)
comStcArgs =
  (,,) (TimingCheckEvent
 -> TimingCheckEvent
 -> Expr
 -> (TimingCheckEvent, TimingCheckEvent, Expr))
-> Parser TimingCheckEvent
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (TimingCheckEvent
      -> Expr -> (TimingCheckEvent, TimingCheckEvent, Expr))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TimingCheckEvent
timingCheckEvent ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (TimingCheckEvent
   -> Expr -> (TimingCheckEvent, TimingCheckEvent, Expr))
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (TimingCheckEvent
      -> Expr -> (TimingCheckEvent, TimingCheckEvent, Expr))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymComma ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (TimingCheckEvent
   -> Expr -> (TimingCheckEvent, TimingCheckEvent, Expr))
-> Parser TimingCheckEvent
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Expr -> (TimingCheckEvent, TimingCheckEvent, Expr))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TimingCheckEvent
timingCheckEvent ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Expr -> (TimingCheckEvent, TimingCheckEvent, Expr))
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Expr -> (TimingCheckEvent, TimingCheckEvent, Expr))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymComma ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Expr -> (TimingCheckEvent, TimingCheckEvent, Expr))
-> Parser Expr -> Parser (TimingCheckEvent, TimingCheckEvent, Expr)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
expr

stdStcArgs :: Parser STCArgs
stdStcArgs :: Parser STCArgs
stdStcArgs = do
  (TimingCheckEvent
r, TimingCheckEvent
d, Expr
e) <- Parser (TimingCheckEvent, TimingCheckEvent, Expr)
comStcArgs
  TimingCheckEvent
-> TimingCheckEvent -> Expr -> Maybe Identifier -> STCArgs
STCArgs TimingCheckEvent
d TimingCheckEvent
r Expr
e (Maybe Identifier -> STCArgs)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> Parser STCArgs
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe Identifier
forall a. Maybe a
Nothing (Token -> Parser ()
consume Token
SymComma Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Identifier
ident)

addStcArgs :: Parser (STCArgs, STCAddArgs)
addStcArgs :: Parser (STCArgs, STCAddArgs)
addStcArgs = do
  (TimingCheckEvent
r, TimingCheckEvent
d, Expr
ll) <- Parser (TimingCheckEvent, TimingCheckEvent, Expr)
comStcArgs
  Token -> Parser ()
consume Token
SymComma
  Expr
lr <- Parser Expr
expr
  let def1 :: (Maybe a, Maybe a)
def1 = (Maybe a
forall a. Maybe a
Nothing, Maybe a
forall a. Maybe a
Nothing)
      def2 :: (Maybe a, (Maybe a, Maybe a))
def2 = (Maybe a
forall a. Maybe a
Nothing, (Maybe a, Maybe a)
forall {a} {a}. (Maybe a, Maybe a)
def1)
      def3 :: (Maybe a, (Maybe a, (Maybe a, Maybe a)))
def3 = (Maybe a
forall a. Maybe a
Nothing, (Maybe a, (Maybe a, Maybe a))
forall {a} {a} {a}. (Maybe a, (Maybe a, Maybe a))
def2)
  (Maybe Identifier
n, (Maybe (GenMinTypMax Expr)
sc, (Maybe (GenMinTypMax Expr)
cc, (Maybe (Identified (Maybe (GenMinTypMax CExpr)))
dr, Maybe (Identified (Maybe (GenMinTypMax CExpr)))
dd)))) <-
    (Maybe (GenMinTypMax Expr),
 (Maybe (GenMinTypMax Expr),
  (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
   Maybe (Identified (Maybe (GenMinTypMax CExpr))))))
-> Parser Identifier
-> Parser
     (Maybe (GenMinTypMax Expr),
      (Maybe (GenMinTypMax Expr),
       (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
        Maybe (Identified (Maybe (GenMinTypMax CExpr))))))
-> Parser
     (Maybe Identifier,
      (Maybe (GenMinTypMax Expr),
       (Maybe (GenMinTypMax Expr),
        (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
         Maybe (Identified (Maybe (GenMinTypMax CExpr)))))))
forall b a. b -> Parser a -> Parser b -> Parser (Maybe a, b)
optoptChain (Maybe (GenMinTypMax Expr),
 (Maybe (GenMinTypMax Expr),
  (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
   Maybe (Identified (Maybe (GenMinTypMax CExpr))))))
forall {a} {a} {a} {a}. (Maybe a, (Maybe a, (Maybe a, Maybe a)))
def3 Parser Identifier
ident (Parser
   (Maybe (GenMinTypMax Expr),
    (Maybe (GenMinTypMax Expr),
     (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
      Maybe (Identified (Maybe (GenMinTypMax CExpr))))))
 -> Parser
      (Maybe Identifier,
       (Maybe (GenMinTypMax Expr),
        (Maybe (GenMinTypMax Expr),
         (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
          Maybe (Identified (Maybe (GenMinTypMax CExpr))))))))
-> Parser
     (Maybe (GenMinTypMax Expr),
      (Maybe (GenMinTypMax Expr),
       (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
        Maybe (Identified (Maybe (GenMinTypMax CExpr))))))
-> Parser
     (Maybe Identifier,
      (Maybe (GenMinTypMax Expr),
       (Maybe (GenMinTypMax Expr),
        (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
         Maybe (Identified (Maybe (GenMinTypMax CExpr)))))))
forall a b. (a -> b) -> a -> b
$
      (Maybe (GenMinTypMax Expr),
 (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
  Maybe (Identified (Maybe (GenMinTypMax CExpr)))))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> Parser
     (Maybe (GenMinTypMax Expr),
      (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
       Maybe (Identified (Maybe (GenMinTypMax CExpr)))))
-> Parser
     (Maybe (GenMinTypMax Expr),
      (Maybe (GenMinTypMax Expr),
       (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
        Maybe (Identified (Maybe (GenMinTypMax CExpr))))))
forall b a. b -> Parser a -> Parser b -> Parser (Maybe a, b)
optoptChain (Maybe (GenMinTypMax Expr),
 (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
  Maybe (Identified (Maybe (GenMinTypMax CExpr)))))
forall {a} {a} {a}. (Maybe a, (Maybe a, Maybe a))
def2 (Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser Expr
expr) (Parser
   (Maybe (GenMinTypMax Expr),
    (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
     Maybe (Identified (Maybe (GenMinTypMax CExpr)))))
 -> Parser
      (Maybe (GenMinTypMax Expr),
       (Maybe (GenMinTypMax Expr),
        (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
         Maybe (Identified (Maybe (GenMinTypMax CExpr)))))))
-> Parser
     (Maybe (GenMinTypMax Expr),
      (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
       Maybe (Identified (Maybe (GenMinTypMax CExpr)))))
-> Parser
     (Maybe (GenMinTypMax Expr),
      (Maybe (GenMinTypMax Expr),
       (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
        Maybe (Identified (Maybe (GenMinTypMax CExpr))))))
forall a b. (a -> b) -> a -> b
$
        (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
 Maybe (Identified (Maybe (GenMinTypMax CExpr))))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> Parser
     (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
      Maybe (Identified (Maybe (GenMinTypMax CExpr))))
-> Parser
     (Maybe (GenMinTypMax Expr),
      (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
       Maybe (Identified (Maybe (GenMinTypMax CExpr)))))
forall b a. b -> Parser a -> Parser b -> Parser (Maybe a, b)
optoptChain (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
 Maybe (Identified (Maybe (GenMinTypMax CExpr))))
forall {a} {a}. (Maybe a, Maybe a)
def1 (Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser Expr
expr) (Parser
   (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
    Maybe (Identified (Maybe (GenMinTypMax CExpr))))
 -> Parser
      (Maybe (GenMinTypMax Expr),
       (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
        Maybe (Identified (Maybe (GenMinTypMax CExpr))))))
-> Parser
     (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
      Maybe (Identified (Maybe (GenMinTypMax CExpr))))
-> Parser
     (Maybe (GenMinTypMax Expr),
      (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
       Maybe (Identified (Maybe (GenMinTypMax CExpr)))))
forall a b. (a -> b) -> a -> b
$
          Maybe (Identified (Maybe (GenMinTypMax CExpr)))
-> Parser (Identified (Maybe (GenMinTypMax CExpr)))
-> Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
-> Parser
     (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
      Maybe (Identified (Maybe (GenMinTypMax CExpr))))
forall b a. b -> Parser a -> Parser b -> Parser (Maybe a, b)
optoptChain Maybe (Identified (Maybe (GenMinTypMax CExpr)))
forall a. Maybe a
Nothing Parser (Identified (Maybe (GenMinTypMax CExpr)))
cmtmRef (Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
 -> Parser
      (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
       Maybe (Identified (Maybe (GenMinTypMax CExpr)))))
-> Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
-> Parser
     (Maybe (Identified (Maybe (GenMinTypMax CExpr))),
      Maybe (Identified (Maybe (GenMinTypMax CExpr))))
forall a b. (a -> b) -> a -> b
$ Maybe (Identified (Maybe (GenMinTypMax CExpr)))
-> Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
-> Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe (Identified (Maybe (GenMinTypMax CExpr)))
forall a. Maybe a
Nothing (Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
 -> Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr)))))
-> Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
-> Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymComma Parser ()
-> Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
-> Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser (Identified (Maybe (GenMinTypMax CExpr)))
-> Parser (Maybe (Identified (Maybe (GenMinTypMax CExpr))))
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser (Identified (Maybe (GenMinTypMax CExpr)))
cmtmRef
  (STCArgs, STCAddArgs) -> Parser (STCArgs, STCAddArgs)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (TimingCheckEvent
-> TimingCheckEvent -> Expr -> Maybe Identifier -> STCArgs
STCArgs TimingCheckEvent
d TimingCheckEvent
r Expr
ll Maybe Identifier
n, Expr
-> Maybe (GenMinTypMax Expr)
-> Maybe (GenMinTypMax Expr)
-> Maybe (Identified (Maybe (GenMinTypMax CExpr)))
-> Maybe (Identified (Maybe (GenMinTypMax CExpr)))
-> STCAddArgs
STCAddArgs Expr
lr Maybe (GenMinTypMax Expr)
sc Maybe (GenMinTypMax Expr)
cc Maybe (Identified (Maybe (GenMinTypMax CExpr)))
dr Maybe (Identified (Maybe (GenMinTypMax CExpr)))
dd)

skewStcArgs :: Parser (Maybe Identifier, Maybe CExpr, Maybe CExpr)
skewStcArgs :: Parser (Maybe Identifier, Maybe CExpr, Maybe CExpr)
skewStcArgs = do
  (Maybe Identifier
n, (Maybe CExpr
eb, Maybe CExpr
ra)) <-
    (Maybe CExpr, Maybe CExpr)
-> Parser Identifier
-> Parser (Maybe CExpr, Maybe CExpr)
-> Parser (Maybe Identifier, (Maybe CExpr, Maybe CExpr))
forall b a. b -> Parser a -> Parser b -> Parser (Maybe a, b)
optoptChain (Maybe CExpr
forall a. Maybe a
Nothing, Maybe CExpr
forall a. Maybe a
Nothing) Parser Identifier
ident (Parser (Maybe CExpr, Maybe CExpr)
 -> Parser (Maybe Identifier, (Maybe CExpr, Maybe CExpr)))
-> Parser (Maybe CExpr, Maybe CExpr)
-> Parser (Maybe Identifier, (Maybe CExpr, Maybe CExpr))
forall a b. (a -> b) -> a -> b
$
      Maybe CExpr
-> Parser CExpr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> Parser (Maybe CExpr, Maybe CExpr)
forall b a. b -> Parser a -> Parser b -> Parser (Maybe a, b)
optoptChain Maybe CExpr
forall a. Maybe a
Nothing Parser CExpr
constExpr (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
 -> Parser (Maybe CExpr, Maybe CExpr))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> Parser (Maybe CExpr, Maybe CExpr)
forall a b. (a -> b) -> a -> b
$ Maybe CExpr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe CExpr
forall a. Maybe a
Nothing (ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr))
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
SymComma Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser CExpr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser CExpr
constExpr
  (Maybe Identifier, Maybe CExpr, Maybe CExpr)
-> Parser (Maybe Identifier, Maybe CExpr, Maybe CExpr)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Identifier
n, Maybe CExpr
eb, Maybe CExpr
ra)

-- | System timing check functions
stcfMap :: HashMap.HashMap B.ByteString (Parser SpecifyBlockedItem)
stcfMap :: HashMap ByteString (Parser SpecifyBlockedItem)
stcfMap =
  [(ByteString, Parser SpecifyBlockedItem)]
-> HashMap ByteString (Parser SpecifyBlockedItem)
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HashMap.fromList
    [ (ByteString
"setup", STCArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SISetup (STCArgs -> SpecifyBlockedItem)
-> (STCArgs -> STCArgs) -> STCArgs -> SpecifyBlockedItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\(STCArgs TimingCheckEvent
d TimingCheckEvent
r Expr
e Maybe Identifier
n) -> TimingCheckEvent
-> TimingCheckEvent -> Expr -> Maybe Identifier -> STCArgs
STCArgs TimingCheckEvent
r TimingCheckEvent
d Expr
e Maybe Identifier
n) (STCArgs -> SpecifyBlockedItem)
-> Parser STCArgs -> Parser SpecifyBlockedItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser STCArgs
stdStcArgs),
      (ByteString
"hold", STCArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SIHold (STCArgs -> SpecifyBlockedItem)
-> Parser STCArgs -> Parser SpecifyBlockedItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser STCArgs
stdStcArgs),
      (ByteString
"setuphold", (STCArgs -> STCAddArgs -> SpecifyBlockedItem)
-> (STCArgs, STCAddArgs) -> SpecifyBlockedItem
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry STCArgs -> STCAddArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> STCAddArgs -> SpecifyItem f
SISetupHold ((STCArgs, STCAddArgs) -> SpecifyBlockedItem)
-> Parser (STCArgs, STCAddArgs) -> Parser SpecifyBlockedItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (STCArgs, STCAddArgs)
addStcArgs),
      (ByteString
"recovery", STCArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SIRecovery (STCArgs -> SpecifyBlockedItem)
-> Parser STCArgs -> Parser SpecifyBlockedItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser STCArgs
stdStcArgs),
      (ByteString
"removal", STCArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SIRemoval (STCArgs -> SpecifyBlockedItem)
-> Parser STCArgs -> Parser SpecifyBlockedItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser STCArgs
stdStcArgs),
      (ByteString
"recrem", (STCArgs -> STCAddArgs -> SpecifyBlockedItem)
-> (STCArgs, STCAddArgs) -> SpecifyBlockedItem
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry STCArgs -> STCAddArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> STCAddArgs -> SpecifyItem f
SIRecrem ((STCArgs, STCAddArgs) -> SpecifyBlockedItem)
-> Parser (STCArgs, STCAddArgs) -> Parser SpecifyBlockedItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (STCArgs, STCAddArgs)
addStcArgs),
      (ByteString
"skew", STCArgs -> SpecifyBlockedItem
forall (f :: * -> *). STCArgs -> SpecifyItem f
SISkew (STCArgs -> SpecifyBlockedItem)
-> Parser STCArgs -> Parser SpecifyBlockedItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser STCArgs
stdStcArgs),
      ( ByteString
"timeskew",
        do
          (TimingCheckEvent
r, TimingCheckEvent
d, Expr
e) <- Parser (TimingCheckEvent, TimingCheckEvent, Expr)
comStcArgs
          (Maybe Identifier
n, Maybe CExpr
eb, Maybe CExpr
ra) <- Parser (Maybe Identifier, Maybe CExpr, Maybe CExpr)
skewStcArgs
          SpecifyBlockedItem -> Parser SpecifyBlockedItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (SpecifyBlockedItem -> Parser SpecifyBlockedItem)
-> SpecifyBlockedItem -> Parser SpecifyBlockedItem
forall a b. (a -> b) -> a -> b
$ STCArgs -> Maybe CExpr -> Maybe CExpr -> SpecifyBlockedItem
forall (f :: * -> *).
STCArgs -> Maybe CExpr -> Maybe CExpr -> SpecifyItem f
SITimeSkew (TimingCheckEvent
-> TimingCheckEvent -> Expr -> Maybe Identifier -> STCArgs
STCArgs TimingCheckEvent
d TimingCheckEvent
r Expr
e Maybe Identifier
n) Maybe CExpr
eb Maybe CExpr
ra
      ),
      ( ByteString
"fullskew",
        do
          (TimingCheckEvent
r, TimingCheckEvent
d, Expr
e) <- Parser (TimingCheckEvent, TimingCheckEvent, Expr)
comStcArgs
          Token -> Parser ()
consume Token
SymComma
          Expr
tcl <- Parser Expr
expr
          (Maybe Identifier
n, Maybe CExpr
eb, Maybe CExpr
ra) <- Parser (Maybe Identifier, Maybe CExpr, Maybe CExpr)
skewStcArgs
          SpecifyBlockedItem -> Parser SpecifyBlockedItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (SpecifyBlockedItem -> Parser SpecifyBlockedItem)
-> SpecifyBlockedItem -> Parser SpecifyBlockedItem
forall a b. (a -> b) -> a -> b
$ STCArgs -> Expr -> Maybe CExpr -> Maybe CExpr -> SpecifyBlockedItem
forall (f :: * -> *).
STCArgs -> Expr -> Maybe CExpr -> Maybe CExpr -> SpecifyItem f
SIFullSkew (TimingCheckEvent
-> TimingCheckEvent -> Expr -> Maybe Identifier -> STCArgs
STCArgs TimingCheckEvent
d TimingCheckEvent
r Expr
e Maybe Identifier
n) Expr
tcl Maybe CExpr
eb Maybe CExpr
ra
      ),
      ( ByteString
"period",
        ControlledTimingCheckEvent
-> Expr -> Maybe Identifier -> SpecifyBlockedItem
forall (f :: * -> *).
ControlledTimingCheckEvent
-> Expr -> Maybe Identifier -> SpecifyItem f
SIPeriod (ControlledTimingCheckEvent
 -> Expr -> Maybe Identifier -> SpecifyBlockedItem)
-> Parser ControlledTimingCheckEvent
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Expr -> Maybe Identifier -> SpecifyBlockedItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ControlledTimingCheckEvent
controlledTimingCheckEvent
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Expr -> Maybe Identifier -> SpecifyBlockedItem)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Expr -> Maybe Identifier -> SpecifyBlockedItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymComma
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Expr -> Maybe Identifier -> SpecifyBlockedItem)
-> Parser Expr
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe Identifier -> SpecifyBlockedItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
expr
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe Identifier -> SpecifyBlockedItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> Parser SpecifyBlockedItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe Identifier
forall a. Maybe a
Nothing (Token -> Parser ()
consume Token
SymComma Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Identifier
ident)
      ),
      ( ByteString
"width",
        do
          ControlledTimingCheckEvent
e <- Parser ControlledTimingCheckEvent
controlledTimingCheckEvent
          Token -> Parser ()
consume Token
SymComma
          Expr
tcl <- Parser Expr
expr
          (Maybe CExpr
t, Maybe Identifier
n) <- (Maybe CExpr, Maybe Identifier)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe CExpr, Maybe Identifier)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe CExpr, Maybe Identifier)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option (Maybe CExpr
forall a. Maybe a
Nothing, Maybe Identifier
forall a. Maybe a
Nothing) (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (Maybe CExpr, Maybe Identifier)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe CExpr, Maybe Identifier))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe CExpr, Maybe Identifier)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe CExpr, Maybe Identifier)
forall a b. (a -> b) -> a -> b
$ do
            Token -> Parser ()
consume Token
SymComma
            ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe CExpr, Maybe Identifier)
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f (a, b)
mkpair (CExpr -> Maybe CExpr
forall a. a -> Maybe a
Just (CExpr -> Maybe CExpr)
-> Parser CExpr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser CExpr
constExpr) (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe CExpr, Maybe Identifier))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe CExpr, Maybe Identifier)
forall a b. (a -> b) -> a -> b
$ Maybe Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe Identifier
forall a. Maybe a
Nothing (ParsecT
   [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall a b. (a -> b) -> a -> b
$ do
              Token -> Parser ()
consume Token
SymComma
              SourcePos
pos <- ParsecT [PosToken] LocalCompDir (Writer [String]) SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
              Maybe Identifier
mid <- Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Identifier
ident
              if Maybe Identifier
mid Maybe Identifier -> Maybe Identifier -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe Identifier
forall a. Maybe a
Nothing
                then SourcePos -> String -> Parser ()
warn SourcePos
pos String
"Optional $width notifier is a SystemVerilog feature"
                else () -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
              Maybe Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Identifier
mid
          SpecifyBlockedItem -> Parser SpecifyBlockedItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (SpecifyBlockedItem -> Parser SpecifyBlockedItem)
-> SpecifyBlockedItem -> Parser SpecifyBlockedItem
forall a b. (a -> b) -> a -> b
$ ControlledTimingCheckEvent
-> Expr -> Maybe CExpr -> Maybe Identifier -> SpecifyBlockedItem
forall (f :: * -> *).
ControlledTimingCheckEvent
-> Expr -> Maybe CExpr -> Maybe Identifier -> SpecifyItem f
SIWidth ControlledTimingCheckEvent
e Expr
tcl Maybe CExpr
t Maybe Identifier
n
      ),
      ( ByteString
"nochange",
        TimingCheckEvent
-> TimingCheckEvent
-> GenMinTypMax Expr
-> GenMinTypMax Expr
-> Maybe Identifier
-> SpecifyBlockedItem
forall (f :: * -> *).
TimingCheckEvent
-> TimingCheckEvent
-> GenMinTypMax Expr
-> GenMinTypMax Expr
-> Maybe Identifier
-> SpecifyItem f
SINoChange (TimingCheckEvent
 -> TimingCheckEvent
 -> GenMinTypMax Expr
 -> GenMinTypMax Expr
 -> Maybe Identifier
 -> SpecifyBlockedItem)
-> Parser TimingCheckEvent
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (TimingCheckEvent
      -> GenMinTypMax Expr
      -> GenMinTypMax Expr
      -> Maybe Identifier
      -> SpecifyBlockedItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser TimingCheckEvent
timingCheckEvent
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (TimingCheckEvent
   -> GenMinTypMax Expr
   -> GenMinTypMax Expr
   -> Maybe Identifier
   -> SpecifyBlockedItem)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (TimingCheckEvent
      -> GenMinTypMax Expr
      -> GenMinTypMax Expr
      -> Maybe Identifier
      -> SpecifyBlockedItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymComma
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (TimingCheckEvent
   -> GenMinTypMax Expr
   -> GenMinTypMax Expr
   -> Maybe Identifier
   -> SpecifyBlockedItem)
-> Parser TimingCheckEvent
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenMinTypMax Expr
      -> GenMinTypMax Expr -> Maybe Identifier -> SpecifyBlockedItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser TimingCheckEvent
timingCheckEvent
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenMinTypMax Expr
   -> GenMinTypMax Expr -> Maybe Identifier -> SpecifyBlockedItem)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenMinTypMax Expr
      -> GenMinTypMax Expr -> Maybe Identifier -> SpecifyBlockedItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymComma
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenMinTypMax Expr
   -> GenMinTypMax Expr -> Maybe Identifier -> SpecifyBlockedItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenMinTypMax Expr -> Maybe Identifier -> SpecifyBlockedItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser Expr
expr
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenMinTypMax Expr -> Maybe Identifier -> SpecifyBlockedItem)
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (GenMinTypMax Expr -> Maybe Identifier -> SpecifyBlockedItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymComma
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (GenMinTypMax Expr -> Maybe Identifier -> SpecifyBlockedItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe Identifier -> SpecifyBlockedItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Expr
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (GenMinTypMax Expr)
forall a. Parser a -> Parser (GenMinTypMax a)
mtm Parser Expr
expr
          ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe Identifier -> SpecifyBlockedItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> Parser SpecifyBlockedItem
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe Identifier
forall a. Maybe a
Nothing (Token -> Parser ()
consume Token
SymComma Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe Identifier)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe Parser Identifier
ident)
      )
    ]

-- | Specify block item
specifyItem :: Parser (NonEmpty SpecifyBlockedItem)
specifyItem :: Parser (NonEmpty SpecifyBlockedItem)
specifyItem = (SourcePos
 -> Token -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
-> Parser (NonEmpty SpecifyBlockedItem)
forall a. (SourcePos -> Token -> Maybe (Parser a)) -> Parser a
fpbranch ((SourcePos
  -> Token -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
 -> Parser (NonEmpty SpecifyBlockedItem))
-> (SourcePos
    -> Token -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
-> Parser (NonEmpty SpecifyBlockedItem)
forall a b. (a -> b) -> a -> b
$ \SourcePos
p Token
t -> case Token
t of
  Token
KWSpecparam -> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a. a -> Maybe a
Just (Parser (NonEmpty SpecifyBlockedItem)
 -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
-> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a b. (a -> b) -> a -> b
$ (\(Maybe Range2
rng, NonEmpty SpecParamDecl
l) -> Maybe Range2 -> Identity SpecParamDecl -> SpecifyBlockedItem
forall (f :: * -> *).
Maybe Range2 -> f SpecParamDecl -> SpecifyItem f
SISpecParam Maybe Range2
rng (Identity SpecParamDecl -> SpecifyBlockedItem)
-> (SpecParamDecl -> Identity SpecParamDecl)
-> SpecParamDecl
-> SpecifyBlockedItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpecParamDecl -> Identity SpecParamDecl
forall a. a -> Identity a
Identity (SpecParamDecl -> SpecifyBlockedItem)
-> NonEmpty SpecParamDecl -> NonEmpty SpecifyBlockedItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty SpecParamDecl
l) ((Maybe Range2, NonEmpty SpecParamDecl)
 -> NonEmpty SpecifyBlockedItem)
-> Parser (Maybe Range2, NonEmpty SpecParamDecl)
-> Parser (NonEmpty SpecifyBlockedItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Maybe Range2, NonEmpty SpecParamDecl)
specParam
  Token
KWPulsestyleonevent -> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a. a -> Maybe a
Just (Parser (NonEmpty SpecifyBlockedItem)
 -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
-> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a b. (a -> b) -> a -> b
$ (Identity SpecTerm -> SpecifyBlockedItem)
-> Parser (NonEmpty SpecifyBlockedItem)
forall {a}. (Identity SpecTerm -> a) -> Parser (NonEmpty a)
psi Identity SpecTerm -> SpecifyBlockedItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIPulsestyleOnevent
  Token
KWPulsestyleondetect -> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a. a -> Maybe a
Just (Parser (NonEmpty SpecifyBlockedItem)
 -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
-> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a b. (a -> b) -> a -> b
$ (Identity SpecTerm -> SpecifyBlockedItem)
-> Parser (NonEmpty SpecifyBlockedItem)
forall {a}. (Identity SpecTerm -> a) -> Parser (NonEmpty a)
psi Identity SpecTerm -> SpecifyBlockedItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIPulsestyleOndetect
  Token
KWShowcancelled -> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a. a -> Maybe a
Just (Parser (NonEmpty SpecifyBlockedItem)
 -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
-> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a b. (a -> b) -> a -> b
$ (Identity SpecTerm -> SpecifyBlockedItem)
-> Parser (NonEmpty SpecifyBlockedItem)
forall {a}. (Identity SpecTerm -> a) -> Parser (NonEmpty a)
psi Identity SpecTerm -> SpecifyBlockedItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SIShowcancelled
  Token
KWNoshowcancelled -> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a. a -> Maybe a
Just (Parser (NonEmpty SpecifyBlockedItem)
 -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
-> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a b. (a -> b) -> a -> b
$ (Identity SpecTerm -> SpecifyBlockedItem)
-> Parser (NonEmpty SpecifyBlockedItem)
forall {a}. (Identity SpecTerm -> a) -> Parser (NonEmpty a)
psi Identity SpecTerm -> SpecifyBlockedItem
forall (f :: * -> *). f SpecTerm -> SpecifyItem f
SINoshowcancelled
  Token
KWIf -> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a. a -> Maybe a
Just (Parser (NonEmpty SpecifyBlockedItem)
 -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
-> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a b. (a -> b) -> a -> b
$ do
    GenExpr Identifier () Attributes
c <- Parser (GenExpr Identifier () Attributes)
-> Parser (GenExpr Identifier () Attributes)
forall a. Parser a -> Parser a
parens (Parser (GenExpr Identifier () Attributes)
 -> Parser (GenExpr Identifier () Attributes))
-> Parser (GenExpr Identifier () Attributes)
-> Parser (GenExpr Identifier () Attributes)
forall a b. (a -> b) -> a -> b
$
      PGenExpr GenExpr Identifier () Attributes
forall i r a. PGenExpr GenExpr i r a
genExpr (Identifier -> Parser Identifier
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Identifier -> Parser Identifier)
-> (ByteString -> Identifier) -> ByteString -> Parser Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Identifier
Identifier) (() -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()) Parser Attributes
attributes Identifier -> Maybe Identifier
forall a. a -> Maybe a
Just ((Maybe DimRange -> Maybe ())
 -> Parser (GenExpr Identifier () Attributes))
-> (Maybe DimRange -> Maybe ())
-> Parser (GenExpr Identifier () Attributes)
forall a b. (a -> b) -> a -> b
$ Maybe () -> (DimRange -> Maybe ()) -> Maybe DimRange -> Maybe ()
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (() -> Maybe ()
forall a. a -> Maybe a
Just ()) ((DimRange -> Maybe ()) -> Maybe DimRange -> Maybe ())
-> (DimRange -> Maybe ()) -> Maybe DimRange -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Maybe () -> DimRange -> Maybe ()
forall a b. a -> b -> a
const Maybe ()
forall a. Maybe a
Nothing
    ModulePathCondition -> Parser (NonEmpty SpecifyBlockedItem)
pathDecl (ModulePathCondition -> Parser (NonEmpty SpecifyBlockedItem))
-> ModulePathCondition -> Parser (NonEmpty SpecifyBlockedItem)
forall a b. (a -> b) -> a -> b
$ GenExpr Identifier () Attributes -> ModulePathCondition
MPCCond GenExpr Identifier () Attributes
c
  Token
KWIfnone -> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a. a -> Maybe a
Just (Parser (NonEmpty SpecifyBlockedItem)
 -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
-> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a b. (a -> b) -> a -> b
$ ModulePathCondition -> Parser (NonEmpty SpecifyBlockedItem)
pathDecl ModulePathCondition
MPCNone
  Token
SymParenL -> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a. a -> Maybe a
Just (Parser (NonEmpty SpecifyBlockedItem)
 -> Maybe (Parser (NonEmpty SpecifyBlockedItem)))
-> Parser (NonEmpty SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a b. (a -> b) -> a -> b
$ SourcePos
-> ModulePathCondition -> Parser (NonEmpty SpecifyBlockedItem)
trPathDecl SourcePos
p ModulePathCondition
MPCAlways
  IdSystem ByteString
s -> (SpecifyBlockedItem -> NonEmpty SpecifyBlockedItem)
-> Parser SpecifyBlockedItem
-> Parser (NonEmpty SpecifyBlockedItem)
forall a b.
(a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (SpecifyBlockedItem
-> [SpecifyBlockedItem] -> NonEmpty SpecifyBlockedItem
forall a. a -> [a] -> NonEmpty a
:| []) (Parser SpecifyBlockedItem -> Parser (NonEmpty SpecifyBlockedItem))
-> (Parser SpecifyBlockedItem -> Parser SpecifyBlockedItem)
-> Parser SpecifyBlockedItem
-> Parser (NonEmpty SpecifyBlockedItem)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parser SpecifyBlockedItem -> Parser SpecifyBlockedItem
forall a. Parser a -> Parser a
parens (Parser SpecifyBlockedItem -> Parser (NonEmpty SpecifyBlockedItem))
-> Maybe (Parser SpecifyBlockedItem)
-> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString
-> HashMap ByteString (Parser SpecifyBlockedItem)
-> Maybe (Parser SpecifyBlockedItem)
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
HashMap.lookup ByteString
s HashMap ByteString (Parser SpecifyBlockedItem)
stcfMap
  Token
_ -> Maybe (Parser (NonEmpty SpecifyBlockedItem))
forall a. Maybe a
Nothing
  where
    psi :: (Identity SpecTerm -> a) -> Parser (NonEmpty a)
psi Identity SpecTerm -> a
f = Parser a -> Parser (NonEmpty a)
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Identity SpecTerm -> a
f (Identity SpecTerm -> a)
-> (SpecTerm -> Identity SpecTerm) -> SpecTerm -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpecTerm -> Identity SpecTerm
forall a. a -> Identity a
Identity (SpecTerm -> a) -> Parser SpecTerm -> Parser a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SpecTerm
specTerm)

-- | Non port declaration module item
npmodItem :: LAPBranch (NonEmpty ModuleItem)
npmodItem :: [APBranch (NonEmpty ModuleItem)]
npmodItem =
  (Token
KWParameter, \Attributes
a SourcePos
_ -> ((Identifier, Parameter) -> ModuleItem)
-> NonEmpty (Identifier, Parameter) -> NonEmpty ModuleItem
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(Identifier
i, Parameter
x) -> AttrIded Parameter -> ModuleItem
MIParameter (AttrIded Parameter -> ModuleItem)
-> AttrIded Parameter -> ModuleItem
forall a b. (a -> b) -> a -> b
$ Attributes -> Identifier -> Parameter -> AttrIded Parameter
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
a Identifier
i Parameter
x) (NonEmpty (Identifier, Parameter) -> NonEmpty ModuleItem)
-> Parser (NonEmpty (Identifier, Parameter))
-> Parser (NonEmpty ModuleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Parser (NonEmpty (Identifier, Parameter))
paramDecl Bool
False) APBranch (NonEmpty ModuleItem)
-> [APBranch (NonEmpty ModuleItem)]
-> [APBranch (NonEmpty ModuleItem)]
forall a. a -> [a] -> [a]
:
  [ (Token
KWSpecparam, \Attributes
a SourcePos
_ -> (\(Maybe Range2
rng, NonEmpty SpecParamDecl
l) -> Attributes -> Maybe Range2 -> SpecParamDecl -> ModuleItem
MISpecParam Attributes
a Maybe Range2
rng (SpecParamDecl -> ModuleItem)
-> NonEmpty SpecParamDecl -> NonEmpty ModuleItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty SpecParamDecl
l) ((Maybe Range2, NonEmpty SpecParamDecl) -> NonEmpty ModuleItem)
-> Parser (Maybe Range2, NonEmpty SpecParamDecl)
-> Parser (NonEmpty ModuleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Maybe Range2, NonEmpty SpecParamDecl)
specParam Parser (NonEmpty ModuleItem)
-> Parser () -> Parser (NonEmpty ModuleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi),
    ( Token
KWGenerate,
      \Attributes
a SourcePos
pos -> if Attributes -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Attributes
a
        then (ModuleItem -> [ModuleItem] -> NonEmpty ModuleItem
forall a. a -> [a] -> NonEmpty a
:|[]) (ModuleItem -> NonEmpty ModuleItem)
-> ([[Attributed ModGenBlockedItem]] -> ModuleItem)
-> [[Attributed ModGenBlockedItem]]
-> NonEmpty ModuleItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Attributed ModGenBlockedItem] -> ModuleItem
MIGenReg ([Attributed ModGenBlockedItem] -> ModuleItem)
-> ([[Attributed ModGenBlockedItem]]
    -> [Attributed ModGenBlockedItem])
-> [[Attributed ModGenBlockedItem]]
-> ModuleItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Attributed ModGenBlockedItem]] -> [Attributed ModGenBlockedItem]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Attributed ModGenBlockedItem]] -> NonEmpty ModuleItem)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[Attributed ModGenBlockedItem]]
-> Parser (NonEmpty ModuleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  [Attributed ModGenBlockedItem]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [[Attributed ModGenBlockedItem]]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ((Attributed ModGenBlockedItem -> Attributed ModGenBlockedItem)
-> LAPBranch (NonEmpty (Attributed ModGenBlockedItem))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [Attributed ModGenBlockedItem]
forall a.
(Attributed ModGenBlockedItem -> a)
-> LAPBranch (NonEmpty a) -> Parser [a]
parseItem Attributed ModGenBlockedItem -> Attributed ModGenBlockedItem
forall a. a -> a
id [])
          Parser (NonEmpty ModuleItem)
-> Parser () -> Parser (NonEmpty ModuleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
pos Token
KWGenerate Token
KWEndgenerate
        else String -> Parser (NonEmpty ModuleItem)
forall a. String -> Parser a
hardfail String
"Generate region doesn't accept attributes"
    ),
    ( Token
KWSpecify,
      \Attributes
a SourcePos
pos -> if Attributes -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Attributes
a
        then (ModuleItem -> [ModuleItem] -> NonEmpty ModuleItem
forall a. a -> [a] -> NonEmpty a
:|[]) (ModuleItem -> NonEmpty ModuleItem)
-> ([[SpecifyBlockedItem]] -> ModuleItem)
-> [[SpecifyBlockedItem]]
-> NonEmpty ModuleItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [SpecifyBlockedItem] -> ModuleItem
MISpecBlock ([SpecifyBlockedItem] -> ModuleItem)
-> ([[SpecifyBlockedItem]] -> [SpecifyBlockedItem])
-> [[SpecifyBlockedItem]]
-> ModuleItem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[SpecifyBlockedItem]] -> [SpecifyBlockedItem]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[SpecifyBlockedItem]] -> NonEmpty ModuleItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [[SpecifyBlockedItem]]
-> Parser (NonEmpty ModuleItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT
  [PosToken] LocalCompDir (Writer [String]) [SpecifyBlockedItem]
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [[SpecifyBlockedItem]]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (NonEmpty SpecifyBlockedItem -> [SpecifyBlockedItem]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty SpecifyBlockedItem -> [SpecifyBlockedItem])
-> Parser (NonEmpty SpecifyBlockedItem)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [SpecifyBlockedItem]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (NonEmpty SpecifyBlockedItem)
specifyItem ParsecT
  [PosToken] LocalCompDir (Writer [String]) [SpecifyBlockedItem]
-> Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [SpecifyBlockedItem]
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi)
          Parser (NonEmpty ModuleItem)
-> Parser () -> Parser (NonEmpty ModuleItem)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
pos Token
KWSpecify Token
KWEndspecify
        else String -> Parser (NonEmpty ModuleItem)
forall a. String -> Parser a
hardfail String
"Specify region doesn't accept attributes"
    )
  ]

-- | Module
parseModule :: LocalCompDir -> Attributes -> Parser Verilog2005
parseModule :: LocalCompDir -> Attributes -> Parser Verilog2005
parseModule (LocalCompDir Maybe (Line, Line)
ts Bool
cl Maybe Bool
pull Maybe NetType
dnt) Attributes
a = do
  Identifier
s <- Parser Identifier
lenientIdent
  [NonEmpty (Identifier, Parameter)]
params <- [NonEmpty (Identifier, Parameter)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [NonEmpty (Identifier, Parameter)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [NonEmpty (Identifier, Parameter)]
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   [NonEmpty (Identifier, Parameter)]
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      [NonEmpty (Identifier, Parameter)])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [NonEmpty (Identifier, Parameter)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [NonEmpty (Identifier, Parameter)]
forall a b. (a -> b) -> a -> b
$ do
    Token -> Parser ()
consume Token
SymPound
    ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  [NonEmpty (Identifier, Parameter)]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [NonEmpty (Identifier, Parameter)]
forall a. Parser a -> Parser a
parens (String
-> Parser (NonEmpty (Identifier, Parameter))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [NonEmpty (Identifier, Parameter)]
forall a. String -> Parser a -> Parser [a]
wxcsl String
"parameter declaration" (Parser (NonEmpty (Identifier, Parameter))
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      [NonEmpty (Identifier, Parameter)])
-> Parser (NonEmpty (Identifier, Parameter))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     [NonEmpty (Identifier, Parameter)]
forall a b. (a -> b) -> a -> b
$ Token -> Parser ()
consume Token
KWParameter Parser ()
-> Parser (NonEmpty (Identifier, Parameter))
-> Parser (NonEmpty (Identifier, Parameter))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Bool -> Parser (NonEmpty (Identifier, Parameter))
trParamDecl Bool
True)
  -- if there is nothing the standard says the module cannot contain port declaration
  -- if there is empty parenthesis `()` the standard says it can or cannot, so it can
  (Maybe [ModuleItem]
pd, [PortInterface]
pi) <- (Maybe [ModuleItem], [PortInterface])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option ([ModuleItem] -> Maybe [ModuleItem]
forall a. a -> Maybe a
Just [], []) (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (Maybe [ModuleItem], [PortInterface])
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe [ModuleItem], [PortInterface]))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
forall a b. (a -> b) -> a -> b
$ ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe [ModuleItem], [PortInterface])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
forall a. Parser a -> Parser a
parens (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (Maybe [ModuleItem], [PortInterface])
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (Maybe [ModuleItem], [PortInterface]))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
forall a b. (a -> b) -> a -> b
$ ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe [ModuleItem], [PortInterface])
fullPort ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe [ModuleItem], [PortInterface])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (,) Maybe [ModuleItem]
forall a. Maybe a
Nothing ([PortInterface] -> (Maybe [ModuleItem], [PortInterface]))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [PortInterface]
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser PortInterface
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) [PortInterface]
forall a. Parser a -> Parser [a]
csl Parser PortInterface
partialPort
  Token -> Parser ()
consume Token
SymSemi
  [[ModuleItem]]
mi <- case Maybe [ModuleItem]
pd of
    Maybe [ModuleItem]
Nothing ->
      ParsecT [PosToken] LocalCompDir (Writer [String]) [ModuleItem]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [[ModuleItem]]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT [PosToken] LocalCompDir (Writer [String]) [ModuleItem]
 -> ParsecT
      [PosToken] LocalCompDir (Writer [String]) [[ModuleItem]])
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [ModuleItem]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [[ModuleItem]]
forall a b. (a -> b) -> a -> b
$ (Attributed ModGenBlockedItem -> ModuleItem)
-> [APBranch (NonEmpty ModuleItem)]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [ModuleItem]
forall a.
(Attributed ModGenBlockedItem -> a)
-> LAPBranch (NonEmpty a) -> Parser [a]
parseItem Attributed ModGenBlockedItem -> ModuleItem
MIMGI ([APBranch (NonEmpty ModuleItem)]
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) [ModuleItem])
-> [APBranch (NonEmpty ModuleItem)]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [ModuleItem]
forall a b. (a -> b) -> a -> b
$ (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   (NonEmpty ModuleItem, NonEmpty PortInterface)
 -> SourcePos -> Parser (NonEmpty ModuleItem))
-> LABranch (NonEmpty ModuleItem, NonEmpty PortInterface)
-> [APBranch (NonEmpty ModuleItem)]
forall a b. (a -> b) -> LAProduce a -> LAProduce b
maplaproduce (Parser (NonEmpty ModuleItem)
-> SourcePos -> Parser (NonEmpty ModuleItem)
forall a b. a -> b -> a
const (Parser (NonEmpty ModuleItem)
 -> SourcePos -> Parser (NonEmpty ModuleItem))
-> (ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (NonEmpty ModuleItem, NonEmpty PortInterface)
    -> Parser (NonEmpty ModuleItem))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
-> SourcePos
-> Parser (NonEmpty ModuleItem)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((NonEmpty ModuleItem, NonEmpty PortInterface)
 -> NonEmpty ModuleItem)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
-> Parser (NonEmpty ModuleItem)
forall a b.
(a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (NonEmpty ModuleItem, NonEmpty PortInterface)
-> NonEmpty ModuleItem
forall a b. (a, b) -> a
fst) (Maybe NetType
-> Bool -> LABranch (NonEmpty ModuleItem, NonEmpty PortInterface)
portDecl Maybe NetType
dnt Bool
False) [APBranch (NonEmpty ModuleItem)]
-> [APBranch (NonEmpty ModuleItem)]
-> [APBranch (NonEmpty ModuleItem)]
forall a. [a] -> [a] -> [a]
++ [APBranch (NonEmpty ModuleItem)]
npmodItem
    Just [ModuleItem]
pd -> ([ModuleItem]
pd [ModuleItem] -> [[ModuleItem]] -> [[ModuleItem]]
forall a. a -> [a] -> [a]
:) ([[ModuleItem]] -> [[ModuleItem]])
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [[ModuleItem]]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [[ModuleItem]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [PosToken] LocalCompDir (Writer [String]) [ModuleItem]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [[ModuleItem]]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ((Attributed ModGenBlockedItem -> ModuleItem)
-> [APBranch (NonEmpty ModuleItem)]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [ModuleItem]
forall a.
(Attributed ModGenBlockedItem -> a)
-> LAPBranch (NonEmpty a) -> Parser [a]
parseItem Attributed ModGenBlockedItem -> ModuleItem
MIMGI [APBranch (NonEmpty ModuleItem)]
npmodItem)
  Verilog2005 -> Parser Verilog2005
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Verilog2005
forall a. Monoid a => a
mempty {_vModule = [ModuleBlock a s pi (concat mi) ts cl pull dnt]}
  where
    -- Fully specified port declaration list
    fullPort :: ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe [ModuleItem], [PortInterface])
fullPort =
      (NonEmpty (NonEmpty ModuleItem) -> Maybe [ModuleItem])
-> (NonEmpty (NonEmpty PortInterface) -> [PortInterface])
-> (NonEmpty (NonEmpty ModuleItem),
    NonEmpty (NonEmpty PortInterface))
-> (Maybe [ModuleItem], [PortInterface])
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap ([ModuleItem] -> Maybe [ModuleItem]
forall a. a -> Maybe a
Just ([ModuleItem] -> Maybe [ModuleItem])
-> (NonEmpty (NonEmpty ModuleItem) -> [ModuleItem])
-> NonEmpty (NonEmpty ModuleItem)
-> Maybe [ModuleItem]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty ModuleItem -> [ModuleItem]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty ModuleItem -> [ModuleItem])
-> (NonEmpty (NonEmpty ModuleItem) -> NonEmpty ModuleItem)
-> NonEmpty (NonEmpty ModuleItem)
-> [ModuleItem]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (NonEmpty ModuleItem) -> NonEmpty ModuleItem
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join) (NonEmpty PortInterface -> [PortInterface]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty PortInterface -> [PortInterface])
-> (NonEmpty (NonEmpty PortInterface) -> NonEmpty PortInterface)
-> NonEmpty (NonEmpty PortInterface)
-> [PortInterface]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (NonEmpty PortInterface) -> NonEmpty PortInterface
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join) ((NonEmpty (NonEmpty ModuleItem),
  NonEmpty (NonEmpty PortInterface))
 -> (Maybe [ModuleItem], [PortInterface]))
-> (NonEmpty (NonEmpty ModuleItem, NonEmpty PortInterface)
    -> (NonEmpty (NonEmpty ModuleItem),
        NonEmpty (NonEmpty PortInterface)))
-> NonEmpty (NonEmpty ModuleItem, NonEmpty PortInterface)
-> (Maybe [ModuleItem], [PortInterface])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (NonEmpty ModuleItem, NonEmpty PortInterface)
-> (NonEmpty (NonEmpty ModuleItem),
    NonEmpty (NonEmpty PortInterface))
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
DF.unzip
        (NonEmpty (NonEmpty ModuleItem, NonEmpty PortInterface)
 -> (Maybe [ModuleItem], [PortInterface]))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (NonEmpty ModuleItem, NonEmpty PortInterface))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe [ModuleItem], [PortInterface])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty (NonEmpty ModuleItem, NonEmpty PortInterface))
forall a. String -> Parser a -> Parser (NonEmpty a)
xcsl1 String
"port declaration" (LABranch (NonEmpty ModuleItem, NonEmpty PortInterface)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
forall a. LABranch a -> Parser a
labranch (LABranch (NonEmpty ModuleItem, NonEmpty PortInterface)
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      (NonEmpty ModuleItem, NonEmpty PortInterface))
-> LABranch (NonEmpty ModuleItem, NonEmpty PortInterface)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty ModuleItem, NonEmpty PortInterface)
forall a b. (a -> b) -> a -> b
$ Maybe NetType
-> Bool -> LABranch (NonEmpty ModuleItem, NonEmpty PortInterface)
portDecl Maybe NetType
dnt Bool
True)
    -- Partially specified port declaration list
    partialPort :: Parser PortInterface
partialPort =
      (Token -> Parser ()
consume Token
SymDot Parser () -> Parser PortInterface -> Parser PortInterface
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Identifier -> [Identified (Maybe CRangeExpr)] -> PortInterface
forall t. Identifier -> t -> Identified t
Identified (Identifier -> [Identified (Maybe CRangeExpr)] -> PortInterface)
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     ([Identified (Maybe CRangeExpr)] -> PortInterface)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  ([Identified (Maybe CRangeExpr)] -> PortInterface)
-> Parser [Identified (Maybe CRangeExpr)] -> Parser PortInterface
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser [Identified (Maybe CRangeExpr)]
-> Parser [Identified (Maybe CRangeExpr)]
forall a. Parser a -> Parser a
parens Parser [Identified (Maybe CRangeExpr)]
portExpr)
        Parser PortInterface
-> Parser PortInterface -> Parser PortInterface
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (\[Identified (Maybe CRangeExpr)]
l -> case [Identified (Maybe CRangeExpr)]
l of [Identified Identifier
s Maybe CRangeExpr
_] -> Identifier -> [Identified (Maybe CRangeExpr)] -> PortInterface
forall t. Identifier -> t -> Identified t
Identified Identifier
s [Identified (Maybe CRangeExpr)]
l; [Identified (Maybe CRangeExpr)]
_ -> Identifier -> [Identified (Maybe CRangeExpr)] -> PortInterface
forall t. Identifier -> t -> Identified t
Identified Identifier
"" [Identified (Maybe CRangeExpr)]
l) ([Identified (Maybe CRangeExpr)] -> PortInterface)
-> Parser [Identified (Maybe CRangeExpr)] -> Parser PortInterface
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser [Identified (Maybe CRangeExpr)]
portExpr

-- | Primitive output port
udpOutput :: Parser (PrimPort, Identifier)
udpOutput :: Parser (PrimPort, Identifier)
udpOutput = do
  Bool
reg <- Token -> Parser Bool
optConsume Token
KWReg
  Identifier
s <- Parser Identifier
ident
  PrimPort
pp <- if Bool
reg
    then Maybe CExpr -> PrimPort
PPOutReg (Maybe CExpr -> PrimPort)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PrimPort
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser CExpr
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe CExpr)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Token -> Parser ()
consume Token
SymEq Parser () -> Parser CExpr -> Parser CExpr
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser CExpr
constExpr)
    else PrimPort
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PrimPort
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return PrimPort
PPOutput
  (PrimPort, Identifier) -> Parser (PrimPort, Identifier)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (PrimPort
pp, Identifier
s)

-- | Udp port declaration
udpHead :: Parser (Identifier, NonEmpty Identifier, Maybe (NonEmpty (AttrIded PrimPort)))
udpHead :: Parser
  (Identifier, NonEmpty Identifier,
   Maybe (NonEmpty (AttrIded PrimPort)))
udpHead =
  (,,) (Identifier
 -> NonEmpty Identifier
 -> Maybe (NonEmpty (AttrIded PrimPort))
 -> (Identifier, NonEmpty Identifier,
     Maybe (NonEmpty (AttrIded PrimPort))))
-> Parser Identifier
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty Identifier
      -> Maybe (NonEmpty (AttrIded PrimPort))
      -> (Identifier, NonEmpty Identifier,
          Maybe (NonEmpty (AttrIded PrimPort))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty Identifier
   -> Maybe (NonEmpty (AttrIded PrimPort))
   -> (Identifier, NonEmpty Identifier,
       Maybe (NonEmpty (AttrIded PrimPort))))
-> Parser ()
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (NonEmpty Identifier
      -> Maybe (NonEmpty (AttrIded PrimPort))
      -> (Identifier, NonEmpty Identifier,
          Maybe (NonEmpty (AttrIded PrimPort))))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymComma ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (NonEmpty Identifier
   -> Maybe (NonEmpty (AttrIded PrimPort))
   -> (Identifier, NonEmpty Identifier,
       Maybe (NonEmpty (AttrIded PrimPort))))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Identifier)
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (NonEmpty (AttrIded PrimPort))
      -> (Identifier, NonEmpty Identifier,
          Maybe (NonEmpty (AttrIded PrimPort))))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Identifier
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (NonEmpty Identifier)
forall a. Parser a -> Parser (NonEmpty a)
csl1 Parser Identifier
ident ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (Maybe (NonEmpty (AttrIded PrimPort))
   -> (Identifier, NonEmpty Identifier,
       Maybe (NonEmpty (AttrIded PrimPort))))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (NonEmpty (AttrIded PrimPort)))
-> Parser
     (Identifier, NonEmpty Identifier,
      Maybe (NonEmpty (AttrIded PrimPort)))
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (NonEmpty (AttrIded PrimPort))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (Maybe (NonEmpty (AttrIded PrimPort)))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (NonEmpty (AttrIded PrimPort))
forall a. Maybe a
Nothing Parser
  (Identifier, NonEmpty Identifier,
   Maybe (NonEmpty (AttrIded PrimPort)))
-> Parser
     (Identifier, NonEmpty Identifier,
      Maybe (NonEmpty (AttrIded PrimPort)))
-> Parser
     (Identifier, NonEmpty Identifier,
      Maybe (NonEmpty (AttrIded PrimPort)))
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
    Attributes
attr <- Parser Attributes
attributes
    Token -> Parser ()
consume Token
KWOutput
    (PrimPort
od, Identifier
o) <- Parser (PrimPort, Identifier)
udpOutput
    Token -> Parser ()
consume Token
SymComma
    NonEmpty (NonEmpty (AttrIded PrimPort))
ins <- Parser (NonEmpty (AttrIded PrimPort))
-> Parser (NonEmpty (NonEmpty (AttrIded PrimPort)))
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Parser (NonEmpty (AttrIded PrimPort))
 -> Parser (NonEmpty (NonEmpty (AttrIded PrimPort))))
-> Parser (NonEmpty (AttrIded PrimPort))
-> Parser (NonEmpty (NonEmpty (AttrIded PrimPort)))
forall a b. (a -> b) -> a -> b
$ do
      Attributes
attr <- Parser Attributes
attributes
      Token -> Parser ()
consume Token
KWInput
      NonEmpty (AttrIded PrimPort)
l <- Bool
-> Parser Identifier
-> (Identifier -> Parser (AttrIded PrimPort))
-> Parser (NonEmpty (AttrIded PrimPort))
forall a b.
Bool -> Parser a -> (a -> Parser b) -> Parser (NonEmpty b)
scsl1 Bool
True Parser Identifier
ident ((Identifier -> Parser (AttrIded PrimPort))
 -> Parser (NonEmpty (AttrIded PrimPort)))
-> (Identifier -> Parser (AttrIded PrimPort))
-> Parser (NonEmpty (AttrIded PrimPort))
forall a b. (a -> b) -> a -> b
$ AttrIded PrimPort -> Parser (AttrIded PrimPort)
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (AttrIded PrimPort -> Parser (AttrIded PrimPort))
-> (Identifier -> AttrIded PrimPort)
-> Identifier
-> Parser (AttrIded PrimPort)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> PrimPort -> AttrIded PrimPort)
-> PrimPort -> Identifier -> AttrIded PrimPort
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Attributes -> Identifier -> PrimPort -> AttrIded PrimPort
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
attr) PrimPort
PPInput
      NonEmpty (AttrIded PrimPort)
-> Parser (NonEmpty (AttrIded PrimPort))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return NonEmpty (AttrIded PrimPort)
l
    let inl :: NonEmpty (AttrIded PrimPort)
inl = NonEmpty (NonEmpty (AttrIded PrimPort))
-> NonEmpty (AttrIded PrimPort)
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join NonEmpty (NonEmpty (AttrIded PrimPort))
ins
    (Identifier, NonEmpty Identifier,
 Maybe (NonEmpty (AttrIded PrimPort)))
-> Parser
     (Identifier, NonEmpty Identifier,
      Maybe (NonEmpty (AttrIded PrimPort)))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Identifier
o, AttrIded PrimPort -> Identifier
forall t. AttrIded t -> Identifier
_aiIdent (AttrIded PrimPort -> Identifier)
-> NonEmpty (AttrIded PrimPort) -> NonEmpty Identifier
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (AttrIded PrimPort)
inl, NonEmpty (AttrIded PrimPort)
-> Maybe (NonEmpty (AttrIded PrimPort))
forall a. a -> Maybe a
Just (NonEmpty (AttrIded PrimPort)
 -> Maybe (NonEmpty (AttrIded PrimPort)))
-> NonEmpty (AttrIded PrimPort)
-> Maybe (NonEmpty (AttrIded PrimPort))
forall a b. (a -> b) -> a -> b
$ Attributes -> Identifier -> PrimPort -> AttrIded PrimPort
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
attr Identifier
o PrimPort
od AttrIded PrimPort
-> NonEmpty (AttrIded PrimPort) -> NonEmpty (AttrIded PrimPort)
forall a. a -> NonEmpty a -> NonEmpty a
<| NonEmpty (AttrIded PrimPort)
inl)

-- | Parse a udp port declaration list
udpPort :: Parser (NonEmpty (AttrIded PrimPort))
udpPort :: Parser (NonEmpty (AttrIded PrimPort))
udpPort = do
  Attributes
a <- Parser Attributes
attributes
  NonEmpty (PrimPort, Identifier)
l <- (Token -> Maybe (Parser (NonEmpty (PrimPort, Identifier))))
-> Parser (NonEmpty (PrimPort, Identifier))
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token -> Maybe (Parser (NonEmpty (PrimPort, Identifier))))
 -> Parser (NonEmpty (PrimPort, Identifier)))
-> (Token -> Maybe (Parser (NonEmpty (PrimPort, Identifier))))
-> Parser (NonEmpty (PrimPort, Identifier))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
    Token
KWReg -> Parser (NonEmpty (PrimPort, Identifier))
-> Maybe (Parser (NonEmpty (PrimPort, Identifier)))
forall a. a -> Maybe a
Just (Parser (NonEmpty (PrimPort, Identifier))
 -> Maybe (Parser (NonEmpty (PrimPort, Identifier))))
-> Parser (NonEmpty (PrimPort, Identifier))
-> Maybe (Parser (NonEmpty (PrimPort, Identifier)))
forall a b. (a -> b) -> a -> b
$ ((PrimPort, Identifier)
-> [(PrimPort, Identifier)] -> NonEmpty (PrimPort, Identifier)
forall a. a -> [a] -> NonEmpty a
:|[]) ((PrimPort, Identifier) -> NonEmpty (PrimPort, Identifier))
-> (Identifier -> (PrimPort, Identifier))
-> Identifier
-> NonEmpty (PrimPort, Identifier)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) PrimPort
PPReg (Identifier -> NonEmpty (PrimPort, Identifier))
-> Parser Identifier -> Parser (NonEmpty (PrimPort, Identifier))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident
    Token
KWOutput -> Parser (NonEmpty (PrimPort, Identifier))
-> Maybe (Parser (NonEmpty (PrimPort, Identifier)))
forall a. a -> Maybe a
Just (Parser (NonEmpty (PrimPort, Identifier))
 -> Maybe (Parser (NonEmpty (PrimPort, Identifier))))
-> Parser (NonEmpty (PrimPort, Identifier))
-> Maybe (Parser (NonEmpty (PrimPort, Identifier)))
forall a b. (a -> b) -> a -> b
$ ((PrimPort, Identifier)
-> [(PrimPort, Identifier)] -> NonEmpty (PrimPort, Identifier)
forall a. a -> [a] -> NonEmpty a
:|[]) ((PrimPort, Identifier) -> NonEmpty (PrimPort, Identifier))
-> Parser (PrimPort, Identifier)
-> Parser (NonEmpty (PrimPort, Identifier))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (PrimPort, Identifier)
udpOutput
    Token
KWInput -> Parser (NonEmpty (PrimPort, Identifier))
-> Maybe (Parser (NonEmpty (PrimPort, Identifier)))
forall a. a -> Maybe a
Just (Parser (NonEmpty (PrimPort, Identifier))
 -> Maybe (Parser (NonEmpty (PrimPort, Identifier))))
-> Parser (NonEmpty (PrimPort, Identifier))
-> Maybe (Parser (NonEmpty (PrimPort, Identifier)))
forall a b. (a -> b) -> a -> b
$ Parser (PrimPort, Identifier)
-> Parser (NonEmpty (PrimPort, Identifier))
forall a. Parser a -> Parser (NonEmpty a)
csl1 (Parser (PrimPort, Identifier)
 -> Parser (NonEmpty (PrimPort, Identifier)))
-> Parser (PrimPort, Identifier)
-> Parser (NonEmpty (PrimPort, Identifier))
forall a b. (a -> b) -> a -> b
$ (,) PrimPort
PPInput (Identifier -> (PrimPort, Identifier))
-> Parser Identifier -> Parser (PrimPort, Identifier)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
ident
    Token
_ -> Maybe (Parser (NonEmpty (PrimPort, Identifier)))
forall a. Maybe a
Nothing
  Token -> Parser ()
consume Token
SymSemi
  NonEmpty (AttrIded PrimPort)
-> Parser (NonEmpty (AttrIded PrimPort))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty (AttrIded PrimPort)
 -> Parser (NonEmpty (AttrIded PrimPort)))
-> NonEmpty (AttrIded PrimPort)
-> Parser (NonEmpty (AttrIded PrimPort))
forall a b. (a -> b) -> a -> b
$ (PrimPort -> Identifier -> AttrIded PrimPort)
-> (PrimPort, Identifier) -> AttrIded PrimPort
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((Identifier -> PrimPort -> AttrIded PrimPort)
-> PrimPort -> Identifier -> AttrIded PrimPort
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((Identifier -> PrimPort -> AttrIded PrimPort)
 -> PrimPort -> Identifier -> AttrIded PrimPort)
-> (Identifier -> PrimPort -> AttrIded PrimPort)
-> PrimPort
-> Identifier
-> AttrIded PrimPort
forall a b. (a -> b) -> a -> b
$ Attributes -> Identifier -> PrimPort -> AttrIded PrimPort
forall t. Attributes -> Identifier -> t -> AttrIded t
AttrIded Attributes
a) ((PrimPort, Identifier) -> AttrIded PrimPort)
-> NonEmpty (PrimPort, Identifier) -> NonEmpty (AttrIded PrimPort)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (PrimPort, Identifier)
l

-- | Sequential primitive output initial value
initVal :: Parser ZOX
initVal :: Parser ZOX
initVal = (Token -> Maybe (Parser ZOX)) -> Parser ZOX
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token -> Maybe (Parser ZOX)) -> Parser ZOX)
-> (Token -> Maybe (Parser ZOX)) -> Parser ZOX
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
  LitDecimal Natural
0 -> Parser ZOX -> Maybe (Parser ZOX)
forall a. a -> Maybe a
Just (Parser ZOX -> Maybe (Parser ZOX))
-> Parser ZOX -> Maybe (Parser ZOX)
forall a b. (a -> b) -> a -> b
$ ZOX -> Parser ZOX
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ZOX
ZOXZ
  LitDecimal Natural
1 -> Parser ZOX -> Maybe (Parser ZOX)
forall a. a -> Maybe a
Just (Parser ZOX -> Maybe (Parser ZOX))
-> Parser ZOX -> Maybe (Parser ZOX)
forall a b. (a -> b) -> a -> b
$
    ZOX -> Parser ZOX -> Parser ZOX
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option ZOX
ZOXO (Parser ZOX -> Parser ZOX) -> Parser ZOX -> Parser ZOX
forall a b. (a -> b) -> a -> b
$ do
      Token -> Parser ()
consume (Token -> Parser ()) -> Token -> Parser ()
forall a b. (a -> b) -> a -> b
$ Bool -> Base -> Token
NumberBase Bool
False Base
BBin
      (Token -> Maybe ZOX) -> Parser ZOX
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe ZOX) -> Parser ZOX)
-> (Token -> Maybe ZOX) -> Parser ZOX
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
        LitBinary [Item [BXZ]
BXZ
BXZ0] -> ZOX -> Maybe ZOX
forall a. a -> Maybe a
Just ZOX
ZOXZ
        LitBinary [Item [BXZ]
BXZ
BXZ1] -> ZOX -> Maybe ZOX
forall a. a -> Maybe a
Just ZOX
ZOXO
        LitBinary [Item [BXZ]
BXZ
BXZX] -> ZOX -> Maybe ZOX
forall a. a -> Maybe a
Just ZOX
ZOXX
        Token
_ -> Maybe ZOX
forall a. Maybe a
Nothing
  Token
_ -> Maybe (Parser ZOX)
forall a. Maybe a
Nothing

-- | Signal level
level :: Parser SigLevel
level :: Parser SigLevel
level = (Token -> Maybe SigLevel) -> Parser SigLevel
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe SigLevel) -> Parser SigLevel)
-> (Token -> Maybe SigLevel) -> Parser SigLevel
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
  TableOut ZOX
ZOXZ -> SigLevel -> Maybe SigLevel
forall a. a -> Maybe a
Just SigLevel
L0
  TableOut ZOX
ZOXO -> SigLevel -> Maybe SigLevel
forall a. a -> Maybe a
Just SigLevel
L1
  TableOut ZOX
ZOXX -> SigLevel -> Maybe SigLevel
forall a. a -> Maybe a
Just SigLevel
LX
  TableIn Bool
False -> SigLevel -> Maybe SigLevel
forall a. a -> Maybe a
Just SigLevel
LQ
  TableIn Bool
True -> SigLevel -> Maybe SigLevel
forall a. a -> Maybe a
Just SigLevel
LB
  Token
_ -> Maybe SigLevel
forall a. Maybe a
Nothing

-- | Sequential primitive nest state
nextState :: Parser (Maybe ZOX)
nextState :: Parser (Maybe ZOX)
nextState =
  (Token -> Maybe (Maybe ZOX)) -> Parser (Maybe ZOX)
forall a. (Token -> Maybe a) -> Parser a
fproduce (\Token
t -> case Token
t of TableOut ZOX
zox -> Maybe ZOX -> Maybe (Maybe ZOX)
forall a. a -> Maybe a
Just (Maybe ZOX -> Maybe (Maybe ZOX)) -> Maybe ZOX -> Maybe (Maybe ZOX)
forall a b. (a -> b) -> a -> b
$ ZOX -> Maybe ZOX
forall a. a -> Maybe a
Just ZOX
zox; Token
SymDash -> Maybe ZOX -> Maybe (Maybe ZOX)
forall a. a -> Maybe a
Just Maybe ZOX
forall a. Maybe a
Nothing; Token
_ -> Maybe (Maybe ZOX)
forall a. Maybe a
Nothing)
    Parser (Maybe ZOX) -> Parser () -> Parser (Maybe ZOX)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi

-- | Sequential primitive input row
seqRow :: Parser SeqIn
seqRow :: Parser SeqIn
seqRow = do
  [SigLevel]
comb <- Parser SigLevel
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [SigLevel]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser SigLevel
level
  SeqIn
res <- (if [SigLevel] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [SigLevel]
comb then Parser SeqIn -> Parser SeqIn
forall a. a -> a
id else SeqIn -> Parser SeqIn -> Parser SeqIn
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option (SeqIn -> Parser SeqIn -> Parser SeqIn)
-> SeqIn -> Parser SeqIn -> Parser SeqIn
forall a b. (a -> b) -> a -> b
$ NonEmpty SigLevel -> SeqIn
SIComb (NonEmpty SigLevel -> SeqIn) -> NonEmpty SigLevel -> SeqIn
forall a b. (a -> b) -> a -> b
$ [SigLevel] -> NonEmpty SigLevel
forall a. HasCallStack => [a] -> NonEmpty a
NE.fromList [SigLevel]
comb) (Parser SeqIn -> Parser SeqIn) -> Parser SeqIn -> Parser SeqIn
forall a b. (a -> b) -> a -> b
$ do
    Edge
e <- (SourcePos -> Token -> Maybe (Parser Edge)) -> Parser Edge
forall a. (SourcePos -> Token -> Maybe (Parser a)) -> Parser a
fpbranch ((SourcePos -> Token -> Maybe (Parser Edge)) -> Parser Edge)
-> (SourcePos -> Token -> Maybe (Parser Edge)) -> Parser Edge
forall a b. (a -> b) -> a -> b
$ \SourcePos
sp Token
t -> case Token
t of
      TableEdge AFRNP
AFRNPA -> Parser Edge -> Maybe (Parser Edge)
forall a. a -> Maybe a
Just (Parser Edge -> Maybe (Parser Edge))
-> Parser Edge -> Maybe (Parser Edge)
forall a b. (a -> b) -> a -> b
$ Edge -> Parser Edge
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Edge -> Parser Edge) -> Edge -> Parser Edge
forall a b. (a -> b) -> a -> b
$ SigLevel -> SigLevel -> Edge
EdgeDesc SigLevel
LQ SigLevel
LQ
      TableEdge AFRNP
AFRNPF -> Parser Edge -> Maybe (Parser Edge)
forall a. a -> Maybe a
Just (Parser Edge -> Maybe (Parser Edge))
-> Parser Edge -> Maybe (Parser Edge)
forall a b. (a -> b) -> a -> b
$ Edge -> Parser Edge
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Edge -> Parser Edge) -> Edge -> Parser Edge
forall a b. (a -> b) -> a -> b
$ SigLevel -> SigLevel -> Edge
EdgeDesc SigLevel
L1 SigLevel
L0
      TableEdge AFRNP
AFRNPR -> Parser Edge -> Maybe (Parser Edge)
forall a. a -> Maybe a
Just (Parser Edge -> Maybe (Parser Edge))
-> Parser Edge -> Maybe (Parser Edge)
forall a b. (a -> b) -> a -> b
$ Edge -> Parser Edge
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Edge -> Parser Edge) -> Edge -> Parser Edge
forall a b. (a -> b) -> a -> b
$ SigLevel -> SigLevel -> Edge
EdgeDesc SigLevel
L0 SigLevel
L1
      TableEdge AFRNP
AFRNPN -> Parser Edge -> Maybe (Parser Edge)
forall a. a -> Maybe a
Just (Parser Edge -> Maybe (Parser Edge))
-> Parser Edge -> Maybe (Parser Edge)
forall a b. (a -> b) -> a -> b
$ Edge -> Parser Edge
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Edge
EdgePos_neg Bool
False)
      TableEdge AFRNP
AFRNPP -> Parser Edge -> Maybe (Parser Edge)
forall a. a -> Maybe a
Just (Parser Edge -> Maybe (Parser Edge))
-> Parser Edge -> Maybe (Parser Edge)
forall a b. (a -> b) -> a -> b
$ Edge -> Parser Edge
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Edge
EdgePos_neg Bool
True)
      Token
SymParenL -> Parser Edge -> Maybe (Parser Edge)
forall a. a -> Maybe a
Just (Parser Edge -> Maybe (Parser Edge))
-> Parser Edge -> Maybe (Parser Edge)
forall a b. (a -> b) -> a -> b
$ SigLevel -> SigLevel -> Edge
EdgeDesc (SigLevel -> SigLevel -> Edge)
-> Parser SigLevel
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (SigLevel -> Edge)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SigLevel
level ParsecT
  [PosToken] LocalCompDir (Writer [String]) (SigLevel -> Edge)
-> Parser SigLevel -> Parser Edge
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SigLevel
level Parser Edge -> Parser () -> Parser Edge
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
sp Token
SymParenL Token
SymParenR
      Token
_ -> Maybe (Parser Edge)
forall a. Maybe a
Nothing
    [SigLevel] -> Edge -> [SigLevel] -> SeqIn
SISeq [SigLevel]
comb Edge
e ([SigLevel] -> SeqIn)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [SigLevel]
-> Parser SeqIn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SigLevel
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [SigLevel]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser SigLevel
level
  Token -> Parser ()
consume Token
SymColon
  SeqIn -> Parser SeqIn
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return SeqIn
res

-- | Parses a primitive block
udp :: Attributes -> Parser Verilog2005
udp :: Attributes -> Parser Verilog2005
udp Attributes
attr = do
  Identifier
udpid <- Parser Identifier
ident
  (Identifier
out, NonEmpty Identifier
ins, Maybe (NonEmpty (AttrIded PrimPort))
mpd) <- Parser
  (Identifier, NonEmpty Identifier,
   Maybe (NonEmpty (AttrIded PrimPort)))
-> Parser
     (Identifier, NonEmpty Identifier,
      Maybe (NonEmpty (AttrIded PrimPort)))
forall a. Parser a -> Parser a
parens Parser
  (Identifier, NonEmpty Identifier,
   Maybe (NonEmpty (AttrIded PrimPort)))
udpHead
  Token -> Parser ()
consume Token
SymSemi
  NonEmpty (AttrIded PrimPort)
pd <- Parser (NonEmpty (AttrIded PrimPort))
-> (NonEmpty (AttrIded PrimPort)
    -> Parser (NonEmpty (AttrIded PrimPort)))
-> Maybe (NonEmpty (AttrIded PrimPort))
-> Parser (NonEmpty (AttrIded PrimPort))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (NonEmpty (NonEmpty (AttrIded PrimPort))
-> NonEmpty (AttrIded PrimPort)
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (NonEmpty (NonEmpty (AttrIded PrimPort))
 -> NonEmpty (AttrIded PrimPort))
-> Parser (NonEmpty (NonEmpty (AttrIded PrimPort)))
-> Parser (NonEmpty (AttrIded PrimPort))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (NonEmpty (AttrIded PrimPort))
-> Parser (NonEmpty (NonEmpty (AttrIded PrimPort)))
forall a. Parser a -> Parser (NonEmpty a)
manyNE Parser (NonEmpty (AttrIded PrimPort))
udpPort) NonEmpty (AttrIded PrimPort)
-> Parser (NonEmpty (AttrIded PrimPort))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (NonEmpty (AttrIded PrimPort))
mpd
  Maybe ZOX
init <- Parser ZOX -> Parser (Maybe ZOX)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Parser ZOX -> Parser (Maybe ZOX))
-> Parser ZOX -> Parser (Maybe ZOX)
forall a b. (a -> b) -> a -> b
$ do
    Token -> Parser ()
consume Token
KWInitial
    Identifier
s <- Parser Identifier
ident
    if Identifier
s Identifier -> Identifier -> Bool
forall a. Eq a => a -> a -> Bool
/= Identifier
out
      then String -> Parser ZOX
forall a. String -> Parser a
hardfail String
"Initial value can only be assigned to output port"
      else Token -> Parser ()
consume Token
SymEq Parser () -> Parser ZOX -> Parser ZOX
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser ZOX
initVal Parser ZOX -> Parser () -> Parser ZOX
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymSemi
  Token -> Parser ()
consume Token
KWTable
  -- parse a seqRow to know the table kind, if it's not an allowed kind we can error later
  SeqIn
hdi <- Parser SeqIn
seqRow
  SigLevel
sl <- Parser SigLevel
level
  Maybe (Maybe ZOX)
hdd <- (Token -> Maybe (Parser (Maybe (Maybe ZOX))))
-> Parser (Maybe (Maybe ZOX))
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token -> Maybe (Parser (Maybe (Maybe ZOX))))
 -> Parser (Maybe (Maybe ZOX)))
-> (Token -> Maybe (Parser (Maybe (Maybe ZOX))))
-> Parser (Maybe (Maybe ZOX))
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
    Token
SymSemi -> Parser (Maybe (Maybe ZOX)) -> Maybe (Parser (Maybe (Maybe ZOX)))
forall a. a -> Maybe a
Just (Parser (Maybe (Maybe ZOX)) -> Maybe (Parser (Maybe (Maybe ZOX))))
-> Parser (Maybe (Maybe ZOX)) -> Maybe (Parser (Maybe (Maybe ZOX)))
forall a b. (a -> b) -> a -> b
$ Maybe (Maybe ZOX) -> Parser (Maybe (Maybe ZOX))
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Maybe ZOX)
forall a. Maybe a
Nothing
    Token
SymColon -> Parser (Maybe (Maybe ZOX)) -> Maybe (Parser (Maybe (Maybe ZOX)))
forall a. a -> Maybe a
Just (Parser (Maybe (Maybe ZOX)) -> Maybe (Parser (Maybe (Maybe ZOX))))
-> Parser (Maybe (Maybe ZOX)) -> Maybe (Parser (Maybe (Maybe ZOX)))
forall a b. (a -> b) -> a -> b
$ Maybe ZOX -> Maybe (Maybe ZOX)
forall a. a -> Maybe a
Just (Maybe ZOX -> Maybe (Maybe ZOX))
-> Parser (Maybe ZOX) -> Parser (Maybe (Maybe ZOX))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser (Maybe ZOX)
nextState
    Token
_ -> Maybe (Parser (Maybe (Maybe ZOX)))
forall a. Maybe a
Nothing
  let hdu :: Maybe ZOX
hdu = case SigLevel
sl of SigLevel
L0 -> ZOX -> Maybe ZOX
forall a. a -> Maybe a
Just ZOX
ZOXZ; SigLevel
L1 -> ZOX -> Maybe ZOX
forall a. a -> Maybe a
Just ZOX
ZOXO; SigLevel
LX -> ZOX -> Maybe ZOX
forall a. a -> Maybe a
Just ZOX
ZOXX; SigLevel
_ -> Maybe ZOX
forall a. Maybe a
Nothing
  -- use all the information to decide if the primitive is sequential or combinational
  PrimTable
body <- case (Maybe (Maybe ZOX)
hdd, SeqIn
hdi, Maybe ZOX
hdu) of
    (Maybe (Maybe ZOX)
Nothing, SIComb NonEmpty SigLevel
comb, Just ZOX
zox) | Maybe ZOX
init Maybe ZOX -> Maybe ZOX -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe ZOX
forall a. Maybe a
Nothing ->
      NonEmpty CombRow -> PrimTable
CombTable (NonEmpty CombRow -> PrimTable)
-> ([CombRow] -> NonEmpty CombRow) -> [CombRow] -> PrimTable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NonEmpty SigLevel -> ZOX -> CombRow
CombRow NonEmpty SigLevel
comb ZOX
zox CombRow -> [CombRow] -> NonEmpty CombRow
forall a. a -> [a] -> NonEmpty a
:|) ([CombRow] -> PrimTable)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [CombRow]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PrimTable
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [PosToken] LocalCompDir (Writer [String]) CombRow
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [CombRow]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT [PosToken] LocalCompDir (Writer [String]) CombRow
combRow
    (Just Maybe ZOX
ns, SeqIn
_, Maybe ZOX
_) ->
      Maybe ZOX -> NonEmpty SeqRow -> PrimTable
SeqTable Maybe ZOX
init (NonEmpty SeqRow -> PrimTable)
-> ([SeqRow] -> NonEmpty SeqRow) -> [SeqRow] -> PrimTable
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SeqIn -> SigLevel -> Maybe ZOX -> SeqRow
SeqRow SeqIn
hdi SigLevel
sl Maybe ZOX
ns SeqRow -> [SeqRow] -> NonEmpty SeqRow
forall a. a -> [a] -> NonEmpty a
:|)
        ([SeqRow] -> PrimTable)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [SeqRow]
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PrimTable
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [PosToken] LocalCompDir (Writer [String]) SeqRow
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [SeqRow]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (SeqIn -> SigLevel -> Maybe ZOX -> SeqRow
SeqRow (SeqIn -> SigLevel -> Maybe ZOX -> SeqRow)
-> Parser SeqIn
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     (SigLevel -> Maybe ZOX -> SeqRow)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser SeqIn
seqRow ParsecT
  [PosToken]
  LocalCompDir
  (Writer [String])
  (SigLevel -> Maybe ZOX -> SeqRow)
-> Parser SigLevel
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe ZOX -> SeqRow)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser SigLevel
level ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Maybe ZOX -> SeqRow)
-> Parser ()
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe ZOX -> SeqRow)
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Token -> Parser ()
consume Token
SymColon ParsecT
  [PosToken] LocalCompDir (Writer [String]) (Maybe ZOX -> SeqRow)
-> Parser (Maybe ZOX)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) SeqRow
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Maybe ZOX)
nextState)
    (Maybe (Maybe ZOX), SeqIn, Maybe ZOX)
_ -> String
-> ParsecT [PosToken] LocalCompDir (Writer [String]) PrimTable
forall a. String -> Parser a
hardfail String
"Got mixed information between sequential and combinatorial UDP"
  Token -> Parser ()
consume Token
KWEndtable
  Verilog2005 -> Parser Verilog2005
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Verilog2005
forall a. Monoid a => a
mempty {_vPrimitive = [PrimitiveBlock attr udpid out ins pd body]}
  where
    -- Combinational primitive input row
    combRow :: ParsecT [PosToken] LocalCompDir (Writer [String]) CombRow
combRow = do
      NonEmpty SigLevel
l <- Parser SigLevel -> Parser (NonEmpty SigLevel)
forall a. Parser a -> Parser (NonEmpty a)
manyNE Parser SigLevel
level
      Token -> Parser ()
consume Token
SymColon
      ZOX
o <- (Token -> Maybe ZOX) -> Parser ZOX
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe ZOX) -> Parser ZOX)
-> (Token -> Maybe ZOX) -> Parser ZOX
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of TableOut ZOX
zox -> ZOX -> Maybe ZOX
forall a. a -> Maybe a
Just ZOX
zox; Token
_ -> Maybe ZOX
forall a. Maybe a
Nothing
      Token -> Parser ()
consume Token
SymSemi
      CombRow
-> ParsecT [PosToken] LocalCompDir (Writer [String]) CombRow
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (CombRow
 -> ParsecT [PosToken] LocalCompDir (Writer [String]) CombRow)
-> CombRow
-> ParsecT [PosToken] LocalCompDir (Writer [String]) CombRow
forall a b. (a -> b) -> a -> b
$ NonEmpty SigLevel -> ZOX -> CombRow
CombRow NonEmpty SigLevel
l ZOX
o

-- | Parses an element of config blocks body
configItem :: Parser ConfigItem
configItem :: Parser ConfigItem
configItem = do
  Cell_inst
ci <- (Token -> Maybe (Parser Cell_inst)) -> Parser Cell_inst
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token -> Maybe (Parser Cell_inst)) -> Parser Cell_inst)
-> (Token -> Maybe (Parser Cell_inst)) -> Parser Cell_inst
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
    Token
KWCell -> Parser Cell_inst -> Maybe (Parser Cell_inst)
forall a. a -> Maybe a
Just (Parser Cell_inst -> Maybe (Parser Cell_inst))
-> Parser Cell_inst -> Maybe (Parser Cell_inst)
forall a b. (a -> b) -> a -> b
$ Dot1Ident -> Cell_inst
CICell (Dot1Ident -> Cell_inst) -> Parser Dot1Ident -> Parser Cell_inst
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Dot1Ident
dot1Ident
    Token
KWInstance -> Parser Cell_inst -> Maybe (Parser Cell_inst)
forall a. a -> Maybe a
Just (Parser Cell_inst -> Maybe (Parser Cell_inst))
-> Parser Cell_inst -> Maybe (Parser Cell_inst)
forall a b. (a -> b) -> a -> b
$ NonEmpty Identifier -> Cell_inst
CIInst (NonEmpty Identifier -> Cell_inst)
-> ([Identifier] -> NonEmpty Identifier)
-> [Identifier]
-> Cell_inst
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Identifier] -> NonEmpty Identifier
forall a. HasCallStack => [a] -> NonEmpty a
NE.fromList ([Identifier] -> Cell_inst)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Identifier]
-> Parser Cell_inst
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Identifier
-> Parser ()
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Identifier]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy1 Parser Identifier
ident (Token -> Parser ()
consume Token
SymDot)
    Token
_ -> Maybe (Parser Cell_inst)
forall a. Maybe a
Nothing
  LLU
llu <- (Token -> Maybe (Parser LLU)) -> Parser LLU
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token -> Maybe (Parser LLU)) -> Parser LLU)
-> (Token -> Maybe (Parser LLU)) -> Parser LLU
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
    Token
KWLiblist -> Parser LLU -> Maybe (Parser LLU)
forall a. a -> Maybe a
Just (Parser LLU -> Maybe (Parser LLU))
-> Parser LLU -> Maybe (Parser LLU)
forall a b. (a -> b) -> a -> b
$ [ByteString] -> LLU
LLULiblist ([ByteString] -> LLU)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [ByteString]
-> Parser LLU
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ByteString
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [ByteString]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser ByteString
parseBS
    Token
KWUse ->
      Parser LLU -> Maybe (Parser LLU)
forall a. a -> Maybe a
Just (Parser LLU -> Maybe (Parser LLU))
-> Parser LLU -> Maybe (Parser LLU)
forall a b. (a -> b) -> a -> b
$
        Dot1Ident -> Bool -> LLU
LLUUse (Dot1Ident -> Bool -> LLU)
-> Parser Dot1Ident
-> ParsecT [PosToken] LocalCompDir (Writer [String]) (Bool -> LLU)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Dot1Ident
dot1Ident
          ParsecT [PosToken] LocalCompDir (Writer [String]) (Bool -> LLU)
-> Parser Bool -> Parser LLU
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) (a -> b)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> Parser Bool -> Parser Bool
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Bool
False (Token -> Parser ()
consume Token
SymColon Parser () -> Parser () -> Parser ()
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Token -> Parser ()
consume Token
KWConfig Parser () -> Parser Bool -> Parser Bool
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Bool -> Parser Bool
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True)
    Token
_ -> Maybe (Parser LLU)
forall a. Maybe a
Nothing
  Token -> Parser ()
consume Token
SymSemi
  ConfigItem -> Parser ConfigItem
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConfigItem -> Parser ConfigItem)
-> ConfigItem -> Parser ConfigItem
forall a b. (a -> b) -> a -> b
$ Cell_inst -> LLU -> ConfigItem
ConfigItem Cell_inst
ci LLU
llu

-- | Parses a config block
config :: Parser Verilog2005
config :: Parser Verilog2005
config = do
  Identifier
s <- Parser Identifier
ident
  Token -> Parser ()
consume Token
SymSemi
  Token -> Parser ()
consume Token
KWDesign
  [Dot1Ident]
design <- Parser Dot1Ident
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [Dot1Ident]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser Dot1Ident
dot1Ident
  Token -> Parser ()
consume Token
SymSemi
  [ConfigItem]
b <- Parser ConfigItem
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [ConfigItem]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser ConfigItem
configItem
  ([ConfigItem]
b', [ByteString]
d) <- ([ConfigItem], [ByteString])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     ([ConfigItem], [ByteString])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     ([ConfigItem], [ByteString])
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option ([], []) (ParsecT
   [PosToken]
   LocalCompDir
   (Writer [String])
   ([ConfigItem], [ByteString])
 -> ParsecT
      [PosToken]
      LocalCompDir
      (Writer [String])
      ([ConfigItem], [ByteString]))
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     ([ConfigItem], [ByteString])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     ([ConfigItem], [ByteString])
forall a b. (a -> b) -> a -> b
$ do
    Token -> Parser ()
consume Token
KWDefault
    Token -> Parser ()
consume Token
KWLiblist
    [ByteString]
d <- Parser ByteString
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [ByteString]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser ByteString
parseBS
    Token -> Parser ()
consume Token
SymSemi
    [ConfigItem]
body <- Parser ConfigItem
-> ParsecT [PosToken] LocalCompDir (Writer [String]) [ConfigItem]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parser ConfigItem
configItem
    ([ConfigItem], [ByteString])
-> ParsecT
     [PosToken]
     LocalCompDir
     (Writer [String])
     ([ConfigItem], [ByteString])
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([ConfigItem]
body, [ByteString]
d)
  Verilog2005 -> Parser Verilog2005
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Verilog2005
forall a. Monoid a => a
mempty {_vConfig = [ConfigBlock s design (b <> b') d]}

-- | Parses compiler directives
compDir :: Parser ()
compDir :: Parser ()
compDir = (Token -> Maybe (Parser ())) -> Parser ()
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token -> Maybe (Parser ())) -> Parser ())
-> (Token -> Maybe (Parser ())) -> Parser ()
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of
  Token
CDUnconnecteddrive ->
    Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$
      (Token -> Maybe (Parser ())) -> Parser ()
forall a. (Token -> Maybe (Parser a)) -> Parser a
fbranch ((Token -> Maybe (Parser ())) -> Parser ())
-> (Token -> Maybe (Parser ())) -> Parser ()
forall a b. (a -> b) -> a -> b
$
        \Token
t -> case Token
t of
          Token
KWPull0 -> Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$ (LocalCompDir -> LocalCompDir) -> Parser ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
modifyState ((LocalCompDir -> LocalCompDir) -> Parser ())
-> (LocalCompDir -> LocalCompDir) -> Parser ()
forall a b. (a -> b) -> a -> b
$ (Maybe Bool -> Identity (Maybe Bool))
-> LocalCompDir -> Identity LocalCompDir
Lens' LocalCompDir (Maybe Bool)
lcdPull ((Maybe Bool -> Identity (Maybe Bool))
 -> LocalCompDir -> Identity LocalCompDir)
-> Maybe Bool -> LocalCompDir -> LocalCompDir
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False
          Token
KWPull1 -> Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$ (LocalCompDir -> LocalCompDir) -> Parser ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
modifyState ((LocalCompDir -> LocalCompDir) -> Parser ())
-> (LocalCompDir -> LocalCompDir) -> Parser ()
forall a b. (a -> b) -> a -> b
$ (Maybe Bool -> Identity (Maybe Bool))
-> LocalCompDir -> Identity LocalCompDir
Lens' LocalCompDir (Maybe Bool)
lcdPull ((Maybe Bool -> Identity (Maybe Bool))
 -> LocalCompDir -> Identity LocalCompDir)
-> Maybe Bool -> LocalCompDir -> LocalCompDir
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
          Token
_ -> Maybe (Parser ())
forall a. Maybe a
Nothing
  Token
CDNounconnecteddrive -> Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$ (LocalCompDir -> LocalCompDir) -> Parser ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
modifyState ((LocalCompDir -> LocalCompDir) -> Parser ())
-> (LocalCompDir -> LocalCompDir) -> Parser ()
forall a b. (a -> b) -> a -> b
$ (Maybe Bool -> Identity (Maybe Bool))
-> LocalCompDir -> Identity LocalCompDir
Lens' LocalCompDir (Maybe Bool)
lcdPull ((Maybe Bool -> Identity (Maybe Bool))
 -> LocalCompDir -> Identity LocalCompDir)
-> Maybe Bool -> LocalCompDir -> LocalCompDir
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe Bool
forall a. Maybe a
Nothing
  Token
CDDefaultnettype -> Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$ do
    Maybe NetType
nt <-
      NetType -> Maybe NetType
forall a. a -> Maybe a
Just (NetType -> Maybe NetType)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) NetType
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe NetType)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Token -> Maybe NetType)
-> ParsecT [PosToken] LocalCompDir (Writer [String]) NetType
forall a. (Token -> Maybe a) -> Parser a
fproduce (\Token
t -> Line -> IntMap NetType -> Maybe NetType
forall a. Line -> IntMap a -> Maybe a
IntMap.lookup (Token -> Line
forall a. Data a => a -> Line
getConsIndex Token
t) (IntMap NetType -> Maybe NetType)
-> IntMap NetType -> Maybe NetType
forall a b. (a -> b) -> a -> b
$ LProduce NetType -> IntMap NetType
forall a. LProduce a -> IntMap a
mkActionMap LProduce NetType
netType)
        ParsecT [PosToken] LocalCompDir (Writer [String]) (Maybe NetType)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe NetType)
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe NetType)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Token -> Maybe (Maybe NetType))
-> ParsecT
     [PosToken] LocalCompDir (Writer [String]) (Maybe NetType)
forall a. (Token -> Maybe a) -> Parser a
fproduce (\Token
t -> if Token
t Token -> Token -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString -> Token
IdSimple ByteString
"none" then Maybe NetType -> Maybe (Maybe NetType)
forall a. a -> Maybe a
Just Maybe NetType
forall a. Maybe a
Nothing else Maybe (Maybe NetType)
forall a. Maybe a
Nothing)
    (LocalCompDir -> LocalCompDir) -> Parser ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
modifyState ((LocalCompDir -> LocalCompDir) -> Parser ())
-> (LocalCompDir -> LocalCompDir) -> Parser ()
forall a b. (a -> b) -> a -> b
$ (Maybe NetType -> Identity (Maybe NetType))
-> LocalCompDir -> Identity LocalCompDir
Lens' LocalCompDir (Maybe NetType)
lcdDefNetType ((Maybe NetType -> Identity (Maybe NetType))
 -> LocalCompDir -> Identity LocalCompDir)
-> Maybe NetType -> LocalCompDir -> LocalCompDir
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Maybe NetType
nt
  Token
CDResetall -> Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$ LocalCompDir -> Parser ()
forall (m :: * -> *) u s. Monad m => u -> ParsecT s u m ()
putState LocalCompDir
lcdDefault
  Token
CDTimescale -> Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$ do
    Line
uoff <- (Token -> Maybe Line) -> Parser Line
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Line) -> Parser Line)
-> (Token -> Maybe Line) -> Parser Line
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of CDTSInt Line
i -> Line -> Maybe Line
forall a. a -> Maybe a
Just Line
i; Token
_ -> Maybe Line
forall a. Maybe a
Nothing
    Line
ubase <- (Token -> Maybe Line) -> Parser Line
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Line) -> Parser Line)
-> (Token -> Maybe Line) -> Parser Line
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of CDTSUnit Line
i -> Line -> Maybe Line
forall a. a -> Maybe a
Just Line
i; Token
_ -> Maybe Line
forall a. Maybe a
Nothing
    Line
poff <- (Token -> Maybe Line) -> Parser Line
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Line) -> Parser Line)
-> (Token -> Maybe Line) -> Parser Line
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of CDTSInt Line
i -> Line -> Maybe Line
forall a. a -> Maybe a
Just Line
i; Token
_ -> Maybe Line
forall a. Maybe a
Nothing
    Line
pbase <- (Token -> Maybe Line) -> Parser Line
forall a. (Token -> Maybe a) -> Parser a
fproduce ((Token -> Maybe Line) -> Parser Line)
-> (Token -> Maybe Line) -> Parser Line
forall a b. (a -> b) -> a -> b
$ \Token
t -> case Token
t of CDTSUnit Line
i -> Line -> Maybe Line
forall a. a -> Maybe a
Just Line
i; Token
_ -> Maybe Line
forall a. Maybe a
Nothing
    (LocalCompDir -> LocalCompDir) -> Parser ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
modifyState ((LocalCompDir -> LocalCompDir) -> Parser ())
-> (LocalCompDir -> LocalCompDir) -> Parser ()
forall a b. (a -> b) -> a -> b
$ (Maybe (Line, Line) -> Identity (Maybe (Line, Line)))
-> LocalCompDir -> Identity LocalCompDir
Lens' LocalCompDir (Maybe (Line, Line))
lcdTimescale ((Maybe (Line, Line) -> Identity (Maybe (Line, Line)))
 -> LocalCompDir -> Identity LocalCompDir)
-> Maybe (Line, Line) -> LocalCompDir -> LocalCompDir
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Line, Line) -> Maybe (Line, Line)
forall a. a -> Maybe a
Just (Line
ubase Line -> Line -> Line
forall a. Num a => a -> a -> a
+ Line
uoff, Line
pbase Line -> Line -> Line
forall a. Num a => a -> a -> a
+ Line
poff)
  Token
CDBeginKeywords -> Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$ () -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure () -- handled at lexing, this makes sure it is used outside modules
  Token
CDEndKeywords -> Parser () -> Maybe (Parser ())
forall a. a -> Maybe a
Just (Parser () -> Maybe (Parser ())) -> Parser () -> Maybe (Parser ())
forall a b. (a -> b) -> a -> b
$ () -> Parser ()
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure () -- same as above
  Token
_ -> Maybe (Parser ())
forall a. Maybe a
Nothing

-- | Parses a top-level declaration: config, module or primitive block
topDecl :: Parser Verilog2005
topDecl :: Parser Verilog2005
topDecl =
  Parser () -> Parser ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
skipMany1 Parser ()
compDir Parser () -> Parser Verilog2005 -> Parser Verilog2005
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Verilog2005 -> Parser Verilog2005
forall a. a -> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (m :: * -> *) a. Monad m => a -> m a
return Verilog2005
forall a. Monoid a => a
mempty Parser Verilog2005 -> Parser Verilog2005 -> Parser Verilog2005
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do
    -- I'm not sure whether these compiler directives are allowed here
    Attributes
a <- Parser [Attribute] -> Parser Attributes
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (Parser [Attribute]
attributeOne Parser [Attribute] -> Parser () -> Parser [Attribute]
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser () -> Parser ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany Parser ()
compDir)
    LocalCompDir
st <- ParsecT [PosToken] LocalCompDir (Writer [String]) LocalCompDir
forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
    (SourcePos -> Token -> Maybe (Parser Verilog2005))
-> Parser Verilog2005
forall a. (SourcePos -> Token -> Maybe (Parser a)) -> Parser a
fpbranch ((SourcePos -> Token -> Maybe (Parser Verilog2005))
 -> Parser Verilog2005)
-> (SourcePos -> Token -> Maybe (Parser Verilog2005))
-> Parser Verilog2005
forall a b. (a -> b) -> a -> b
$ \SourcePos
p Token
t -> case Token
t of
      Token
KWPrimitive -> Parser Verilog2005 -> Maybe (Parser Verilog2005)
forall a. a -> Maybe a
Just (Parser Verilog2005 -> Maybe (Parser Verilog2005))
-> Parser Verilog2005 -> Maybe (Parser Verilog2005)
forall a b. (a -> b) -> a -> b
$ Attributes -> Parser Verilog2005
udp Attributes
a Parser Verilog2005 -> Parser () -> Parser Verilog2005
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
KWPrimitive Token
KWEndprimitive
      Token
KWModule -> Parser Verilog2005 -> Maybe (Parser Verilog2005)
forall a. a -> Maybe a
Just (Parser Verilog2005 -> Maybe (Parser Verilog2005))
-> Parser Verilog2005 -> Maybe (Parser Verilog2005)
forall a b. (a -> b) -> a -> b
$ LocalCompDir -> Attributes -> Parser Verilog2005
parseModule LocalCompDir
st Attributes
a Parser Verilog2005 -> Parser () -> Parser Verilog2005
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
KWModule Token
KWEndmodule
      Token
KWMacromodule -> Parser Verilog2005 -> Maybe (Parser Verilog2005)
forall a. a -> Maybe a
Just (Parser Verilog2005 -> Maybe (Parser Verilog2005))
-> Parser Verilog2005 -> Maybe (Parser Verilog2005)
forall a b. (a -> b) -> a -> b
$ LocalCompDir -> Attributes -> Parser Verilog2005
parseModule LocalCompDir
st Attributes
a Parser Verilog2005 -> Parser () -> Parser Verilog2005
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
KWMacromodule Token
KWEndmodule
      Token
KWConfig | Attributes -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Attributes
a -> Parser Verilog2005 -> Maybe (Parser Verilog2005)
forall a. a -> Maybe a
Just (Parser Verilog2005 -> Maybe (Parser Verilog2005))
-> Parser Verilog2005 -> Maybe (Parser Verilog2005)
forall a b. (a -> b) -> a -> b
$ Parser Verilog2005
config Parser Verilog2005 -> Parser () -> Parser Verilog2005
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SourcePos -> Token -> Token -> Parser ()
closeConsume SourcePos
p Token
KWConfig Token
KWEndconfig
      Token
_ -> Maybe (Parser Verilog2005)
forall a. Maybe a
Nothing

-- | Parses a verilog file by accumulating top-level declarations
verilog2005Parser :: Parser Verilog2005
verilog2005Parser :: Parser Verilog2005
verilog2005Parser = Parser ()
anywherecompdir Parser () -> Parser Verilog2005 -> Parser Verilog2005
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser Verilog2005 -> Parser Verilog2005
forall a. Monoid a => Parser a -> Parser a
monoAccum Parser Verilog2005
topDecl Parser Verilog2005 -> Parser () -> Parser Verilog2005
forall a b.
ParsecT [PosToken] LocalCompDir (Writer [String]) a
-> ParsecT [PosToken] LocalCompDir (Writer [String]) b
-> ParsecT [PosToken] LocalCompDir (Writer [String]) a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof

-- | Parse a file containing Verilog 2005 code, also return non Verilog2005 conformity warnings
-- The lists in the Verilog2005 structure are in reverse order from source
parseVerilog2005 :: FilePath -> IO (Verilog2005, [String])
parseVerilog2005 :: String -> IO (Verilog2005, [String])
parseVerilog2005 String
file = do
  Either String [PosToken]
stres <- String -> IO (Either String [PosToken])
scanTokens String
file
  case Either String [PosToken]
stres of
    Left String
s -> String -> IO (Verilog2005, [String])
forall a. HasCallStack => String -> a
error String
s
    Right [PosToken]
strm ->
      let (Either ParseError Verilog2005
x, [String]
w) = Writer [String] (Either ParseError Verilog2005)
-> (Either ParseError Verilog2005, [String])
forall w a. Monoid w => Writer w a -> (a, w)
runWriter (Writer [String] (Either ParseError Verilog2005)
 -> (Either ParseError Verilog2005, [String]))
-> Writer [String] (Either ParseError Verilog2005)
-> (Either ParseError Verilog2005, [String])
forall a b. (a -> b) -> a -> b
$ Parser Verilog2005
-> LocalCompDir
-> String
-> [PosToken]
-> Writer [String] (Either ParseError Verilog2005)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> u -> String -> s -> m (Either ParseError a)
runParserT Parser Verilog2005
verilog2005Parser LocalCompDir
lcdDefault String
file [PosToken]
strm
       in case Either ParseError Verilog2005
x of
          Left ParseError
s -> String -> IO (Verilog2005, [String])
forall a. HasCallStack => String -> a
error (String -> IO (Verilog2005, [String]))
-> String -> IO (Verilog2005, [String])
forall a b. (a -> b) -> a -> b
$ ParseError -> String
forall a. Show a => a -> String
show ParseError
s
          Right Verilog2005
ast -> (Verilog2005, [String]) -> IO (Verilog2005, [String])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Verilog2005
ast, [String]
w)