{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}

-- |
-- Module      : Verismith.Verilog.AST
-- Description : Definition of the Verilog AST types.
-- Copyright   : (c) 2018-2019, Yann Herklotz
-- License     : GPL-3
-- Maintainer  : yann [at] yannherklotz [dot] com
-- Stability   : experimental
-- Poratbility : POSIX
--
-- Defines the types to build a Verilog AST.
module Verismith.Verilog.AST
  ( -- * Top level types
    SourceInfo (..),
    infoTop,
    infoSrc,
    Verilog (..),

    -- * Primitives

    -- ** Identifier
    Identifier (..),

    -- ** Control
    Delay (..),
    Event (..),

    -- ** Operators
    BinaryOperator (..),
    UnaryOperator (..),

    -- ** Task
    Task (..),
    taskName,
    taskExpr,

    -- ** Left hand side value
    LVal (..),
    regId,
    regExprId,
    regExpr,
    regSizeId,
    regSizeRange,
    regConc,

    -- ** Ports
    PortDir (..),
    PortType (..),
    Port (..),
    portType,
    portSigned,
    portSize,
    portName,

    -- * Expression
    Expr (..),
    _Id,
    ConstExpr (..),
    ConstExprF (..),
    constToExpr,
    exprToConst,
    Range (..),
    constNum,
    constParamId,
    constConcat,
    constUnOp,
    constPrim,
    constLhs,
    constBinOp,
    constRhs,
    constCond,
    constTrue,
    constFalse,
    constStr,

    -- * Assignment
    Assign (..),
    assignReg,
    assignDelay,
    assignExpr,
    ContAssign (..),
    contAssignNetLVal,
    contAssignExpr,

    -- ** Parameters
    Parameter (..),
    paramIdent,
    paramValue,
    LocalParam (..),
    localParamIdent,
    localParamValue,

    -- * Statment
    CaseType (..),
    CasePair (..),
    Statement (..),
    statDelay,
    statDStat,
    statEvent,
    statEStat,
    statements,
    stmntBA,
    stmntNBA,
    stmntTask,
    stmntSysTask,
    stmntCondExpr,
    stmntCondTrue,
    stmntCondFalse,
    stmntCaseType,
    stmntCaseExpr,
    stmntCasePair,
    stmntCaseDefault,
    forAssign,
    forExpr,
    forIncr,
    forStmnt,

    -- * Module
    ModDecl (..),
    modId,
    modOutPorts,
    modInPorts,
    modItems,
    modParams,
    _ModDeclAnn,
    _ModDecl,
    ModItem (..),
    modContAssign,
    modInstId,
    modInstName,
    modInstConns,
    _Initial,
    _Always,
    paramDecl,
    localParamDecl,
    traverseModItem,
    declDir,
    declPort,
    declVal,
    ModConn (..),
    modConnName,
    modExpr,

    -- * Useful Lenses and Traversals
    aModule,
    getModule,
    getSourceId,
    mainModule,
    Annotations (..),
  )
where

import Control.DeepSeq (NFData)
import Control.Lens hiding ((<|))
import Data.Data
import Data.Data.Lens
import Data.Functor.Foldable.TH (makeBaseFunctor)
import Data.List.NonEmpty (NonEmpty (..), (<|))
import Data.String (IsString, fromString)
import Data.Text (Text, pack)
import GHC.Generics (Generic)
import Verismith.Verilog.BitVec

class (Functor m) => Annotations m where
  removeAnn :: m a -> m a
  clearAnn :: m a -> m ()
  clearAnn = (a -> ()) -> m a -> m ()
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
_ -> ()) (m a -> m ()) -> (m a -> m a) -> m a -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> m a
forall a. m a -> m a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn
  collectAnn :: m a -> [a]

-- | Identifier in Verilog. This is just a string of characters that can either
-- be lowercase and uppercase for now. This might change in the future though,
-- as Verilog supports many more characters in Identifiers.
newtype Identifier = Identifier {Identifier -> Text
getIdentifier :: Text}
  deriving (Identifier -> Identifier -> Bool
(Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool) -> Eq Identifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Identifier -> Identifier -> Bool
== :: Identifier -> Identifier -> Bool
$c/= :: Identifier -> Identifier -> Bool
/= :: Identifier -> Identifier -> Bool
Eq, Int -> Identifier -> ShowS
[Identifier] -> ShowS
Identifier -> String
(Int -> Identifier -> ShowS)
-> (Identifier -> String)
-> ([Identifier] -> ShowS)
-> Show Identifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Identifier -> ShowS
showsPrec :: Int -> Identifier -> ShowS
$cshow :: Identifier -> String
show :: Identifier -> String
$cshowList :: [Identifier] -> ShowS
showList :: [Identifier] -> ShowS
Show, Eq Identifier
Eq Identifier =>
(Identifier -> Identifier -> Ordering)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Identifier)
-> (Identifier -> Identifier -> Identifier)
-> Ord Identifier
Identifier -> Identifier -> Bool
Identifier -> Identifier -> Ordering
Identifier -> Identifier -> Identifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Identifier -> Identifier -> Ordering
compare :: Identifier -> Identifier -> Ordering
$c< :: Identifier -> Identifier -> Bool
< :: Identifier -> Identifier -> Bool
$c<= :: Identifier -> Identifier -> Bool
<= :: Identifier -> Identifier -> Bool
$c> :: Identifier -> Identifier -> Bool
> :: Identifier -> Identifier -> Bool
$c>= :: Identifier -> Identifier -> Bool
>= :: Identifier -> Identifier -> Bool
$cmax :: Identifier -> Identifier -> Identifier
max :: Identifier -> Identifier -> Identifier
$cmin :: Identifier -> Identifier -> Identifier
min :: Identifier -> Identifier -> Identifier
Ord, Typeable Identifier
Typeable Identifier =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Identifier -> c Identifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Identifier)
-> (Identifier -> Constr)
-> (Identifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Identifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Identifier))
-> ((forall b. Data b => b -> b) -> Identifier -> Identifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Identifier -> r)
-> (forall u. (forall d. Data d => d -> u) -> Identifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Identifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Identifier -> m Identifier)
-> Data Identifier
Identifier -> Constr
Identifier -> DataType
(forall b. Data b => b -> b) -> Identifier -> Identifier
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Identifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Identifier -> c Identifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Identifier
$ctoConstr :: Identifier -> Constr
toConstr :: Identifier -> Constr
$cdataTypeOf :: Identifier -> DataType
dataTypeOf :: Identifier -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Identifier)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Identifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Identifier)
$cgmapT :: (forall b. Data b => b -> b) -> Identifier -> Identifier
gmapT :: (forall b. Data b => b -> b) -> Identifier -> Identifier
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Identifier -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Identifier -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Identifier -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Identifier -> m Identifier
Data, (forall x. Identifier -> Rep Identifier x)
-> (forall x. Rep Identifier x -> Identifier) -> Generic Identifier
forall x. Rep Identifier x -> Identifier
forall x. Identifier -> Rep Identifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Identifier -> Rep Identifier x
from :: forall x. Identifier -> Rep Identifier x
$cto :: forall x. Rep Identifier x -> Identifier
to :: forall x. Rep Identifier x -> Identifier
Generic, Identifier -> ()
(Identifier -> ()) -> NFData Identifier
forall a. (a -> ()) -> NFData a
$crnf :: Identifier -> ()
rnf :: Identifier -> ()
NFData)

$(makeWrapped ''Identifier)

instance IsString Identifier where
  fromString :: String -> Identifier
fromString = Text -> Identifier
Identifier (Text -> Identifier) -> (String -> Text) -> String -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
pack

instance Semigroup Identifier where
  Identifier Text
a <> :: Identifier -> Identifier -> Identifier
<> Identifier Text
b = Text -> Identifier
Identifier (Text -> Identifier) -> Text -> Identifier
forall a b. (a -> b) -> a -> b
$ Text
a Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
b

instance Monoid Identifier where
  mempty :: Identifier
mempty = Text -> Identifier
Identifier Text
forall a. Monoid a => a
mempty

-- | Verilog syntax for adding a delay, which is represented as @#num@.
newtype Delay = Delay {Delay -> Int
_getDelay :: Int}
  deriving (Delay -> Delay -> Bool
(Delay -> Delay -> Bool) -> (Delay -> Delay -> Bool) -> Eq Delay
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Delay -> Delay -> Bool
== :: Delay -> Delay -> Bool
$c/= :: Delay -> Delay -> Bool
/= :: Delay -> Delay -> Bool
Eq, Int -> Delay -> ShowS
[Delay] -> ShowS
Delay -> String
(Int -> Delay -> ShowS)
-> (Delay -> String) -> ([Delay] -> ShowS) -> Show Delay
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Delay -> ShowS
showsPrec :: Int -> Delay -> ShowS
$cshow :: Delay -> String
show :: Delay -> String
$cshowList :: [Delay] -> ShowS
showList :: [Delay] -> ShowS
Show, Eq Delay
Eq Delay =>
(Delay -> Delay -> Ordering)
-> (Delay -> Delay -> Bool)
-> (Delay -> Delay -> Bool)
-> (Delay -> Delay -> Bool)
-> (Delay -> Delay -> Bool)
-> (Delay -> Delay -> Delay)
-> (Delay -> Delay -> Delay)
-> Ord Delay
Delay -> Delay -> Bool
Delay -> Delay -> Ordering
Delay -> Delay -> Delay
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Delay -> Delay -> Ordering
compare :: Delay -> Delay -> Ordering
$c< :: Delay -> Delay -> Bool
< :: Delay -> Delay -> Bool
$c<= :: Delay -> Delay -> Bool
<= :: Delay -> Delay -> Bool
$c> :: Delay -> Delay -> Bool
> :: Delay -> Delay -> Bool
$c>= :: Delay -> Delay -> Bool
>= :: Delay -> Delay -> Bool
$cmax :: Delay -> Delay -> Delay
max :: Delay -> Delay -> Delay
$cmin :: Delay -> Delay -> Delay
min :: Delay -> Delay -> Delay
Ord, Typeable Delay
Typeable Delay =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Delay -> c Delay)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Delay)
-> (Delay -> Constr)
-> (Delay -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Delay))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Delay))
-> ((forall b. Data b => b -> b) -> Delay -> Delay)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Delay -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Delay -> r)
-> (forall u. (forall d. Data d => d -> u) -> Delay -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Delay -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Delay -> m Delay)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Delay -> m Delay)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Delay -> m Delay)
-> Data Delay
Delay -> Constr
Delay -> DataType
(forall b. Data b => b -> b) -> Delay -> Delay
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Delay -> u
forall u. (forall d. Data d => d -> u) -> Delay -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Delay -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Delay -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Delay -> m Delay
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Delay -> m Delay
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Delay
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Delay -> c Delay
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Delay)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Delay)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Delay -> c Delay
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Delay -> c Delay
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Delay
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Delay
$ctoConstr :: Delay -> Constr
toConstr :: Delay -> Constr
$cdataTypeOf :: Delay -> DataType
dataTypeOf :: Delay -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Delay)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Delay)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Delay)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Delay)
$cgmapT :: (forall b. Data b => b -> b) -> Delay -> Delay
gmapT :: (forall b. Data b => b -> b) -> Delay -> Delay
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Delay -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Delay -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Delay -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Delay -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Delay -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Delay -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Delay -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Delay -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Delay -> m Delay
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Delay -> m Delay
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Delay -> m Delay
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Delay -> m Delay
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Delay -> m Delay
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Delay -> m Delay
Data, (forall x. Delay -> Rep Delay x)
-> (forall x. Rep Delay x -> Delay) -> Generic Delay
forall x. Rep Delay x -> Delay
forall x. Delay -> Rep Delay x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Delay -> Rep Delay x
from :: forall x. Delay -> Rep Delay x
$cto :: forall x. Rep Delay x -> Delay
to :: forall x. Rep Delay x -> Delay
Generic, Delay -> ()
(Delay -> ()) -> NFData Delay
forall a. (a -> ()) -> NFData a
$crnf :: Delay -> ()
rnf :: Delay -> ()
NFData)

$(makeWrapped ''Delay)

instance Num Delay where
  Delay Int
a + :: Delay -> Delay -> Delay
+ Delay Int
b = Int -> Delay
Delay (Int -> Delay) -> Int -> Delay
forall a b. (a -> b) -> a -> b
$ Int
a Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
b
  Delay Int
a - :: Delay -> Delay -> Delay
- Delay Int
b = Int -> Delay
Delay (Int -> Delay) -> Int -> Delay
forall a b. (a -> b) -> a -> b
$ Int
a Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
b
  Delay Int
a * :: Delay -> Delay -> Delay
* Delay Int
b = Int -> Delay
Delay (Int -> Delay) -> Int -> Delay
forall a b. (a -> b) -> a -> b
$ Int
a Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
b
  negate :: Delay -> Delay
negate (Delay Int
a) = Int -> Delay
Delay (Int -> Delay) -> Int -> Delay
forall a b. (a -> b) -> a -> b
$ Int -> Int
forall a. Num a => a -> a
negate Int
a
  abs :: Delay -> Delay
abs (Delay Int
a) = Int -> Delay
Delay (Int -> Delay) -> Int -> Delay
forall a b. (a -> b) -> a -> b
$ Int -> Int
forall a. Num a => a -> a
abs Int
a
  signum :: Delay -> Delay
signum (Delay Int
a) = Int -> Delay
Delay (Int -> Delay) -> Int -> Delay
forall a b. (a -> b) -> a -> b
$ Int -> Int
forall a. Num a => a -> a
signum Int
a
  fromInteger :: Integer -> Delay
fromInteger = Int -> Delay
Delay (Int -> Delay) -> (Integer -> Int) -> Integer -> Delay
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int
forall a. Num a => Integer -> a
fromInteger

-- | Binary operators that are currently supported in the verilog generation.
data BinaryOperator
  = BinPlus
  | BinMinus
  | BinTimes
  | BinDiv
  | BinMod
  | BinEq
  | BinNEq
  | BinCEq
  | BinCNEq
  | BinLAnd
  | BinLOr
  | BinLT
  | BinLEq
  | BinGT
  | BinGEq
  | BinAnd
  | BinOr
  | BinXor
  | BinXNor
  | BinXNorInv
  | BinPower
  | BinLSL
  | BinLSR
  | BinASL
  | BinASR
  deriving (BinaryOperator -> BinaryOperator -> Bool
(BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> Bool) -> Eq BinaryOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryOperator -> BinaryOperator -> Bool
== :: BinaryOperator -> BinaryOperator -> Bool
$c/= :: BinaryOperator -> BinaryOperator -> Bool
/= :: BinaryOperator -> BinaryOperator -> Bool
Eq, Int -> BinaryOperator -> ShowS
[BinaryOperator] -> ShowS
BinaryOperator -> String
(Int -> BinaryOperator -> ShowS)
-> (BinaryOperator -> String)
-> ([BinaryOperator] -> ShowS)
-> Show BinaryOperator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BinaryOperator -> ShowS
showsPrec :: Int -> BinaryOperator -> ShowS
$cshow :: BinaryOperator -> String
show :: BinaryOperator -> String
$cshowList :: [BinaryOperator] -> ShowS
showList :: [BinaryOperator] -> ShowS
Show, Eq BinaryOperator
Eq BinaryOperator =>
(BinaryOperator -> BinaryOperator -> Ordering)
-> (BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> Bool)
-> (BinaryOperator -> BinaryOperator -> BinaryOperator)
-> (BinaryOperator -> BinaryOperator -> BinaryOperator)
-> Ord BinaryOperator
BinaryOperator -> BinaryOperator -> Bool
BinaryOperator -> BinaryOperator -> Ordering
BinaryOperator -> BinaryOperator -> BinaryOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryOperator -> BinaryOperator -> Ordering
compare :: BinaryOperator -> BinaryOperator -> Ordering
$c< :: BinaryOperator -> BinaryOperator -> Bool
< :: BinaryOperator -> BinaryOperator -> Bool
$c<= :: BinaryOperator -> BinaryOperator -> Bool
<= :: BinaryOperator -> BinaryOperator -> Bool
$c> :: BinaryOperator -> BinaryOperator -> Bool
> :: BinaryOperator -> BinaryOperator -> Bool
$c>= :: BinaryOperator -> BinaryOperator -> Bool
>= :: BinaryOperator -> BinaryOperator -> Bool
$cmax :: BinaryOperator -> BinaryOperator -> BinaryOperator
max :: BinaryOperator -> BinaryOperator -> BinaryOperator
$cmin :: BinaryOperator -> BinaryOperator -> BinaryOperator
min :: BinaryOperator -> BinaryOperator -> BinaryOperator
Ord, Typeable BinaryOperator
Typeable BinaryOperator =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BinaryOperator -> c BinaryOperator)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BinaryOperator)
-> (BinaryOperator -> Constr)
-> (BinaryOperator -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BinaryOperator))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BinaryOperator))
-> ((forall b. Data b => b -> b)
    -> BinaryOperator -> BinaryOperator)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> BinaryOperator -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BinaryOperator -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BinaryOperator -> m BinaryOperator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BinaryOperator -> m BinaryOperator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BinaryOperator -> m BinaryOperator)
-> Data BinaryOperator
BinaryOperator -> Constr
BinaryOperator -> DataType
(forall b. Data b => b -> b) -> BinaryOperator -> BinaryOperator
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> BinaryOperator -> u
forall u. (forall d. Data d => d -> u) -> BinaryOperator -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinaryOperator
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinaryOperator -> c BinaryOperator
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinaryOperator)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BinaryOperator)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinaryOperator -> c BinaryOperator
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BinaryOperator -> c BinaryOperator
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinaryOperator
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BinaryOperator
$ctoConstr :: BinaryOperator -> Constr
toConstr :: BinaryOperator -> Constr
$cdataTypeOf :: BinaryOperator -> DataType
dataTypeOf :: BinaryOperator -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinaryOperator)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BinaryOperator)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BinaryOperator)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BinaryOperator)
$cgmapT :: (forall b. Data b => b -> b) -> BinaryOperator -> BinaryOperator
gmapT :: (forall b. Data b => b -> b) -> BinaryOperator -> BinaryOperator
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BinaryOperator -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BinaryOperator -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BinaryOperator -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BinaryOperator -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BinaryOperator -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BinaryOperator -> m BinaryOperator
Data, (forall x. BinaryOperator -> Rep BinaryOperator x)
-> (forall x. Rep BinaryOperator x -> BinaryOperator)
-> Generic BinaryOperator
forall x. Rep BinaryOperator x -> BinaryOperator
forall x. BinaryOperator -> Rep BinaryOperator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BinaryOperator -> Rep BinaryOperator x
from :: forall x. BinaryOperator -> Rep BinaryOperator x
$cto :: forall x. Rep BinaryOperator x -> BinaryOperator
to :: forall x. Rep BinaryOperator x -> BinaryOperator
Generic, BinaryOperator -> ()
(BinaryOperator -> ()) -> NFData BinaryOperator
forall a. (a -> ()) -> NFData a
$crnf :: BinaryOperator -> ()
rnf :: BinaryOperator -> ()
NFData)

-- | Unary operators that are currently supported by the generator.
data UnaryOperator
  = UnPlus
  | UnMinus
  | UnLNot
  | UnNot
  | UnAnd
  | UnNand
  | UnOr
  | UnNor
  | UnXor
  | UnNxor
  | UnNxorInv
  deriving (UnaryOperator -> UnaryOperator -> Bool
(UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> Bool) -> Eq UnaryOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnaryOperator -> UnaryOperator -> Bool
== :: UnaryOperator -> UnaryOperator -> Bool
$c/= :: UnaryOperator -> UnaryOperator -> Bool
/= :: UnaryOperator -> UnaryOperator -> Bool
Eq, Int -> UnaryOperator -> ShowS
[UnaryOperator] -> ShowS
UnaryOperator -> String
(Int -> UnaryOperator -> ShowS)
-> (UnaryOperator -> String)
-> ([UnaryOperator] -> ShowS)
-> Show UnaryOperator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UnaryOperator -> ShowS
showsPrec :: Int -> UnaryOperator -> ShowS
$cshow :: UnaryOperator -> String
show :: UnaryOperator -> String
$cshowList :: [UnaryOperator] -> ShowS
showList :: [UnaryOperator] -> ShowS
Show, Eq UnaryOperator
Eq UnaryOperator =>
(UnaryOperator -> UnaryOperator -> Ordering)
-> (UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> Bool)
-> (UnaryOperator -> UnaryOperator -> UnaryOperator)
-> (UnaryOperator -> UnaryOperator -> UnaryOperator)
-> Ord UnaryOperator
UnaryOperator -> UnaryOperator -> Bool
UnaryOperator -> UnaryOperator -> Ordering
UnaryOperator -> UnaryOperator -> UnaryOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnaryOperator -> UnaryOperator -> Ordering
compare :: UnaryOperator -> UnaryOperator -> Ordering
$c< :: UnaryOperator -> UnaryOperator -> Bool
< :: UnaryOperator -> UnaryOperator -> Bool
$c<= :: UnaryOperator -> UnaryOperator -> Bool
<= :: UnaryOperator -> UnaryOperator -> Bool
$c> :: UnaryOperator -> UnaryOperator -> Bool
> :: UnaryOperator -> UnaryOperator -> Bool
$c>= :: UnaryOperator -> UnaryOperator -> Bool
>= :: UnaryOperator -> UnaryOperator -> Bool
$cmax :: UnaryOperator -> UnaryOperator -> UnaryOperator
max :: UnaryOperator -> UnaryOperator -> UnaryOperator
$cmin :: UnaryOperator -> UnaryOperator -> UnaryOperator
min :: UnaryOperator -> UnaryOperator -> UnaryOperator
Ord, Typeable UnaryOperator
Typeable UnaryOperator =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UnaryOperator -> c UnaryOperator)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UnaryOperator)
-> (UnaryOperator -> Constr)
-> (UnaryOperator -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UnaryOperator))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UnaryOperator))
-> ((forall b. Data b => b -> b) -> UnaryOperator -> UnaryOperator)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r)
-> (forall u. (forall d. Data d => d -> u) -> UnaryOperator -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UnaryOperator -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator)
-> Data UnaryOperator
UnaryOperator -> Constr
UnaryOperator -> DataType
(forall b. Data b => b -> b) -> UnaryOperator -> UnaryOperator
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UnaryOperator -> u
forall u. (forall d. Data d => d -> u) -> UnaryOperator -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryOperator
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryOperator -> c UnaryOperator
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryOperator)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryOperator)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryOperator -> c UnaryOperator
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UnaryOperator -> c UnaryOperator
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryOperator
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UnaryOperator
$ctoConstr :: UnaryOperator -> Constr
toConstr :: UnaryOperator -> Constr
$cdataTypeOf :: UnaryOperator -> DataType
dataTypeOf :: UnaryOperator -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryOperator)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UnaryOperator)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryOperator)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UnaryOperator)
$cgmapT :: (forall b. Data b => b -> b) -> UnaryOperator -> UnaryOperator
gmapT :: (forall b. Data b => b -> b) -> UnaryOperator -> UnaryOperator
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UnaryOperator -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryOperator -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> UnaryOperator -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryOperator -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UnaryOperator -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UnaryOperator -> m UnaryOperator
Data, (forall x. UnaryOperator -> Rep UnaryOperator x)
-> (forall x. Rep UnaryOperator x -> UnaryOperator)
-> Generic UnaryOperator
forall x. Rep UnaryOperator x -> UnaryOperator
forall x. UnaryOperator -> Rep UnaryOperator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UnaryOperator -> Rep UnaryOperator x
from :: forall x. UnaryOperator -> Rep UnaryOperator x
$cto :: forall x. Rep UnaryOperator x -> UnaryOperator
to :: forall x. Rep UnaryOperator x -> UnaryOperator
Generic, UnaryOperator -> ()
(UnaryOperator -> ()) -> NFData UnaryOperator
forall a. (a -> ()) -> NFData a
$crnf :: UnaryOperator -> ()
rnf :: UnaryOperator -> ()
NFData)

-- | Constant expression, which are known before simulation at compile time.
data ConstExpr
  = ConstNum
      { ConstExpr -> BitVec
_constNum :: {-# UNPACK #-} !BitVec
      }
  | ParamId
      { ConstExpr -> Identifier
_constParamId :: {-# UNPACK #-} !Identifier
      }
  | ConstConcat
      { ConstExpr -> NonEmpty ConstExpr
_constConcat :: !(NonEmpty ConstExpr)
      }
  | ConstUnOp
      { ConstExpr -> UnaryOperator
_constUnOp :: !UnaryOperator,
        ConstExpr -> ConstExpr
_constPrim :: !ConstExpr
      }
  | ConstBinOp
      { ConstExpr -> ConstExpr
_constLhs :: !ConstExpr,
        ConstExpr -> BinaryOperator
_constBinOp :: !BinaryOperator,
        ConstExpr -> ConstExpr
_constRhs :: !ConstExpr
      }
  | ConstCond
      { ConstExpr -> ConstExpr
_constCond :: !ConstExpr,
        ConstExpr -> ConstExpr
_constTrue :: !ConstExpr,
        ConstExpr -> ConstExpr
_constFalse :: !ConstExpr
      }
  | ConstStr
      { ConstExpr -> Text
_constStr :: {-# UNPACK #-} !Text
      }
  deriving (ConstExpr -> ConstExpr -> Bool
(ConstExpr -> ConstExpr -> Bool)
-> (ConstExpr -> ConstExpr -> Bool) -> Eq ConstExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstExpr -> ConstExpr -> Bool
== :: ConstExpr -> ConstExpr -> Bool
$c/= :: ConstExpr -> ConstExpr -> Bool
/= :: ConstExpr -> ConstExpr -> Bool
Eq, Int -> ConstExpr -> ShowS
[ConstExpr] -> ShowS
ConstExpr -> String
(Int -> ConstExpr -> ShowS)
-> (ConstExpr -> String)
-> ([ConstExpr] -> ShowS)
-> Show ConstExpr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConstExpr -> ShowS
showsPrec :: Int -> ConstExpr -> ShowS
$cshow :: ConstExpr -> String
show :: ConstExpr -> String
$cshowList :: [ConstExpr] -> ShowS
showList :: [ConstExpr] -> ShowS
Show, Eq ConstExpr
Eq ConstExpr =>
(ConstExpr -> ConstExpr -> Ordering)
-> (ConstExpr -> ConstExpr -> Bool)
-> (ConstExpr -> ConstExpr -> Bool)
-> (ConstExpr -> ConstExpr -> Bool)
-> (ConstExpr -> ConstExpr -> Bool)
-> (ConstExpr -> ConstExpr -> ConstExpr)
-> (ConstExpr -> ConstExpr -> ConstExpr)
-> Ord ConstExpr
ConstExpr -> ConstExpr -> Bool
ConstExpr -> ConstExpr -> Ordering
ConstExpr -> ConstExpr -> ConstExpr
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstExpr -> ConstExpr -> Ordering
compare :: ConstExpr -> ConstExpr -> Ordering
$c< :: ConstExpr -> ConstExpr -> Bool
< :: ConstExpr -> ConstExpr -> Bool
$c<= :: ConstExpr -> ConstExpr -> Bool
<= :: ConstExpr -> ConstExpr -> Bool
$c> :: ConstExpr -> ConstExpr -> Bool
> :: ConstExpr -> ConstExpr -> Bool
$c>= :: ConstExpr -> ConstExpr -> Bool
>= :: ConstExpr -> ConstExpr -> Bool
$cmax :: ConstExpr -> ConstExpr -> ConstExpr
max :: ConstExpr -> ConstExpr -> ConstExpr
$cmin :: ConstExpr -> ConstExpr -> ConstExpr
min :: ConstExpr -> ConstExpr -> ConstExpr
Ord, Typeable ConstExpr
Typeable ConstExpr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ConstExpr -> c ConstExpr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ConstExpr)
-> (ConstExpr -> Constr)
-> (ConstExpr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ConstExpr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstExpr))
-> ((forall b. Data b => b -> b) -> ConstExpr -> ConstExpr)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ConstExpr -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ConstExpr -> r)
-> (forall u. (forall d. Data d => d -> u) -> ConstExpr -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ConstExpr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr)
-> Data ConstExpr
ConstExpr -> Constr
ConstExpr -> DataType
(forall b. Data b => b -> b) -> ConstExpr -> ConstExpr
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ConstExpr -> u
forall u. (forall d. Data d => d -> u) -> ConstExpr -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstExpr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstExpr -> c ConstExpr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstExpr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstExpr)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstExpr -> c ConstExpr
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstExpr -> c ConstExpr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstExpr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstExpr
$ctoConstr :: ConstExpr -> Constr
toConstr :: ConstExpr -> Constr
$cdataTypeOf :: ConstExpr -> DataType
dataTypeOf :: ConstExpr -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstExpr)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstExpr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstExpr)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstExpr)
$cgmapT :: (forall b. Data b => b -> b) -> ConstExpr -> ConstExpr
gmapT :: (forall b. Data b => b -> b) -> ConstExpr -> ConstExpr
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstExpr -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConstExpr -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ConstExpr -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConstExpr -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ConstExpr -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ConstExpr -> m ConstExpr
Data, (forall x. ConstExpr -> Rep ConstExpr x)
-> (forall x. Rep ConstExpr x -> ConstExpr) -> Generic ConstExpr
forall x. Rep ConstExpr x -> ConstExpr
forall x. ConstExpr -> Rep ConstExpr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ConstExpr -> Rep ConstExpr x
from :: forall x. ConstExpr -> Rep ConstExpr x
$cto :: forall x. Rep ConstExpr x -> ConstExpr
to :: forall x. Rep ConstExpr x -> ConstExpr
Generic, ConstExpr -> ()
(ConstExpr -> ()) -> NFData ConstExpr
forall a. (a -> ()) -> NFData a
$crnf :: ConstExpr -> ()
rnf :: ConstExpr -> ()
NFData)

$(makeLenses ''ConstExpr)

$(makeBaseFunctor ''ConstExpr)

constToExpr :: ConstExpr -> Expr
constToExpr :: ConstExpr -> Expr
constToExpr (ConstNum BitVec
a) = BitVec -> Expr
Number BitVec
a
constToExpr (ParamId Identifier
a) = Identifier -> Expr
Id Identifier
a
constToExpr (ConstConcat NonEmpty ConstExpr
a) = NonEmpty Expr -> Expr
Concat (NonEmpty Expr -> Expr) -> NonEmpty Expr -> Expr
forall a b. (a -> b) -> a -> b
$ (ConstExpr -> Expr) -> NonEmpty ConstExpr -> NonEmpty Expr
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ConstExpr -> Expr
constToExpr NonEmpty ConstExpr
a
constToExpr (ConstUnOp UnaryOperator
a ConstExpr
b) = UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
a (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ConstExpr -> Expr
constToExpr ConstExpr
b
constToExpr (ConstBinOp ConstExpr
a BinaryOperator
b ConstExpr
c) = Expr -> BinaryOperator -> Expr -> Expr
BinOp (ConstExpr -> Expr
constToExpr ConstExpr
a) BinaryOperator
b (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ConstExpr -> Expr
constToExpr ConstExpr
c
constToExpr (ConstCond ConstExpr
a ConstExpr
b ConstExpr
c) =
  Expr -> Expr -> Expr -> Expr
Cond (ConstExpr -> Expr
constToExpr ConstExpr
a) (ConstExpr -> Expr
constToExpr ConstExpr
b) (Expr -> Expr) -> Expr -> Expr
forall a b. (a -> b) -> a -> b
$ ConstExpr -> Expr
constToExpr ConstExpr
c
constToExpr (ConstStr Text
a) = Text -> Expr
Str Text
a

exprToConst :: Expr -> ConstExpr
exprToConst :: Expr -> ConstExpr
exprToConst (Number BitVec
a) = BitVec -> ConstExpr
ConstNum BitVec
a
exprToConst (Id Identifier
a) = Identifier -> ConstExpr
ParamId Identifier
a
exprToConst (Concat NonEmpty Expr
a) = NonEmpty ConstExpr -> ConstExpr
ConstConcat (NonEmpty ConstExpr -> ConstExpr)
-> NonEmpty ConstExpr -> ConstExpr
forall a b. (a -> b) -> a -> b
$ (Expr -> ConstExpr) -> NonEmpty Expr -> NonEmpty ConstExpr
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr -> ConstExpr
exprToConst NonEmpty Expr
a
exprToConst (UnOp UnaryOperator
a Expr
b) = UnaryOperator -> ConstExpr -> ConstExpr
ConstUnOp UnaryOperator
a (ConstExpr -> ConstExpr) -> ConstExpr -> ConstExpr
forall a b. (a -> b) -> a -> b
$ Expr -> ConstExpr
exprToConst Expr
b
exprToConst (BinOp Expr
a BinaryOperator
b Expr
c) = ConstExpr -> BinaryOperator -> ConstExpr -> ConstExpr
ConstBinOp (Expr -> ConstExpr
exprToConst Expr
a) BinaryOperator
b (ConstExpr -> ConstExpr) -> ConstExpr -> ConstExpr
forall a b. (a -> b) -> a -> b
$ Expr -> ConstExpr
exprToConst Expr
c
exprToConst (Cond Expr
a Expr
b Expr
c) =
  ConstExpr -> ConstExpr -> ConstExpr -> ConstExpr
ConstCond (Expr -> ConstExpr
exprToConst Expr
a) (Expr -> ConstExpr
exprToConst Expr
b) (ConstExpr -> ConstExpr) -> ConstExpr -> ConstExpr
forall a b. (a -> b) -> a -> b
$ Expr -> ConstExpr
exprToConst Expr
c
exprToConst (Str Text
a) = Text -> ConstExpr
ConstStr Text
a
exprToConst Expr
_ = String -> ConstExpr
forall a. HasCallStack => String -> a
error String
"Not a constant expression"

instance Num ConstExpr where
  ConstExpr
a + :: ConstExpr -> ConstExpr -> ConstExpr
+ ConstExpr
b = ConstExpr -> BinaryOperator -> ConstExpr -> ConstExpr
ConstBinOp ConstExpr
a BinaryOperator
BinPlus ConstExpr
b
  ConstExpr
a - :: ConstExpr -> ConstExpr -> ConstExpr
- ConstExpr
b = ConstExpr -> BinaryOperator -> ConstExpr -> ConstExpr
ConstBinOp ConstExpr
a BinaryOperator
BinMinus ConstExpr
b
  ConstExpr
a * :: ConstExpr -> ConstExpr -> ConstExpr
* ConstExpr
b = ConstExpr -> BinaryOperator -> ConstExpr -> ConstExpr
ConstBinOp ConstExpr
a BinaryOperator
BinTimes ConstExpr
b
  negate :: ConstExpr -> ConstExpr
negate = UnaryOperator -> ConstExpr -> ConstExpr
ConstUnOp UnaryOperator
UnMinus
  abs :: ConstExpr -> ConstExpr
abs = ConstExpr -> ConstExpr
forall a. HasCallStack => a
undefined
  signum :: ConstExpr -> ConstExpr
signum = ConstExpr -> ConstExpr
forall a. HasCallStack => a
undefined
  fromInteger :: Integer -> ConstExpr
fromInteger = BitVec -> ConstExpr
ConstNum (BitVec -> ConstExpr)
-> (Integer -> BitVec) -> Integer -> ConstExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> BitVec
forall a. Num a => Integer -> a
fromInteger

instance Semigroup ConstExpr where
  (ConstConcat NonEmpty ConstExpr
a) <> :: ConstExpr -> ConstExpr -> ConstExpr
<> (ConstConcat NonEmpty ConstExpr
b) = NonEmpty ConstExpr -> ConstExpr
ConstConcat (NonEmpty ConstExpr -> ConstExpr)
-> NonEmpty ConstExpr -> ConstExpr
forall a b. (a -> b) -> a -> b
$ NonEmpty ConstExpr
a NonEmpty ConstExpr -> NonEmpty ConstExpr -> NonEmpty ConstExpr
forall a. Semigroup a => a -> a -> a
<> NonEmpty ConstExpr
b
  (ConstConcat NonEmpty ConstExpr
a) <> ConstExpr
b = NonEmpty ConstExpr -> ConstExpr
ConstConcat (NonEmpty ConstExpr -> ConstExpr)
-> NonEmpty ConstExpr -> ConstExpr
forall a b. (a -> b) -> a -> b
$ NonEmpty ConstExpr
a NonEmpty ConstExpr -> NonEmpty ConstExpr -> NonEmpty ConstExpr
forall a. Semigroup a => a -> a -> a
<> (ConstExpr
b ConstExpr -> [ConstExpr] -> NonEmpty ConstExpr
forall a. a -> [a] -> NonEmpty a
:| [])
  ConstExpr
a <> (ConstConcat NonEmpty ConstExpr
b) = NonEmpty ConstExpr -> ConstExpr
ConstConcat (NonEmpty ConstExpr -> ConstExpr)
-> NonEmpty ConstExpr -> ConstExpr
forall a b. (a -> b) -> a -> b
$ ConstExpr
a ConstExpr -> NonEmpty ConstExpr -> NonEmpty ConstExpr
forall a. a -> NonEmpty a -> NonEmpty a
<| NonEmpty ConstExpr
b
  ConstExpr
a <> ConstExpr
b = NonEmpty ConstExpr -> ConstExpr
ConstConcat (NonEmpty ConstExpr -> ConstExpr)
-> NonEmpty ConstExpr -> ConstExpr
forall a b. (a -> b) -> a -> b
$ ConstExpr
a ConstExpr -> NonEmpty ConstExpr -> NonEmpty ConstExpr
forall a. a -> NonEmpty a -> NonEmpty a
<| ConstExpr
b ConstExpr -> [ConstExpr] -> NonEmpty ConstExpr
forall a. a -> [a] -> NonEmpty a
:| []

instance Monoid ConstExpr where
  mempty :: ConstExpr
mempty = BitVec -> ConstExpr
ConstNum BitVec
0

instance IsString ConstExpr where
  fromString :: String -> ConstExpr
fromString = Text -> ConstExpr
ConstStr (Text -> ConstExpr) -> (String -> Text) -> String -> ConstExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
forall a. IsString a => String -> a
fromString

instance Plated ConstExpr where
  plate :: Traversal' ConstExpr ConstExpr
plate = (ConstExpr -> f ConstExpr) -> ConstExpr -> f ConstExpr
forall a. Data a => Traversal' a a
Traversal' ConstExpr ConstExpr
uniplate

-- | Range that can be associated with any port or left hand side. Contains the
-- msb and lsb bits as 'ConstExpr'. This means that they can be generated using
-- parameters, which can in turn be changed at synthesis time.
data Range = Range
  { Range -> ConstExpr
rangeMSB :: !ConstExpr,
    Range -> ConstExpr
rangeLSB :: !ConstExpr
  }
  deriving (Range -> Range -> Bool
(Range -> Range -> Bool) -> (Range -> Range -> Bool) -> Eq Range
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Range -> Range -> Bool
== :: Range -> Range -> Bool
$c/= :: Range -> Range -> Bool
/= :: Range -> Range -> Bool
Eq, Int -> Range -> ShowS
[Range] -> ShowS
Range -> String
(Int -> Range -> ShowS)
-> (Range -> String) -> ([Range] -> ShowS) -> Show Range
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Range -> ShowS
showsPrec :: Int -> Range -> ShowS
$cshow :: Range -> String
show :: Range -> String
$cshowList :: [Range] -> ShowS
showList :: [Range] -> ShowS
Show, Eq Range
Eq Range =>
(Range -> Range -> Ordering)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Bool)
-> (Range -> Range -> Range)
-> (Range -> Range -> Range)
-> Ord Range
Range -> Range -> Bool
Range -> Range -> Ordering
Range -> Range -> Range
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Range -> Range -> Ordering
compare :: Range -> Range -> Ordering
$c< :: Range -> Range -> Bool
< :: Range -> Range -> Bool
$c<= :: Range -> Range -> Bool
<= :: Range -> Range -> Bool
$c> :: Range -> Range -> Bool
> :: Range -> Range -> Bool
$c>= :: Range -> Range -> Bool
>= :: Range -> Range -> Bool
$cmax :: Range -> Range -> Range
max :: Range -> Range -> Range
$cmin :: Range -> Range -> Range
min :: Range -> Range -> Range
Ord, Typeable Range
Typeable Range =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Range -> c Range)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Range)
-> (Range -> Constr)
-> (Range -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Range))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range))
-> ((forall b. Data b => b -> b) -> Range -> Range)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r)
-> (forall u. (forall d. Data d => d -> u) -> Range -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Range -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Range -> m Range)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Range -> m Range)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Range -> m Range)
-> Data Range
Range -> Constr
Range -> DataType
(forall b. Data b => b -> b) -> Range -> Range
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Range -> u
forall u. (forall d. Data d => d -> u) -> Range -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Range -> m Range
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Range -> m Range
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Range
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Range -> c Range
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Range)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Range -> c Range
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Range -> c Range
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Range
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Range
$ctoConstr :: Range -> Constr
toConstr :: Range -> Constr
$cdataTypeOf :: Range -> DataType
dataTypeOf :: Range -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Range)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Range)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range)
$cgmapT :: (forall b. Data b => b -> b) -> Range -> Range
gmapT :: (forall b. Data b => b -> b) -> Range -> Range
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Range -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Range -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Range -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Range -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Range -> m Range
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Range -> m Range
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Range -> m Range
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Range -> m Range
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Range -> m Range
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Range -> m Range
Data, (forall x. Range -> Rep Range x)
-> (forall x. Rep Range x -> Range) -> Generic Range
forall x. Rep Range x -> Range
forall x. Range -> Rep Range x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Range -> Rep Range x
from :: forall x. Range -> Rep Range x
$cto :: forall x. Rep Range x -> Range
to :: forall x. Rep Range x -> Range
Generic, Range -> ()
(Range -> ()) -> NFData Range
forall a. (a -> ()) -> NFData a
$crnf :: Range -> ()
rnf :: Range -> ()
NFData)

instance Num Range where
  (Range ConstExpr
s1 ConstExpr
a) + :: Range -> Range -> Range
+ (Range ConstExpr
s2 ConstExpr
b) = ConstExpr -> ConstExpr -> Range
Range (ConstExpr
s1 ConstExpr -> ConstExpr -> ConstExpr
forall a. Num a => a -> a -> a
+ ConstExpr
s2) (ConstExpr -> Range) -> ConstExpr -> Range
forall a b. (a -> b) -> a -> b
$ ConstExpr
a ConstExpr -> ConstExpr -> ConstExpr
forall a. Num a => a -> a -> a
+ ConstExpr
b
  (Range ConstExpr
s1 ConstExpr
a) - :: Range -> Range -> Range
- (Range ConstExpr
s2 ConstExpr
b) = ConstExpr -> ConstExpr -> Range
Range (ConstExpr
s1 ConstExpr -> ConstExpr -> ConstExpr
forall a. Num a => a -> a -> a
- ConstExpr
s2) (ConstExpr -> Range)
-> (ConstExpr -> ConstExpr) -> ConstExpr -> Range
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConstExpr -> ConstExpr -> ConstExpr
forall a. Ord a => a -> a -> a
max ConstExpr
0 (ConstExpr -> Range) -> ConstExpr -> Range
forall a b. (a -> b) -> a -> b
$ ConstExpr
a ConstExpr -> ConstExpr -> ConstExpr
forall a. Num a => a -> a -> a
- ConstExpr
b
  (Range ConstExpr
s1 ConstExpr
a) * :: Range -> Range -> Range
* (Range ConstExpr
s2 ConstExpr
b) = ConstExpr -> ConstExpr -> Range
Range (ConstExpr
s1 ConstExpr -> ConstExpr -> ConstExpr
forall a. Num a => a -> a -> a
* ConstExpr
s2) (ConstExpr -> Range) -> ConstExpr -> Range
forall a b. (a -> b) -> a -> b
$ ConstExpr
a ConstExpr -> ConstExpr -> ConstExpr
forall a. Num a => a -> a -> a
* ConstExpr
b
  negate :: Range -> Range
negate = Range -> Range
forall a. HasCallStack => a
undefined
  abs :: Range -> Range
abs = Range -> Range
forall a. a -> a
id
  signum :: Range -> Range
signum Range
_ = Range
1
  fromInteger :: Integer -> Range
fromInteger = (ConstExpr -> ConstExpr -> Range)
-> ConstExpr -> ConstExpr -> Range
forall a b c. (a -> b -> c) -> b -> a -> c
flip ConstExpr -> ConstExpr -> Range
Range ConstExpr
0 (ConstExpr -> Range) -> (Integer -> ConstExpr) -> Integer -> Range
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> ConstExpr
forall a. Num a => Integer -> a
fromInteger (Integer -> ConstExpr)
-> (Integer -> Integer) -> Integer -> ConstExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (-) Integer
1

-- | Verilog expression, which can either be a primary expression, unary
-- expression, binary operator expression or a conditional expression.
data Expr
  = Number {-# UNPACK #-} !BitVec
  | Id {-# UNPACK #-} !Identifier
  | VecSelect {-# UNPACK #-} !Identifier !Expr
  | RangeSelect {-# UNPACK #-} !Identifier !Range
  | Concat !(NonEmpty Expr)
  | UnOp !UnaryOperator !Expr
  | BinOp !Expr !BinaryOperator !Expr
  | Cond !Expr !Expr !Expr
  | Appl !Identifier !Expr
  | Str {-# UNPACK #-} !Text
  deriving (Expr -> Expr -> Bool
(Expr -> Expr -> Bool) -> (Expr -> Expr -> Bool) -> Eq Expr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Expr -> Expr -> Bool
== :: Expr -> Expr -> Bool
$c/= :: Expr -> Expr -> Bool
/= :: Expr -> Expr -> Bool
Eq, Int -> Expr -> ShowS
[Expr] -> ShowS
Expr -> String
(Int -> Expr -> ShowS)
-> (Expr -> String) -> ([Expr] -> ShowS) -> Show Expr
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Expr -> ShowS
showsPrec :: Int -> Expr -> ShowS
$cshow :: Expr -> String
show :: Expr -> String
$cshowList :: [Expr] -> ShowS
showList :: [Expr] -> ShowS
Show, Eq Expr
Eq Expr =>
(Expr -> Expr -> Ordering)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Bool)
-> (Expr -> Expr -> Expr)
-> (Expr -> Expr -> Expr)
-> Ord Expr
Expr -> Expr -> Bool
Expr -> Expr -> Ordering
Expr -> Expr -> Expr
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Expr -> Expr -> Ordering
compare :: Expr -> Expr -> Ordering
$c< :: Expr -> Expr -> Bool
< :: Expr -> Expr -> Bool
$c<= :: Expr -> Expr -> Bool
<= :: Expr -> Expr -> Bool
$c> :: Expr -> Expr -> Bool
> :: Expr -> Expr -> Bool
$c>= :: Expr -> Expr -> Bool
>= :: Expr -> Expr -> Bool
$cmax :: Expr -> Expr -> Expr
max :: Expr -> Expr -> Expr
$cmin :: Expr -> Expr -> Expr
min :: Expr -> Expr -> Expr
Ord, Typeable Expr
Typeable Expr =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Expr -> c Expr)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Expr)
-> (Expr -> Constr)
-> (Expr -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Expr))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr))
-> ((forall b. Data b => b -> b) -> Expr -> Expr)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
-> (forall u. (forall d. Data d => d -> u) -> Expr -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr)
-> Data Expr
Expr -> Constr
Expr -> DataType
(forall b. Data b => b -> b) -> Expr -> Expr
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
forall u. (forall d. Data d => d -> u) -> Expr -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Expr -> c Expr
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Expr
$ctoConstr :: Expr -> Constr
toConstr :: Expr -> Constr
$cdataTypeOf :: Expr -> DataType
dataTypeOf :: Expr -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Expr)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
$cgmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
gmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Expr -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Expr -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Expr -> m Expr
Data, (forall x. Expr -> Rep Expr x)
-> (forall x. Rep Expr x -> Expr) -> Generic Expr
forall x. Rep Expr x -> Expr
forall x. Expr -> Rep Expr x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Expr -> Rep Expr x
from :: forall x. Expr -> Rep Expr x
$cto :: forall x. Rep Expr x -> Expr
to :: forall x. Rep Expr x -> Expr
Generic, Expr -> ()
(Expr -> ()) -> NFData Expr
forall a. (a -> ()) -> NFData a
$crnf :: Expr -> ()
rnf :: Expr -> ()
NFData)

$(makeLenses ''Expr)
$(makePrisms ''Expr)

$(makeBaseFunctor ''Expr)

instance Num Expr where
  Expr
a + :: Expr -> Expr -> Expr
+ Expr
b = Expr -> BinaryOperator -> Expr -> Expr
BinOp Expr
a BinaryOperator
BinPlus Expr
b
  Expr
a - :: Expr -> Expr -> Expr
- Expr
b = Expr -> BinaryOperator -> Expr -> Expr
BinOp Expr
a BinaryOperator
BinMinus Expr
b
  Expr
a * :: Expr -> Expr -> Expr
* Expr
b = Expr -> BinaryOperator -> Expr -> Expr
BinOp Expr
a BinaryOperator
BinTimes Expr
b
  negate :: Expr -> Expr
negate = UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnMinus
  abs :: Expr -> Expr
abs = Expr -> Expr
forall a. HasCallStack => a
undefined
  signum :: Expr -> Expr
signum = Expr -> Expr
forall a. HasCallStack => a
undefined
  fromInteger :: Integer -> Expr
fromInteger = BitVec -> Expr
Number (BitVec -> Expr) -> (Integer -> BitVec) -> Integer -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> BitVec
forall a. Num a => Integer -> a
fromInteger

instance Semigroup Expr where
  (Concat NonEmpty Expr
a) <> :: Expr -> Expr -> Expr
<> (Concat NonEmpty Expr
b) = NonEmpty Expr -> Expr
Concat (NonEmpty Expr -> Expr) -> NonEmpty Expr -> Expr
forall a b. (a -> b) -> a -> b
$ NonEmpty Expr
a NonEmpty Expr -> NonEmpty Expr -> NonEmpty Expr
forall a. Semigroup a => a -> a -> a
<> NonEmpty Expr
b
  (Concat NonEmpty Expr
a) <> Expr
b = NonEmpty Expr -> Expr
Concat (NonEmpty Expr -> Expr) -> NonEmpty Expr -> Expr
forall a b. (a -> b) -> a -> b
$ NonEmpty Expr
a NonEmpty Expr -> NonEmpty Expr -> NonEmpty Expr
forall a. Semigroup a => a -> a -> a
<> (Expr
b Expr -> [Expr] -> NonEmpty Expr
forall a. a -> [a] -> NonEmpty a
:| [])
  Expr
a <> (Concat NonEmpty Expr
b) = NonEmpty Expr -> Expr
Concat (NonEmpty Expr -> Expr) -> NonEmpty Expr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr
a Expr -> NonEmpty Expr -> NonEmpty Expr
forall a. a -> NonEmpty a -> NonEmpty a
<| NonEmpty Expr
b
  Expr
a <> Expr
b = NonEmpty Expr -> Expr
Concat (NonEmpty Expr -> Expr) -> NonEmpty Expr -> Expr
forall a b. (a -> b) -> a -> b
$ Expr
a Expr -> NonEmpty Expr -> NonEmpty Expr
forall a. a -> NonEmpty a -> NonEmpty a
<| Expr
b Expr -> [Expr] -> NonEmpty Expr
forall a. a -> [a] -> NonEmpty a
:| []

instance Monoid Expr where
  mempty :: Expr
mempty = BitVec -> Expr
Number BitVec
0

instance IsString Expr where
  fromString :: String -> Expr
fromString = Text -> Expr
Str (Text -> Expr) -> (String -> Text) -> String -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
forall a. IsString a => String -> a
fromString

instance Plated Expr where
  plate :: Traversal' Expr Expr
plate = (Expr -> f Expr) -> Expr -> f Expr
forall a. Data a => Traversal' a a
Traversal' Expr Expr
uniplate

-- | Verilog syntax for an event, such as @\@x@, which is used for always blocks
data Event
  = EId {-# UNPACK #-} !Identifier
  | EExpr !Expr
  | EAll
  | EPosEdge {-# UNPACK #-} !Identifier
  | ENegEdge {-# UNPACK #-} !Identifier
  | EOr !Event !Event
  | EComb !Event !Event
  deriving (Event -> Event -> Bool
(Event -> Event -> Bool) -> (Event -> Event -> Bool) -> Eq Event
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Event -> Event -> Bool
== :: Event -> Event -> Bool
$c/= :: Event -> Event -> Bool
/= :: Event -> Event -> Bool
Eq, Int -> Event -> ShowS
[Event] -> ShowS
Event -> String
(Int -> Event -> ShowS)
-> (Event -> String) -> ([Event] -> ShowS) -> Show Event
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Event -> ShowS
showsPrec :: Int -> Event -> ShowS
$cshow :: Event -> String
show :: Event -> String
$cshowList :: [Event] -> ShowS
showList :: [Event] -> ShowS
Show, Eq Event
Eq Event =>
(Event -> Event -> Ordering)
-> (Event -> Event -> Bool)
-> (Event -> Event -> Bool)
-> (Event -> Event -> Bool)
-> (Event -> Event -> Bool)
-> (Event -> Event -> Event)
-> (Event -> Event -> Event)
-> Ord Event
Event -> Event -> Bool
Event -> Event -> Ordering
Event -> Event -> Event
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Event -> Event -> Ordering
compare :: Event -> Event -> Ordering
$c< :: Event -> Event -> Bool
< :: Event -> Event -> Bool
$c<= :: Event -> Event -> Bool
<= :: Event -> Event -> Bool
$c> :: Event -> Event -> Bool
> :: Event -> Event -> Bool
$c>= :: Event -> Event -> Bool
>= :: Event -> Event -> Bool
$cmax :: Event -> Event -> Event
max :: Event -> Event -> Event
$cmin :: Event -> Event -> Event
min :: Event -> Event -> Event
Ord, Typeable Event
Typeable Event =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Event -> c Event)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Event)
-> (Event -> Constr)
-> (Event -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Event))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Event))
-> ((forall b. Data b => b -> b) -> Event -> Event)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Event -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Event -> r)
-> (forall u. (forall d. Data d => d -> u) -> Event -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Event -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Event -> m Event)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Event -> m Event)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Event -> m Event)
-> Data Event
Event -> Constr
Event -> DataType
(forall b. Data b => b -> b) -> Event -> Event
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Event -> u
forall u. (forall d. Data d => d -> u) -> Event -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Event -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Event -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Event -> m Event
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Event -> m Event
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Event
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Event -> c Event
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Event)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Event)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Event -> c Event
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Event -> c Event
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Event
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Event
$ctoConstr :: Event -> Constr
toConstr :: Event -> Constr
$cdataTypeOf :: Event -> DataType
dataTypeOf :: Event -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Event)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Event)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Event)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Event)
$cgmapT :: (forall b. Data b => b -> b) -> Event -> Event
gmapT :: (forall b. Data b => b -> b) -> Event -> Event
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Event -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Event -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Event -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Event -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Event -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Event -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Event -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Event -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Event -> m Event
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Event -> m Event
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Event -> m Event
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Event -> m Event
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Event -> m Event
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Event -> m Event
Data, (forall x. Event -> Rep Event x)
-> (forall x. Rep Event x -> Event) -> Generic Event
forall x. Rep Event x -> Event
forall x. Event -> Rep Event x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Event -> Rep Event x
from :: forall x. Event -> Rep Event x
$cto :: forall x. Rep Event x -> Event
to :: forall x. Rep Event x -> Event
Generic, Event -> ()
(Event -> ()) -> NFData Event
forall a. (a -> ()) -> NFData a
$crnf :: Event -> ()
rnf :: Event -> ()
NFData)

$(makeBaseFunctor ''Event)

instance Plated Event where
  plate :: Traversal' Event Event
plate = (Event -> f Event) -> Event -> f Event
forall a. Data a => Traversal' a a
Traversal' Event Event
uniplate

-- | Task call, which is similar to function calls.
data Task = Task
  { Task -> Identifier
_taskName :: {-# UNPACK #-} !Identifier,
    Task -> [Expr]
_taskExpr :: [Expr]
  }
  deriving (Task -> Task -> Bool
(Task -> Task -> Bool) -> (Task -> Task -> Bool) -> Eq Task
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Task -> Task -> Bool
== :: Task -> Task -> Bool
$c/= :: Task -> Task -> Bool
/= :: Task -> Task -> Bool
Eq, Int -> Task -> ShowS
[Task] -> ShowS
Task -> String
(Int -> Task -> ShowS)
-> (Task -> String) -> ([Task] -> ShowS) -> Show Task
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Task -> ShowS
showsPrec :: Int -> Task -> ShowS
$cshow :: Task -> String
show :: Task -> String
$cshowList :: [Task] -> ShowS
showList :: [Task] -> ShowS
Show, Eq Task
Eq Task =>
(Task -> Task -> Ordering)
-> (Task -> Task -> Bool)
-> (Task -> Task -> Bool)
-> (Task -> Task -> Bool)
-> (Task -> Task -> Bool)
-> (Task -> Task -> Task)
-> (Task -> Task -> Task)
-> Ord Task
Task -> Task -> Bool
Task -> Task -> Ordering
Task -> Task -> Task
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Task -> Task -> Ordering
compare :: Task -> Task -> Ordering
$c< :: Task -> Task -> Bool
< :: Task -> Task -> Bool
$c<= :: Task -> Task -> Bool
<= :: Task -> Task -> Bool
$c> :: Task -> Task -> Bool
> :: Task -> Task -> Bool
$c>= :: Task -> Task -> Bool
>= :: Task -> Task -> Bool
$cmax :: Task -> Task -> Task
max :: Task -> Task -> Task
$cmin :: Task -> Task -> Task
min :: Task -> Task -> Task
Ord, Typeable Task
Typeable Task =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Task -> c Task)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Task)
-> (Task -> Constr)
-> (Task -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Task))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Task))
-> ((forall b. Data b => b -> b) -> Task -> Task)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Task -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Task -> r)
-> (forall u. (forall d. Data d => d -> u) -> Task -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Task -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Task -> m Task)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Task -> m Task)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Task -> m Task)
-> Data Task
Task -> Constr
Task -> DataType
(forall b. Data b => b -> b) -> Task -> Task
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Task -> u
forall u. (forall d. Data d => d -> u) -> Task -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Task -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Task -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Task -> m Task
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Task -> m Task
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Task
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Task -> c Task
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Task)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Task)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Task -> c Task
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Task -> c Task
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Task
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Task
$ctoConstr :: Task -> Constr
toConstr :: Task -> Constr
$cdataTypeOf :: Task -> DataType
dataTypeOf :: Task -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Task)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Task)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Task)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Task)
$cgmapT :: (forall b. Data b => b -> b) -> Task -> Task
gmapT :: (forall b. Data b => b -> b) -> Task -> Task
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Task -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Task -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Task -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Task -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Task -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Task -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Task -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Task -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Task -> m Task
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Task -> m Task
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Task -> m Task
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Task -> m Task
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Task -> m Task
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Task -> m Task
Data, (forall x. Task -> Rep Task x)
-> (forall x. Rep Task x -> Task) -> Generic Task
forall x. Rep Task x -> Task
forall x. Task -> Rep Task x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Task -> Rep Task x
from :: forall x. Task -> Rep Task x
$cto :: forall x. Rep Task x -> Task
to :: forall x. Rep Task x -> Task
Generic, Task -> ()
(Task -> ()) -> NFData Task
forall a. (a -> ()) -> NFData a
$crnf :: Task -> ()
rnf :: Task -> ()
NFData)

$(makeLenses ''Task)

-- | Type that represents the left hand side of an assignment, which can be a
-- concatenation such as in:
--
-- @
-- {a, b, c} = 32'h94238;
-- @
data LVal
  = RegId
      { LVal -> Identifier
_regId :: {-# UNPACK #-} !Identifier
      }
  | RegExpr
      { LVal -> Identifier
_regExprId :: {-# UNPACK #-} !Identifier,
        LVal -> Expr
_regExpr :: !Expr
      }
  | RegSize
      { LVal -> Identifier
_regSizeId :: {-# UNPACK #-} !Identifier,
        LVal -> Range
_regSizeRange :: {-# UNPACK #-} !Range
      }
  | RegConcat
      { LVal -> [Expr]
_regConc :: [Expr]
      }
  deriving (LVal -> LVal -> Bool
(LVal -> LVal -> Bool) -> (LVal -> LVal -> Bool) -> Eq LVal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LVal -> LVal -> Bool
== :: LVal -> LVal -> Bool
$c/= :: LVal -> LVal -> Bool
/= :: LVal -> LVal -> Bool
Eq, Int -> LVal -> ShowS
[LVal] -> ShowS
LVal -> String
(Int -> LVal -> ShowS)
-> (LVal -> String) -> ([LVal] -> ShowS) -> Show LVal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LVal -> ShowS
showsPrec :: Int -> LVal -> ShowS
$cshow :: LVal -> String
show :: LVal -> String
$cshowList :: [LVal] -> ShowS
showList :: [LVal] -> ShowS
Show, Eq LVal
Eq LVal =>
(LVal -> LVal -> Ordering)
-> (LVal -> LVal -> Bool)
-> (LVal -> LVal -> Bool)
-> (LVal -> LVal -> Bool)
-> (LVal -> LVal -> Bool)
-> (LVal -> LVal -> LVal)
-> (LVal -> LVal -> LVal)
-> Ord LVal
LVal -> LVal -> Bool
LVal -> LVal -> Ordering
LVal -> LVal -> LVal
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LVal -> LVal -> Ordering
compare :: LVal -> LVal -> Ordering
$c< :: LVal -> LVal -> Bool
< :: LVal -> LVal -> Bool
$c<= :: LVal -> LVal -> Bool
<= :: LVal -> LVal -> Bool
$c> :: LVal -> LVal -> Bool
> :: LVal -> LVal -> Bool
$c>= :: LVal -> LVal -> Bool
>= :: LVal -> LVal -> Bool
$cmax :: LVal -> LVal -> LVal
max :: LVal -> LVal -> LVal
$cmin :: LVal -> LVal -> LVal
min :: LVal -> LVal -> LVal
Ord, Typeable LVal
Typeable LVal =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LVal -> c LVal)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LVal)
-> (LVal -> Constr)
-> (LVal -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LVal))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LVal))
-> ((forall b. Data b => b -> b) -> LVal -> LVal)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LVal -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LVal -> r)
-> (forall u. (forall d. Data d => d -> u) -> LVal -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> LVal -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LVal -> m LVal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LVal -> m LVal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LVal -> m LVal)
-> Data LVal
LVal -> Constr
LVal -> DataType
(forall b. Data b => b -> b) -> LVal -> LVal
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> LVal -> u
forall u. (forall d. Data d => d -> u) -> LVal -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LVal -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LVal -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LVal -> m LVal
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LVal -> m LVal
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LVal
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LVal -> c LVal
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LVal)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LVal)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LVal -> c LVal
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LVal -> c LVal
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LVal
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LVal
$ctoConstr :: LVal -> Constr
toConstr :: LVal -> Constr
$cdataTypeOf :: LVal -> DataType
dataTypeOf :: LVal -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LVal)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LVal)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LVal)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LVal)
$cgmapT :: (forall b. Data b => b -> b) -> LVal -> LVal
gmapT :: (forall b. Data b => b -> b) -> LVal -> LVal
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LVal -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LVal -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LVal -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LVal -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LVal -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LVal -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LVal -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LVal -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LVal -> m LVal
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LVal -> m LVal
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LVal -> m LVal
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LVal -> m LVal
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LVal -> m LVal
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LVal -> m LVal
Data, (forall x. LVal -> Rep LVal x)
-> (forall x. Rep LVal x -> LVal) -> Generic LVal
forall x. Rep LVal x -> LVal
forall x. LVal -> Rep LVal x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LVal -> Rep LVal x
from :: forall x. LVal -> Rep LVal x
$cto :: forall x. Rep LVal x -> LVal
to :: forall x. Rep LVal x -> LVal
Generic, LVal -> ()
(LVal -> ()) -> NFData LVal
forall a. (a -> ()) -> NFData a
$crnf :: LVal -> ()
rnf :: LVal -> ()
NFData)

$(makeLenses ''LVal)

instance IsString LVal where
  fromString :: String -> LVal
fromString = Identifier -> LVal
RegId (Identifier -> LVal) -> (String -> Identifier) -> String -> LVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Identifier
forall a. IsString a => String -> a
fromString

-- | Different port direction that are supported in Verilog.
data PortDir
  = PortIn
  | PortOut
  | PortInOut
  deriving (PortDir -> PortDir -> Bool
(PortDir -> PortDir -> Bool)
-> (PortDir -> PortDir -> Bool) -> Eq PortDir
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PortDir -> PortDir -> Bool
== :: PortDir -> PortDir -> Bool
$c/= :: PortDir -> PortDir -> Bool
/= :: PortDir -> PortDir -> Bool
Eq, Int -> PortDir -> ShowS
[PortDir] -> ShowS
PortDir -> String
(Int -> PortDir -> ShowS)
-> (PortDir -> String) -> ([PortDir] -> ShowS) -> Show PortDir
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PortDir -> ShowS
showsPrec :: Int -> PortDir -> ShowS
$cshow :: PortDir -> String
show :: PortDir -> String
$cshowList :: [PortDir] -> ShowS
showList :: [PortDir] -> ShowS
Show, Eq PortDir
Eq PortDir =>
(PortDir -> PortDir -> Ordering)
-> (PortDir -> PortDir -> Bool)
-> (PortDir -> PortDir -> Bool)
-> (PortDir -> PortDir -> Bool)
-> (PortDir -> PortDir -> Bool)
-> (PortDir -> PortDir -> PortDir)
-> (PortDir -> PortDir -> PortDir)
-> Ord PortDir
PortDir -> PortDir -> Bool
PortDir -> PortDir -> Ordering
PortDir -> PortDir -> PortDir
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PortDir -> PortDir -> Ordering
compare :: PortDir -> PortDir -> Ordering
$c< :: PortDir -> PortDir -> Bool
< :: PortDir -> PortDir -> Bool
$c<= :: PortDir -> PortDir -> Bool
<= :: PortDir -> PortDir -> Bool
$c> :: PortDir -> PortDir -> Bool
> :: PortDir -> PortDir -> Bool
$c>= :: PortDir -> PortDir -> Bool
>= :: PortDir -> PortDir -> Bool
$cmax :: PortDir -> PortDir -> PortDir
max :: PortDir -> PortDir -> PortDir
$cmin :: PortDir -> PortDir -> PortDir
min :: PortDir -> PortDir -> PortDir
Ord, Typeable PortDir
Typeable PortDir =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PortDir -> c PortDir)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PortDir)
-> (PortDir -> Constr)
-> (PortDir -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PortDir))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PortDir))
-> ((forall b. Data b => b -> b) -> PortDir -> PortDir)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PortDir -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PortDir -> r)
-> (forall u. (forall d. Data d => d -> u) -> PortDir -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PortDir -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PortDir -> m PortDir)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PortDir -> m PortDir)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PortDir -> m PortDir)
-> Data PortDir
PortDir -> Constr
PortDir -> DataType
(forall b. Data b => b -> b) -> PortDir -> PortDir
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PortDir -> u
forall u. (forall d. Data d => d -> u) -> PortDir -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PortDir -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PortDir -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PortDir -> m PortDir
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PortDir -> m PortDir
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PortDir
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PortDir -> c PortDir
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PortDir)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PortDir)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PortDir -> c PortDir
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PortDir -> c PortDir
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PortDir
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PortDir
$ctoConstr :: PortDir -> Constr
toConstr :: PortDir -> Constr
$cdataTypeOf :: PortDir -> DataType
dataTypeOf :: PortDir -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PortDir)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PortDir)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PortDir)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PortDir)
$cgmapT :: (forall b. Data b => b -> b) -> PortDir -> PortDir
gmapT :: (forall b. Data b => b -> b) -> PortDir -> PortDir
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PortDir -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PortDir -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PortDir -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PortDir -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PortDir -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PortDir -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PortDir -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PortDir -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PortDir -> m PortDir
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PortDir -> m PortDir
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PortDir -> m PortDir
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PortDir -> m PortDir
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PortDir -> m PortDir
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PortDir -> m PortDir
Data, (forall x. PortDir -> Rep PortDir x)
-> (forall x. Rep PortDir x -> PortDir) -> Generic PortDir
forall x. Rep PortDir x -> PortDir
forall x. PortDir -> Rep PortDir x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PortDir -> Rep PortDir x
from :: forall x. PortDir -> Rep PortDir x
$cto :: forall x. Rep PortDir x -> PortDir
to :: forall x. Rep PortDir x -> PortDir
Generic, PortDir -> ()
(PortDir -> ()) -> NFData PortDir
forall a. (a -> ()) -> NFData a
$crnf :: PortDir -> ()
rnf :: PortDir -> ()
NFData)

