import qualified Maybe
import Data.Traversable
import qualified Data.Foldable as Foldable
-import qualified Control.Monad.State as State
+import qualified Control.Monad.Trans.State as State
import CoreSyn
import qualified Type
import HsValueMap
+import CoreShow
-- | A signal identifier
type SignalId = Int
(FApp _ _ _) -> True
_ -> False
+-- | Which signals are used by the given SigDef?
+sigDefUses :: SigDef -> [SignalId]
+sigDefUses (UncondDef (Left id) _) = [id]
+sigDefUses (UncondDef (Right expr) _) = sigExprUses expr
+sigDefUses (CondDef cond true false _) = [cond, true, false]
+sigDefUses (FApp _ args _) = concat $ map Foldable.toList args
+
-- | An expression on signals
data SignalExpr =
EqLit SignalId String -- ^ Is the given signal equal to the given (VHDL) literal
| Eq SignalId SignalId -- ^ A comparison between to signals
deriving (Show, Eq)
+-- | Which signals are used by the given SignalExpr?
+sigExprUses :: SignalExpr -> [SignalId]
+sigExprUses (EqLit id _) = [id]
+sigExprUses (Literal _) = []
+sigExprUses (Eq a b) = [a, b]
+
-- Returns the function used by the given SigDef, if any
usedHsFunc :: SigDef -> Maybe HsFunction
usedHsFunc (FApp hsfunc _ _) = Just hsfunc
| SigStateOld StateId -- | Use as the current internal state
| SigStateNew StateId -- | Use as the new internal state
| SigSubState -- | Do not use, state variable is used in a subcircuit
+ deriving (Show)
-- | Is this a port signal use?
isPortSigUse :: SigUse -> Bool
isInternalSigUse SigInternal = True
isInternalSigUse _ = False
+oldStateId :: SigUse -> Maybe StateId
+oldStateId (SigStateOld id) = Just id
+oldStateId _ = Nothing
+
+newStateId :: SigUse -> Maybe StateId
+newStateId (SigStateNew id) = Just id
+newStateId _ = Nothing
+
-- | Information on a signal definition
data SignalInfo = SignalInfo {
sigName :: Maybe String,
sigUse :: SigUse,
sigTy :: Type.Type,
nameHints :: [String]
-}
+} deriving (Show)
-- | A flattened function
data FlatFunction = FlatFunction {
flat_res :: SignalMap,
flat_defs :: [SigDef],
flat_sigs :: [(SignalId, SignalInfo)]
-}
+} deriving (Show)
-- | Lookup a given signal id in a signal map, and return the associated
-- SignalInfo. Errors out if the signal was not found.
(defs, sigs, n) <- State.get
let sigs' = map (\(id, info) -> (id, if id == id' then info' else info)) sigs
State.put (defs, sigs', n)
+
+-- vim: set ts=8 sw=2 sts=2 expandtab: