-- This corresponds to src/comp/VModInfo.hs in bsc.
module Language.Bluespec.Classic.AST.VModInfo
  ( VName(..)
  , VPathInfo(..)
  , VeriPortProp(..)
  , VArgInfo(..)
  , VPort
  , VSchedInfo
  , VFieldInfo(..)
  , InputClockInf
  , OutputClockInf
  , VOscPort
  , VInputGatePort
  , VOutputGatePort
  , VClockInfo(..)
  , ResetInf
  , VResetInfo(..)
  ) where

import qualified Data.List as L
import Text.PrettyPrint.HughesPJClass

import Language.Bluespec.Classic.AST.Id
import Language.Bluespec.Classic.AST.Position
import Language.Bluespec.Classic.AST.SchedInfo
import Language.Bluespec.Prelude
import Language.Bluespec.Pretty

newtype VName = VName String
        deriving (VName -> VName -> Bool
(VName -> VName -> Bool) -> (VName -> VName -> Bool) -> Eq VName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VName -> VName -> Bool
== :: VName -> VName -> Bool
$c/= :: VName -> VName -> Bool
/= :: VName -> VName -> Bool
Eq, Eq VName
Eq VName =>
(VName -> VName -> Ordering)
-> (VName -> VName -> Bool)
-> (VName -> VName -> Bool)
-> (VName -> VName -> Bool)
-> (VName -> VName -> Bool)
-> (VName -> VName -> VName)
-> (VName -> VName -> VName)
-> Ord VName
VName -> VName -> Bool
VName -> VName -> Ordering
VName -> VName -> VName
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 :: VName -> VName -> Ordering
compare :: VName -> VName -> Ordering
$c< :: VName -> VName -> Bool
< :: VName -> VName -> Bool
$c<= :: VName -> VName -> Bool
<= :: VName -> VName -> Bool
$c> :: VName -> VName -> Bool
> :: VName -> VName -> Bool
$c>= :: VName -> VName -> Bool
>= :: VName -> VName -> Bool
$cmax :: VName -> VName -> VName
max :: VName -> VName -> VName
$cmin :: VName -> VName -> VName
min :: VName -> VName -> VName
Ord, Int -> VName -> String -> String
[VName] -> String -> String
VName -> String
(Int -> VName -> String -> String)
-> (VName -> String) -> ([VName] -> String -> String) -> Show VName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VName -> String -> String
showsPrec :: Int -> VName -> String -> String
$cshow :: VName -> String
show :: VName -> String
$cshowList :: [VName] -> String -> String
showList :: [VName] -> String -> String
Show)

instance Pretty VName where
    pPrintPrec :: PrettyLevel -> Rational -> VName -> Doc
pPrintPrec PrettyLevel
_ Rational
_ (VName String
s) = String -> Doc
text String
s

newtype VPathInfo = VPathInfo [(VName, VName)]
                  deriving (VPathInfo -> VPathInfo -> Bool
(VPathInfo -> VPathInfo -> Bool)
-> (VPathInfo -> VPathInfo -> Bool) -> Eq VPathInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VPathInfo -> VPathInfo -> Bool
== :: VPathInfo -> VPathInfo -> Bool
$c/= :: VPathInfo -> VPathInfo -> Bool
/= :: VPathInfo -> VPathInfo -> Bool
Eq, Eq VPathInfo
Eq VPathInfo =>
(VPathInfo -> VPathInfo -> Ordering)
-> (VPathInfo -> VPathInfo -> Bool)
-> (VPathInfo -> VPathInfo -> Bool)
-> (VPathInfo -> VPathInfo -> Bool)
-> (VPathInfo -> VPathInfo -> Bool)
-> (VPathInfo -> VPathInfo -> VPathInfo)
-> (VPathInfo -> VPathInfo -> VPathInfo)
-> Ord VPathInfo
VPathInfo -> VPathInfo -> Bool
VPathInfo -> VPathInfo -> Ordering
VPathInfo -> VPathInfo -> VPathInfo
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 :: VPathInfo -> VPathInfo -> Ordering
compare :: VPathInfo -> VPathInfo -> Ordering
$c< :: VPathInfo -> VPathInfo -> Bool
< :: VPathInfo -> VPathInfo -> Bool
$c<= :: VPathInfo -> VPathInfo -> Bool
<= :: VPathInfo -> VPathInfo -> Bool
$c> :: VPathInfo -> VPathInfo -> Bool
> :: VPathInfo -> VPathInfo -> Bool
$c>= :: VPathInfo -> VPathInfo -> Bool
>= :: VPathInfo -> VPathInfo -> Bool
$cmax :: VPathInfo -> VPathInfo -> VPathInfo
max :: VPathInfo -> VPathInfo -> VPathInfo
$cmin :: VPathInfo -> VPathInfo -> VPathInfo
min :: VPathInfo -> VPathInfo -> VPathInfo
Ord, Int -> VPathInfo -> String -> String
[VPathInfo] -> String -> String
VPathInfo -> String
(Int -> VPathInfo -> String -> String)
-> (VPathInfo -> String)
-> ([VPathInfo] -> String -> String)
-> Show VPathInfo
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VPathInfo -> String -> String
showsPrec :: Int -> VPathInfo -> String -> String
$cshow :: VPathInfo -> String
show :: VPathInfo -> String
$cshowList :: [VPathInfo] -> String -> String
showList :: [VPathInfo] -> String -> String
Show)

instance Pretty VPathInfo where
    pPrintPrec :: PrettyLevel -> Rational -> VPathInfo -> Doc
pPrintPrec PrettyLevel
_d Rational
_p (VPathInfo []) =
        String -> Doc
s2par String
"No combinational paths from inputs to outputs"
    pPrintPrec PrettyLevel
d Rational
p (VPathInfo [(VName, VName)]
nns) =
        let
            -- function to join paths going to the same output
            joinPaths :: [(b, b)] -> [([b], b)]
joinPaths [] = []
            joinPaths zs :: [(b, b)]
zs@((b
_,b
o):[(b, b)]
_) =
                case (((b, b) -> Bool) -> [(b, b)] -> ([(b, b)], [(b, b)])
forall a. (a -> Bool) -> [a] -> ([a], [a])
L.partition ((b -> b -> Bool
forall a. Eq a => a -> a -> Bool
== b
o) (b -> Bool) -> ((b, b) -> b) -> (b, b) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b, b) -> b
forall a b. (a, b) -> b
snd) [(b, b)]
zs) of
                    ([(b, b)]
xs, [(b, b)]
ys) -> (((b, b) -> b) -> [(b, b)] -> [b]
forall a b. (a -> b) -> [a] -> [b]
map (b, b) -> b
forall a b. (a, b) -> a
fst [(b, b)]
xs, b
o) ([b], b) -> [([b], b)] -> [([b], b)]
forall a. a -> [a] -> [a]
: [(b, b)] -> [([b], b)]
joinPaths [(b, b)]
ys

            -- function to display one pair
            ppOne :: ([a], a) -> Doc
ppOne ([a
i],a
out) = PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p a
i Doc -> Doc -> Doc
<+> String -> Doc
text String
"->" Doc -> Doc -> Doc
<+> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p a
out
            ppOne ([a]
ins,a
out) = String -> Doc
text String
"(" Doc -> Doc -> Doc
<>
                              [Doc] -> Doc -> Doc
sepList ((a -> Doc) -> [a] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p) [a]
ins) (String -> Doc
text String
",") Doc -> Doc -> Doc
<>
                              String -> Doc
text String
")" Doc -> Doc -> Doc
<+> String -> Doc
text String
"->" Doc -> Doc -> Doc
<+> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p a
out
        in
            String -> Doc
s2par String
"Combinational paths from inputs to outputs:" Doc -> Doc -> Doc
$+$
            Int -> Doc -> Doc
nest Int
2 ([Doc] -> Doc
vcat ((([VName], VName) -> Doc) -> [([VName], VName)] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map ([VName], VName) -> Doc
forall {a} {a}. (Pretty a, Pretty a) => ([a], a) -> Doc
ppOne ([(VName, VName)] -> [([VName], VName)]
forall {b} {b}. Eq b => [(b, b)] -> [([b], b)]
joinPaths [(VName, VName)]
nns)))

instance HasPosition VFieldInfo where
  getPosition :: VFieldInfo -> Position
getPosition (Method { vf_name :: VFieldInfo -> Id
vf_name = Id
n }) = Id -> Position
forall a. HasPosition a => a -> Position
getPosition Id
n
  getPosition (Clock Id
i)                 = Id -> Position
forall a. HasPosition a => a -> Position
getPosition Id
i -- or noPosition?
  getPosition (Reset Id
i)                 = Id -> Position
forall a. HasPosition a => a -> Position
getPosition Id
i -- or noPosition?
  getPosition (Inout { vf_name :: VFieldInfo -> Id
vf_name = Id
n })  = Id -> Position
forall a. HasPosition a => a -> Position
getPosition Id
n

-- the order is important for VIOProps ("unused" should come last)
data VeriPortProp = VPreg
                  | VPconst
                  | VPinhigh
                  | VPouthigh
                  | VPclock
                  | VPclockgate
                  | VPreset
                  | VPinout
                  | VPunused
        deriving (VeriPortProp -> VeriPortProp -> Bool
(VeriPortProp -> VeriPortProp -> Bool)
-> (VeriPortProp -> VeriPortProp -> Bool) -> Eq VeriPortProp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VeriPortProp -> VeriPortProp -> Bool
== :: VeriPortProp -> VeriPortProp -> Bool
$c/= :: VeriPortProp -> VeriPortProp -> Bool
/= :: VeriPortProp -> VeriPortProp -> Bool
Eq, Eq VeriPortProp
Eq VeriPortProp =>
(VeriPortProp -> VeriPortProp -> Ordering)
-> (VeriPortProp -> VeriPortProp -> Bool)
-> (VeriPortProp -> VeriPortProp -> Bool)
-> (VeriPortProp -> VeriPortProp -> Bool)
-> (VeriPortProp -> VeriPortProp -> Bool)
-> (VeriPortProp -> VeriPortProp -> VeriPortProp)
-> (VeriPortProp -> VeriPortProp -> VeriPortProp)
-> Ord VeriPortProp
VeriPortProp -> VeriPortProp -> Bool
VeriPortProp -> VeriPortProp -> Ordering
VeriPortProp -> VeriPortProp -> VeriPortProp
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 :: VeriPortProp -> VeriPortProp -> Ordering
compare :: VeriPortProp -> VeriPortProp -> Ordering
$c< :: VeriPortProp -> VeriPortProp -> Bool
< :: VeriPortProp -> VeriPortProp -> Bool
$c<= :: VeriPortProp -> VeriPortProp -> Bool
<= :: VeriPortProp -> VeriPortProp -> Bool
$c> :: VeriPortProp -> VeriPortProp -> Bool
> :: VeriPortProp -> VeriPortProp -> Bool
$c>= :: VeriPortProp -> VeriPortProp -> Bool
>= :: VeriPortProp -> VeriPortProp -> Bool
$cmax :: VeriPortProp -> VeriPortProp -> VeriPortProp
max :: VeriPortProp -> VeriPortProp -> VeriPortProp
$cmin :: VeriPortProp -> VeriPortProp -> VeriPortProp
min :: VeriPortProp -> VeriPortProp -> VeriPortProp
Ord, Int -> VeriPortProp -> String -> String
[VeriPortProp] -> String -> String
VeriPortProp -> String
(Int -> VeriPortProp -> String -> String)
-> (VeriPortProp -> String)
-> ([VeriPortProp] -> String -> String)
-> Show VeriPortProp
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VeriPortProp -> String -> String
showsPrec :: Int -> VeriPortProp -> String -> String
$cshow :: VeriPortProp -> String
show :: VeriPortProp -> String
$cshowList :: [VeriPortProp] -> String -> String
showList :: [VeriPortProp] -> String -> String
Show)

instance Pretty VeriPortProp where
    pPrintPrec :: PrettyLevel -> Rational -> VeriPortProp -> Doc
pPrintPrec PrettyLevel
_ Rational
_ VeriPortProp
VPreg = String -> Doc
text String
"reg"
    pPrintPrec PrettyLevel
_ Rational
_ VeriPortProp
VPclock = String -> Doc
text String
"clock"
    pPrintPrec PrettyLevel
_ Rational
_ VeriPortProp
VPconst = String -> Doc
text String
"const"
    pPrintPrec PrettyLevel
_ Rational
_ VeriPortProp
VPinhigh = String -> Doc
text String
"inhigh"
    pPrintPrec PrettyLevel
_ Rational
_ VeriPortProp
VPouthigh = String -> Doc
text String
"outhigh"
    pPrintPrec PrettyLevel
_ Rational
_ VeriPortProp
VPunused = String -> Doc
text String
"unused"
    pPrintPrec PrettyLevel
_ Rational
_ VeriPortProp
VPreset  = String -> Doc
text String
"reset"
    pPrintPrec PrettyLevel
_ Rational
_ VeriPortProp
VPinout  = String -> Doc
text String
"inout"
    pPrintPrec PrettyLevel
_ Rational
_ VeriPortProp
VPclockgate = String -> Doc
text String
"clock gate"

data VArgInfo = Param VName    -- named module parameter
              -- named module port, with associated clock and reset
              | Port VPort (Maybe Id) (Maybe Id)
              | ClockArg Id    -- named clock
              | ResetArg Id    -- named reset
              -- named module inout, with associated clock and reset
              | InoutArg VName (Maybe Id) (Maybe Id)
              deriving (VArgInfo -> VArgInfo -> Bool
(VArgInfo -> VArgInfo -> Bool)
-> (VArgInfo -> VArgInfo -> Bool) -> Eq VArgInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VArgInfo -> VArgInfo -> Bool
== :: VArgInfo -> VArgInfo -> Bool
$c/= :: VArgInfo -> VArgInfo -> Bool
/= :: VArgInfo -> VArgInfo -> Bool
Eq, Eq VArgInfo
Eq VArgInfo =>
(VArgInfo -> VArgInfo -> Ordering)
-> (VArgInfo -> VArgInfo -> Bool)
-> (VArgInfo -> VArgInfo -> Bool)
-> (VArgInfo -> VArgInfo -> Bool)
-> (VArgInfo -> VArgInfo -> Bool)
-> (VArgInfo -> VArgInfo -> VArgInfo)
-> (VArgInfo -> VArgInfo -> VArgInfo)
-> Ord VArgInfo
VArgInfo -> VArgInfo -> Bool
VArgInfo -> VArgInfo -> Ordering
VArgInfo -> VArgInfo -> VArgInfo
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 :: VArgInfo -> VArgInfo -> Ordering
compare :: VArgInfo -> VArgInfo -> Ordering
$c< :: VArgInfo -> VArgInfo -> Bool
< :: VArgInfo -> VArgInfo -> Bool
$c<= :: VArgInfo -> VArgInfo -> Bool
<= :: VArgInfo -> VArgInfo -> Bool
$c> :: VArgInfo -> VArgInfo -> Bool
> :: VArgInfo -> VArgInfo -> Bool
$c>= :: VArgInfo -> VArgInfo -> Bool
>= :: VArgInfo -> VArgInfo -> Bool
$cmax :: VArgInfo -> VArgInfo -> VArgInfo
max :: VArgInfo -> VArgInfo -> VArgInfo
$cmin :: VArgInfo -> VArgInfo -> VArgInfo
min :: VArgInfo -> VArgInfo -> VArgInfo
Ord, Int -> VArgInfo -> String -> String
[VArgInfo] -> String -> String
VArgInfo -> String
(Int -> VArgInfo -> String -> String)
-> (VArgInfo -> String)
-> ([VArgInfo] -> String -> String)
-> Show VArgInfo
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VArgInfo -> String -> String
showsPrec :: Int -> VArgInfo -> String -> String
$cshow :: VArgInfo -> String
show :: VArgInfo -> String
$cshowList :: [VArgInfo] -> String -> String
showList :: [VArgInfo] -> String -> String
Show)