-- | Currently, only @wire@ and @reg@ are supported, as the other net types are
-- not that common and not a priority.
data PortType
  = Wire
  | Reg
  deriving (PortType -> PortType -> Bool
(PortType -> PortType -> Bool)
-> (PortType -> PortType -> Bool) -> Eq PortType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PortType -> PortType -> Bool
== :: PortType -> PortType -> Bool
$c/= :: PortType -> PortType -> Bool
/= :: PortType -> PortType -> Bool
Eq, Int -> PortType -> ShowS
[PortType] -> ShowS
PortType -> String
(Int -> PortType -> ShowS)
-> (PortType -> String) -> ([PortType] -> ShowS) -> Show PortType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PortType -> ShowS
showsPrec :: Int -> PortType -> ShowS
$cshow :: PortType -> String
show :: PortType -> String
$cshowList :: [PortType] -> ShowS
showList :: [PortType] -> ShowS
Show, Eq PortType
Eq PortType =>
(PortType -> PortType -> Ordering)
-> (PortType -> PortType -> Bool)
-> (PortType -> PortType -> Bool)
-> (PortType -> PortType -> Bool)
-> (PortType -> PortType -> Bool)
-> (PortType -> PortType -> PortType)
-> (PortType -> PortType -> PortType)
-> Ord PortType
PortType -> PortType -> Bool
PortType -> PortType -> Ordering
PortType -> PortType -> PortType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PortType -> PortType -> Ordering
compare :: PortType -> PortType -> Ordering
$c< :: PortType -> PortType -> Bool
< :: PortType -> PortType -> Bool
$c<= :: PortType -> PortType -> Bool
<= :: PortType -> PortType -> Bool
$c> :: PortType -> PortType -> Bool
> :: PortType -> PortType -> Bool
$c>= :: PortType -> PortType -> Bool
>= :: PortType -> PortType -> Bool
$cmax :: PortType -> PortType -> PortType
max :: PortType -> PortType -> PortType
$cmin :: PortType -> PortType -> PortType
min :: PortType -> PortType -> PortType
Ord, Typeable PortType
Typeable PortType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PortType -> c PortType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PortType)
-> (PortType -> Constr)
-> (PortType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PortType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PortType))
-> ((forall b. Data b => b -> b) -> PortType -> PortType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PortType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PortType -> r)
-> (forall u. (forall d. Data d => d -> u) -> PortType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PortType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PortType -> m PortType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PortType -> m PortType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PortType -> m PortType)
-> Data PortType
PortType -> Constr
PortType -> DataType
(forall b. Data b => b -> b) -> PortType -> PortType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PortType -> u
forall u. (forall d. Data d => d -> u) -> PortType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PortType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PortType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PortType -> m PortType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PortType -> m PortType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PortType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PortType -> c PortType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PortType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PortType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PortType -> c PortType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PortType -> c PortType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PortType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PortType
$ctoConstr :: PortType -> Constr
toConstr :: PortType -> Constr
$cdataTypeOf :: PortType -> DataType
dataTypeOf :: PortType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PortType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PortType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PortType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PortType)
$cgmapT :: (forall b. Data b => b -> b) -> PortType -> PortType
gmapT :: (forall b. Data b => b -> b) -> PortType -> PortType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PortType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PortType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PortType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PortType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PortType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PortType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PortType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PortType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PortType -> m PortType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PortType -> m PortType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PortType -> m PortType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PortType -> m PortType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PortType -> m PortType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PortType -> m PortType
Data, (forall x. PortType -> Rep PortType x)
-> (forall x. Rep PortType x -> PortType) -> Generic PortType
forall x. Rep PortType x -> PortType
forall x. PortType -> Rep PortType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PortType -> Rep PortType x
from :: forall x. PortType -> Rep PortType x
$cto :: forall x. Rep PortType x -> PortType
to :: forall x. Rep PortType x -> PortType
Generic, PortType -> ()
(PortType -> ()) -> NFData PortType
forall a. (a -> ()) -> NFData a
$crnf :: PortType -> ()
rnf :: PortType -> ()
NFData)

$(makeLenses ''PortType)

-- | Port declaration. It contains information about the type of the port, the
-- size, and the port name. It used to also contain information about if it was
-- an input or output port. However, this is not always necessary and was more
-- cumbersome than useful, as a lot of ports can be declared without input and
-- output port.
--
-- This is now implemented inside '(ModDecl ann)' itself, which uses a list of output
-- and input ports.
data Port = Port
  { Port -> PortType
_portType :: !PortType,
    Port -> Bool
_portSigned :: !Bool,
    Port -> Range
_portSize :: {-# UNPACK #-} !Range,
    Port -> Identifier
_portName :: {-# UNPACK #-} !Identifier
  }
  deriving (Port -> Port -> Bool
(Port -> Port -> Bool) -> (Port -> Port -> Bool) -> Eq Port
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Port -> Port -> Bool
== :: Port -> Port -> Bool
$c/= :: Port -> Port -> Bool
/= :: Port -> Port -> Bool
Eq, Int -> Port -> ShowS
[Port] -> ShowS
Port -> String
(Int -> Port -> ShowS)
-> (Port -> String) -> ([Port] -> ShowS) -> Show Port
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Port -> ShowS
showsPrec :: Int -> Port -> ShowS
$cshow :: Port -> String
show :: Port -> String
$cshowList :: [Port] -> ShowS
showList :: [Port] -> ShowS
Show, Eq Port
Eq Port =>
(Port -> Port -> Ordering)
-> (Port -> Port -> Bool)
-> (Port -> Port -> Bool)
-> (Port -> Port -> Bool)
-> (Port -> Port -> Bool)
-> (Port -> Port -> Port)
-> (Port -> Port -> Port)
-> Ord Port
Port -> Port -> Bool
Port -> Port -> Ordering
Port -> Port -> Port
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Port -> Port -> Ordering
compare :: Port -> Port -> Ordering
$c< :: Port -> Port -> Bool
< :: Port -> Port -> Bool
$c<= :: Port -> Port -> Bool
<= :: Port -> Port -> Bool
$c> :: Port -> Port -> Bool
> :: Port -> Port -> Bool
$c>= :: Port -> Port -> Bool
>= :: Port -> Port -> Bool
$cmax :: Port -> Port -> Port
max :: Port -> Port -> Port
$cmin :: Port -> Port -> Port
min :: Port -> Port -> Port
Ord, Typeable Port
Typeable Port =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Port -> c Port)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Port)
-> (Port -> Constr)
-> (Port -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Port))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Port))
-> ((forall b. Data b => b -> b) -> Port -> Port)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Port -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Port -> r)
-> (forall u. (forall d. Data d => d -> u) -> Port -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Port -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Port -> m Port)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Port -> m Port)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Port -> m Port)
-> Data Port
Port -> Constr
Port -> DataType
(forall b. Data b => b -> b) -> Port -> Port
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Port -> u
forall u. (forall d. Data d => d -> u) -> Port -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Port -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Port -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Port -> m Port
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Port -> m Port
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Port
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Port -> c Port
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Port)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Port)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Port -> c Port
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Port -> c Port
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Port
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Port
$ctoConstr :: Port -> Constr
toConstr :: Port -> Constr
$cdataTypeOf :: Port -> DataType
dataTypeOf :: Port -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Port)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Port)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Port)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Port)
$cgmapT :: (forall b. Data b => b -> b) -> Port -> Port
gmapT :: (forall b. Data b => b -> b) -> Port -> Port
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Port -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Port -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Port -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Port -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Port -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Port -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Port -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Port -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Port -> m Port
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Port -> m Port
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Port -> m Port
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Port -> m Port
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Port -> m Port
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Port -> m Port
Data, (forall x. Port -> Rep Port x)
-> (forall x. Rep Port x -> Port) -> Generic Port
forall x. Rep Port x -> Port
forall x. Port -> Rep Port x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Port -> Rep Port x
from :: forall x. Port -> Rep Port x
$cto :: forall x. Rep Port x -> Port
to :: forall x. Rep Port x -> Port
Generic, Port -> ()
(Port -> ()) -> NFData Port
forall a. (a -> ()) -> NFData a
$crnf :: Port -> ()
rnf :: Port -> ()
NFData)

$(makeLenses ''Port)

-- | This is currently a type because direct module declaration should also be
-- added:
--
-- @
-- mod a(.y(y1), .x1(x11), .x2(x22));
-- @
data ModConn
  = ModConn
      { ModConn -> Expr
_modExpr :: !Expr
      }
  | ModConnNamed
      { ModConn -> Identifier
_modConnName :: {-# UNPACK #-} !Identifier,
        _modExpr :: !Expr
      }
  deriving (ModConn -> ModConn -> Bool
(ModConn -> ModConn -> Bool)
-> (ModConn -> ModConn -> Bool) -> Eq ModConn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModConn -> ModConn -> Bool
== :: ModConn -> ModConn -> Bool
$c/= :: ModConn -> ModConn -> Bool
/= :: ModConn -> ModConn -> Bool
Eq, Int -> ModConn -> ShowS
[ModConn] -> ShowS
ModConn -> String
(Int -> ModConn -> ShowS)
-> (ModConn -> String) -> ([ModConn] -> ShowS) -> Show ModConn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ModConn -> ShowS
showsPrec :: Int -> ModConn -> ShowS
$cshow :: ModConn -> String
show :: ModConn -> String
$cshowList :: [ModConn] -> ShowS
showList :: [ModConn] -> ShowS
Show, Eq ModConn
Eq ModConn =>
(ModConn -> ModConn -> Ordering)
-> (ModConn -> ModConn -> Bool)
-> (ModConn -> ModConn -> Bool)
-> (ModConn -> ModConn -> Bool)
-> (ModConn -> ModConn -> Bool)
-> (ModConn -> ModConn -> ModConn)
-> (ModConn -> ModConn -> ModConn)
-> Ord ModConn
ModConn -> ModConn -> Bool
ModConn -> ModConn -> Ordering
ModConn -> ModConn -> ModConn
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ModConn -> ModConn -> Ordering
compare :: ModConn -> ModConn -> Ordering
$c< :: ModConn -> ModConn -> Bool
< :: ModConn -> ModConn -> Bool
$c<= :: ModConn -> ModConn -> Bool
<= :: ModConn -> ModConn -> Bool
$c> :: ModConn -> ModConn -> Bool
> :: ModConn -> ModConn -> Bool
$c>= :: ModConn -> ModConn -> Bool
>= :: ModConn -> ModConn -> Bool
$cmax :: ModConn -> ModConn -> ModConn
max :: ModConn -> ModConn -> ModConn
$cmin :: ModConn -> ModConn -> ModConn
min :: ModConn -> ModConn -> ModConn
Ord, Typeable ModConn
Typeable ModConn =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModConn -> c ModConn)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModConn)
-> (ModConn -> Constr)
-> (ModConn -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModConn))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModConn))
-> ((forall b. Data b => b -> b) -> ModConn -> ModConn)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModConn -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModConn -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModConn -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ModConn -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModConn -> m ModConn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModConn -> m ModConn)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModConn -> m ModConn)
-> Data ModConn
ModConn -> Constr
ModConn -> DataType
(forall b. Data b => b -> b) -> ModConn -> ModConn
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ModConn -> u
forall u. (forall d. Data d => d -> u) -> ModConn -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModConn -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModConn -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModConn -> m ModConn
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModConn -> m ModConn
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModConn
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModConn -> c ModConn
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModConn)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModConn)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModConn -> c ModConn
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModConn -> c ModConn
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModConn
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModConn
$ctoConstr :: ModConn -> Constr
toConstr :: ModConn -> Constr
$cdataTypeOf :: ModConn -> DataType
dataTypeOf :: ModConn -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModConn)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModConn)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModConn)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModConn)
$cgmapT :: (forall b. Data b => b -> b) -> ModConn -> ModConn
gmapT :: (forall b. Data b => b -> b) -> ModConn -> ModConn
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModConn -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModConn -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModConn -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModConn -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModConn -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModConn -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModConn -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModConn -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModConn -> m ModConn
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModConn -> m ModConn
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModConn -> m ModConn
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModConn -> m ModConn
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModConn -> m ModConn
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModConn -> m ModConn
Data, (forall x. ModConn -> Rep ModConn x)
-> (forall x. Rep ModConn x -> ModConn) -> Generic ModConn
forall x. Rep ModConn x -> ModConn
forall x. ModConn -> Rep ModConn x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ModConn -> Rep ModConn x
from :: forall x. ModConn -> Rep ModConn x
$cto :: forall x. Rep ModConn x -> ModConn
to :: forall x. Rep ModConn x -> ModConn
Generic, ModConn -> ()
(ModConn -> ()) -> NFData ModConn
forall a. (a -> ()) -> NFData a
$crnf :: ModConn -> ()
rnf :: ModConn -> ()
NFData)

$(makeLenses ''ModConn)

data Assign = Assign
  { Assign -> LVal
_assignReg :: !LVal,
    Assign -> Maybe Delay
_assignDelay :: !(Maybe Delay),
    Assign -> Expr
_assignExpr :: !Expr
  }
  deriving (Assign -> Assign -> Bool
(Assign -> Assign -> Bool)
-> (Assign -> Assign -> Bool) -> Eq Assign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Assign -> Assign -> Bool
== :: Assign -> Assign -> Bool
$c/= :: Assign -> Assign -> Bool
/= :: Assign -> Assign -> Bool
Eq, Int -> Assign -> ShowS
[Assign] -> ShowS
Assign -> String
(Int -> Assign -> ShowS)
-> (Assign -> String) -> ([Assign] -> ShowS) -> Show Assign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Assign -> ShowS
showsPrec :: Int -> Assign -> ShowS
$cshow :: Assign -> String
show :: Assign -> String
$cshowList :: [Assign] -> ShowS
showList :: [Assign] -> ShowS
Show, Eq Assign
Eq Assign =>
(Assign -> Assign -> Ordering)
-> (Assign -> Assign -> Bool)
-> (Assign -> Assign -> Bool)
-> (Assign -> Assign -> Bool)
-> (Assign -> Assign -> Bool)
-> (Assign -> Assign -> Assign)
-> (Assign -> Assign -> Assign)
-> Ord Assign
Assign -> Assign -> Bool
Assign -> Assign -> Ordering
Assign -> Assign -> Assign
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Assign -> Assign -> Ordering
compare :: Assign -> Assign -> Ordering
$c< :: Assign -> Assign -> Bool
< :: Assign -> Assign -> Bool
$c<= :: Assign -> Assign -> Bool
<= :: Assign -> Assign -> Bool
$c> :: Assign -> Assign -> Bool
> :: Assign -> Assign -> Bool
$c>= :: Assign -> Assign -> Bool
>= :: Assign -> Assign -> Bool
$cmax :: Assign -> Assign -> Assign
max :: Assign -> Assign -> Assign
$cmin :: Assign -> Assign -> Assign
min :: Assign -> Assign -> Assign
Ord, Typeable Assign
Typeable Assign =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Assign -> c Assign)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Assign)
-> (Assign -> Constr)
-> (Assign -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Assign))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assign))
-> ((forall b. Data b => b -> b) -> Assign -> Assign)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Assign -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Assign -> r)
-> (forall u. (forall d. Data d => d -> u) -> Assign -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Assign -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Assign -> m Assign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Assign -> m Assign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Assign -> m Assign)
-> Data Assign
Assign -> Constr
Assign -> DataType
(forall b. Data b => b -> b) -> Assign -> Assign
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Assign -> u
forall u. (forall d. Data d => d -> u) -> Assign -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assign
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assign -> c Assign
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Assign)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assign)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assign -> c Assign
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Assign -> c Assign
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assign
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Assign
$ctoConstr :: Assign -> Constr
toConstr :: Assign -> Constr
$cdataTypeOf :: Assign -> DataType
dataTypeOf :: Assign -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Assign)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Assign)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assign)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Assign)
$cgmapT :: (forall b. Data b => b -> b) -> Assign -> Assign
gmapT :: (forall b. Data b => b -> b) -> Assign -> Assign
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Assign -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Assign -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Assign -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Assign -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Assign -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Assign -> m Assign
Data, (forall x. Assign -> Rep Assign x)
-> (forall x. Rep Assign x -> Assign) -> Generic Assign
forall x. Rep Assign x -> Assign
forall x. Assign -> Rep Assign x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Assign -> Rep Assign x
from :: forall x. Assign -> Rep Assign x
$cto :: forall x. Rep Assign x -> Assign
to :: forall x. Rep Assign x -> Assign
Generic, Assign -> ()
(Assign -> ()) -> NFData Assign
forall a. (a -> ()) -> NFData a
$crnf :: Assign -> ()
rnf :: Assign -> ()
NFData)

$(makeLenses ''Assign)

-- | Type for continuous assignment.
--
-- @
-- assign x = 2'b1;
-- @
data ContAssign = ContAssign
  { ContAssign -> Identifier
_contAssignNetLVal :: {-# UNPACK #-} !Identifier,
    ContAssign -> Expr
_contAssignExpr :: !Expr
  }
  deriving (ContAssign -> ContAssign -> Bool
(ContAssign -> ContAssign -> Bool)
-> (ContAssign -> ContAssign -> Bool) -> Eq ContAssign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ContAssign -> ContAssign -> Bool
== :: ContAssign -> ContAssign -> Bool
$c/= :: ContAssign -> ContAssign -> Bool
/= :: ContAssign -> ContAssign -> Bool
Eq, Int -> ContAssign -> ShowS
[ContAssign] -> ShowS
ContAssign -> String
(Int -> ContAssign -> ShowS)
-> (ContAssign -> String)
-> ([ContAssign] -> ShowS)
-> Show ContAssign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ContAssign -> ShowS
showsPrec :: Int -> ContAssign -> ShowS
$cshow :: ContAssign -> String
show :: ContAssign -> String
$cshowList :: [ContAssign] -> ShowS
showList :: [ContAssign] -> ShowS
Show, Eq ContAssign
Eq ContAssign =>
(ContAssign -> ContAssign -> Ordering)
-> (ContAssign -> ContAssign -> Bool)
-> (ContAssign -> ContAssign -> Bool)
-> (ContAssign -> ContAssign -> Bool)
-> (ContAssign -> ContAssign -> Bool)
-> (ContAssign -> ContAssign -> ContAssign)
-> (ContAssign -> ContAssign -> ContAssign)
-> Ord ContAssign
ContAssign -> ContAssign -> Bool
ContAssign -> ContAssign -> Ordering
ContAssign -> ContAssign -> ContAssign
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ContAssign -> ContAssign -> Ordering
compare :: ContAssign -> ContAssign -> Ordering
$c< :: ContAssign -> ContAssign -> Bool
< :: ContAssign -> ContAssign -> Bool
$c<= :: ContAssign -> ContAssign -> Bool
<= :: ContAssign -> ContAssign -> Bool
$c> :: ContAssign -> ContAssign -> Bool
> :: ContAssign -> ContAssign -> Bool
$c>= :: ContAssign -> ContAssign -> Bool
>= :: ContAssign -> ContAssign -> Bool
$cmax :: ContAssign -> ContAssign -> ContAssign
max :: ContAssign -> ContAssign -> ContAssign
$cmin :: ContAssign -> ContAssign -> ContAssign
min :: ContAssign -> ContAssign -> ContAssign
Ord, Typeable ContAssign
Typeable ContAssign =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ContAssign -> c ContAssign)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ContAssign)
-> (ContAssign -> Constr)
-> (ContAssign -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ContAssign))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ContAssign))
-> ((forall b. Data b => b -> b) -> ContAssign -> ContAssign)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ContAssign -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ContAssign -> r)
-> (forall u. (forall d. Data d => d -> u) -> ContAssign -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ContAssign -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ContAssign -> m ContAssign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ContAssign -> m ContAssign)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ContAssign -> m ContAssign)
-> Data ContAssign
ContAssign -> Constr
ContAssign -> DataType
(forall b. Data b => b -> b) -> ContAssign -> ContAssign
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ContAssign -> u
forall u. (forall d. Data d => d -> u) -> ContAssign -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContAssign -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContAssign -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContAssign -> m ContAssign
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContAssign -> m ContAssign
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContAssign
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContAssign -> c ContAssign
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContAssign)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ContAssign)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContAssign -> c ContAssign
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ContAssign -> c ContAssign
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContAssign
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ContAssign
$ctoConstr :: ContAssign -> Constr
toConstr :: ContAssign -> Constr
$cdataTypeOf :: ContAssign -> DataType
dataTypeOf :: ContAssign -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContAssign)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ContAssign)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ContAssign)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ContAssign)
$cgmapT :: (forall b. Data b => b -> b) -> ContAssign -> ContAssign
gmapT :: (forall b. Data b => b -> b) -> ContAssign -> ContAssign
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContAssign -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ContAssign -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContAssign -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ContAssign -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ContAssign -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ContAssign -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ContAssign -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ContAssign -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContAssign -> m ContAssign
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ContAssign -> m ContAssign
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContAssign -> m ContAssign
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContAssign -> m ContAssign
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContAssign -> m ContAssign
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ContAssign -> m ContAssign
Data, (forall x. ContAssign -> Rep ContAssign x)
-> (forall x. Rep ContAssign x -> ContAssign) -> Generic ContAssign
forall x. Rep ContAssign x -> ContAssign
forall x. ContAssign -> Rep ContAssign x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ContAssign -> Rep ContAssign x
from :: forall x. ContAssign -> Rep ContAssign x
$cto :: forall x. Rep ContAssign x -> ContAssign
to :: forall x. Rep ContAssign x -> ContAssign
Generic, ContAssign -> ()
(ContAssign -> ()) -> NFData ContAssign
forall a. (a -> ()) -> NFData a
$crnf :: ContAssign -> ()
rnf :: ContAssign -> ()
NFData)

$(makeLenses ''ContAssign)

