{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE FlexibleInstances #-}

-- |
-- Module      : Verismith.Verilog.CodeGen
-- Description : Code generation for Verilog AST.
-- Copyright   : (c) 2018-2019, Yann Herklotz
-- License     : GPL-3
-- Maintainer  : yann [at] yannherklotz [dot] com
-- Stability   : experimental
-- Portability : POSIX
--
-- This module generates the code from the Verilog AST defined in
-- "Verismith.Verilog.AST".
module Verismith.Verilog.CodeGen
  ( -- * Code Generation
    GenVerilog (..),
    Source (..),
    render,
  )
where

import Data.Data (Data)
import Data.List.NonEmpty (NonEmpty (..), toList)
import Data.Text (Text)
import qualified Data.Text as T
import Prettyprinter
import Numeric (showHex)
import Verismith.Utils hiding (comma)
import Verismith.Verilog.AST
import Verismith.Verilog.BitVec

-- | 'Source' class which determines that source code is able to be generated
-- from the data structure using 'genSource'. This will be stored in 'Text' and
-- can then be processed further.
class Source a where
  genSource :: a -> Text

-- | Map a 'Maybe (Statement ann)' to 'Text'. If it is 'Just statement', the generated
-- statements are returned. If it is 'Nothing', then @;\n@ is returned.
defMap :: (Show ann) => Maybe (Statement ann) -> Doc a
defMap :: forall ann a. Show ann => Maybe (Statement ann) -> Doc a
defMap = Doc a -> (Statement ann -> Doc a) -> Maybe (Statement ann) -> Doc a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc a
forall ann. Doc ann
semi Statement ann -> Doc a
forall ann a. Show ann => Statement ann -> Doc a
statement

-- | Convert the 'Verilog ann' type to 'Text' so that it can be rendered.
verilogSrc :: (Show ann) => (Verilog ann) -> Doc a
verilogSrc :: forall ann a. Show ann => Verilog ann -> Doc a
verilogSrc (Verilog [ModDecl ann]
modules) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep ([Doc a] -> Doc a) -> ([Doc a] -> [Doc a]) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc a
forall ann. Doc ann
line ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ ModDecl ann -> Doc a
forall ann a. Show ann => ModDecl ann -> Doc a
moduleDecl (ModDecl ann -> Doc a) -> [ModDecl ann] -> [Doc a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ModDecl ann]
modules

-- | Generate the 'ModDecl ann' for a module and convert it to 'Text'.
moduleDecl :: (Show ann) => ModDecl ann -> Doc a
moduleDecl :: forall ann a. Show ann => ModDecl ann -> Doc a
moduleDecl (ModDecl Identifier
i [Port]
outP [Port]
inP [ModItem ann]
items [Parameter]
ps) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep
    [ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
sep [Doc a
"module" Doc a -> Doc a -> Doc a
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i, [Parameter] -> Doc a
forall {ann}. [Parameter] -> Doc ann
params [Parameter]
ps, Doc a
forall ann. Doc ann
ports Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
forall ann. Doc ann
semi],
      Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 Doc a
forall ann. Doc ann
modI,
      Doc a
"endmodule"
    ]
  where
    ports :: Doc ann
ports
      | [Port] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Port]
outP Bool -> Bool -> Bool
&& [Port] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Port]
inP = Doc ann
""
      | Bool
otherwise = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann)
-> ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
align (Doc ann -> Doc ann)
-> ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
sep ([Doc ann] -> Doc ann)
-> ([Doc ann] -> [Doc ann]) -> [Doc ann] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
comma ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ Port -> Doc ann
forall a. Port -> Doc a
modPort (Port -> Doc ann) -> [Port] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Port]
outIn
    modI :: Doc ann
modI = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ ModItem ann -> Doc ann
forall ann a. Show ann => ModItem ann -> Doc a
moduleItem (ModItem ann -> Doc ann) -> [ModItem ann] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ModItem ann]
items
    outIn :: [Port]
outIn = [Port]
outP [Port] -> [Port] -> [Port]
forall a. [a] -> [a] -> [a]
++ [Port]
inP
    params :: [Parameter] -> Doc ann
params [] = Doc ann
""
    params (Parameter
p : [Parameter]
pps) = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hcat [Doc ann
"#(", NonEmpty Parameter -> Doc ann
forall a. NonEmpty Parameter -> Doc a
paramList (Parameter
p Parameter -> [Parameter] -> NonEmpty Parameter
forall a. a -> [a] -> NonEmpty a
:| [Parameter]
pps), Doc ann
")"]
moduleDecl (ModDeclAnn ann
a ModDecl ann
m) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
sep [[Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Doc a
"/*", String -> Doc a
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc a) -> String -> Doc a
forall a b. (a -> b) -> a -> b
$ ann -> String
forall a. Show a => a -> String
show ann
a, Doc a
"*/"], ModDecl ann -> Doc a
forall ann a. Show ann => ModDecl ann -> Doc a
moduleDecl ModDecl ann
m]

-- | Generates a parameter list. Can only be called with a 'NonEmpty' list.
paramList :: NonEmpty Parameter -> Doc a
paramList :: forall a. NonEmpty Parameter -> Doc a
paramList NonEmpty Parameter
ps = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep ([Doc a] -> Doc a)
-> (NonEmpty (Doc a) -> [Doc a]) -> NonEmpty (Doc a) -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc a
", " ([Doc a] -> [Doc a])
-> (NonEmpty (Doc a) -> [Doc a]) -> NonEmpty (Doc a) -> [Doc a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (Doc a) -> [Doc a]
forall a. NonEmpty a -> [a]
toList (NonEmpty (Doc a) -> Doc a) -> NonEmpty (Doc a) -> Doc a
forall a b. (a -> b) -> a -> b
$ Parameter -> Doc a
forall a. Parameter -> Doc a
parameter (Parameter -> Doc a) -> NonEmpty Parameter -> NonEmpty (Doc a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty Parameter
ps

-- | Generates a localparam list. Can only be called with a 'NonEmpty' list.
localParamList :: NonEmpty LocalParam -> Doc a
localParamList :: forall a. NonEmpty LocalParam -> Doc a
localParamList NonEmpty LocalParam
ps = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep ([Doc a] -> Doc a)
-> (NonEmpty (Doc a) -> [Doc a]) -> NonEmpty (Doc a) -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc a
", " ([Doc a] -> [Doc a])
-> (NonEmpty (Doc a) -> [Doc a]) -> NonEmpty (Doc a) -> [Doc a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (Doc a) -> [Doc a]
forall a. NonEmpty a -> [a]
toList (NonEmpty (Doc a) -> Doc a) -> NonEmpty (Doc a) -> Doc a
forall a b. (a -> b) -> a -> b
$ LocalParam -> Doc a
forall a. LocalParam -> Doc a
localParam (LocalParam -> Doc a) -> NonEmpty LocalParam -> NonEmpty (Doc a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty LocalParam
ps

-- | Generates the assignment for a 'Parameter'.
parameter :: Parameter -> Doc a
parameter :: forall a. Parameter -> Doc a
parameter (Parameter Identifier
name ConstExpr
val) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Doc a
"parameter", Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
name, Doc a
"=", ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr ConstExpr
val]

-- | Generates the assignment for a 'LocalParam'.
localParam :: LocalParam -> Doc a
localParam :: forall a. LocalParam -> Doc a
localParam (LocalParam Identifier
name ConstExpr
val) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Doc a
"localparameter", Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
name, Doc a
"=", ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr ConstExpr
val]

identifier :: Identifier -> Doc a
identifier :: forall a. Identifier -> Doc a
identifier (Identifier Text
i) = Text -> Doc a
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
i

-- | Converts 'Port' to 'Text' for the module list, which means it only
-- generates a list of identifiers.
modPort :: Port -> Doc a
modPort :: forall a. Port -> Doc a
modPort (Port PortType
_ Bool
_ Range
_ Identifier
i) = Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i

addOpt :: Bool -> Doc a -> [Doc a] -> [Doc a]
addOpt :: forall a. Bool -> Doc a -> [Doc a] -> [Doc a]
addOpt Bool
b Doc a
a = if Bool
b then (Doc a
a Doc a -> [Doc a] -> [Doc a]
forall a. a -> [a] -> [a]
:) else [Doc a] -> [Doc a]
forall a. a -> a
id

addMay :: Maybe (Doc a) -> [Doc a] -> [Doc a]
addMay :: forall a. Maybe (Doc a) -> [Doc a] -> [Doc a]
addMay Maybe (Doc a)
Nothing = [Doc a] -> [Doc a]
forall a. a -> a
id
addMay (Just Doc a
a) = (Doc a
a Doc a -> [Doc a] -> [Doc a]
forall a. a -> [a] -> [a]
:)

-- | Generate the 'Port' description.
port :: Port -> Doc a
port :: forall a. Port -> Doc a
port (Port PortType
tp Bool
sgn Range
r Identifier
name) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ PortType -> Doc a
forall a. PortType -> Doc a
pType PortType
tp Doc a -> [Doc a] -> [Doc a]
forall a. a -> [a] -> [a]
: Bool -> Doc a -> [Doc a] -> [Doc a]
forall a. Bool -> Doc a -> [Doc a] -> [Doc a]
addOpt Bool
sgn Doc a
"signed" [Range -> Doc a
forall a. Range -> Doc a
range Range
r, Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
name]

range :: Range -> Doc a
range :: forall a. Range -> Doc a
range (Range ConstExpr
msb ConstExpr
lsb) = Doc a -> Doc a
forall ann. Doc ann -> Doc ann
brackets (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr ConstExpr
msb, Doc a
forall ann. Doc ann
colon, ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr ConstExpr
lsb]

-- | Convert the 'PortDir' type to 'Text'.
portDir :: PortDir -> Doc a
portDir :: forall a. PortDir -> Doc a
portDir PortDir
PortIn = Doc a
"input"
portDir PortDir
PortOut = Doc a
"output"
portDir PortDir
PortInOut = Doc a
"inout"

-- | Generate a '(ModItem ann)'.
moduleItem :: (Show ann) => ModItem ann -> Doc a
moduleItem :: forall ann a. Show ann => ModItem ann -> Doc a
moduleItem (ModCA ContAssign
ca) = ContAssign -> Doc a
forall a. ContAssign -> Doc a
contAssign ContAssign
ca
moduleItem (ModInst Identifier
i [ModConn]
param Identifier
name [ModConn]
conn) =
  (Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
forall ann. Doc ann
semi) (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$
    [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep
      [ Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i,
        Doc a
"#" Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> (Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc a
forall ann. Doc ann
comma (ModConn -> Doc a
forall a. ModConn -> Doc a
mConn (ModConn -> Doc a) -> [ModConn] -> [Doc a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ModConn]
param)),
        Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
name,
        Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc a
forall ann. Doc ann
comma (ModConn -> Doc a
forall a. ModConn -> Doc a
mConn (ModConn -> Doc a) -> [ModConn] -> [Doc a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ModConn]
conn)
      ]
moduleItem (Initial Statement ann
stat) = Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep [Doc a
"initial", Statement ann -> Doc a
forall ann a. Show ann => Statement ann -> Doc a
statement Statement ann
stat]
moduleItem (Always Statement ann
stat) = Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep [Doc a
"always", Statement ann -> Doc a
forall ann a. Show ann => Statement ann -> Doc a
statement Statement ann
stat]
moduleItem (Decl Maybe PortDir
dir Port
p Maybe ConstExpr
ini) =
  (Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
forall ann. Doc ann
semi)
    (Doc a -> Doc a) -> ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep
    ([Doc a] -> Doc a) -> ([Doc a] -> [Doc a]) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe (Doc a) -> [Doc a] -> [Doc a]
forall a. Maybe (Doc a) -> [Doc a] -> [Doc a]
addMay (PortDir -> Doc a
forall a. PortDir -> Doc a
portDir (PortDir -> Doc a) -> Maybe PortDir -> Maybe (Doc a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe PortDir
dir)
    ([Doc a] -> [Doc a]) -> ([Doc a] -> [Doc a]) -> [Doc a] -> [Doc a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Port -> Doc a
forall a. Port -> Doc a
port Port
p Doc a -> [Doc a] -> [Doc a]
forall a. a -> [a] -> [a]
:)
    ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ Maybe (Doc a) -> [Doc a] -> [Doc a]
forall a. Maybe (Doc a) -> [Doc a] -> [Doc a]
addMay (ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
makeIni (ConstExpr -> Doc a) -> Maybe ConstExpr -> Maybe (Doc a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ConstExpr
ini) []
  where
    makeIni :: ConstExpr -> Doc ann
makeIni = (Doc ann
"=" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>) (Doc ann -> Doc ann)
-> (ConstExpr -> Doc ann) -> ConstExpr -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConstExpr -> Doc ann
forall a. ConstExpr -> Doc a
constExpr
moduleItem (ParamDecl NonEmpty Parameter
p) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [NonEmpty Parameter -> Doc a
forall a. NonEmpty Parameter -> Doc a
paramList NonEmpty Parameter
p, Doc a
forall ann. Doc ann
semi]
moduleItem (LocalParamDecl NonEmpty LocalParam
p) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [NonEmpty LocalParam -> Doc a
forall a. NonEmpty LocalParam -> Doc a
localParamList NonEmpty LocalParam
p, Doc a
forall ann. Doc ann
semi]
moduleItem (ModItemAnn ann
a ModItem ann
mi) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
sep [[Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Doc a
"/*", String -> Doc a
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc a) -> String -> Doc a
forall a b. (a -> b) -> a -> b
$ ann -> String
forall a. Show a => a -> String
show ann
a, Doc a
"*/"], ModItem ann -> Doc a
forall ann a. Show ann => ModItem ann -> Doc a
moduleItem ModItem ann
mi]
moduleItem (Property Identifier
l Event
e Maybe Expr
bl Expr
br) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
sep
    [ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
l, Doc a
":"],
      Doc a
"assume property",
      Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Event -> Doc a
forall a. Event -> Doc a
event Event
e,
      [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat
        [ case Maybe Expr
bl of
            Just Expr
bl' -> [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
sep [Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
bl', Doc a
"|=>", Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
br]
            Maybe Expr
Nothing -> Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
br,
          Doc a
forall ann. Doc ann
semi
        ]
    ]

mConn :: ModConn -> Doc a
mConn :: forall a. ModConn -> Doc a
mConn (ModConn Expr
c) = Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
c
mConn (ModConnNamed Identifier
n Expr
c) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Doc a
forall ann. Doc ann
dot, Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
n, Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
c]

-- | Generate continuous assignment
contAssign :: ContAssign -> Doc a
contAssign :: forall a. ContAssign -> Doc a
contAssign (ContAssign Identifier
val Expr
e) =
  (Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
forall ann. Doc ann
semi) (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Doc a
"assign", Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
val, Doc a
"=", Doc a -> Doc a
forall ann. Doc ann -> Doc ann
align (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e]

-- | Generate 'Expr' to 'Text'.
expr :: Expr -> Doc a
expr :: forall a. Expr -> Doc a
expr (BinOp Expr
eRhs BinaryOperator
bin Expr
eLhs) = Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
eRhs, BinaryOperator -> Doc a
forall a. BinaryOperator -> Doc a
binaryOp BinaryOperator
bin, Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
eLhs]
expr (Number BitVec
b) = BitVec -> Doc a
forall a. BitVec -> Doc a
showNum BitVec
b
expr (Id Identifier
i) = Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i
expr (VecSelect Identifier
i Expr
e) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i, Doc a -> Doc a
forall ann. Doc ann -> Doc ann
brackets (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e]
expr (RangeSelect Identifier
i Range
r) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i, Range -> Doc a
forall a. Range -> Doc a
range Range
r]
expr (Concat NonEmpty Expr
c) = Doc a -> Doc a
forall ann. Doc ann -> Doc ann
braces (Doc a -> Doc a) -> ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
nest Int
4 (Doc a -> Doc a) -> ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
sep ([Doc a] -> Doc a) -> ([Doc a] -> [Doc a]) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc a
forall ann. Doc ann
comma ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ NonEmpty (Doc a) -> [Doc a]
forall a. NonEmpty a -> [a]
toList (Expr -> Doc a
forall a. Expr -> Doc a
expr (Expr -> Doc a) -> NonEmpty Expr -> NonEmpty (Doc a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty Expr
c)
expr (UnOp UnaryOperator
u Expr
e) = Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [UnaryOperator -> Doc a
forall a. UnaryOperator -> Doc a
unaryOp UnaryOperator
u, Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e]
expr (Cond Expr
l Expr
t Expr
f) =
  Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> (Doc a -> Doc a) -> Doc a -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
nest Int
4 (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
sep [Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
l Doc a -> Doc a -> Doc a
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Doc a
"?", [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
t, Doc a
forall ann. Doc ann
colon, Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
f]]
expr (Appl Identifier
f Expr
e) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
f, Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e]
expr (Str Text
t) = Doc a -> Doc a
forall ann. Doc ann -> Doc ann
dquotes (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Text -> Doc a
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
t

showNum :: BitVec -> Doc a
showNum :: forall a. BitVec -> Doc a
showNum (BitVec Int
s Integer
n) =
  Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$
    [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Doc a
minus, Text -> Doc a
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty (Text -> Doc a) -> Text -> Doc a
forall a b. (a -> b) -> a -> b
$ Int -> Text
forall a. Show a => a -> Text
showT Int
s, Doc a
"'h", Text -> Doc a
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty (Text -> Doc a) -> Text -> Doc a
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (Integer -> ShowS
forall a. Integral a => a -> ShowS
showHex (Integer -> Integer
forall a. Num a => a -> a
abs Integer
n) String
"")]
  where
    minus :: Doc a
minus
      | Integer -> Integer
forall a. Num a => a -> a
signum Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
0 = Doc a
forall a. Monoid a => a
mempty
      | Bool
otherwise = Doc a
"-"

constExpr :: ConstExpr -> Doc a
constExpr :: forall a. ConstExpr -> Doc a
constExpr (ConstNum BitVec
b) = BitVec -> Doc a
forall a. BitVec -> Doc a
showNum BitVec
b
constExpr (ParamId Identifier
i) = Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i
constExpr (ConstConcat NonEmpty ConstExpr
c) =
  Doc a -> Doc a
forall ann. Doc ann -> Doc ann
braces (Doc a -> Doc a) -> ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep ([Doc a] -> Doc a) -> ([Doc a] -> [Doc a]) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc a
forall ann. Doc ann
comma ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ NonEmpty (Doc a) -> [Doc a]
forall a. NonEmpty a -> [a]
toList (ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr (ConstExpr -> Doc a) -> NonEmpty ConstExpr -> NonEmpty (Doc a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty ConstExpr
c)
constExpr (ConstUnOp UnaryOperator
u ConstExpr
e) = Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [UnaryOperator -> Doc a
forall a. UnaryOperator -> Doc a
unaryOp UnaryOperator
u, ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr ConstExpr
e]
constExpr (ConstBinOp ConstExpr
eRhs BinaryOperator
bin ConstExpr
eLhs) =
  Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr ConstExpr
eRhs, BinaryOperator -> Doc a
forall a. BinaryOperator -> Doc a
binaryOp BinaryOperator
bin, ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr ConstExpr
eLhs]
constExpr (ConstCond ConstExpr
l ConstExpr
t ConstExpr
f) =
  Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr ConstExpr
l, Doc a
"?", ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr ConstExpr
t, Doc a
forall ann. Doc ann
colon, ConstExpr -> Doc a
forall a. ConstExpr -> Doc a
constExpr ConstExpr
f]
constExpr (ConstStr Text
t) = Doc a -> Doc a
forall ann. Doc ann -> Doc ann
dquotes (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Text -> Doc a
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
t

-- | Convert 'BinaryOperator' to 'Text'.
binaryOp :: BinaryOperator -> Doc a
binaryOp :: forall a. BinaryOperator -> Doc a
binaryOp BinaryOperator
BinPlus = Doc a
"+"
binaryOp BinaryOperator
BinMinus = Doc a
"-"
binaryOp BinaryOperator
BinTimes = Doc a
"*"
binaryOp BinaryOperator
BinDiv = Doc a
"/"
binaryOp BinaryOperator
BinMod = Doc a
"%"
binaryOp BinaryOperator
BinEq = Doc a
"=="
binaryOp BinaryOperator
BinNEq = Doc a
"!="
binaryOp BinaryOperator
BinCEq = Doc a
"==="
binaryOp BinaryOperator
BinCNEq = Doc a
"!=="
binaryOp BinaryOperator
BinLAnd = Doc a
"&&"
binaryOp BinaryOperator
BinLOr = Doc a
"||"
binaryOp BinaryOperator
BinLT = Doc a
"<"
binaryOp BinaryOperator
BinLEq = Doc a
"<="
binaryOp BinaryOperator
BinGT = Doc a
">"
binaryOp BinaryOperator
BinGEq = Doc a
">="
binaryOp BinaryOperator
BinAnd = Doc a
"&"
binaryOp BinaryOperator
BinOr = Doc a
"|"
binaryOp BinaryOperator
BinXor = Doc a
"^"
binaryOp BinaryOperator
BinXNor = Doc a
"^~"
binaryOp BinaryOperator
BinXNorInv = Doc a
"~^"
binaryOp BinaryOperator
BinPower = Doc a
"**"
binaryOp BinaryOperator
BinLSL = Doc a
"<<"
binaryOp BinaryOperator
BinLSR = Doc a
">>"
binaryOp BinaryOperator
BinASL = Doc a
"<<<"
binaryOp BinaryOperator
BinASR = Doc a
">>>"

-- | Convert 'UnaryOperator' to 'Text'.
unaryOp :: UnaryOperator -> Doc a
unaryOp :: forall a. UnaryOperator -> Doc a
unaryOp UnaryOperator
UnPlus = Doc a
"+"
unaryOp UnaryOperator
UnMinus = Doc a
"-"
unaryOp UnaryOperator
UnLNot = Doc a
"!"
unaryOp UnaryOperator
UnNot = Doc a
"~"
unaryOp UnaryOperator
UnAnd = Doc a
"&"
unaryOp UnaryOperator
UnNand = Doc a
"~&"
unaryOp UnaryOperator
UnOr = Doc a
"|"
unaryOp UnaryOperator
UnNor = Doc a
"~|"
unaryOp UnaryOperator
UnXor = Doc a
"^"
unaryOp UnaryOperator
UnNxor = Doc a
"~^"
unaryOp UnaryOperator
UnNxorInv = Doc a
"^~"

event :: Event -> Doc a
event :: forall a. Event -> Doc a
event Event
a = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Doc a
"@", Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Event -> Doc a
forall a. Event -> Doc a
eventRec Event
a]

-- | Generate verilog code for an 'Event'.
eventRec :: Event -> Doc a
eventRec :: forall a. Event -> Doc a
eventRec (EId Identifier
i) = Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i
eventRec (EExpr Expr
e) = Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e
eventRec Event
EAll = Doc a
"*"
eventRec (EPosEdge Identifier
i) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Doc a
"posedge", Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i]
eventRec (ENegEdge Identifier
i) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Doc a
"negedge", Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i]
eventRec (EOr Event
a Event
b) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Event -> Doc a
forall a. Event -> Doc a
eventRec Event
a, Doc a
"or", Event -> Doc a
forall a. Event -> Doc a
eventRec Event
b]
eventRec (EComb Event
a Event
b) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc a
forall ann. Doc ann
comma [Event -> Doc a
forall a. Event -> Doc a
eventRec Event
a, Event -> Doc a
forall a. Event -> Doc a
eventRec Event
b]

-- | Generates verilog code for a 'Delay'.
delay :: Delay -> Doc a
delay :: forall a. Delay -> Doc a
delay (Delay Int
i) = Doc a
"#" Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Int -> Doc a
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i

-- | Generate the verilog code for an 'LVal'.
lVal :: LVal -> Doc a
lVal :: forall a. LVal -> Doc a
lVal (RegId Identifier
i) = Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i
lVal (RegExpr Identifier
i Expr
e) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i, Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e]
lVal (RegSize Identifier
i Range
r) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i, Range -> Doc a
forall a. Range -> Doc a
range Range
r]
lVal (RegConcat [Expr]
e) = Doc a -> Doc a
forall ann. Doc ann -> Doc ann
braces (Doc a -> Doc a) -> ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc a
forall ann. Doc ann
comma (Expr -> Doc a
forall a. Expr -> Doc a
expr (Expr -> Doc a) -> [Expr] -> [Doc a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Expr]
e)

pType :: PortType -> Doc a
pType :: forall a. PortType -> Doc a
pType PortType
Wire = Doc a
"wire"
pType PortType
Reg = Doc a
"reg"

genAssign :: Text -> Assign -> Doc a
genAssign :: forall a. Text -> Assign -> Doc a
genAssign Text
op (Assign LVal
r Maybe Delay
d Expr
e) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep ([Doc a] -> Doc a) -> ([Doc a] -> [Doc a]) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LVal -> Doc a
forall a. LVal -> Doc a
lVal LVal
r Doc a -> [Doc a] -> [Doc a]
forall a. a -> [a] -> [a]
:) ([Doc a] -> [Doc a]) -> ([Doc a] -> [Doc a]) -> [Doc a] -> [Doc a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Doc a
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
op Doc a -> [Doc a] -> [Doc a]
forall a. a -> [a] -> [a]
:) ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ Maybe (Doc a) -> [Doc a] -> [Doc a]
forall a. Maybe (Doc a) -> [Doc a] -> [Doc a]
addMay (Delay -> Doc a
forall a. Delay -> Doc a
delay (Delay -> Doc a) -> Maybe Delay -> Maybe (Doc a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Delay
d) [Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e]

caseType :: CaseType -> Doc a
caseType :: forall a. CaseType -> Doc a
caseType CaseType
CaseStandard = Doc a
"case"
caseType CaseType
CaseX = Doc a
"casex"
caseType CaseType
CaseZ = Doc a
"casez"

casePair :: (Show ann) => (CasePair ann) -> Doc a
casePair :: forall ann a. Show ann => CasePair ann -> Doc a
casePair (CasePair Expr
e Statement ann
s) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep [[Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e, Doc a
forall ann. Doc ann
colon], Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Statement ann -> Doc a
forall ann a. Show ann => Statement ann -> Doc a
statement Statement ann
s]

statement :: (Show ann) => Statement ann -> Doc a
statement :: forall ann a. Show ann => Statement ann -> Doc a
statement (TimeCtrl Delay
d Maybe (Statement ann)
stat) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Delay -> Doc a
forall a. Delay -> Doc a
delay Delay
d, Maybe (Statement ann) -> Doc a
forall ann a. Show ann => Maybe (Statement ann) -> Doc a
defMap Maybe (Statement ann)
stat]
statement (EventCtrl Event
e Maybe (Statement ann)
stat) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Event -> Doc a
forall a. Event -> Doc a
event Event
e, Maybe (Statement ann) -> Doc a
forall ann a. Show ann => Maybe (Statement ann) -> Doc a
defMap Maybe (Statement ann)
stat]
statement (SeqBlock [Statement ann]
s) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep [Doc a
"begin", Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 (Doc a -> Doc a) -> ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ Statement ann -> Doc a
forall ann a. Show ann => Statement ann -> Doc a
statement (Statement ann -> Doc a) -> [Statement ann] -> [Doc a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Statement ann]
s, Doc a
"end"]
statement (BlockAssign Assign
a) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Text -> Assign -> Doc a
forall a. Text -> Assign -> Doc a
genAssign Text
"=" Assign
a, Doc a
forall ann. Doc ann
semi]
statement (NonBlockAssign Assign
a) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Text -> Assign -> Doc a
forall a. Text -> Assign -> Doc a
genAssign Text
"<=" Assign
a, Doc a
forall ann. Doc ann
semi]
statement (TaskEnable Task
t) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Task -> Doc a
forall a. Task -> Doc a
task Task
t, Doc a
forall ann. Doc ann
semi]
statement (SysTaskEnable Task
t) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [Doc a
"$", Task -> Doc a
forall a. Task -> Doc a
task Task
t, Doc a
forall ann. Doc ann
semi]
statement (CondStmnt Expr
e Maybe (Statement ann)
t Maybe (Statement ann)
Nothing) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep [[Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Doc a
"if", Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e], Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Maybe (Statement ann) -> Doc a
forall ann a. Show ann => Maybe (Statement ann) -> Doc a
defMap Maybe (Statement ann)
t]
statement (StmntCase CaseType
t Expr
e [CasePair ann]
ls Maybe (Statement ann)
d) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vcat
    [ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hcat [CaseType -> Doc a
forall a. CaseType -> Doc a
caseType CaseType
t, Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e],
      [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vcat ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ CasePair ann -> Doc a
forall ann a. Show ann => CasePair ann -> Doc a
casePair (CasePair ann -> Doc a) -> [CasePair ann] -> [Doc a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [CasePair ann]
ls,
      Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep [Doc a
"default:", Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Maybe (Statement ann) -> Doc a
forall ann a. Show ann => Maybe (Statement ann) -> Doc a
defMap Maybe (Statement ann)
d],
      Doc a
"endcase"
    ]
statement (CondStmnt Expr
e Maybe (Statement ann)
t Maybe (Statement ann)
f) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep
    [ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Doc a
"if", Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e],
      Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Maybe (Statement ann) -> Doc a
forall ann a. Show ann => Maybe (Statement ann) -> Doc a
defMap Maybe (Statement ann)
t,
      Doc a
"else",
      Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Maybe (Statement ann) -> Doc a
forall ann a. Show ann => Maybe (Statement ann) -> Doc a
defMap Maybe (Statement ann)
f
    ]
statement (ForLoop Assign
a Expr
e Assign
incr Statement ann
stmnt) =
  [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
vsep
    [ [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep
        [ Doc a
"for",
          Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$
            Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate
              Doc a
forall ann. Doc ann
semi
              [Text -> Assign -> Doc a
forall a. Text -> Assign -> Doc a
genAssign Text
"=" Assign
a, Expr -> Doc a
forall a. Expr -> Doc a
expr Expr
e, Text -> Assign -> Doc a
forall a. Text -> Assign -> Doc a
genAssign Text
"=" Assign
incr]
        ],
      Int -> Doc a -> Doc a
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 (Doc a -> Doc a) -> Doc a -> Doc a
forall a b. (a -> b) -> a -> b
$ Statement ann -> Doc a
forall ann a. Show ann => Statement ann -> Doc a
statement Statement ann
stmnt
    ]
statement (StmntAnn ann
a Statement ann
s) = [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
sep [[Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep [Doc a
"/*", String -> Doc a
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc a) -> String -> Doc a
forall a b. (a -> b) -> a -> b
$ ann -> String
forall a. Show a => a -> String
show ann
a, Doc a
"*/"], Statement ann -> Doc a
forall ann a. Show ann => Statement ann -> Doc a
statement Statement ann
s]

task :: Task -> Doc a
task :: forall a. Task -> Doc a
task (Task Identifier
i [Expr]
e)
  | [Expr] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Expr]
e = Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i
  | Bool
otherwise =
    [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep
      [Identifier -> Doc a
forall a. Identifier -> Doc a
identifier Identifier
i, Doc a -> Doc a
forall ann. Doc ann -> Doc ann
parens (Doc a -> Doc a) -> ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc a] -> Doc a
forall ann. [Doc ann] -> Doc ann
hsep ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ Doc a -> [Doc a] -> [Doc a]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc a
forall ann. Doc ann
comma (Expr -> Doc a
forall a. Expr -> Doc a
expr (Expr -> Doc a) -> [Expr] -> [Doc a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Expr]
e)]

-- | Render the 'Text' to 'IO'. This is equivalent to 'putStrLn'.
render :: (Source a) => a -> IO ()
render :: forall a. Source a => a -> IO ()
render = Text -> IO ()
forall a. Show a => a -> IO ()
print (Text -> IO ()) -> (a -> Text) -> a -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Text
forall a. Source a => a -> Text
genSource

-- Instances

instance Source Identifier where
  genSource :: Identifier -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (Identifier -> Doc Any) -> Identifier -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Doc Any
forall a. Identifier -> Doc a
identifier

instance Source Task where
  genSource :: Task -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (Task -> Doc Any) -> Task -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Task -> Doc Any
forall a. Task -> Doc a
task

instance (Show ann) => Source (Statement ann) where
  genSource :: Statement ann -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text)
-> (Statement ann -> Doc Any) -> Statement ann -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Statement ann -> Doc Any
forall ann a. Show ann => Statement ann -> Doc a
statement

instance Source PortType where
  genSource :: PortType -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (PortType -> Doc Any) -> PortType -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PortType -> Doc Any
forall a. PortType -> Doc a
pType

instance Source ConstExpr where
  genSource :: ConstExpr -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (ConstExpr -> Doc Any) -> ConstExpr -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConstExpr -> Doc Any
forall a. ConstExpr -> Doc a
constExpr

instance Source LVal where
  genSource :: LVal -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (LVal -> Doc Any) -> LVal -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LVal -> Doc Any
forall a. LVal -> Doc a
lVal

instance Source Delay where
  genSource :: Delay -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (Delay -> Doc Any) -> Delay -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Delay -> Doc Any
forall a. Delay -> Doc a
delay

instance Source Event where
  genSource :: Event -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (Event -> Doc Any) -> Event -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Event -> Doc Any
forall a. Event -> Doc a
event

instance Source UnaryOperator where
  genSource :: UnaryOperator -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text)
-> (UnaryOperator -> Doc Any) -> UnaryOperator -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnaryOperator -> Doc Any
forall a. UnaryOperator -> Doc a
unaryOp

instance Source Expr where
  genSource :: Expr -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (Expr -> Doc Any) -> Expr -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expr -> Doc Any
forall a. Expr -> Doc a
expr

instance Source ContAssign where
  genSource :: ContAssign -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (ContAssign -> Doc Any) -> ContAssign -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ContAssign -> Doc Any
forall a. ContAssign -> Doc a
contAssign

instance (Show ann) => Source (ModItem ann) where
  genSource :: ModItem ann -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text)