instance Pretty VArgInfo where
    pPrintPrec :: PrettyLevel -> Rational -> VArgInfo -> Doc
pPrintPrec PrettyLevel
d Rational
_p (Param VName
x) = String -> Doc
text String
"param " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> VName -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 VName
x Doc -> Doc -> Doc
<> String -> Doc
text String
";"
    pPrintPrec PrettyLevel
d Rational
_p (Port VPort
x Maybe Id
mclk Maybe Id
mrst) =
        String -> Doc
text String
"port " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> VPort -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 VPort
x Doc -> Doc -> Doc
<+>
        PrettyLevel -> Maybe Id -> Doc
ppMClk PrettyLevel
d Maybe Id
mclk Doc -> Doc -> Doc
<+> PrettyLevel -> Maybe Id -> Doc
ppMRst PrettyLevel
d Maybe Id
mrst Doc -> Doc -> Doc
<>
        String -> Doc
text String
";"
    pPrintPrec PrettyLevel
d Rational
p (ClockArg Id
x) = String -> Doc
text String
"clockarg " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> Id -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p Id
x Doc -> Doc -> Doc
<> String -> Doc
text String
";"
    pPrintPrec PrettyLevel
d Rational
p (ResetArg Id
x) = String -> Doc
text String
"resetarg " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> Id -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p Id
x Doc -> Doc -> Doc
<> String -> Doc
text String
";"
    pPrintPrec PrettyLevel
d Rational
_p (InoutArg VName
x Maybe Id
mclk Maybe Id
mrst) =
        String -> Doc
text String
"inoutarg " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> VName -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 VName
x Doc -> Doc -> Doc
<+>
        PrettyLevel -> Maybe Id -> Doc
ppMClk PrettyLevel
d Maybe Id
mclk Doc -> Doc -> Doc
<+> PrettyLevel -> Maybe Id -> Doc
ppMRst PrettyLevel
d Maybe Id
mrst Doc -> Doc -> Doc
<>
        String -> Doc
text String
";"

ppMClk :: PDetail -> Maybe Id -> Doc
ppMClk :: PrettyLevel -> Maybe Id -> Doc
ppMClk PrettyLevel
d Maybe Id
mclk =
    let clk :: Doc
clk = case Maybe Id
mclk of
                  Maybe Id
Nothing -> String -> Doc
text String
"no_clock"
                  Just Id
c  -> PrettyLevel -> Rational -> Id -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 Id
c
    in  String -> Doc
text String
"clocked_by (" Doc -> Doc -> Doc
<> Doc
clk Doc -> Doc -> Doc
<> String -> Doc
text String
")"

ppMRst :: PDetail -> Maybe Id -> Doc
ppMRst :: PrettyLevel -> Maybe Id -> Doc
ppMRst PrettyLevel
d Maybe Id
mrst =
    let rst :: Doc
rst = case Maybe Id
mrst of
                  Maybe Id
Nothing -> String -> Doc
text String
"no_reset"
                  Just Id
r  -> PrettyLevel -> Rational -> Id -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 Id
r
    in  String -> Doc
text String
"reset_by (" Doc -> Doc -> Doc
<> Doc
rst Doc -> Doc -> Doc
<> String -> Doc
text String
")"

type VPort = (VName, [VeriPortProp])

type VSchedInfo = SchedInfo Id