-- | Case pair which contains an expression followed by a statement which will
-- get executed if the expression matches the expression in the case statement.
data CasePair a = CasePair
  { forall a. CasePair a -> Expr
_casePairExpr :: !Expr,
    forall a. CasePair a -> Statement a
_casePairStmnt :: !(Statement a)
  }
  deriving (CasePair a -> CasePair a -> Bool
(CasePair a -> CasePair a -> Bool)
-> (CasePair a -> CasePair a -> Bool) -> Eq (CasePair a)
forall a. Eq a => CasePair a -> CasePair a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => CasePair a -> CasePair a -> Bool
== :: CasePair a -> CasePair a -> Bool
$c/= :: forall a. Eq a => CasePair a -> CasePair a -> Bool
/= :: CasePair a -> CasePair a -> Bool
Eq, Int -> CasePair a -> ShowS
[CasePair a] -> ShowS
CasePair a -> String
(Int -> CasePair a -> ShowS)
-> (CasePair a -> String)
-> ([CasePair a] -> ShowS)
-> Show (CasePair a)
forall a. Show a => Int -> CasePair a -> ShowS
forall a. Show a => [CasePair a] -> ShowS
forall a. Show a => CasePair a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> CasePair a -> ShowS
showsPrec :: Int -> CasePair a -> ShowS
$cshow :: forall a. Show a => CasePair a -> String
show :: CasePair a -> String
$cshowList :: forall a. Show a => [CasePair a] -> ShowS
showList :: [CasePair a] -> ShowS
Show, Eq (CasePair a)
Eq (CasePair a) =>
(CasePair a -> CasePair a -> Ordering)
-> (CasePair a -> CasePair a -> Bool)
-> (CasePair a -> CasePair a -> Bool)
-> (CasePair a -> CasePair a -> Bool)
-> (CasePair a -> CasePair a -> Bool)
-> (CasePair a -> CasePair a -> CasePair a)
-> (CasePair a -> CasePair a -> CasePair a)
-> Ord (CasePair a)
CasePair a -> CasePair a -> Bool
CasePair a -> CasePair a -> Ordering
CasePair a -> CasePair a -> CasePair a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (CasePair a)
forall a. Ord a => CasePair a -> CasePair a -> Bool
forall a. Ord a => CasePair a -> CasePair a -> Ordering
forall a. Ord a => CasePair a -> CasePair a -> CasePair a
$ccompare :: forall a. Ord a => CasePair a -> CasePair a -> Ordering
compare :: CasePair a -> CasePair a -> Ordering
$c< :: forall a. Ord a => CasePair a -> CasePair a -> Bool
< :: CasePair a -> CasePair a -> Bool
$c<= :: forall a. Ord a => CasePair a -> CasePair a -> Bool
<= :: CasePair a -> CasePair a -> Bool
$c> :: forall a. Ord a => CasePair a -> CasePair a -> Bool
> :: CasePair a -> CasePair a -> Bool
$c>= :: forall a. Ord a => CasePair a -> CasePair a -> Bool
>= :: CasePair a -> CasePair a -> Bool
$cmax :: forall a. Ord a => CasePair a -> CasePair a -> CasePair a
max :: CasePair a -> CasePair a -> CasePair a
$cmin :: forall a. Ord a => CasePair a -> CasePair a -> CasePair a
min :: CasePair a -> CasePair a -> CasePair a
Ord, (forall a b. (a -> b) -> CasePair a -> CasePair b)
-> (forall a b. a -> CasePair b -> CasePair a) -> Functor CasePair
forall a b. a -> CasePair b -> CasePair a
forall a b. (a -> b) -> CasePair a -> CasePair b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> CasePair a -> CasePair b
fmap :: forall a b. (a -> b) -> CasePair a -> CasePair b
$c<$ :: forall a b. a -> CasePair b -> CasePair a
<$ :: forall a b. a -> CasePair b -> CasePair a
Functor, Typeable (CasePair a)
Typeable (CasePair a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CasePair a -> c (CasePair a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CasePair a))
-> (CasePair a -> Constr)
-> (CasePair a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CasePair a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CasePair a)))
-> ((forall b. Data b => b -> b) -> CasePair a -> CasePair a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CasePair a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CasePair a -> r)
-> (forall u. (forall d. Data d => d -> u) -> CasePair a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CasePair a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a))
-> Data (CasePair a)
CasePair a -> Constr
CasePair a -> DataType
(forall b. Data b => b -> b) -> CasePair a -> CasePair a
forall a. Data a => Typeable (CasePair a)
forall a. Data a => CasePair a -> Constr
forall a. Data a => CasePair a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> CasePair a -> CasePair a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CasePair a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> CasePair a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CasePair a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CasePair a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CasePair a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CasePair a -> c (CasePair a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CasePair a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CasePair a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CasePair a -> u
forall u. (forall d. Data d => d -> u) -> CasePair a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CasePair a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CasePair a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CasePair a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CasePair a -> c (CasePair a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CasePair a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CasePair a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CasePair a -> c (CasePair a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CasePair a -> c (CasePair a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CasePair a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (CasePair a)
$ctoConstr :: forall a. Data a => CasePair a -> Constr
toConstr :: CasePair a -> Constr
$cdataTypeOf :: forall a. Data a => CasePair a -> DataType
dataTypeOf :: CasePair a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (CasePair a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (CasePair a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CasePair a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (CasePair a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> CasePair a -> CasePair a
gmapT :: (forall b. Data b => b -> b) -> CasePair a -> CasePair a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CasePair a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CasePair a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CasePair a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CasePair a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> CasePair a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CasePair a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> CasePair a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CasePair a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CasePair a -> m (CasePair a)
Data, (forall x. CasePair a -> Rep (CasePair a) x)
-> (forall x. Rep (CasePair a) x -> CasePair a)
-> Generic (CasePair a)
forall x. Rep (CasePair a) x -> CasePair a
forall x. CasePair a -> Rep (CasePair a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (CasePair a) x -> CasePair a
forall a x. CasePair a -> Rep (CasePair a) x
$cfrom :: forall a x. CasePair a -> Rep (CasePair a) x
from :: forall x. CasePair a -> Rep (CasePair a) x
$cto :: forall a x. Rep (CasePair a) x -> CasePair a
to :: forall x. Rep (CasePair a) x -> CasePair a
Generic, CasePair a -> ()
(CasePair a -> ()) -> NFData (CasePair a)
forall a. NFData a => CasePair a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => CasePair a -> ()
rnf :: CasePair a -> ()
NFData)

traverseStmntCasePair ::
  (Functor f) =>
  (Statement a1 -> f (Statement a2)) ->
  CasePair a1 ->
  f (CasePair a2)
traverseStmntCasePair :: forall (f :: * -> *) a1 a2.
Functor f =>
(Statement a1 -> f (Statement a2))
-> CasePair a1 -> f (CasePair a2)
traverseStmntCasePair Statement a1 -> f (Statement a2)
f (CasePair Expr
a Statement a1
s) = Expr -> Statement a2 -> CasePair a2
forall a. Expr -> Statement a -> CasePair a
CasePair Expr
a (Statement a2 -> CasePair a2)
-> f (Statement a2) -> f (CasePair a2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Statement a1 -> f (Statement a2)
f Statement a1
s

-- | Type of case statement, which determines how it is interpreted.
data CaseType
  = CaseStandard
  | CaseX
  | CaseZ
  deriving (CaseType -> CaseType -> Bool
(CaseType -> CaseType -> Bool)
-> (CaseType -> CaseType -> Bool) -> Eq CaseType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CaseType -> CaseType -> Bool
== :: CaseType -> CaseType -> Bool
$c/= :: CaseType -> CaseType -> Bool
/= :: CaseType -> CaseType -> Bool
Eq, Int -> CaseType -> ShowS
[CaseType] -> ShowS
CaseType -> String
(Int -> CaseType -> ShowS)
-> (CaseType -> String) -> ([CaseType] -> ShowS) -> Show CaseType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CaseType -> ShowS
showsPrec :: Int -> CaseType -> ShowS
$cshow :: CaseType -> String
show :: CaseType -> String
$cshowList :: [CaseType] -> ShowS
showList :: [CaseType] -> ShowS
Show, Eq CaseType
Eq CaseType =>
(CaseType -> CaseType -> Ordering)
-> (CaseType -> CaseType -> Bool)
-> (CaseType -> CaseType -> Bool)
-> (CaseType -> CaseType -> Bool)
-> (CaseType -> CaseType -> Bool)
-> (CaseType -> CaseType -> CaseType)
-> (CaseType -> CaseType -> CaseType)
-> Ord CaseType
CaseType -> CaseType -> Bool
CaseType -> CaseType -> Ordering
CaseType -> CaseType -> CaseType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CaseType -> CaseType -> Ordering
compare :: CaseType -> CaseType -> Ordering
$c< :: CaseType -> CaseType -> Bool
< :: CaseType -> CaseType -> Bool
$c<= :: CaseType -> CaseType -> Bool
<= :: CaseType -> CaseType -> Bool
$c> :: CaseType -> CaseType -> Bool
> :: CaseType -> CaseType -> Bool
$c>= :: CaseType -> CaseType -> Bool
>= :: CaseType -> CaseType -> Bool
$cmax :: CaseType -> CaseType -> CaseType
max :: CaseType -> CaseType -> CaseType
$cmin :: CaseType -> CaseType -> CaseType
min :: CaseType -> CaseType -> CaseType
Ord, Typeable CaseType
Typeable CaseType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CaseType -> c CaseType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CaseType)
-> (CaseType -> Constr)
-> (CaseType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CaseType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseType))
-> ((forall b. Data b => b -> b) -> CaseType -> CaseType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CaseType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CaseType -> r)
-> (forall u. (forall d. Data d => d -> u) -> CaseType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CaseType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CaseType -> m CaseType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CaseType -> m CaseType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CaseType -> m CaseType)
-> Data CaseType
CaseType -> Constr
CaseType -> DataType
(forall b. Data b => b -> b) -> CaseType -> CaseType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CaseType -> u
forall u. (forall d. Data d => d -> u) -> CaseType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseType -> m CaseType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseType -> m CaseType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseType -> c CaseType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseType -> c CaseType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CaseType -> c CaseType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CaseType
$ctoConstr :: CaseType -> Constr
toConstr :: CaseType -> Constr
$cdataTypeOf :: CaseType -> DataType
dataTypeOf :: CaseType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CaseType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CaseType)
$cgmapT :: (forall b. Data b => b -> b) -> CaseType -> CaseType
gmapT :: (forall b. Data b => b -> b) -> CaseType -> CaseType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CaseType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CaseType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CaseType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CaseType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CaseType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CaseType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseType -> m CaseType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CaseType -> m CaseType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseType -> m CaseType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseType -> m CaseType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseType -> m CaseType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CaseType -> m CaseType
Data, (forall x. CaseType -> Rep CaseType x)
-> (forall x. Rep CaseType x -> CaseType) -> Generic CaseType
forall x. Rep CaseType x -> CaseType
forall x. CaseType -> Rep CaseType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CaseType -> Rep CaseType x
from :: forall x. CaseType -> Rep CaseType x
$cto :: forall x. Rep CaseType x -> CaseType
to :: forall x. Rep CaseType x -> CaseType
Generic, CaseType -> ()
(CaseType -> ()) -> NFData CaseType
forall a. (a -> ()) -> NFData a
$crnf :: CaseType -> ()
rnf :: CaseType -> ()
NFData)

-- | Statements in Verilog.
data Statement a
  = -- | Time control (@#NUM@)
    TimeCtrl
      { forall a. Statement a -> Delay
_statDelay :: {-# UNPACK #-} !Delay,
        forall a. Statement a -> Maybe (Statement a)
_statDStat :: Maybe (Statement a)
      }
  | EventCtrl
      { forall a. Statement a -> Event
_statEvent :: !Event,
        forall a. Statement a -> Maybe (Statement a)
_statEStat :: Maybe (Statement a)
      }
  | -- | Sequential block (@begin ... end@)
    SeqBlock {forall a. Statement a -> [Statement a]
_statements :: [Statement a]}
  | -- | blocking assignment (@=@)
    BlockAssign {forall a. Statement a -> Assign
_stmntBA :: !Assign}
  | -- | Non blocking assignment (@<=@)
    NonBlockAssign {forall a. Statement a -> Assign
_stmntNBA :: !Assign}
  | TaskEnable {forall a. Statement a -> Task
_stmntTask :: !Task}
  | SysTaskEnable {forall a. Statement a -> Task
_stmntSysTask :: !Task}
  | CondStmnt
      { forall a. Statement a -> Expr
_stmntCondExpr :: Expr,
        forall a. Statement a -> Maybe (Statement a)
_stmntCondTrue :: Maybe (Statement a),
        forall a. Statement a -> Maybe (Statement a)
_stmntCondFalse :: Maybe (Statement a)
      }
  | StmntCase
      { forall a. Statement a -> CaseType
_stmntCaseType :: !CaseType,
        forall a. Statement a -> Expr
_stmntCaseExpr :: !Expr,
        forall a. Statement a -> [CasePair a]
_stmntCasePair :: ![CasePair a],
        forall a. Statement a -> Maybe (Statement a)
_stmntCaseDefault :: !(Maybe (Statement a))
      }
  | -- | Loop bounds shall be statically computable for a for loop.
    ForLoop
      { forall a. Statement a -> Assign
_forAssign :: !Assign,
        forall a. Statement a -> Expr
_forExpr :: Expr,
        forall a. Statement a -> Assign
_forIncr :: !Assign,
        forall a. Statement a -> Statement a
_forStmnt :: Statement a
      }
  | StmntAnn a (Statement a)
  deriving (Statement a -> Statement a -> Bool
(Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Bool) -> Eq (Statement a)
forall a. Eq a => Statement a -> Statement a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Statement a -> Statement a -> Bool
== :: Statement a -> Statement a -> Bool
$c/= :: forall a. Eq a => Statement a -> Statement a -> Bool
/= :: Statement a -> Statement a -> Bool
Eq, Int -> Statement a -> ShowS
[Statement a] -> ShowS
Statement a -> String
(Int -> Statement a -> ShowS)
-> (Statement a -> String)
-> ([Statement a] -> ShowS)
-> Show (Statement a)
forall a. Show a => Int -> Statement a -> ShowS
forall a. Show a => [Statement a] -> ShowS
forall a. Show a => Statement a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Statement a -> ShowS
showsPrec :: Int -> Statement a -> ShowS
$cshow :: forall a. Show a => Statement a -> String
show :: Statement a -> String
$cshowList :: forall a. Show a => [Statement a] -> ShowS
showList :: [Statement a] -> ShowS
Show, Eq (Statement a)
Eq (Statement a) =>
(Statement a -> Statement a -> Ordering)
-> (Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Bool)
-> (Statement a -> Statement a -> Statement a)
-> (Statement a -> Statement a -> Statement a)
-> Ord (Statement a)
Statement a -> Statement a -> Bool
Statement a -> Statement a -> Ordering
Statement a -> Statement a -> Statement a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Statement a)
forall a. Ord a => Statement a -> Statement a -> Bool
forall a. Ord a => Statement a -> Statement a -> Ordering
forall a. Ord a => Statement a -> Statement a -> Statement a
$ccompare :: forall a. Ord a => Statement a -> Statement a -> Ordering
compare :: Statement a -> Statement a -> Ordering
$c< :: forall a. Ord a => Statement a -> Statement a -> Bool
< :: Statement a -> Statement a -> Bool
$c<= :: forall a. Ord a => Statement a -> Statement a -> Bool
<= :: Statement a -> Statement a -> Bool
$c> :: forall a. Ord a => Statement a -> Statement a -> Bool
> :: Statement a -> Statement a -> Bool
$c>= :: forall a. Ord a => Statement a -> Statement a -> Bool
>= :: Statement a -> Statement a -> Bool
$cmax :: forall a. Ord a => Statement a -> Statement a -> Statement a
max :: Statement a -> Statement a -> Statement a
$cmin :: forall a. Ord a => Statement a -> Statement a -> Statement a
min :: Statement a -> Statement a -> Statement a
Ord, Typeable (Statement a)
Typeable (Statement a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Statement a -> c (Statement a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Statement a))
-> (Statement a -> Constr)
-> (Statement a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Statement a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Statement a)))
-> ((forall b. Data b => b -> b) -> Statement a -> Statement a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Statement a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Statement a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement a -> m (Statement a))
-> Data (Statement a)
Statement a -> Constr
Statement a -> DataType
(forall b. Data b => b -> b) -> Statement a -> Statement a
forall a. Data a => Typeable (Statement a)
forall a. Data a => Statement a -> Constr
forall a. Data a => Statement a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Statement a -> Statement a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Statement a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Statement a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Statement a -> u
forall u. (forall d. Data d => d -> u) -> Statement a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Statement a -> c (Statement a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Statement a)
$ctoConstr :: forall a. Data a => Statement a -> Constr
toConstr :: Statement a -> Constr
$cdataTypeOf :: forall a. Data a => Statement a -> DataType
dataTypeOf :: Statement a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Statement a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Statement a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Statement a -> Statement a
gmapT :: (forall b. Data b => b -> b) -> Statement a -> Statement a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Statement a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Statement a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Statement a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Statement a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Statement a -> m (Statement a)
Data, (forall a b. (a -> b) -> Statement a -> Statement b)
-> (forall a b. a -> Statement b -> Statement a)
-> Functor Statement
forall a b. a -> Statement b -> Statement a
forall a b. (a -> b) -> Statement a -> Statement b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Statement a -> Statement b
fmap :: forall a b. (a -> b) -> Statement a -> Statement b
$c<$ :: forall a b. a -> Statement b -> Statement a
<$ :: forall a b. a -> Statement b -> Statement a
Functor, (forall x. Statement a -> Rep (Statement a) x)
-> (forall x. Rep (Statement a) x -> Statement a)
-> Generic (Statement a)
forall x. Rep (Statement a) x -> Statement a
forall x. Statement a -> Rep (Statement a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Statement a) x -> Statement a
forall a x. Statement a -> Rep (Statement a) x
$cfrom :: forall a x. Statement a -> Rep (Statement a) x
from :: forall x. Statement a -> Rep (Statement a) x
$cto :: forall a x. Rep (Statement a) x -> Statement a
to :: forall x. Rep (Statement a) x -> Statement a
Generic, Statement a -> ()
(Statement a -> ()) -> NFData (Statement a)
forall a. NFData a => Statement a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => Statement a -> ()
rnf :: Statement a -> ()
NFData)

$(makeLenses ''Statement)

instance Plated (Statement a) where
  plate :: Traversal' (Statement a) (Statement a)
plate Statement a -> f (Statement a)
f (TimeCtrl Delay
d Maybe (Statement a)
s) = Delay -> Maybe (Statement a) -> Statement a
forall a. Delay -> Maybe (Statement a) -> Statement a
TimeCtrl Delay
d (Maybe (Statement a) -> Statement a)
-> f (Maybe (Statement a)) -> f (Statement a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Statement a -> f (Statement a))
-> Maybe (Statement a) -> f (Maybe (Statement a))
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) -> Maybe a -> f (Maybe b)
traverse Statement a -> f (Statement a)
f Maybe (Statement a)
s
  plate Statement a -> f (Statement a)
f (EventCtrl Event
d Maybe (Statement a)
s) = Event -> Maybe (Statement a) -> Statement a
forall a. Event -> Maybe (Statement a) -> Statement a
EventCtrl Event
d (Maybe (Statement a) -> Statement a)
-> f (Maybe (Statement a)) -> f (Statement a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Statement a -> f (Statement a))
-> Maybe (Statement a) -> f (Maybe (Statement a))
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) -> Maybe a -> f (Maybe b)
traverse Statement a -> f (Statement a)
f Maybe (Statement a)
s
  plate Statement a -> f (Statement a)
f (SeqBlock [Statement a]
s) = [Statement a] -> Statement a
forall a. [Statement a] -> Statement a
SeqBlock ([Statement a] -> Statement a)
-> f [Statement a] -> f (Statement a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Statement a -> f (Statement a))
-> [Statement a] -> f [Statement a]
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 a -> f (Statement a)
f [Statement a]
s
  plate Statement a -> f (Statement a)
f (CondStmnt Expr
e Maybe (Statement a)
s1 Maybe (Statement a)
s2) = Expr -> Maybe (Statement a) -> Maybe (Statement a) -> Statement a
forall a.
Expr -> Maybe (Statement a) -> Maybe (Statement a) -> Statement a
CondStmnt Expr
e (Maybe (Statement a) -> Maybe (Statement a) -> Statement a)
-> f (Maybe (Statement a))
-> f (Maybe (Statement a) -> Statement a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Statement a -> f (Statement a))
-> Maybe (Statement a) -> f (Maybe (Statement a))
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) -> Maybe a -> f (Maybe b)
traverse Statement a -> f (Statement a)
f Maybe (Statement a)
s1 f (Maybe (Statement a) -> Statement a)
-> f (Maybe (Statement a)) -> f (Statement a)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Statement a -> f (Statement a))
-> Maybe (Statement a) -> f (Maybe (Statement a))
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) -> Maybe a -> f (Maybe b)
traverse Statement a -> f (Statement a)
f Maybe (Statement a)
s2
  plate Statement a -> f (Statement a)
f (StmntCase CaseType
a Expr
b [CasePair a]
c Maybe (Statement a)
d) =
    CaseType
-> Expr -> [CasePair a] -> Maybe (Statement a) -> Statement a
forall a.
CaseType
-> Expr -> [CasePair a] -> Maybe (Statement a) -> Statement a
StmntCase CaseType
a Expr
b
      ([CasePair a] -> Maybe (Statement a) -> Statement a)
-> f [CasePair a] -> f (Maybe (Statement a) -> Statement a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CasePair a -> f (CasePair a)) -> [CasePair a] -> f [CasePair a]
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 a -> f (Statement a)) -> CasePair a -> f (CasePair a)
forall (f :: * -> *) a1 a2.
Functor f =>
(Statement a1 -> f (Statement a2))
-> CasePair a1 -> f (CasePair a2)
traverseStmntCasePair Statement a -> f (Statement a)
f) [CasePair a]
c
      f (Maybe (Statement a) -> Statement a)
-> f (Maybe (Statement a)) -> f (Statement a)
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Statement a -> f (Statement a))
-> Maybe (Statement a) -> f (Maybe (Statement a))
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) -> Maybe a -> f (Maybe b)
traverse Statement a -> f (Statement a)
f Maybe (Statement a)
d
  plate Statement a -> f (Statement a)