-> (ModItem ann -> Doc Any) -> ModItem ann -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModItem ann -> Doc Any
forall ann a. Show ann => ModItem ann -> Doc a
moduleItem

instance Source PortDir where
  genSource :: PortDir -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (PortDir -> Doc Any) -> PortDir -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PortDir -> Doc Any
forall a. PortDir -> Doc a
portDir

instance Source Port where
  genSource :: Port -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text) -> (Port -> Doc Any) -> Port -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Port -> Doc Any
forall a. Port -> Doc a
port

instance (Show ann) => Source (ModDecl ann) where
  genSource :: ModDecl ann -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text)
-> (ModDecl ann -> Doc Any) -> ModDecl ann -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModDecl ann -> Doc Any
forall ann a. Show ann => ModDecl ann -> Doc a
moduleDecl

instance (Show ann) => Source (Verilog ann) where
  genSource :: Verilog ann -> Text
genSource = Doc Any -> Text
forall a. Show a => a -> Text
showT (Doc Any -> Text)
-> (Verilog ann -> Doc Any) -> Verilog ann -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Verilog ann -> Doc Any
forall ann a. Show ann => Verilog ann -> Doc a
verilogSrc

instance (Show ann) => Source (SourceInfo ann) where
  genSource :: SourceInfo ann -> Text