-- XXX why does the VFieldInfo not contain a ready signal?
data VFieldInfo = Method { VFieldInfo -> Id
vf_name   :: Id, -- method name
                           VFieldInfo -> Maybe Id
vf_clock  :: (Maybe Id), -- optional clock
                           -- optional because the method may be combinational
                           VFieldInfo -> Maybe Id
vf_reset  :: (Maybe Id), -- optional reset
                           -- optional because the method may be independent of a reset signal
                           VFieldInfo -> Integer
vf_mult   :: Integer, -- multiplicity
                           VFieldInfo -> [VPort]
vf_inputs :: [VPort],
                           VFieldInfo -> Maybe VPort
vf_output :: Maybe VPort,
                           VFieldInfo -> Maybe VPort
vf_enable :: Maybe VPort }
                | Clock { vf_name :: Id } -- output clock name
                                           -- connection information is in the ClockInfo
                | Reset { vf_name :: Id } -- output reset name
                                           -- connection information is in the ResetInfo
                | Inout { vf_name :: Id, -- output inout name
                          VFieldInfo -> VName
vf_inout :: VName,
                          vf_clock :: (Maybe Id), -- optional clock
                          vf_reset :: (Maybe Id) } -- optional reset
                deriving (VFieldInfo -> VFieldInfo -> Bool
(VFieldInfo -> VFieldInfo -> Bool)
-> (VFieldInfo -> VFieldInfo -> Bool) -> Eq VFieldInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VFieldInfo -> VFieldInfo -> Bool
== :: VFieldInfo -> VFieldInfo -> Bool
$c/= :: VFieldInfo -> VFieldInfo -> Bool
/= :: VFieldInfo -> VFieldInfo -> Bool
Eq, Eq VFieldInfo
Eq VFieldInfo =>
(VFieldInfo -> VFieldInfo -> Ordering)
-> (VFieldInfo -> VFieldInfo -> Bool)
-> (VFieldInfo -> VFieldInfo -> Bool)
-> (VFieldInfo -> VFieldInfo -> Bool)
-> (VFieldInfo -> VFieldInfo -> Bool)
-> (VFieldInfo -> VFieldInfo -> VFieldInfo)
-> (VFieldInfo -> VFieldInfo -> VFieldInfo)
-> Ord VFieldInfo
VFieldInfo -> VFieldInfo -> Bool
VFieldInfo -> VFieldInfo -> Ordering
VFieldInfo -> VFieldInfo -> VFieldInfo
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 :: VFieldInfo -> VFieldInfo -> Ordering
compare :: VFieldInfo -> VFieldInfo -> Ordering
$c< :: VFieldInfo -> VFieldInfo -> Bool
< :: VFieldInfo -> VFieldInfo -> Bool
$c<= :: VFieldInfo -> VFieldInfo -> Bool
<= :: VFieldInfo -> VFieldInfo -> Bool
$c> :: VFieldInfo -> VFieldInfo -> Bool
> :: VFieldInfo -> VFieldInfo -> Bool
$c>= :: VFieldInfo -> VFieldInfo -> Bool
>= :: VFieldInfo -> VFieldInfo -> Bool
$cmax :: VFieldInfo -> VFieldInfo -> VFieldInfo
max :: VFieldInfo -> VFieldInfo -> VFieldInfo
$cmin :: VFieldInfo -> VFieldInfo -> VFieldInfo
min :: VFieldInfo -> VFieldInfo -> VFieldInfo
Ord, Int -> VFieldInfo -> String -> String
[VFieldInfo] -> String -> String
VFieldInfo -> String
(Int -> VFieldInfo -> String -> String)
-> (VFieldInfo -> String)
-> ([VFieldInfo] -> String -> String)
-> Show VFieldInfo
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VFieldInfo -> String -> String
showsPrec :: Int -> VFieldInfo -> String -> String
$cshow :: VFieldInfo -> String
show :: VFieldInfo -> String
$cshowList :: [VFieldInfo] -> String -> String
showList :: [VFieldInfo] -> String -> String
Show)

instance Pretty VFieldInfo where
    pPrintPrec :: PrettyLevel -> Rational -> VFieldInfo -> Doc
pPrintPrec PrettyLevel
d Rational
p (Method Id
n Maybe Id
c Maybe Id
r Integer
m [VPort]
i Maybe VPort
o Maybe VPort
e) =
      String -> Doc
text String
"method " Doc -> Doc -> Doc
<> Maybe VPort -> Doc
forall {a}. Pretty a => Maybe a -> Doc
pout Maybe VPort
o Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> Id -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p Id
n Doc -> Doc -> Doc
<> Integer -> Doc
forall {a}. (Eq a, Num a, Pretty a) => a -> Doc
pmult Integer
m Doc -> Doc -> Doc
<>
      [VPort] -> Doc
forall {a}. Pretty a => [a] -> Doc
pins [VPort]
i Doc -> Doc -> Doc
<> Maybe VPort -> Doc
forall {a}. Pretty a => Maybe a -> Doc
pena Maybe VPort
e Doc -> Doc -> Doc
<+> PrettyLevel -> Maybe Id -> Doc
ppMClk PrettyLevel
d Maybe Id
c Doc -> Doc -> Doc
<+> PrettyLevel -> Maybe Id -> Doc
ppMRst PrettyLevel
d Maybe Id
r Doc -> Doc -> Doc
<>
      String -> Doc
text String
";"
        where pout :: Maybe a -> Doc
pout Maybe a
Nothing = Doc
empty
              pout (Just a
po) = PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p a
po
              pmult :: a -> Doc
pmult a
1  = Doc
empty
              pmult a
n' = String -> Doc
text String
"[" Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p a
n' Doc -> Doc -> Doc
<> String -> Doc
text String
"]"
              pins :: [a] -> Doc
pins []  = Doc
empty
              pins [a]
i'  = String -> Doc
text String
"(" Doc -> Doc -> Doc
<> [Doc] -> Doc -> Doc
sepList ((a -> Doc) -> [a] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p) [a]
i') (String -> Doc
text String
",") Doc -> Doc -> Doc
<> String -> Doc
text String
")"
              pena :: Maybe a -> Doc
pena Maybe a
Nothing = Doc
empty
              pena (Just a
en) = String -> Doc
text String
" enable (" Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p a
en Doc -> Doc -> Doc
<> String -> Doc
text String
")"
    pPrintPrec PrettyLevel
d Rational
p (Clock Id
i) = String -> Doc
text String
"clock " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> Id -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p Id
i Doc -> Doc -> Doc
<> String -> Doc
text String
";"
    pPrintPrec PrettyLevel
d Rational
p (Reset Id
i) = String -> Doc
text String
"reset " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> Id -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p Id
i Doc -> Doc -> Doc
<> String -> Doc
text String
";"
    pPrintPrec PrettyLevel
d Rational
p (Inout Id
n VName
port Maybe Id
c Maybe Id
r) =
        String -> Doc
text String
"inout " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> Id -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p Id
n Doc -> Doc -> Doc
<+>
        String -> Doc