f (ForLoop Assign
a Expr
b Assign
c Statement a
d) = Assign -> Expr -> Assign -> Statement a -> Statement a
forall a. Assign -> Expr -> Assign -> Statement a -> Statement a
ForLoop Assign
a Expr
b Assign
c (Statement a -> Statement a) -> f (Statement a) -> f (Statement a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Statement a -> f (Statement a)
f Statement a
d
  plate Statement a -> f (Statement a)
_ Statement a
a = Statement a -> f (Statement a)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Statement a
a

instance Semigroup (Statement a) where
  (SeqBlock [Statement a]
a) <> :: Statement a -> Statement a -> Statement a
<> (SeqBlock [Statement a]
b) = [Statement a] -> Statement a
forall a. [Statement a] -> Statement a
SeqBlock ([Statement a] -> Statement a) -> [Statement a] -> Statement a
forall a b. (a -> b) -> a -> b
$ [Statement a]
a [Statement a] -> [Statement a] -> [Statement a]
forall a. Semigroup a => a -> a -> a
<> [Statement a]
b
  (SeqBlock [Statement a]
a) <> Statement a
b = [Statement a] -> Statement a
forall a. [Statement a] -> Statement a
SeqBlock ([Statement a] -> Statement a) -> [Statement a] -> Statement a
forall a b. (a -> b) -> a -> b
$ [Statement a]
a [Statement a] -> [Statement a] -> [Statement a]
forall a. Semigroup a => a -> a -> a
<> [Statement a
b]
  Statement a
a <> (SeqBlock [Statement a]
b) = [Statement a] -> Statement a
forall a. [Statement a] -> Statement a
SeqBlock ([Statement a] -> Statement a) -> [Statement a] -> Statement a
forall a b. (a -> b) -> a -> b
$ Statement a
a Statement a -> [Statement a] -> [Statement a]
forall a. a -> [a] -> [a]
: [Statement a]
b
  Statement a
a <> Statement a
b = [Statement a] -> Statement a
forall a. [Statement a] -> Statement a
SeqBlock [Statement a
a, Statement a
b]

instance Monoid (Statement a) where
  mempty :: Statement a
mempty = [Statement a] -> Statement a
forall a. [Statement a] -> Statement a
SeqBlock []

instance Annotations Statement where
  removeAnn :: forall a. Statement a -> Statement a
removeAnn (StmntAnn a
_ Statement a
s) = Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Statement a
s
  removeAnn (TimeCtrl Delay
e Maybe (Statement a)
s) = Delay -> Maybe (Statement a) -> Statement a
forall a. Delay -> Maybe (Statement a) -> Statement a
TimeCtrl Delay
e (Maybe (Statement a) -> Statement a)
-> Maybe (Statement a) -> Statement a
forall a b. (a -> b) -> a -> b
$ (Statement a -> Statement a)
-> Maybe (Statement a) -> Maybe (Statement a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Maybe (Statement a)
s
  removeAnn (EventCtrl Event
e Maybe (Statement a)
s) = Event -> Maybe (Statement a) -> Statement a
forall a. Event -> Maybe (Statement a) -> Statement a
EventCtrl Event
e (Maybe (Statement a) -> Statement a)
-> Maybe (Statement a) -> Statement a
forall a b. (a -> b) -> a -> b
$ (Statement a -> Statement a)
-> Maybe (Statement a) -> Maybe (Statement a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Maybe (Statement a)
s
  removeAnn (SeqBlock [Statement a]
s) = [Statement a] -> Statement a
forall a. [Statement a] -> Statement a
SeqBlock ([Statement a] -> Statement a) -> [Statement a] -> Statement a
forall a b. (a -> b) -> a -> b
$ (Statement a -> Statement a) -> [Statement a] -> [Statement a]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn [Statement a]
s
  removeAnn (CondStmnt Expr
c Maybe (Statement a)
ms1 Maybe (Statement a)
ms2) = Expr -> Maybe (Statement a) -> Maybe (Statement a) -> Statement a
forall a.
Expr -> Maybe (Statement a) -> Maybe (Statement a) -> Statement a
CondStmnt Expr
c ((Statement a -> Statement a)
-> Maybe (Statement a) -> Maybe (Statement a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Maybe (Statement a)
ms1) (Maybe (Statement a) -> Statement a)
-> Maybe (Statement a) -> Statement a
forall a b. (a -> b) -> a -> b
$ (Statement a -> Statement a)
-> Maybe (Statement a) -> Maybe (Statement a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Maybe (Statement a)
ms2
  removeAnn (StmntCase CaseType
ct Expr
ce [CasePair a]
cp Maybe (Statement a)
cdef) = CaseType
-> Expr -> [CasePair a] -> Maybe (Statement a) -> Statement a
forall a.
CaseType
-> Expr -> [CasePair a] -> Maybe (Statement a) -> Statement a
StmntCase CaseType
ct Expr
ce ((CasePair a -> CasePair a) -> [CasePair a] -> [CasePair a]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CasePair a -> CasePair a
forall a. CasePair a -> CasePair a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn [CasePair a]
cp) (Maybe (Statement a) -> Statement a)
-> Maybe (Statement a) -> Statement a
forall a b. (a -> b) -> a -> b
$ (Statement a -> Statement a)
-> Maybe (Statement a) -> Maybe (Statement a)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Maybe (Statement a)
cdef
  removeAnn (ForLoop Assign
a Expr
b Assign
c Statement a
s) = Assign -> Expr -> Assign -> Statement a -> Statement a
forall a. Assign -> Expr -> Assign -> Statement a -> Statement a
ForLoop Assign
a Expr
b Assign
c (Statement a -> Statement a) -> Statement a -> Statement a
forall a b. (a -> b) -> a -> b
$ Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Statement a
s
  removeAnn Statement a
s = Statement a
s
  collectAnn :: forall a. Statement a -> [a]
collectAnn (StmntAnn a
_ Statement a
s) = Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Statement a
s
  collectAnn (TimeCtrl Delay
_ Maybe (Statement a)
s) = (Statement a -> [a]) -> Maybe (Statement a) -> [a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Maybe (Statement a)
s
  collectAnn (EventCtrl Event
_ Maybe (Statement a)
s) = (Statement a -> [a]) -> Maybe (Statement a) -> [a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Maybe (Statement a)
s
  collectAnn (SeqBlock [Statement a]
s) = (Statement a -> [a]) -> [Statement a] -> [a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn [Statement a]
s
  collectAnn (CondStmnt Expr
_ Maybe (Statement a)
ms1 Maybe (Statement a)
ms2) = (Statement a -> [a]) -> Maybe (Statement a) -> [a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Maybe (Statement a)
ms1 [a] -> [a] -> [a]
forall a. Semigroup a => a -> a -> a
<> (Statement a -> [a]) -> Maybe (Statement a) -> [a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Maybe (Statement a)
ms2
  collectAnn (StmntCase CaseType
_ Expr
_ [CasePair a]
cp Maybe (Statement a)
cdef) = (CasePair a -> [a]) -> [CasePair a] -> [a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap CasePair a -> [a]
forall a. CasePair a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn [CasePair a]
cp [a] -> [a] -> [a]
forall a. Semigroup a => a -> a -> a
<> (Statement a -> [a]) -> Maybe (Statement a) -> [a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Maybe (Statement a)
cdef
  collectAnn (ForLoop Assign
_ Expr
_ Assign
_ Statement a
s) = Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Statement a
s
  collectAnn Statement a
_ = []

instance Annotations CasePair where
  removeAnn :: forall a. CasePair a -> CasePair a
removeAnn (CasePair Expr
e Statement a
s) = Expr -> Statement a -> CasePair a
forall a. Expr -> Statement a -> CasePair a
CasePair Expr
e (Statement a -> CasePair a) -> Statement a -> CasePair a
forall a b. (a -> b) -> a -> b
$ Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Statement a
s
  collectAnn :: forall a. CasePair a -> [a]
collectAnn (CasePair Expr
_ Statement a
s) = Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Statement a
s

-- | Parameter that can be assigned in blocks or modules using @parameter@.
data Parameter = Parameter
  { Parameter -> Identifier
_paramIdent :: {-# UNPACK #-} !Identifier,
    Parameter -> ConstExpr
_paramValue :: ConstExpr
  }
  deriving (Parameter -> Parameter -> Bool
(Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Bool) -> Eq Parameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Parameter -> Parameter -> Bool
== :: Parameter -> Parameter -> Bool
$c/= :: Parameter -> Parameter -> Bool
/= :: Parameter -> Parameter -> Bool
Eq, Int -> Parameter -> ShowS
[Parameter] -> ShowS
Parameter -> String
(Int -> Parameter -> ShowS)
-> (Parameter -> String)
-> ([Parameter] -> ShowS)
-> Show Parameter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Parameter -> ShowS
showsPrec :: Int -> Parameter -> ShowS
$cshow :: Parameter -> String
show :: Parameter -> String
$cshowList :: [Parameter] -> ShowS
showList :: [Parameter] -> ShowS
Show, Eq Parameter
Eq Parameter =>
(Parameter -> Parameter -> Ordering)
-> (Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Bool)
-> (Parameter -> Parameter -> Parameter)
-> (Parameter -> Parameter -> Parameter)
-> Ord Parameter
Parameter -> Parameter -> Bool
Parameter -> Parameter -> Ordering
Parameter -> Parameter -> Parameter
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Parameter -> Parameter -> Ordering
compare :: Parameter -> Parameter -> Ordering
$c< :: Parameter -> Parameter -> Bool
< :: Parameter -> Parameter -> Bool
$c<= :: Parameter -> Parameter -> Bool
<= :: Parameter -> Parameter -> Bool
$c> :: Parameter -> Parameter -> Bool
> :: Parameter -> Parameter -> Bool
$c>= :: Parameter -> Parameter -> Bool
>= :: Parameter -> Parameter -> Bool
$cmax :: Parameter -> Parameter -> Parameter
max :: Parameter -> Parameter -> Parameter
$cmin :: Parameter -> Parameter -> Parameter
min :: Parameter -> Parameter -> Parameter
Ord, Typeable Parameter
Typeable Parameter =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Parameter -> c Parameter)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Parameter)
-> (Parameter -> Constr)
-> (Parameter -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Parameter))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parameter))
-> ((forall b. Data b => b -> b) -> Parameter -> Parameter)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameter -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameter -> r)
-> (forall u. (forall d. Data d => d -> u) -> Parameter -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Parameter -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Parameter -> m Parameter)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Parameter -> m Parameter)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Parameter -> m Parameter)
-> Data Parameter
Parameter -> Constr
Parameter -> DataType
(forall b. Data b => b -> b) -> Parameter -> Parameter
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Parameter -> u
forall u. (forall d. Data d => d -> u) -> Parameter -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parameter
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameter -> c Parameter
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parameter)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parameter)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameter -> c Parameter
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Parameter -> c Parameter
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parameter
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Parameter
$ctoConstr :: Parameter -> Constr
toConstr :: Parameter -> Constr
$cdataTypeOf :: Parameter -> DataType
dataTypeOf :: Parameter -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parameter)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Parameter)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parameter)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parameter)
$cgmapT :: (forall b. Data b => b -> b) -> Parameter -> Parameter
gmapT :: (forall b. Data b => b -> b) -> Parameter -> Parameter
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Parameter -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Parameter -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Parameter -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Parameter -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Parameter -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Parameter -> m Parameter
Data, (forall x. Parameter -> Rep Parameter x)
-> (forall x. Rep Parameter x -> Parameter) -> Generic Parameter
forall x. Rep Parameter x -> Parameter
forall x. Parameter -> Rep Parameter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Parameter -> Rep Parameter x
from :: forall x. Parameter -> Rep Parameter x
$cto :: forall x. Rep Parameter x -> Parameter
to :: forall x. Rep Parameter x -> Parameter
Generic, Parameter -> ()
(Parameter -> ()) -> NFData Parameter
forall a. (a -> ()) -> NFData a
$crnf :: Parameter -> ()
rnf :: Parameter -> ()
NFData)

$(makeLenses ''Parameter)

-- | Local parameter that can be assigned anywhere using @localparam@. It cannot
-- be changed by initialising the module.
data LocalParam = LocalParam
  { LocalParam -> Identifier
_localParamIdent :: {-# UNPACK #-} !Identifier,
    LocalParam -> ConstExpr
_localParamValue :: ConstExpr
  }
  deriving (LocalParam -> LocalParam -> Bool
(LocalParam -> LocalParam -> Bool)
-> (LocalParam -> LocalParam -> Bool) -> Eq LocalParam
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalParam -> LocalParam -> Bool
== :: LocalParam -> LocalParam -> Bool
$c/= :: LocalParam -> LocalParam -> Bool
/= :: LocalParam -> LocalParam -> Bool
Eq, Int -> LocalParam -> ShowS
[LocalParam] -> ShowS
LocalParam -> String
(Int -> LocalParam -> ShowS)
-> (LocalParam -> String)
-> ([LocalParam] -> ShowS)
-> Show LocalParam
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LocalParam -> ShowS
showsPrec :: Int -> LocalParam -> ShowS
$cshow :: LocalParam -> String
show :: LocalParam -> String
$cshowList :: [LocalParam] -> ShowS
showList :: [LocalParam] -> ShowS
Show, Eq LocalParam
Eq LocalParam =>
(LocalParam -> LocalParam -> Ordering)
-> (LocalParam -> LocalParam -> Bool)
-> (LocalParam -> LocalParam -> Bool)
-> (LocalParam -> LocalParam -> Bool)
-> (LocalParam -> LocalParam -> Bool)
-> (LocalParam -> LocalParam -> LocalParam)
-> (LocalParam -> LocalParam -> LocalParam)
-> Ord LocalParam
LocalParam -> LocalParam -> Bool
LocalParam -> LocalParam -> Ordering
LocalParam -> LocalParam -> LocalParam
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LocalParam -> LocalParam -> Ordering
compare :: LocalParam -> LocalParam -> Ordering
$c< :: LocalParam -> LocalParam -> Bool
< :: LocalParam -> LocalParam -> Bool
$c<= :: LocalParam -> LocalParam -> Bool
<= :: LocalParam -> LocalParam -> Bool
$c> :: LocalParam -> LocalParam -> Bool
> :: LocalParam -> LocalParam -> Bool
$c>= :: LocalParam -> LocalParam -> Bool
>= :: LocalParam -> LocalParam -> Bool
$cmax :: LocalParam -> LocalParam -> LocalParam
max :: LocalParam -> LocalParam -> LocalParam
$cmin :: LocalParam -> LocalParam -> LocalParam
min :: LocalParam -> LocalParam -> LocalParam
Ord, Typeable LocalParam
Typeable LocalParam =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LocalParam -> c LocalParam)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LocalParam)
-> (LocalParam -> Constr)
-> (LocalParam -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LocalParam))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c LocalParam))
-> ((forall b. Data b => b -> b) -> LocalParam -> LocalParam)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LocalParam -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LocalParam -> r)
-> (forall u. (forall d. Data d => d -> u) -> LocalParam -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LocalParam -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LocalParam -> m LocalParam)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LocalParam -> m LocalParam)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LocalParam -> m LocalParam)
-> Data LocalParam
LocalParam -> Constr
LocalParam -> DataType
(forall b. Data b => b -> b) -> LocalParam -> LocalParam
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> LocalParam -> u
forall u. (forall d. Data d => d -> u) -> LocalParam -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LocalParam -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LocalParam -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LocalParam -> m LocalParam
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LocalParam -> m LocalParam
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LocalParam
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LocalParam -> c LocalParam
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LocalParam)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LocalParam)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LocalParam -> c LocalParam
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LocalParam -> c LocalParam
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LocalParam
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LocalParam
$ctoConstr :: LocalParam -> Constr
toConstr :: LocalParam -> Constr
$cdataTypeOf :: LocalParam -> DataType
dataTypeOf :: LocalParam -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LocalParam)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LocalParam)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LocalParam)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LocalParam)
$cgmapT :: (forall b. Data b => b -> b) -> LocalParam -> LocalParam
gmapT :: (forall b. Data b => b -> b) -> LocalParam -> LocalParam
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LocalParam -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LocalParam -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LocalParam -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LocalParam -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LocalParam -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LocalParam -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LocalParam -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LocalParam -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LocalParam -> m LocalParam
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LocalParam -> m LocalParam
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LocalParam -> m LocalParam
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LocalParam -> m LocalParam
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LocalParam -> m LocalParam
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LocalParam -> m LocalParam
Data, (forall x. LocalParam -> Rep LocalParam x)
-> (forall x. Rep LocalParam x -> LocalParam) -> Generic LocalParam
forall x. Rep LocalParam x -> LocalParam
forall x. LocalParam -> Rep LocalParam x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LocalParam -> Rep LocalParam x
from :: forall x. LocalParam -> Rep LocalParam x
$cto :: forall x. Rep LocalParam x -> LocalParam
to :: forall x. Rep LocalParam x -> LocalParam
Generic, LocalParam -> ()
(LocalParam -> ()) -> NFData LocalParam
forall a. (a -> ()) -> NFData a
$crnf :: LocalParam -> ()
rnf :: LocalParam -> ()
NFData)

$(makeLenses ''LocalParam)