genSource (SourceInfo Text
_ Verilog ann
src) = Verilog ann -> Text
forall a. Source a => a -> Text
genSource Verilog ann
src

newtype GenVerilog a = GenVerilog {forall a. GenVerilog a -> a
unGenVerilog :: a}
  deriving (GenVerilog a -> GenVerilog a -> Bool
(GenVerilog a -> GenVerilog a -> Bool)
-> (GenVerilog a -> GenVerilog a -> Bool) -> Eq (GenVerilog a)
forall a. Eq a => GenVerilog a -> GenVerilog a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => GenVerilog a -> GenVerilog a -> Bool
== :: GenVerilog a -> GenVerilog a -> Bool
$c/= :: forall a. Eq a => GenVerilog a -> GenVerilog a -> Bool
/= :: GenVerilog a -> GenVerilog a -> Bool
Eq, Eq (GenVerilog a)
Eq (GenVerilog a) =>
(GenVerilog a -> GenVerilog a -> Ordering)
-> (GenVerilog a -> GenVerilog a -> Bool)
-> (GenVerilog a -> GenVerilog a -> Bool)
-> (GenVerilog a -> GenVerilog a -> Bool)
-> (GenVerilog a -> GenVerilog a -> Bool)
-> (GenVerilog a -> GenVerilog a -> GenVerilog a)
-> (GenVerilog a -> GenVerilog a -> GenVerilog a)
-> Ord (GenVerilog a)
GenVerilog a -> GenVerilog a -> Bool
GenVerilog a -> GenVerilog a -> Ordering
GenVerilog a -> GenVerilog a -> GenVerilog 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 (GenVerilog a)
forall a. Ord a => GenVerilog a -> GenVerilog a -> Bool
forall a. Ord a => GenVerilog a -> GenVerilog a -> Ordering
forall a. Ord a => GenVerilog a -> GenVerilog a -> GenVerilog a
$ccompare :: forall a. Ord a => GenVerilog a -> GenVerilog a -> Ordering
compare :: GenVerilog a -> GenVerilog a -> Ordering
$c< :: forall a. Ord a => GenVerilog a -> GenVerilog a -> Bool
< :: GenVerilog a -> GenVerilog a -> Bool
$c<= :: forall a. Ord a => GenVerilog a -> GenVerilog a -> Bool
<= :: GenVerilog a -> GenVerilog a -> Bool
$c> :: forall a. Ord a => GenVerilog a -> GenVerilog a -> Bool
> :: GenVerilog a -> GenVerilog a -> Bool
$c>= :: forall a. Ord a => GenVerilog a -> GenVerilog a -> Bool
>= :: GenVerilog a -> GenVerilog a -> Bool
$cmax :: forall a. Ord a => GenVerilog a -> GenVerilog a -> GenVerilog a
max :: GenVerilog a -> GenVerilog a -> GenVerilog a
$cmin :: forall a. Ord a => GenVerilog a -> GenVerilog a -> GenVerilog a
min :: GenVerilog a -> GenVerilog a -> GenVerilog a
Ord, Typeable (GenVerilog a)
Typeable (GenVerilog a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> GenVerilog a -> c (GenVerilog a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GenVerilog a))
-> (GenVerilog a -> Constr)
-> (GenVerilog a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GenVerilog a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GenVerilog a)))
-> ((forall b. Data b => b -> b) -> GenVerilog a -> GenVerilog a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GenVerilog a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GenVerilog a -> r)
-> (forall u. (forall d. Data d => d -> u) -> GenVerilog a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GenVerilog a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a))
-> Data (GenVerilog a)
GenVerilog a -> Constr
GenVerilog a -> DataType
(forall b. Data b => b -> b) -> GenVerilog a -> GenVerilog a
forall a. Data a => Typeable (GenVerilog a)
forall a. Data a => GenVerilog a -> Constr
forall a. Data a => GenVerilog a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> GenVerilog a -> GenVerilog a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> GenVerilog a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> GenVerilog a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenVerilog a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenVerilog a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenVerilog a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenVerilog a -> c (GenVerilog a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GenVerilog a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenVerilog 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) -> GenVerilog a -> u
forall u. (forall d. Data d => d -> u) -> GenVerilog a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenVerilog a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenVerilog a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenVerilog a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenVerilog a -> c (GenVerilog a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GenVerilog a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenVerilog a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenVerilog a -> c (GenVerilog a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GenVerilog a -> c (GenVerilog a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenVerilog a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (GenVerilog a)
$ctoConstr :: forall a. Data a => GenVerilog a -> Constr
toConstr :: GenVerilog a -> Constr
$cdataTypeOf :: forall a. Data a => GenVerilog a -> DataType
dataTypeOf :: GenVerilog a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (GenVerilog a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (GenVerilog a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenVerilog a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenVerilog a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> GenVerilog a -> GenVerilog a
gmapT :: (forall b. Data b => b -> b) -> GenVerilog a -> GenVerilog a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenVerilog a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GenVerilog a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenVerilog a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GenVerilog a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> GenVerilog a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> GenVerilog a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> GenVerilog a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GenVerilog a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GenVerilog a -> m (GenVerilog a)
Data)

instance (Source a) => Show (GenVerilog a) where
  show :: GenVerilog a -> String
show = Text -> String
T.unpack (Text -> String)
-> (GenVerilog a -> Text) -> GenVerilog a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Text
forall a. Source a => a -> Text
genSource (a -> Text) -> (GenVerilog a -> a) -> GenVerilog a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenVerilog a -> a
forall a. GenVerilog a -> a
unGenVerilog