text String
"(" Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> VName -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p VName
port Doc -> Doc -> Doc
<> String -> Doc
text String
")" Doc -> Doc -> Doc
<+>
        PrettyLevel -> Maybe Id -> Doc
ppMClk PrettyLevel
d Maybe Id
c Doc -> Doc -> Doc
<+> PrettyLevel -> Maybe Id -> Doc
ppMRst PrettyLevel
d Maybe Id
r Doc -> Doc -> Doc
<> String -> Doc
text String
";"

-- describes the clocks imported by a module
type InputClockInf = (Id, Maybe (VOscPort, VInputGatePort))

-- describes the clocks exported by a module
type OutputClockInf = (Id, Maybe (VOscPort, VOutputGatePort))

-- no VeriPortProp needed, so we use VName and not VPort
type VOscPort = VName

-- gate port for input clocks
-- Either there is no port, in which case the boolean indicates
-- whether the gate is assumed True or is unneeded, or there is gate port.
type VInputGatePort = Either Bool VName

-- gate port for output clocks
-- Either there is no port, in which case users should assume a value True,
-- or there is a port, and we annotate whether it is "outhigh" with a
-- port property (VPouthigh)
type VOutputGatePort = Maybe VPort

data VClockInfo = ClockInfo {
                 -- named list of input clocks
                 VClockInfo -> [InputClockInf]
input_clocks :: [InputClockInf],
                 -- named list of output clocks
                 VClockInfo -> [OutputClockInf]
output_clocks :: [OutputClockInf],
                 -- edges in the ancestor relationships (transitive)
                 -- first clock is parent, second is child
                 VClockInfo -> [(Id, Id)]
ancestorClocks :: [(Id, Id)],
                 -- other sibling relationships
                 -- transitive (but often trumped by ancestry)
                 -- method calls are permitted across sibling relationships
                 -- but *both* gate conditions must be enforced
                 VClockInfo -> [(Id, Id)]
siblingClocks :: [(Id, Id)] }
                deriving (VClockInfo -> VClockInfo -> Bool
(VClockInfo -> VClockInfo -> Bool)
-> (VClockInfo -> VClockInfo -> Bool) -> Eq VClockInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VClockInfo -> VClockInfo -> Bool
== :: VClockInfo -> VClockInfo -> Bool
$c/= :: VClockInfo -> VClockInfo -> Bool
/= :: VClockInfo -> VClockInfo -> Bool
Eq, Eq VClockInfo
Eq VClockInfo =>
(VClockInfo -> VClockInfo -> Ordering)
-> (VClockInfo -> VClockInfo -> Bool)
-> (VClockInfo -> VClockInfo -> Bool)
-> (VClockInfo -> VClockInfo -> Bool)
-> (VClockInfo -> VClockInfo -> Bool)
-> (VClockInfo -> VClockInfo -> VClockInfo)
-> (VClockInfo -> VClockInfo -> VClockInfo)
-> Ord VClockInfo
VClockInfo -> VClockInfo -> Bool
VClockInfo -> VClockInfo -> Ordering
VClockInfo -> VClockInfo -> VClockInfo
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 :: VClockInfo -> VClockInfo -> Ordering
compare :: VClockInfo -> VClockInfo -> Ordering
$c< :: VClockInfo -> VClockInfo -> Bool
< :: VClockInfo -> VClockInfo -> Bool
$c<= :: VClockInfo -> VClockInfo -> Bool
<= :: VClockInfo -> VClockInfo -> Bool
$c> :: VClockInfo -> VClockInfo -> Bool
> :: VClockInfo -> VClockInfo -> Bool
$c>= :: VClockInfo -> VClockInfo -> Bool
>= :: VClockInfo -> VClockInfo -> Bool
$cmax :: VClockInfo -> VClockInfo -> VClockInfo
max :: VClockInfo -> VClockInfo -> VClockInfo
$cmin :: VClockInfo -> VClockInfo -> VClockInfo
min :: VClockInfo -> VClockInfo -> VClockInfo
Ord, Int -> VClockInfo -> String -> String
[VClockInfo] -> String -> String
VClockInfo -> String
(Int -> VClockInfo -> String -> String)
-> (VClockInfo -> String)
-> ([VClockInfo] -> String -> String)
-> Show VClockInfo
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VClockInfo -> String -> String
showsPrec :: Int -> VClockInfo -> String -> String
$cshow :: VClockInfo -> String
show :: VClockInfo -> String
$cshowList :: [VClockInfo] -> String -> String
showList :: [VClockInfo] -> String -> String
Show)

instance Pretty VClockInfo where
    pPrintPrec :: PrettyLevel -> Rational -> VClockInfo -> Doc
pPrintPrec PrettyLevel
d Rational
_p (ClockInfo [InputClockInf]
in_cs [OutputClockInf]
out_cs [(Id, Id)]
as [(Id, Id)]
ss) =
        [Doc] -> Doc