-- | Module item which is the body of the module expression.
data ModItem a
  = ModCA {forall a. ModItem a -> ContAssign
_modContAssign :: !ContAssign}
  | ModInst
      { forall a. ModItem a -> Identifier
_modInstId :: {-# UNPACK #-} !Identifier,
        forall a. ModItem a -> [ModConn]
_modInstDecl :: [ModConn],
        forall a. ModItem a -> Identifier
_modInstName :: {-# UNPACK #-} !Identifier,
        forall a. ModItem a -> [ModConn]
_modInstConns :: [ModConn]
      }
  | Initial !(Statement a)
  | Always !(Statement a)
  | Property
      { forall a. ModItem a -> Identifier
_moditemPropLabel :: {-# UNPACK #-} !Identifier,
        forall a. ModItem a -> Event
_moditemPropEvent :: !Event,
        forall a. ModItem a -> Maybe Expr
_moditemPropBodyL :: Maybe Expr,
        forall a. ModItem a -> Expr
_moditemPropBodyR :: Expr
      }
  | Decl
      { forall a. ModItem a -> Maybe PortDir
_declDir :: !(Maybe PortDir),
        forall a. ModItem a -> Port
_declPort :: !Port,
        forall a. ModItem a -> Maybe ConstExpr
_declVal :: Maybe ConstExpr
      }
  | ParamDecl {forall a. ModItem a -> NonEmpty Parameter
_paramDecl :: NonEmpty Parameter}
  | LocalParamDecl {forall a. ModItem a -> NonEmpty LocalParam
_localParamDecl :: NonEmpty LocalParam}
  | ModItemAnn a (ModItem a)
  deriving (ModItem a -> ModItem a -> Bool
(ModItem a -> ModItem a -> Bool)
-> (ModItem a -> ModItem a -> Bool) -> Eq (ModItem a)
forall a. Eq a => ModItem a -> ModItem a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => ModItem a -> ModItem a -> Bool
== :: ModItem a -> ModItem a -> Bool
$c/= :: forall a. Eq a => ModItem a -> ModItem a -> Bool
/= :: ModItem a -> ModItem a -> Bool
Eq, Int -> ModItem a -> ShowS
[ModItem a] -> ShowS
ModItem a -> String
(Int -> ModItem a -> ShowS)
-> (ModItem a -> String)
-> ([ModItem a] -> ShowS)
-> Show (ModItem a)
forall a. Show a => Int -> ModItem a -> ShowS
forall a. Show a => [ModItem a] -> ShowS
forall a. Show a => ModItem a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> ModItem a -> ShowS
showsPrec :: Int -> ModItem a -> ShowS
$cshow :: forall a. Show a => ModItem a -> String
show :: ModItem a -> String
$cshowList :: forall a. Show a => [ModItem a] -> ShowS
showList :: [ModItem a] -> ShowS
Show, Eq (ModItem a)
Eq (ModItem a) =>
(ModItem a -> ModItem a -> Ordering)
-> (ModItem a -> ModItem a -> Bool)
-> (ModItem a -> ModItem a -> Bool)
-> (ModItem a -> ModItem a -> Bool)
-> (ModItem a -> ModItem a -> Bool)
-> (ModItem a -> ModItem a -> ModItem a)
-> (ModItem a -> ModItem a -> ModItem a)
-> Ord (ModItem a)
ModItem a -> ModItem a -> Bool
ModItem a -> ModItem a -> Ordering
ModItem a -> ModItem a -> ModItem a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (ModItem a)
forall a. Ord a => ModItem a -> ModItem a -> Bool
forall a. Ord a => ModItem a -> ModItem a -> Ordering
forall a. Ord a => ModItem a -> ModItem a -> ModItem a
$ccompare :: forall a. Ord a => ModItem a -> ModItem a -> Ordering
compare :: ModItem a -> ModItem a -> Ordering
$c< :: forall a. Ord a => ModItem a -> ModItem a -> Bool
< :: ModItem a -> ModItem a -> Bool
$c<= :: forall a. Ord a => ModItem a -> ModItem a -> Bool
<= :: ModItem a -> ModItem a -> Bool
$c> :: forall a. Ord a => ModItem a -> ModItem a -> Bool
> :: ModItem a -> ModItem a -> Bool
$c>= :: forall a. Ord a => ModItem a -> ModItem a -> Bool
>= :: ModItem a -> ModItem a -> Bool
$cmax :: forall a. Ord a => ModItem a -> ModItem a -> ModItem a
max :: ModItem a -> ModItem a -> ModItem a
$cmin :: forall a. Ord a => ModItem a -> ModItem a -> ModItem a
min :: ModItem a -> ModItem a -> ModItem a
Ord, (forall a b. (a -> b) -> ModItem a -> ModItem b)
-> (forall a b. a -> ModItem b -> ModItem a) -> Functor ModItem
forall a b. a -> ModItem b -> ModItem a
forall a b. (a -> b) -> ModItem a -> ModItem b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ModItem a -> ModItem b
fmap :: forall a b. (a -> b) -> ModItem a -> ModItem b
$c<$ :: forall a b. a -> ModItem b -> ModItem a
<$ :: forall a b. a -> ModItem b -> ModItem a
Functor, Typeable (ModItem a)
Typeable (ModItem a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModItem a -> c (ModItem a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModItem a))
-> (ModItem a -> Constr)
-> (ModItem a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModItem a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModItem a)))
-> ((forall b. Data b => b -> b) -> ModItem a -> ModItem a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModItem a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModItem a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModItem a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModItem a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a))
-> Data (ModItem a)
ModItem a -> Constr
ModItem a -> DataType
(forall b. Data b => b -> b) -> ModItem a -> ModItem a
forall a. Data a => Typeable (ModItem a)
forall a. Data a => ModItem a -> Constr
forall a. Data a => ModItem a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> ModItem a -> ModItem a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ModItem a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ModItem a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModItem a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModItem a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModItem a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModItem a -> c (ModItem a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ModItem a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModItem a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ModItem a -> u
forall u. (forall d. Data d => d -> u) -> ModItem a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModItem a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModItem a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModItem a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModItem a -> c (ModItem a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ModItem a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModItem a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModItem a -> c (ModItem a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModItem a -> c (ModItem a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModItem a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModItem a)
$ctoConstr :: forall a. Data a => ModItem a -> Constr
toConstr :: ModItem a -> Constr
$cdataTypeOf :: forall a. Data a => ModItem a -> DataType
dataTypeOf :: ModItem a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ModItem a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ModItem a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModItem a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModItem a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ModItem a -> ModItem a
gmapT :: (forall b. Data b => b -> b) -> ModItem a -> ModItem a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModItem a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModItem a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModItem a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModItem a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ModItem a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModItem a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ModItem a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModItem a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModItem a -> m (ModItem a)
Data, (forall x. ModItem a -> Rep (ModItem a) x)
-> (forall x. Rep (ModItem a) x -> ModItem a)
-> Generic (ModItem a)
forall x. Rep (ModItem a) x -> ModItem a
forall x. ModItem a -> Rep (ModItem a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ModItem a) x -> ModItem a
forall a x. ModItem a -> Rep (ModItem a) x
$cfrom :: forall a x. ModItem a -> Rep (ModItem a) x
from :: forall x. ModItem a -> Rep (ModItem a) x
$cto :: forall a x. Rep (ModItem a) x -> ModItem a
to :: forall x. Rep (ModItem a) x -> ModItem a
Generic, ModItem a -> ()
(ModItem a -> ()) -> NFData (ModItem a)
forall a. NFData a => ModItem a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => ModItem a -> ()
rnf :: ModItem a -> ()
NFData)

$(makePrisms ''ModItem)

$(makeLenses ''ModItem)

instance Annotations ModItem where
  removeAnn :: forall a. ModItem a -> ModItem a
removeAnn (ModItemAnn a
_ ModItem a
mi) = ModItem a -> ModItem a
forall a. ModItem a -> ModItem a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn ModItem a
mi
  removeAnn (Initial Statement a
s) = Statement a -> ModItem a
forall a. Statement a -> ModItem a
Initial (Statement a -> ModItem a) -> Statement a -> ModItem a
forall a b. (a -> b) -> a -> b
$ Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Statement a
s
  removeAnn (Always Statement a
s) = Statement a -> ModItem a
forall a. Statement a -> ModItem a
Always (Statement a -> ModItem a) -> Statement a -> ModItem a
forall a b. (a -> b) -> a -> b
$ Statement a -> Statement a
forall a. Statement a -> Statement a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Statement a
s
  removeAnn ModItem a
mi = ModItem a
mi
  collectAnn :: forall a. ModItem a -> [a]
collectAnn (ModItemAnn a
_ ModItem a
mi) = ModItem a -> [a]
forall a. ModItem a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn ModItem a
mi
  collectAnn (Initial Statement a
s) = Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Statement a
s
  collectAnn (Always Statement a
s) = Statement a -> [a]
forall a. Statement a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Statement a
s
  collectAnn ModItem a
mi = []

-- | 'module' module_identifier [list_of_ports] ';' { module_item } 'end_module'
data ModDecl a
  = ModDecl
      { forall a. ModDecl a -> Identifier
_modId :: {-# UNPACK #-} !Identifier,
        forall a. ModDecl a -> [Port]
_modOutPorts :: ![Port],
        forall a. ModDecl a -> [Port]
_modInPorts :: ![Port],
        forall a. ModDecl a -> [ModItem a]
_modItems :: ![ModItem a],
        forall a. ModDecl a -> [Parameter]
_modParams :: ![Parameter]
      }
  | ModDeclAnn a (ModDecl a)
  deriving (ModDecl a -> ModDecl a -> Bool
(ModDecl a -> ModDecl a -> Bool)
-> (ModDecl a -> ModDecl a -> Bool) -> Eq (ModDecl a)
forall a. Eq a => ModDecl a -> ModDecl a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => ModDecl a -> ModDecl a -> Bool
== :: ModDecl a -> ModDecl a -> Bool
$c/= :: forall a. Eq a => ModDecl a -> ModDecl a -> Bool
/= :: ModDecl a -> ModDecl a -> Bool
Eq, Int -> ModDecl a -> ShowS
[ModDecl a] -> ShowS
ModDecl a -> String
(Int -> ModDecl a -> ShowS)
-> (ModDecl a -> String)
-> ([ModDecl a] -> ShowS)
-> Show (ModDecl a)
forall a. Show a => Int -> ModDecl a -> ShowS
forall a. Show a => [ModDecl a] -> ShowS
forall a. Show a => ModDecl a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> ModDecl a -> ShowS
showsPrec :: Int -> ModDecl a -> ShowS
$cshow :: forall a. Show a => ModDecl a -> String
show :: ModDecl a -> String
$cshowList :: forall a. Show a => [ModDecl a] -> ShowS
showList :: [ModDecl a] -> ShowS
Show, Eq (ModDecl a)
Eq (ModDecl a) =>
(ModDecl a -> ModDecl a -> Ordering)
-> (ModDecl a -> ModDecl a -> Bool)
-> (ModDecl a -> ModDecl a -> Bool)
-> (ModDecl a -> ModDecl a -> Bool)
-> (ModDecl a -> ModDecl a -> Bool)
-> (ModDecl a -> ModDecl a -> ModDecl a)
-> (ModDecl a -> ModDecl a -> ModDecl a)
-> Ord (ModDecl a)
ModDecl a -> ModDecl a -> Bool
ModDecl a -> ModDecl a -> Ordering
ModDecl a -> ModDecl a -> ModDecl a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (ModDecl a)
forall a. Ord a => ModDecl a -> ModDecl a -> Bool
forall a. Ord a => ModDecl a -> ModDecl a -> Ordering
forall a. Ord a => ModDecl a -> ModDecl a -> ModDecl a
$ccompare :: forall a. Ord a => ModDecl a -> ModDecl a -> Ordering
compare :: ModDecl a -> ModDecl a -> Ordering
$c< :: forall a. Ord a => ModDecl a -> ModDecl a -> Bool
< :: ModDecl a -> ModDecl a -> Bool
$c<= :: forall a. Ord a => ModDecl a -> ModDecl a -> Bool
<= :: ModDecl a -> ModDecl a -> Bool
$c> :: forall a. Ord a => ModDecl a -> ModDecl a -> Bool
> :: ModDecl a -> ModDecl a -> Bool
$c>= :: forall a. Ord a => ModDecl a -> ModDecl a -> Bool
>= :: ModDecl a -> ModDecl a -> Bool
$cmax :: forall a. Ord a => ModDecl a -> ModDecl a -> ModDecl a
max :: ModDecl a -> ModDecl a -> ModDecl a
$cmin :: forall a. Ord a => ModDecl a -> ModDecl a -> ModDecl a
min :: ModDecl a -> ModDecl a -> ModDecl a
Ord, (forall a b. (a -> b) -> ModDecl a -> ModDecl b)
-> (forall a b. a -> ModDecl b -> ModDecl a) -> Functor ModDecl
forall a b. a -> ModDecl b -> ModDecl a
forall a b. (a -> b) -> ModDecl a -> ModDecl b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> ModDecl a -> ModDecl b
fmap :: forall a b. (a -> b) -> ModDecl a -> ModDecl b
$c<$ :: forall a b. a -> ModDecl b -> ModDecl a
<$ :: forall a b. a -> ModDecl b -> ModDecl a
Functor, Typeable (ModDecl a)
Typeable (ModDecl a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ModDecl a -> c (ModDecl a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ModDecl a))
-> (ModDecl a -> Constr)
-> (ModDecl a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ModDecl a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ModDecl a)))
-> ((forall b. Data b => b -> b) -> ModDecl a -> ModDecl a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModDecl a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModDecl a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModDecl a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModDecl a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a))
-> Data (ModDecl a)
ModDecl a -> Constr
ModDecl a -> DataType
(forall b. Data b => b -> b) -> ModDecl a -> ModDecl a
forall a. Data a => Typeable (ModDecl a)
forall a. Data a => ModDecl a -> Constr
forall a. Data a => ModDecl a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> ModDecl a -> ModDecl a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ModDecl a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> ModDecl a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModDecl a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModDecl a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModDecl a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModDecl a -> c (ModDecl a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ModDecl a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModDecl a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ModDecl a -> u
forall u. (forall d. Data d => d -> u) -> ModDecl a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModDecl a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModDecl a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModDecl a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModDecl a -> c (ModDecl a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ModDecl a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModDecl a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModDecl a -> c (ModDecl a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModDecl a -> c (ModDecl a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModDecl a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ModDecl a)
$ctoConstr :: forall a. Data a => ModDecl a -> Constr
toConstr :: ModDecl a -> Constr
$cdataTypeOf :: forall a. Data a => ModDecl a -> DataType
dataTypeOf :: ModDecl a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ModDecl a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ModDecl a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModDecl a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ModDecl a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> ModDecl a -> ModDecl a
gmapT :: (forall b. Data b => b -> b) -> ModDecl a -> ModDecl a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModDecl a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModDecl a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModDecl a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModDecl a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> ModDecl a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModDecl a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> ModDecl a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModDecl a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModDecl a -> m (ModDecl a)
Data, (forall x. ModDecl a -> Rep (ModDecl a) x)
-> (forall x. Rep (ModDecl a) x -> ModDecl a)
-> Generic (ModDecl a)
forall x. Rep (ModDecl a) x -> ModDecl a
forall x. ModDecl a -> Rep (ModDecl a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (ModDecl a) x -> ModDecl a
forall a x. ModDecl a -> Rep (ModDecl a) x
$cfrom :: forall a x. ModDecl a -> Rep (ModDecl a) x
from :: forall x. ModDecl a -> Rep (ModDecl a) x
$cto :: forall a x. Rep (ModDecl a) x -> ModDecl a
to :: forall x. Rep (ModDecl a) x -> ModDecl a
Generic, ModDecl a -> ()
(ModDecl a -> ()) -> NFData (ModDecl a)
forall a. NFData a => ModDecl a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => ModDecl a -> ()
rnf :: ModDecl a -> ()
NFData)

instance Plated (ModDecl a) where
  plate :: Traversal' (ModDecl a) (ModDecl a)
plate ModDecl a -> f (ModDecl a)
f (ModDeclAnn a
b ModDecl a
m) = a -> ModDecl a -> ModDecl a
forall a. a -> ModDecl a -> ModDecl a
ModDeclAnn a
b (ModDecl a -> ModDecl a) -> f (ModDecl a) -> f (ModDecl a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ModDecl a -> f (ModDecl a)) -> ModDecl a -> f (ModDecl a)
forall a. Plated a => Traversal' a a
Traversal' (ModDecl a) (ModDecl a)
plate ModDecl a -> f (ModDecl a)
f ModDecl a
m
  plate ModDecl a -> f (ModDecl a)
_ ModDecl a
m = ModDecl a -> f (ModDecl a)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ModDecl a
m

$(makeLenses ''ModDecl)
$(makePrisms ''ModDecl)

instance Annotations ModDecl where
  removeAnn :: forall a. ModDecl a -> ModDecl a
removeAnn (ModDecl Identifier
i [Port]
out [Port]
inp [ModItem a]
mis [Parameter]
params) = Identifier
-> [Port] -> [Port] -> [ModItem a] -> [Parameter] -> ModDecl a
forall a.
Identifier
-> [Port] -> [Port] -> [ModItem a] -> [Parameter] -> ModDecl a
ModDecl Identifier
i [Port]
out [Port]
inp ((ModItem a -> ModItem a) -> [ModItem a] -> [ModItem a]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ModItem a -> ModItem a
forall a. ModItem a -> ModItem a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn [ModItem a]
mis) [Parameter]
params
  removeAnn (ModDeclAnn a
_ ModDecl a
mi) = ModDecl a
mi
  collectAnn :: forall a. ModDecl a -> [a]
collectAnn (ModDecl Identifier
_ [Port]
_ [Port]
_ [ModItem a]
mis [Parameter]
_) = (ModItem a -> [a]) -> [ModItem a] -> [a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ModItem a -> [a]
forall a. ModItem a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn [ModItem a]
mis
  collectAnn (ModDeclAnn a
a ModDecl a
mi) = a
a a -> [a] -> [a]
forall a. a -> [a] -> [a]
: ModDecl a -> [a]
forall a. ModDecl a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn ModDecl a
mi

traverseModConn :: (Applicative f) => (Expr -> f Expr) -> ModConn -> f ModConn
traverseModConn :: forall (f :: * -> *).
Applicative f =>
(Expr -> f Expr) -> ModConn -> f ModConn
traverseModConn Expr -> f Expr
f (ModConn Expr
e) = Expr -> ModConn
ModConn (Expr -> ModConn) -> f Expr -> f ModConn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> f Expr
f Expr
e
traverseModConn Expr -> f Expr
f (ModConnNamed Identifier
a Expr
e) = Identifier -> Expr -> ModConn
ModConnNamed Identifier
a (Expr -> ModConn) -> f Expr -> f ModConn
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> f Expr
f Expr
e

traverseModItem :: (Applicative f) => (Expr -> f Expr) -> (ModItem ann) -> f (ModItem ann)
traverseModItem :: forall (f :: * -> *) ann.
Applicative f =>
(Expr -> f Expr) -> ModItem ann -> f (ModItem ann)
traverseModItem Expr -> f Expr
f (ModCA (ContAssign Identifier
a Expr
e)) = ContAssign -> ModItem ann
forall a. ContAssign -> ModItem a
ModCA (ContAssign -> ModItem ann)
-> (Expr -> ContAssign) -> Expr -> ModItem ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Expr -> ContAssign
ContAssign Identifier
a (Expr -> ModItem ann) -> f Expr -> f (ModItem ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Expr -> f Expr
f Expr
e
traverseModItem Expr -> f Expr
f (ModInst Identifier
a [ModConn]
b Identifier
c [ModConn]
e) =
  Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem ann
forall a.
Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem a
ModInst Identifier
a [ModConn]
b Identifier
c ([ModConn] -> ModItem ann) -> f [ModConn] -> f (ModItem ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [f ModConn] -> f [ModConn]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA ((Expr -> f Expr) -> ModConn -> f ModConn
forall (f :: * -> *).
Applicative f =>
(Expr -> f Expr) -> ModConn -> f ModConn
traverseModConn Expr -> f Expr
f (ModConn -> f ModConn) -> [ModConn] -> [f ModConn]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ModConn]
e)
traverseModItem Expr -> f Expr
_ ModItem ann
e = ModItem ann -> f (ModItem ann)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ModItem ann
e

-- | The complete sourcetext for the Verilog module.
newtype Verilog a = Verilog {forall a. Verilog a -> [ModDecl a]
getVerilog :: [ModDecl a]}
  deriving (Verilog a -> Verilog a -> Bool
(Verilog a -> Verilog a -> Bool)
-> (Verilog a -> Verilog a -> Bool) -> Eq (Verilog a)
forall a. Eq a => Verilog a -> Verilog a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Verilog a -> Verilog a -> Bool
== :: Verilog a -> Verilog a -> Bool
$c/= :: forall a. Eq a => Verilog a -> Verilog a -> Bool
/= :: Verilog a -> Verilog a -> Bool
Eq, Int -> Verilog a -> ShowS
[Verilog a] -> ShowS
Verilog a -> String
(Int -> Verilog a -> ShowS)
-> (Verilog a -> String)
-> ([Verilog a] -> ShowS)
-> Show (Verilog a)
forall a. Show a => Int -> Verilog a -> ShowS
forall a. Show a => [Verilog a] -> ShowS
forall a. Show a => Verilog a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Verilog a -> ShowS
showsPrec :: Int -> Verilog a -> ShowS
$cshow :: forall a. Show a => Verilog a -> String
show :: Verilog a -> String
$cshowList :: forall a. Show a => [Verilog a] -> ShowS
showList :: [Verilog a] -> ShowS
Show, Eq (Verilog a)
Eq (Verilog a) =>
(Verilog a -> Verilog a -> Ordering)
-> (Verilog a -> Verilog a -> Bool)
-> (Verilog a -> Verilog a -> Bool)
-> (Verilog a -> Verilog a -> Bool)
-> (Verilog a -> Verilog a -> Bool)
-> (Verilog a -> Verilog a -> Verilog a)
-> (Verilog a -> Verilog a -> Verilog a)
-> Ord (Verilog a)
Verilog a -> Verilog a -> Bool
Verilog a -> Verilog a -> Ordering
Verilog a -> Verilog a -> Verilog a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Verilog a)
forall a. Ord a => Verilog a -> Verilog a -> Bool
forall a. Ord a => Verilog a -> Verilog a -> Ordering
forall a. Ord a => Verilog a -> Verilog a -> Verilog a
$ccompare :: forall a. Ord a => Verilog a -> Verilog a -> Ordering
compare :: Verilog a -> Verilog a -> Ordering
$c< :: forall a. Ord a => Verilog a -> Verilog a -> Bool
< :: Verilog a -> Verilog a -> Bool
$c<= :: forall a. Ord a => Verilog a -> Verilog a -> Bool
<= :: Verilog a -> Verilog a -> Bool
$c> :: forall a. Ord a => Verilog a -> Verilog a -> Bool
> :: Verilog a -> Verilog a -> Bool
$c>= :: forall a. Ord a => Verilog a -> Verilog a -> Bool
>= :: Verilog a -> Verilog a -> Bool
$cmax :: forall a. Ord a => Verilog a -> Verilog a -> Verilog a
max :: Verilog a -> Verilog a -> Verilog a
$cmin :: forall a. Ord a => Verilog a -> Verilog a -> Verilog a
min :: Verilog a -> Verilog a -> Verilog a
Ord, (forall a b. (a -> b) -> Verilog a -> Verilog b)
-> (forall a b. a -> Verilog b -> Verilog a) -> Functor Verilog
forall a b. a -> Verilog b -> Verilog a
forall a b. (a -> b) -> Verilog a -> Verilog b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Verilog a -> Verilog b
fmap :: forall a b. (a -> b) -> Verilog a -> Verilog b
$c<$ :: forall a b. a -> Verilog b -> Verilog a
<$ :: forall a b. a -> Verilog b -> Verilog a
Functor, Typeable (Verilog a)
Typeable (Verilog a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Verilog a -> c (Verilog a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Verilog a))
-> (Verilog a -> Constr)
-> (Verilog a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Verilog a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Verilog a)))
-> ((forall b. Data b => b -> b) -> Verilog a -> Verilog a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Verilog a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Verilog a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Verilog a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Verilog a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a))
-> Data (Verilog a)
Verilog a -> Constr
Verilog a -> DataType
(forall b. Data b => b -> b) -> Verilog a -> Verilog a
forall a. Data a => Typeable (Verilog a)
forall a. Data a => Verilog a -> Constr
forall a. Data a => Verilog a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Verilog a -> Verilog a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Verilog a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Verilog a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Verilog a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Verilog a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Verilog a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Verilog a -> c (Verilog a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Verilog a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Verilog a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Verilog a -> u
forall u. (forall d. Data d => d -> u) -> Verilog a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Verilog a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Verilog a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Verilog a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Verilog a -> c (Verilog a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Verilog a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Verilog a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Verilog a -> c (Verilog a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Verilog a -> c (Verilog a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Verilog a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Verilog a)
$ctoConstr :: forall a. Data a => Verilog a -> Constr
toConstr :: Verilog a -> Constr
$cdataTypeOf :: forall a. Data a => Verilog a -> DataType
dataTypeOf :: Verilog a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Verilog a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Verilog a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Verilog a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Verilog a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Verilog a -> Verilog a
gmapT :: (forall b. Data b => b -> b) -> Verilog a -> Verilog a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Verilog a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Verilog a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Verilog a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Verilog a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Verilog a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Verilog a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Verilog a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Verilog a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Verilog a -> m (Verilog a)
Data, (forall x. Verilog a -> Rep (Verilog a) x)
-> (forall x. Rep (Verilog a) x -> Verilog a)
-> Generic (Verilog a)
forall x. Rep (Verilog a) x -> Verilog a
forall x. Verilog a -> Rep (Verilog a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Verilog a) x -> Verilog a
forall a x. Verilog a -> Rep (Verilog a) x
$cfrom :: forall a x. Verilog a -> Rep (Verilog a) x
from :: forall x. Verilog a -> Rep (Verilog a) x
$cto :: forall a x. Rep (Verilog a) x -> Verilog a
to :: forall x. Rep (Verilog a) x -> Verilog a
Generic, Verilog a -> ()
(Verilog a -> ()) -> NFData (Verilog a)
forall a. NFData a => Verilog a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => Verilog a -> ()
rnf :: Verilog a -> ()
NFData)

$(makeWrapped ''Verilog)

instance Semigroup (Verilog a) where
  Verilog [ModDecl a]
a <> :: Verilog a -> Verilog a -> Verilog a
<> Verilog [ModDecl a]
b = [ModDecl a] -> Verilog a
forall a. [ModDecl a] -> Verilog a
Verilog ([ModDecl a] -> Verilog a) -> [ModDecl a] -> Verilog a
forall a b. (a -> b) -> a -> b
$ [ModDecl a]
a [ModDecl a] -> [ModDecl a] -> [ModDecl a]
forall a. Semigroup a => a -> a -> a
<> [ModDecl a]
b

instance Monoid (Verilog a) where
  mempty :: Verilog a
mempty = [ModDecl a] -> Verilog a
forall a. [ModDecl a] -> Verilog a
Verilog [ModDecl a]
forall a. Monoid a => a
mempty

instance Annotations Verilog where
  removeAnn :: forall a. Verilog a -> Verilog a
removeAnn (Verilog [ModDecl a]
v) = [ModDecl a] -> Verilog a
forall a. [ModDecl a] -> Verilog a
Verilog ([ModDecl a] -> Verilog a) -> [ModDecl a] -> Verilog a
forall a b. (a -> b) -> a -> b
$ (ModDecl a -> ModDecl a) -> [ModDecl a] -> [ModDecl a]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ModDecl a -> ModDecl a
forall a. ModDecl a -> ModDecl a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn [ModDecl a]
v
  collectAnn :: forall a. Verilog a -> [a]
collectAnn (Verilog [ModDecl a]
v) = (ModDecl a -> [a]) -> [ModDecl a] -> [a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ModDecl a -> [a]
forall a. ModDecl a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn [ModDecl a]
v

-- | Top level type which contains all the source code and associated
-- information.
data SourceInfo a = SourceInfo
  { forall a. SourceInfo a -> Text
_infoTop :: {-# UNPACK #-} !Text,
    forall a. SourceInfo a -> Verilog a
_infoSrc :: !(Verilog a)
  }
  deriving (SourceInfo a -> SourceInfo a -> Bool
(SourceInfo a -> SourceInfo a -> Bool)
-> (SourceInfo a -> SourceInfo a -> Bool) -> Eq (SourceInfo a)
forall a. Eq a => SourceInfo a -> SourceInfo a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => SourceInfo a -> SourceInfo a -> Bool
== :: SourceInfo a -> SourceInfo a -> Bool
$c/= :: forall a. Eq a => SourceInfo a -> SourceInfo a -> Bool
/= :: SourceInfo a -> SourceInfo a -> Bool
Eq, Int -> SourceInfo a -> ShowS
[SourceInfo a] -> ShowS
SourceInfo a -> String
(Int -> SourceInfo a -> ShowS)
-> (SourceInfo a -> String)
-> ([SourceInfo a] -> ShowS)
-> Show (SourceInfo a)
forall a. Show a => Int -> SourceInfo a -> ShowS
forall a. Show a => [SourceInfo a] -> ShowS
forall a. Show a => SourceInfo a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> SourceInfo a -> ShowS
showsPrec :: Int -> SourceInfo a -> ShowS
$cshow :: forall a. Show a => SourceInfo a -> String
show :: SourceInfo a -> String
$cshowList :: forall a. Show a => [SourceInfo a] -> ShowS
showList :: [SourceInfo a] -> ShowS
Show, Eq (SourceInfo a)
Eq (SourceInfo a) =>
(SourceInfo a -> SourceInfo a -> Ordering)
-> (SourceInfo a -> SourceInfo a -> Bool)
-> (SourceInfo a -> SourceInfo a -> Bool)
-> (SourceInfo a -> SourceInfo a -> Bool)
-> (SourceInfo a -> SourceInfo a -> Bool)
-> (SourceInfo a -> SourceInfo a -> SourceInfo a)
-> (SourceInfo a -> SourceInfo a -> SourceInfo a)
-> Ord (SourceInfo a)
SourceInfo a -> SourceInfo a -> Bool
SourceInfo a -> SourceInfo a -> Ordering
SourceInfo a -> SourceInfo a -> SourceInfo a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (SourceInfo a)
forall a. Ord a => SourceInfo a -> SourceInfo a -> Bool
forall a. Ord a => SourceInfo a -> SourceInfo a -> Ordering
forall a. Ord a => SourceInfo a -> SourceInfo a -> SourceInfo a
$ccompare :: forall a. Ord a => SourceInfo a -> SourceInfo a -> Ordering
compare :: SourceInfo a -> SourceInfo a -> Ordering
$c< :: forall a. Ord a => SourceInfo a -> SourceInfo a -> Bool
< :: SourceInfo a -> SourceInfo a -> Bool
$c<= :: forall a. Ord a => SourceInfo a -> SourceInfo a -> Bool
<= :: SourceInfo a -> SourceInfo a -> Bool
$c> :: forall a. Ord a => SourceInfo a -> SourceInfo a -> Bool
> :: SourceInfo a -> SourceInfo a -> Bool
$c>= :: forall a. Ord a => SourceInfo a -> SourceInfo a -> Bool
>= :: SourceInfo a -> SourceInfo a -> Bool
$cmax :: forall a. Ord a => SourceInfo a -> SourceInfo a -> SourceInfo a
max :: SourceInfo a -> SourceInfo a -> SourceInfo a
$cmin :: forall a. Ord a => SourceInfo a -> SourceInfo a -> SourceInfo a
min :: SourceInfo a -> SourceInfo a -> SourceInfo a
Ord, (forall a b. (a -> b) -> SourceInfo a -> SourceInfo b)
-> (forall a b. a -> SourceInfo b -> SourceInfo a)
-> Functor SourceInfo
forall a b. a -> SourceInfo b -> SourceInfo a
forall a b. (a -> b) -> SourceInfo a -> SourceInfo b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> SourceInfo a -> SourceInfo b
fmap :: forall a b. (a -> b) -> SourceInfo a -> SourceInfo b
$c<$ :: forall a b. a -> SourceInfo b -> SourceInfo a
<$ :: forall a b. a -> SourceInfo b -> SourceInfo a
Functor, Typeable (SourceInfo a)
Typeable (SourceInfo a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SourceInfo a -> c (SourceInfo a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SourceInfo a))
-> (SourceInfo a -> Constr)
-> (SourceInfo a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SourceInfo a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SourceInfo a)))
-> ((forall b. Data b => b -> b) -> SourceInfo a -> SourceInfo a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceInfo a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceInfo a -> r)
-> (forall u. (forall d. Data d => d -> u) -> SourceInfo a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SourceInfo a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a))
-> Data (SourceInfo a)
SourceInfo a -> Constr
SourceInfo a -> DataType
(forall b. Data b => b -> b) -> SourceInfo a -> SourceInfo a
forall a. Data a => Typeable (SourceInfo a)
forall a. Data a => SourceInfo a -> Constr
forall a. Data a => SourceInfo a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> SourceInfo a -> SourceInfo a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SourceInfo a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> SourceInfo a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceInfo a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceInfo a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SourceInfo a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceInfo a -> c (SourceInfo a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SourceInfo a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SourceInfo a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SourceInfo a -> u
forall u. (forall d. Data d => d -> u) -> SourceInfo a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceInfo a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceInfo a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SourceInfo a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceInfo a -> c (SourceInfo a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SourceInfo a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SourceInfo a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceInfo a -> c (SourceInfo a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceInfo a -> c (SourceInfo a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SourceInfo a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SourceInfo a)
$ctoConstr :: forall a. Data a => SourceInfo a -> Constr
toConstr :: SourceInfo a -> Constr
$cdataTypeOf :: forall a. Data a => SourceInfo a -> DataType
dataTypeOf :: SourceInfo a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SourceInfo a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SourceInfo a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SourceInfo a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SourceInfo a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> SourceInfo a -> SourceInfo a
gmapT :: (forall b. Data b => b -> b) -> SourceInfo a -> SourceInfo a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceInfo a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceInfo a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceInfo a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceInfo a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> SourceInfo a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SourceInfo a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SourceInfo a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SourceInfo a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceInfo a -> m (SourceInfo a)
Data, (forall x. SourceInfo a -> Rep (SourceInfo a) x)
-> (forall x. Rep (SourceInfo a) x -> SourceInfo a)
-> Generic (SourceInfo a)
forall x. Rep (SourceInfo a) x -> SourceInfo a
forall x. SourceInfo a -> Rep (SourceInfo a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (SourceInfo a) x -> SourceInfo a
forall a x. SourceInfo a -> Rep (SourceInfo a) x
$cfrom :: forall a x. SourceInfo a -> Rep (SourceInfo a) x
from :: forall x. SourceInfo a -> Rep (SourceInfo a) x
$cto :: forall a x. Rep (SourceInfo a) x -> SourceInfo a
to :: forall x. Rep (SourceInfo a) x -> SourceInfo a
Generic, SourceInfo a -> ()
(SourceInfo a -> ()) -> NFData (SourceInfo a)
forall a. NFData a => SourceInfo a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => SourceInfo a -> ()
rnf :: SourceInfo a -> ()
NFData)

$(makeLenses ''SourceInfo)

instance Semigroup (SourceInfo a) where
  (SourceInfo Text
t Verilog a
v) <> :: SourceInfo a -> SourceInfo a -> SourceInfo a
<> (SourceInfo Text
_ Verilog a
v2) = Text -> Verilog a -> SourceInfo a
forall a. Text -> Verilog a -> SourceInfo a
SourceInfo Text
t (Verilog a -> SourceInfo a) -> Verilog a -> SourceInfo a
forall a b. (a -> b) -> a -> b
$ Verilog a
v Verilog a -> Verilog a -> Verilog a
forall a. Semigroup a => a -> a -> a
<> Verilog a
v2

instance Monoid (SourceInfo a) where
  mempty :: SourceInfo a
mempty = Text -> Verilog a -> SourceInfo a
forall a. Text -> Verilog a -> SourceInfo a
SourceInfo Text
forall a. Monoid a => a
mempty Verilog a
forall a. Monoid a => a
mempty

instance Annotations SourceInfo where
  removeAnn :: forall a. SourceInfo a -> SourceInfo a
removeAnn (SourceInfo Text
t Verilog a
v) = Text -> Verilog a -> SourceInfo a
forall a. Text -> Verilog a -> SourceInfo a
SourceInfo Text
t (Verilog a -> SourceInfo a) -> Verilog a -> SourceInfo a
forall a b. (a -> b) -> a -> b
$ Verilog a -> Verilog a
forall a. Verilog a -> Verilog a
forall (m :: * -> *) a. Annotations m => m a -> m a
removeAnn Verilog a
v
  collectAnn :: forall a. SourceInfo a -> [a]
collectAnn (SourceInfo Text
t Verilog a
v) = Verilog a -> [a]
forall a. Verilog a -> [a]
forall (m :: * -> *) a. Annotations m => m a -> [a]
collectAnn Verilog a
v

-- | Attributes which can be set to various nodes in the AST.
--
-- @
-- (* synthesis *)
-- @
data Attribute
  = AttrAssign Identifier ConstExpr
  | AttrName Identifier
  deriving (Attribute -> Attribute -> Bool
(Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool) -> Eq Attribute
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Attribute -> Attribute -> Bool
== :: Attribute -> Attribute -> Bool
$c/= :: Attribute -> Attribute -> Bool
/= :: Attribute -> Attribute -> Bool
Eq, Int -> Attribute -> ShowS
[Attribute] -> ShowS
Attribute -> String
(Int -> Attribute -> ShowS)
-> (Attribute -> String)
-> ([Attribute] -> ShowS)
-> Show Attribute
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Attribute -> ShowS
showsPrec :: Int -> Attribute -> ShowS
$cshow :: Attribute -> String
show :: Attribute -> String
$cshowList :: [Attribute] -> ShowS
showList :: [Attribute] -> ShowS
Show, Eq Attribute
Eq Attribute =>
(Attribute -> Attribute -> Ordering)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Attribute)
-> (Attribute -> Attribute -> Attribute)
-> Ord Attribute
Attribute -> Attribute -> Bool
Attribute -> Attribute -> Ordering
Attribute -> Attribute -> Attribute
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Attribute -> Attribute -> Ordering
compare :: Attribute -> Attribute -> Ordering
$c< :: Attribute -> Attribute -> Bool
< :: Attribute -> Attribute -> Bool
$c<= :: Attribute -> Attribute -> Bool
<= :: Attribute -> Attribute -> Bool
$c> :: Attribute -> Attribute -> Bool
> :: Attribute -> Attribute -> Bool
$c>= :: Attribute -> Attribute -> Bool
>= :: Attribute -> Attribute -> Bool
$cmax :: Attribute -> Attribute -> Attribute
max :: Attribute -> Attribute -> Attribute
$cmin :: Attribute -> Attribute -> Attribute
min :: Attribute -> Attribute -> Attribute
Ord, Typeable Attribute
Typeable Attribute =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Attribute -> c Attribute)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Attribute)
-> (Attribute -> Constr)
-> (Attribute -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Attribute))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute))
-> ((forall b. Data b => b -> b) -> Attribute -> Attribute)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Attribute -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Attribute -> r)
-> (forall u. (forall d. Data d => d -> u) -> Attribute -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Attribute -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attribute -> m Attribute)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attribute -> m Attribute)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attribute -> m Attribute)
-> Data Attribute
Attribute -> Constr
Attribute -> DataType
(forall b. Data b => b -> b) -> Attribute -> Attribute
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Attribute -> u
forall u. (forall d. Data d => d -> u) -> Attribute -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attribute
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute -> c Attribute
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attribute)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute -> c Attribute
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Attribute -> c Attribute
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attribute
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Attribute
$ctoConstr :: Attribute -> Constr
toConstr :: Attribute -> Constr
$cdataTypeOf :: Attribute -> DataType
dataTypeOf :: Attribute -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attribute)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Attribute)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attribute)
$cgmapT :: (forall b. Data b => b -> b) -> Attribute -> Attribute
gmapT :: (forall b. Data b => b -> b) -> Attribute -> Attribute
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Attribute -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Attribute -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Attribute -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attribute -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attribute -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Attribute -> m Attribute
Data, (forall x. Attribute -> Rep Attribute x)
-> (forall x. Rep Attribute x -> Attribute) -> Generic Attribute
forall x. Rep Attribute x -> Attribute
forall x. Attribute -> Rep Attribute x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Attribute -> Rep Attribute x
from :: forall x. Attribute -> Rep Attribute x
$cto :: forall x. Rep Attribute x -> Attribute
to :: forall x. Rep Attribute x -> Attribute
Generic, Attribute -> ()
(Attribute -> ()) -> NFData Attribute
forall a. (a -> ()) -> NFData a
$crnf :: Attribute -> ()
rnf :: Attribute -> ()
NFData)

-- | Annotations which can be added to the AST. These are supported in all the
-- nodes of the AST and a custom type can be declared for them.
data Annotation a
  = Ann a
  | AnnAttrs [Attribute]
  deriving (Annotation a -> Annotation a -> Bool
(Annotation a -> Annotation a -> Bool)
-> (Annotation a -> Annotation a -> Bool) -> Eq (Annotation a)
forall a. Eq a => Annotation a -> Annotation a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Annotation a -> Annotation a -> Bool
== :: Annotation a -> Annotation a -> Bool
$c/= :: forall a. Eq a => Annotation a -> Annotation a -> Bool
/= :: Annotation a -> Annotation a -> Bool
Eq, Int -> Annotation a -> ShowS
[Annotation a] -> ShowS
Annotation a -> String
(Int -> Annotation a -> ShowS)
-> (Annotation a -> String)
-> ([Annotation a] -> ShowS)
-> Show (Annotation a)
forall a. Show a => Int -> Annotation a -> ShowS
forall a. Show a => [Annotation a] -> ShowS
forall a. Show a => Annotation a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Annotation a -> ShowS
showsPrec :: Int -> Annotation a -> ShowS
$cshow :: forall a. Show a => Annotation a -> String
show :: Annotation a -> String
$cshowList :: forall a. Show a => [Annotation a] -> ShowS
showList :: [Annotation a] -> ShowS
Show, Eq (Annotation a)
Eq (Annotation a) =>
(Annotation a -> Annotation a -> Ordering)
-> (Annotation a -> Annotation a -> Bool)
-> (Annotation a -> Annotation a -> Bool)
-> (Annotation a -> Annotation a -> Bool)
-> (Annotation a -> Annotation a -> Bool)
-> (Annotation a -> Annotation a -> Annotation a)
-> (Annotation a -> Annotation a -> Annotation a)
-> Ord (Annotation a)
Annotation a -> Annotation a -> Bool
Annotation a -> Annotation a -> Ordering
Annotation a -> Annotation a -> Annotation a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Annotation a)
forall a. Ord a => Annotation a -> Annotation a -> Bool
forall a. Ord a => Annotation a -> Annotation a -> Ordering
forall a. Ord a => Annotation a -> Annotation a -> Annotation a
$ccompare :: forall a. Ord a => Annotation a -> Annotation a -> Ordering
compare :: Annotation a -> Annotation a -> Ordering
$c< :: forall a. Ord a => Annotation a -> Annotation a -> Bool
< :: Annotation a -> Annotation a -> Bool
$c<= :: forall a. Ord a => Annotation a -> Annotation a -> Bool
<= :: Annotation a -> Annotation a -> Bool
$c> :: forall a. Ord a => Annotation a -> Annotation a -> Bool
> :: Annotation a -> Annotation a -> Bool
$c>= :: forall a. Ord a => Annotation a -> Annotation a -> Bool
>= :: Annotation a -> Annotation a -> Bool
$cmax :: forall a. Ord a => Annotation a -> Annotation a -> Annotation a
max :: Annotation a -> Annotation a -> Annotation a
$cmin :: forall a. Ord a => Annotation a -> Annotation a -> Annotation a
min :: Annotation a -> Annotation a -> Annotation a
Ord, Typeable (Annotation a)
Typeable (Annotation a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Annotation a -> c (Annotation a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Annotation a))
-> (Annotation a -> Constr)
-> (Annotation a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Annotation a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Annotation a)))
-> ((forall b. Data b => b -> b) -> Annotation a -> Annotation a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Annotation a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Annotation a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Annotation a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a))
-> Data (Annotation a)
Annotation a -> Constr
Annotation a -> DataType
(forall b. Data b => b -> b) -> Annotation a -> Annotation a
forall a. Data a => Typeable (Annotation a)
forall a. Data a => Annotation a -> Constr
forall a. Data a => Annotation a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Annotation a -> Annotation a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Annotation a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Annotation a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Annotation a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation a -> c (Annotation a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Annotation a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Annotation a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Annotation a -> u
forall u. (forall d. Data d => d -> u) -> Annotation a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Annotation a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation a -> c (Annotation a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Annotation a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Annotation a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation a -> c (Annotation a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation a -> c (Annotation a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Annotation a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Annotation a)
$ctoConstr :: forall a. Data a => Annotation a -> Constr
toConstr :: Annotation a -> Constr
$cdataTypeOf :: forall a. Data a => Annotation a -> DataType
dataTypeOf :: Annotation a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Annotation a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Annotation a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Annotation a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Annotation a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Annotation a -> Annotation a
gmapT :: (forall b. Data b => b -> b) -> Annotation a -> Annotation a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Annotation a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Annotation a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Annotation a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Annotation a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation a -> m (Annotation a)
Data, (forall x. Annotation a -> Rep (Annotation a) x)
-> (forall x. Rep (Annotation a) x -> Annotation a)
-> Generic (Annotation a)
forall x. Rep (Annotation a) x -> Annotation a
forall x. Annotation a -> Rep (Annotation a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Annotation a) x -> Annotation a
forall a x. Annotation a -> Rep (Annotation a) x
$cfrom :: forall a x. Annotation a -> Rep (Annotation a) x
from :: forall x. Annotation a -> Rep (Annotation a) x
$cto :: forall a x. Rep (Annotation a) x -> Annotation a
to :: forall x. Rep (Annotation a) x -> Annotation a
Generic, Annotation a -> ()
(Annotation a -> ()) -> NFData (Annotation a)
forall a. NFData a => Annotation a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => Annotation a -> ()
rnf :: Annotation a -> ()
NFData)

getModule :: Traversal' (Verilog a) (ModDecl a)
getModule :: forall a (f :: * -> *).
Applicative f =>
(ModDecl a -> f (ModDecl a)) -> Verilog a -> f (Verilog a)
getModule = ([ModDecl a] -> f [ModDecl a]) -> Verilog a -> f (Verilog a)
(Unwrapped (Verilog a) -> f (Unwrapped (Verilog a)))
-> Verilog a -> f (Verilog a)
forall s t. Rewrapping s t => Iso s t (Unwrapped s) (Unwrapped t)
Iso
  (Verilog a)
  (Verilog a)
  (Unwrapped (Verilog a))
  (Unwrapped (Verilog a))
_Wrapped (([ModDecl a] -> f [ModDecl a]) -> Verilog a -> f (Verilog a))
-> ((ModDecl a -> f (ModDecl a)) -> [ModDecl a] -> f [ModDecl a])
-> (ModDecl a -> f (ModDecl a))
-> Verilog a
-> f (Verilog a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ModDecl a -> f (ModDecl a)) -> [ModDecl a] -> f [ModDecl a]
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
{-# INLINE getModule #-}

getSourceId :: Traversal' (Verilog a) Text
getSourceId :: forall a (f :: * -> *).
Applicative f =>
(Text -> f Text) -> Verilog a -> f (Verilog a)
getSourceId = (ModDecl a -> f (ModDecl a)) -> Verilog a -> f (Verilog a)
forall a (f :: * -> *).
Applicative f =>
(ModDecl a -> f (ModDecl a)) -> Verilog a -> f (Verilog a)
getModule ((ModDecl a -> f (ModDecl a)) -> Verilog a -> f (Verilog a))
-> ((Text -> f Text) -> ModDecl a -> f (ModDecl a))
-> (Text -> f Text)
-> Verilog a
-> f (Verilog a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
modId ((Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a))
-> ((Text -> f Text) -> Identifier -> f Identifier)
-> (Text -> f Text)
-> ModDecl a
-> f (ModDecl a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped Identifier -> f (Unwrapped Identifier))
-> Identifier -> f Identifier
(Text -> f Text) -> Identifier -> f Identifier
forall s t. Rewrapping s t => Iso s t (Unwrapped s) (Unwrapped t)
Iso' Identifier (Unwrapped Identifier)
_Wrapped
{-# INLINE getSourceId #-}

-- | May need to change this to Traversal to be safe. For now it will fail when
-- the main has not been properly set with.
aModule :: Identifier -> Lens' (SourceInfo a) (ModDecl a)
aModule :: forall a. Identifier -> Lens' (SourceInfo a) (ModDecl a)
aModule Identifier
t = (SourceInfo a -> ModDecl a)
-> (SourceInfo a -> ModDecl a -> SourceInfo a)
-> Lens (SourceInfo a) (SourceInfo a) (ModDecl a) (ModDecl a)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens SourceInfo a -> ModDecl a
get_ SourceInfo a -> ModDecl a -> SourceInfo a
set_
  where
    set_ :: SourceInfo a -> ModDecl a -> SourceInfo a
set_ (SourceInfo Text
top Verilog a
main) ModDecl a
v =
      Text -> Verilog a -> SourceInfo a
forall a. Text -> Verilog a -> SourceInfo a
SourceInfo Text
top (Verilog a
main Verilog a -> (Verilog a -> Verilog a) -> Verilog a
forall a b. a -> (a -> b) -> b
& (ModDecl a -> Identity (ModDecl a))
-> Verilog a -> Identity (Verilog a)
forall a (f :: * -> *).
Applicative f =>
(ModDecl a -> f (ModDecl a)) -> Verilog a -> f (Verilog a)
getModule ((ModDecl a -> Identity (ModDecl a))
 -> Verilog a -> Identity (Verilog a))
-> (ModDecl a -> ModDecl a) -> Verilog a -> Verilog a
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ Text -> ModDecl a -> ModDecl a -> ModDecl a
forall {a}. Text -> ModDecl a -> ModDecl a -> ModDecl a
update (Identifier -> Text
getIdentifier Identifier
t) ModDecl a
v)
    update :: Text -> ModDecl a -> ModDecl a -> ModDecl a
update Text
top ModDecl a
v m :: ModDecl a
m@(ModDecl (Identifier Text
i) [Port]
_ [Port]
_ [ModItem a]
_ [Parameter]
_)
      | Text
i Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
top = ModDecl a
v
      | Bool
otherwise = ModDecl a
m
    update Text
top ModDecl a
v (ModDeclAnn a
_ ModDecl a
m) = Text -> ModDecl a -> ModDecl a -> ModDecl a
update Text
top ModDecl a
v ModDecl a
m
    get_ :: SourceInfo a -> ModDecl a
get_ (SourceInfo Text
_ Verilog a
main) =
      [ModDecl a] -> ModDecl a
forall a. HasCallStack => [a] -> a
head ([ModDecl a] -> ModDecl a)
-> ([ModDecl a] -> [ModDecl a]) -> [ModDecl a] -> ModDecl a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ModDecl a -> Bool) -> [ModDecl a] -> [ModDecl a]
forall a. (a -> Bool) -> [a] -> [a]
filter (Text -> ModDecl a -> Bool
forall {a}. Text -> ModDecl a -> Bool
f (Text -> ModDecl a -> Bool) -> Text -> ModDecl a -> Bool
forall a b. (a -> b) -> a -> b
$ Identifier -> Text
getIdentifier Identifier
t) ([ModDecl a] -> ModDecl a) -> [ModDecl a] -> ModDecl a
forall a b. (a -> b) -> a -> b
$ Verilog a
main Verilog a
-> Getting (Endo [ModDecl a]) (Verilog a) (ModDecl a)
-> [ModDecl a]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. Getting (Endo [ModDecl a]) (Verilog a) (ModDecl a)
forall a (f :: * -> *).
Applicative f =>
(ModDecl a -> f (ModDecl a)) -> Verilog a -> f (Verilog a)
getModule
    f :: Text -> ModDecl a -> Bool
f Text
top (ModDecl (Identifier Text
i) [Port]
_ [Port]
_ [ModItem a]
_ [Parameter]
_) = Text
i Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
top
    f Text
top (ModDeclAnn a
_ ModDecl a
m) = Text -> ModDecl a -> Bool
f Text
top ModDecl a
m

-- | May need to change this to Traversal to be safe. For now it will fail when
-- the main has not been properly set with.
mainModule :: Lens' (SourceInfo a) (ModDecl a)
mainModule :: forall a (f :: * -> *).
Functor f =>
(ModDecl a -> f (ModDecl a)) -> SourceInfo a -> f (SourceInfo a)
mainModule = (SourceInfo a -> ModDecl a)
-> (SourceInfo a -> ModDecl a -> SourceInfo a)
-> Lens (SourceInfo a) (SourceInfo a) (ModDecl a) (ModDecl a)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens SourceInfo a -> ModDecl a
forall {a}. SourceInfo a -> ModDecl a
get_ SourceInfo a -> ModDecl a -> SourceInfo a
forall {a}. SourceInfo a -> ModDecl a -> SourceInfo a
set_
  where
    set_ :: SourceInfo a -> ModDecl a -> SourceInfo a
set_ (SourceInfo Text
top Verilog a
main) ModDecl a
v =
      Text -> Verilog a -> SourceInfo a
forall a. Text -> Verilog a -> SourceInfo a
SourceInfo Text
top (Verilog a
main Verilog a -> (Verilog a -> Verilog a) -> Verilog a
forall a b. a -> (a -> b) -> b
& (ModDecl a -> Identity (ModDecl a))
-> Verilog a -> Identity (Verilog a)
forall a (f :: * -> *).
Applicative f =>
(ModDecl a -> f (ModDecl a)) -> Verilog a -> f (Verilog a)
getModule ((ModDecl a -> Identity (ModDecl a))
 -> Verilog a -> Identity (Verilog a))
-> (ModDecl a -> ModDecl a) -> Verilog a -> Verilog a
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ Text -> ModDecl a -> ModDecl a -> ModDecl a
forall {a}. Text -> ModDecl a -> ModDecl a -> ModDecl a
update Text
top ModDecl a
v)
    update :: Text -> ModDecl a -> ModDecl a -> ModDecl a
update Text
top ModDecl a
v m :: ModDecl a
m@(ModDecl (Identifier Text
i) [Port]
_ [Port]
_ [ModItem a]
_ [Parameter]
_)
      | Text
i Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
top = ModDecl a
v
      | Bool
otherwise = ModDecl a
m
    update Text
top ModDecl a
v (ModDeclAnn a
_ ModDecl a
m) = Text -> ModDecl a -> ModDecl a -> ModDecl a
update Text
top ModDecl a
v ModDecl a
m
    get_ :: SourceInfo a -> ModDecl a
get_ (SourceInfo Text
top Verilog a
main) = [ModDecl a] -> ModDecl a
forall a. HasCallStack => [a] -> a
head ([ModDecl a] -> ModDecl a)
-> ([ModDecl a] -> [ModDecl a]) -> [ModDecl a] -> ModDecl a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ModDecl a -> Bool) -> [ModDecl a] -> [ModDecl a]
forall a. (a -> Bool) -> [a] -> [a]
filter (Text -> ModDecl a -> Bool
forall {a}. Text -> ModDecl a -> Bool
f Text
top) ([ModDecl a] -> ModDecl a) -> [ModDecl a] -> ModDecl a
forall a b. (a -> b) -> a -> b
$ Verilog a
main Verilog a
-> Getting (Endo [ModDecl a]) (Verilog a) (ModDecl a)
-> [ModDecl a]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. Getting (Endo [ModDecl a]) (Verilog a) (ModDecl a)
forall a (f :: * -> *).
Applicative f =>
(ModDecl a -> f (ModDecl a)) -> Verilog a -> f (Verilog a)
getModule
    f :: Text -> ModDecl a -> Bool
f Text
top (ModDecl (Identifier Text
i) [Port]
_ [Port]
_ [ModItem a]
_ [Parameter]
_) = Text
i Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
top
    f Text
top (ModDeclAnn a
_ ModDecl a
m) = Text -> ModDecl a -> Bool
f Text
top ModDecl a
m