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
-- | An expression on signals
data SignalExpr =
EqLit SignalId String -- ^ Is the given signal equal to the given (VHDL) literal
- | Literal String -- ^ A literal value
+ | Literal String (Maybe Type.Type)-- ^ A literal value, with an optional type to cast to
| Eq SignalId SignalId -- ^ A comparison between to signals
deriving (Show, Eq)
+-- Instantiate Eq for Type, so we can derive Eq for SignalExpr.
+instance Eq Type.Type where
+ (==) = Type.coreEqType
+
-- | Which signals are used by the given SignalExpr?
sigExprUses :: SignalExpr -> [SignalId]
sigExprUses (EqLit id _) = [id]
-sigExprUses (Literal _) = []
+sigExprUses (Literal _ _) = []
sigExprUses (Eq a b) = [a, b]
-- Returns the function used by the given SigDef, if any
| 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
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.