vcat ((OutputClockInf -> Doc) -> [OutputClockInf] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map OutputClockInf -> Doc
forall {a} {a} {a} {a}.
(Pretty a, Pretty a, Pretty a, Pretty a) =>
(a, Maybe (a, Maybe (a, [a]))) -> Doc
pOutCInf [OutputClockInf]
out_cs [Doc] -> [Doc] -> [Doc]
forall a. [a] -> [a] -> [a]
++
              (InputClockInf -> Doc) -> [InputClockInf] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map InputClockInf -> Doc
forall {a} {a} {a}.
(Pretty a, Pretty a, Pretty a) =>
(a, Maybe (a, Either Bool a)) -> Doc
pInCInf [InputClockInf]
in_cs [Doc] -> [Doc] -> [Doc]
forall a. [a] -> [a] -> [a]
++
              ((Id, Id) -> Doc) -> [(Id, Id)] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (Id, Id) -> Doc
forall {a} {a}. (Pretty a, Pretty a) => (a, a) -> Doc
pAnc [(Id, Id)]
as [Doc] -> [Doc] -> [Doc]
forall a. [a] -> [a] -> [a]
++
              ((Id, Id) -> Doc) -> [(Id, Id)] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (Id, Id) -> Doc
forall {a} {a}. (Pretty a, Pretty a) => (a, a) -> Doc
pSib [(Id, Id)]
ss)
        where
              pOutCInf :: (a, Maybe (a, Maybe (a, [a]))) -> Doc
pOutCInf (a
i,Maybe (a, Maybe (a, [a]))
mc) = String -> Doc
text String
"clock " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
i Doc -> Doc -> Doc
<>
                                String -> Doc
text String
"(" Doc -> Doc -> Doc
<> Maybe (a, Maybe (a, [a])) -> Doc
forall {a} {a} {a}.
(Pretty a, Pretty a, Pretty a) =>
Maybe (a, Maybe (a, [a])) -> Doc
pOutMClk Maybe (a, Maybe (a, [a]))
mc Doc -> Doc -> Doc
<> String -> Doc
text String
");"
              pOutMClk :: Maybe (a, Maybe (a, [a])) -> Doc
pOutMClk Maybe (a, Maybe (a, [a]))
Nothing = Doc
empty
              pOutMClk (Just (a
vn, Maybe (a, [a])
mg)) = PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
vn Doc -> Doc -> Doc
<> Maybe (a, [a]) -> Doc
forall {a} {a}. (Pretty a, Pretty a) => Maybe (a, [a]) -> Doc
pOutMGate Maybe (a, [a])
mg
              pOutMGate :: Maybe (a, [a]) -> Doc
pOutMGate Maybe (a, [a])
Nothing = Doc
empty
              pOutMGate (Just (a
vn, [a]
vpps)) =
                  String -> Doc
text String
", " Doc -> Doc -> Doc
<> [a] -> Doc
forall {a}. Pretty a => [a] -> Doc
pPortProps [a]
vpps Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
vn
              pPortProps :: [a] -> Doc
pPortProps [] = Doc
empty
              pPortProps (a
vp:[a]
vpps) =
                  String -> Doc
text String
"{-" Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
vp Doc -> Doc -> Doc
<> String -> Doc
text String
"-} " Doc -> Doc -> Doc
<> [a] -> Doc
pPortProps [a]
vpps

              pInCInf :: (a, Maybe (a, Either Bool a)) -> Doc
pInCInf (a
i,Maybe (a, Either Bool a)
mc) = String -> Doc
text String
"clock " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
i Doc -> Doc -> Doc
<>
                               String -> Doc
text String
"(" Doc -> Doc -> Doc
<> Maybe (a, Either Bool a) -> Doc
forall {a} {a}.
(Pretty a, Pretty a) =>
Maybe (a, Either Bool a) -> Doc
pInMClk Maybe (a, Either Bool a)
mc Doc -> Doc -> Doc
<> String -> Doc
text String
");"
              pInMClk :: Maybe (a, Either Bool a) -> Doc
pInMClk Maybe (a, Either Bool a)
Nothing = Doc
empty
              pInMClk (Just (a
vn, Either Bool a
mg)) = PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
vn Doc -> Doc -> Doc
<> Either Bool a -> Doc
forall {a}. Pretty a => Either Bool a -> Doc
pInMGate Either Bool a
mg
              pInMGate :: Either Bool a -> Doc
pInMGate (Left Bool
True)  = String -> Doc
text String
", {-inhigh-}"
              pInMGate (Left Bool
False) = String -> Doc
text String
", {-unused-}"
              pInMGate (Right a
vn)   = String -> Doc
text String
", " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
vn

              pAnc :: (a, a) -> Doc
pAnc (a
i,a
j) = String -> Doc
text String
"ancestor (" Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
i Doc -> Doc -> Doc
<> String -> Doc
text String
", " Doc -> Doc -> Doc
<>
                           PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
j Doc -> Doc -> Doc
<> String -> Doc
text String
");"
              pSib :: (a, a) -> Doc
pSib (a
i,a
j) = String -> Doc
text String
"sibling (" Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
i Doc -> Doc -> Doc
<> String -> Doc
text String
", " Doc -> Doc -> Doc
<>
                           PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
0 a
j Doc -> Doc -> Doc
<> String -> Doc
text String
");"

instance HasPosition VClockInfo where
  getPosition :: VClockInfo -> Position
getPosition (ClockInfo { output_clocks :: VClockInfo -> [OutputClockInf]
output_clocks = ((Id
id',Maybe (VName, Maybe VPort)
_):[OutputClockInf]
_)}) = Id -> Position
forall a. HasPosition a => a -> Position
getPosition Id
id'
  getPosition (ClockInfo { input_clocks :: VClockInfo -> [InputClockInf]
input_clocks = ((Id
id',Maybe (VName, VInputGatePort)
_):[InputClockInf]
_)}) = Id -> Position
forall a. HasPosition a => a -> Position
getPosition Id
id'
  getPosition VClockInfo
_ = Position
noPosition

-- reset name, Verilog port (optional), clock (optional)
type ResetInf = (Id, (Maybe VName, Maybe Id))

-- basic information on reset signals
-- more information to be added (sync/async, clock relationships, etc.)
data VResetInfo = ResetInfo {
                   VResetInfo -> [ResetInf]
input_resets  :: [ResetInf],
                   VResetInfo -> [ResetInf]
output_resets :: [ResetInf]
                  }
  deriving (VResetInfo -> VResetInfo -> Bool
(VResetInfo -> VResetInfo -> Bool)
-> (VResetInfo -> VResetInfo -> Bool) -> Eq VResetInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VResetInfo -> VResetInfo -> Bool
== :: VResetInfo -> VResetInfo -> Bool
$c/= :: VResetInfo -> VResetInfo -> Bool
/= :: VResetInfo -> VResetInfo -> Bool
Eq, Eq VResetInfo
Eq VResetInfo =>
(VResetInfo -> VResetInfo -> Ordering)
-> (VResetInfo -> VResetInfo -> Bool)
-> (VResetInfo -> VResetInfo -> Bool)
-> (VResetInfo -> VResetInfo -> Bool)
-> (VResetInfo -> VResetInfo -> Bool)
-> (VResetInfo -> VResetInfo -> VResetInfo)
-> (VResetInfo -> VResetInfo -> VResetInfo)
-> Ord VResetInfo
VResetInfo -> VResetInfo -> Bool
VResetInfo -> VResetInfo -> Ordering
VResetInfo -> VResetInfo -> VResetInfo
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 :: VResetInfo -> VResetInfo -> Ordering
compare :: VResetInfo -> VResetInfo -> Ordering
$c< :: VResetInfo -> VResetInfo -> Bool
< :: VResetInfo -> VResetInfo -> Bool
$c<= :: VResetInfo -> VResetInfo -> Bool
<= :: VResetInfo -> VResetInfo -> Bool
$c> :: VResetInfo -> VResetInfo -> Bool
> :: VResetInfo -> VResetInfo -> Bool
$c>= :: VResetInfo -> VResetInfo -> Bool
>= :: VResetInfo -> VResetInfo -> Bool
$cmax :: VResetInfo -> VResetInfo -> VResetInfo
max :: VResetInfo -> VResetInfo -> VResetInfo
$cmin :: VResetInfo -> VResetInfo -> VResetInfo
min :: VResetInfo -> VResetInfo -> VResetInfo
Ord, Int -> VResetInfo -> String -> String
[VResetInfo] -> String -> String
VResetInfo -> String
(Int -> VResetInfo -> String -> String)
-> (VResetInfo -> String)
-> ([VResetInfo] -> String -> String)
-> Show VResetInfo
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VResetInfo -> String -> String
showsPrec :: Int -> VResetInfo -> String -> String
$cshow :: VResetInfo -> String
show :: VResetInfo -> String
$cshowList :: [VResetInfo] -> String -> String
showList :: [VResetInfo] -> String -> String
Show)

instance Pretty VResetInfo where
    pPrintPrec :: PrettyLevel -> Rational -> VResetInfo -> Doc
pPrintPrec PrettyLevel
d Rational
p (ResetInfo [ResetInf]
in_rs [ResetInf]
out_rs) = [Doc] -> Doc
vcat ((ResetInf -> Doc) -> [ResetInf] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map ResetInf -> Doc
forall {a} {a} {a}.
(Pretty a, Pretty a, Pretty a) =>
(a, (Maybe a, Maybe a)) -> Doc
pRInf ([ResetInf]
out_rs [ResetInf] -> [ResetInf] -> [ResetInf]
forall a. [a] -> [a] -> [a]
++ [ResetInf]
in_rs))
      where t :: String -> Doc
t = String -> Doc
text
            pRInf :: (a, (Maybe a, Maybe a)) -> Doc
pRInf (a
i,(Maybe a
mn,Maybe a
mc)) =
                String -> Doc
tString
"reset " Doc -> Doc -> Doc
<> PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p a
i Doc -> Doc -> Doc
<>
                String -> Doc
tString
"(" Doc -> Doc -> Doc
<> Maybe a -> Doc
forall {a}. Pretty a => Maybe a -> Doc
pMRst Maybe a
mn Doc -> Doc -> Doc
<> String -> Doc
tString
")" Doc -> Doc -> Doc
<+>
                String -> Doc
tString
"clocked_by(" Doc -> Doc -> Doc
<> Maybe a -> Doc
forall {a}. Pretty a => Maybe a -> Doc
pMClk Maybe a
mc Doc -> Doc -> Doc
<> String -> Doc
tString
");"
            pMRst :: Maybe a -> Doc
pMRst Maybe a
Nothing  = Doc
empty
            pMRst (Just a
n) = PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p a
n
            pMClk :: Maybe a -> Doc
pMClk Maybe a
Nothing  = String -> Doc
tString
"no_clock"
            pMClk (Just a
c) = PrettyLevel -> Rational -> a -> Doc
forall a. Pretty a => PrettyLevel -> Rational -> a -> Doc
pPrintPrec PrettyLevel
d Rational
p a
c