{-# LANGUAGE FlexibleInstances #-}

-- |
-- Module      : Verismith.Verilog.Mutate
-- Description : Functions to mutate the Verilog AST.
-- Copyright   : (c) 2018-2022, Yann Herklotz
-- License     : GPL-3
-- Maintainer  : yann [at] yannherklotz [dot] com
-- Stability   : experimental
-- Portability : POSIX
--
-- Functions to mutate the Verilog AST from "Verismith.Verilog.AST" to generate more
-- random patterns, such as nesting wires instead of creating new ones.
module Verismith.Verilog.Mutate
  ( Mutate (..),
    inPort,
    findAssign,
    idTrans,
    replace,
    nestId,
    nestSource,
    nestUpTo,
    allVars,
    instantiateMod,
    instantiateMod_,
    instantiateModSpec_,
    filterChar,
    initMod,
    makeIdFrom,
    makeTop,
    makeTopAssert,
    simplify,
    removeId,
    combineAssigns,
    combineAssigns_,
    declareMod,
    fromPort,
  )
where

import Control.Lens
import Data.Foldable (fold)
import Data.Maybe (catMaybes, fromMaybe)
import Data.Text (Text)
import qualified Data.Text as T
import Verismith.Circuit.Internal
import Verismith.Utils
import Verismith.Verilog.AST
import Verismith.Verilog.BitVec
import Verismith.Verilog.CodeGen
import Verismith.Verilog.Internal

class Mutate a where
  mutExpr :: (Expr -> Expr) -> a -> a

instance Mutate Identifier where
  mutExpr :: (Expr -> Expr) -> Identifier -> Identifier
mutExpr Expr -> Expr
_ = Identifier -> Identifier
forall a. a -> a
id

instance Mutate Delay where
  mutExpr :: (Expr -> Expr) -> Delay -> Delay
mutExpr Expr -> Expr
_ = Delay -> Delay
forall a. a -> a
id

instance Mutate Event where
  mutExpr :: (Expr -> Expr) -> Event -> Event
mutExpr Expr -> Expr
f (EExpr Expr
e) = Expr -> Event
EExpr (Expr -> Event) -> Expr -> Event
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
f Expr
e
  mutExpr Expr -> Expr
_ Event
a = Event
a

instance Mutate BinaryOperator where
  mutExpr :: (Expr -> Expr) -> BinaryOperator -> BinaryOperator
mutExpr Expr -> Expr
_ = BinaryOperator -> BinaryOperator
forall a. a -> a
id

instance Mutate UnaryOperator where
  mutExpr :: (Expr -> Expr) -> UnaryOperator -> UnaryOperator
mutExpr Expr -> Expr
_ = UnaryOperator -> UnaryOperator
forall a. a -> a
id

instance Mutate Expr where
  mutExpr :: (Expr -> Expr) -> Expr -> Expr
mutExpr Expr -> Expr
f = Expr -> Expr
f

instance Mutate ConstExpr where
  mutExpr :: (Expr -> Expr) -> ConstExpr -> ConstExpr
mutExpr Expr -> Expr
_ = ConstExpr -> ConstExpr
forall a. a -> a
id

instance Mutate Task where
  mutExpr :: (Expr -> Expr) -> Task -> Task
mutExpr Expr -> Expr
f (Task Identifier
i [Expr]
e) = Identifier -> [Expr] -> Task
Task Identifier
i ([Expr] -> Task) -> [Expr] -> Task
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> [Expr] -> [Expr]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Expr -> Expr
f [Expr]
e

instance Mutate LVal where
  mutExpr :: (Expr -> Expr) -> LVal -> LVal
mutExpr Expr -> Expr
f (RegExpr Identifier
a Expr
e) = Identifier -> Expr -> LVal
RegExpr Identifier
a (Expr -> LVal) -> Expr -> LVal
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
f Expr
e
  mutExpr Expr -> Expr
_ LVal
a = LVal
a

instance Mutate PortDir where
  mutExpr :: (Expr -> Expr) -> PortDir -> PortDir
mutExpr Expr -> Expr
_ = PortDir -> PortDir
forall a. a -> a
id

instance Mutate PortType where
  mutExpr :: (Expr -> Expr) -> PortType -> PortType
mutExpr Expr -> Expr
_ = PortType -> PortType
forall a. a -> a
id

instance Mutate Range where
  mutExpr :: (Expr -> Expr) -> Range -> Range
mutExpr Expr -> Expr
_ = Range -> Range
forall a. a -> a
id

instance Mutate Port where
  mutExpr :: (Expr -> Expr) -> Port -> Port
mutExpr Expr -> Expr
_ = Port -> Port
forall a. a -> a
id

instance Mutate ModConn where
  mutExpr :: (Expr -> Expr) -> ModConn -> ModConn
mutExpr Expr -> Expr
f (ModConn Expr
e) = Expr -> ModConn
ModConn (Expr -> ModConn) -> Expr -> ModConn
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
f Expr
e
  mutExpr Expr -> Expr
f (ModConnNamed Identifier
a Expr
e) = Identifier -> Expr -> ModConn
ModConnNamed Identifier
a (Expr -> ModConn) -> Expr -> ModConn
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
f Expr
e

instance Mutate Assign where
  mutExpr :: (Expr -> Expr) -> Assign -> Assign
mutExpr Expr -> Expr
f (Assign LVal
a Maybe Delay
b Expr
c) = LVal -> Maybe Delay -> Expr -> Assign
Assign LVal
a Maybe Delay
b (Expr -> Assign) -> Expr -> Assign
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
f Expr
c

instance Mutate ContAssign where
  mutExpr :: (Expr -> Expr) -> ContAssign -> ContAssign
mutExpr Expr -> Expr
f (ContAssign Identifier
a Expr
e) = Identifier -> Expr -> ContAssign
ContAssign Identifier
a (Expr -> ContAssign) -> Expr -> ContAssign
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
f Expr
e

instance Mutate (CasePair ann) where
  mutExpr :: (Expr -> Expr) -> CasePair ann -> CasePair ann
mutExpr Expr -> Expr
f (CasePair Expr
e Statement ann
s) = Expr -> Statement ann -> CasePair ann
forall a. Expr -> Statement a -> CasePair a
CasePair (Expr -> Expr
f Expr
e) (Statement ann -> CasePair ann) -> Statement ann -> CasePair ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Statement ann -> Statement ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Statement ann
s

instance Mutate (Statement ann) where
  mutExpr :: (Expr -> Expr) -> Statement ann -> Statement ann
mutExpr Expr -> Expr
f (TimeCtrl Delay
d Maybe (Statement ann)
s) = Delay -> Maybe (Statement ann) -> Statement ann
forall a. Delay -> Maybe (Statement a) -> Statement a
TimeCtrl Delay
d (Maybe (Statement ann) -> Statement ann)
-> Maybe (Statement ann) -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Statement ann -> Statement ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f (Statement ann -> Statement ann)
-> Maybe (Statement ann) -> Maybe (Statement ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Statement ann)
s
  mutExpr Expr -> Expr
f (EventCtrl Event
e Maybe (Statement ann)
s) = Event -> Maybe (Statement ann) -> Statement ann
forall a. Event -> Maybe (Statement a) -> Statement a
EventCtrl Event
e (Maybe (Statement ann) -> Statement ann)
-> Maybe (Statement ann) -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Statement ann -> Statement ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f (Statement ann -> Statement ann)
-> Maybe (Statement ann) -> Maybe (Statement ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Statement ann)
s
  mutExpr Expr -> Expr
f (SeqBlock [Statement ann]
s) = [Statement ann] -> Statement ann
forall a. [Statement a] -> Statement a
SeqBlock ([Statement ann] -> Statement ann)
-> [Statement ann] -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Statement ann -> Statement ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f (Statement ann -> Statement ann)
-> [Statement ann] -> [Statement ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Statement ann]
s
  mutExpr Expr -> Expr
f (BlockAssign Assign
a) = Assign -> Statement ann
forall a. Assign -> Statement a
BlockAssign (Assign -> Statement ann) -> Assign -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Assign -> Assign
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Assign
a
  mutExpr Expr -> Expr
f (NonBlockAssign Assign
a) = Assign -> Statement ann
forall a. Assign -> Statement a
NonBlockAssign (Assign -> Statement ann) -> Assign -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Assign -> Assign
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Assign
a
  mutExpr Expr -> Expr
f (TaskEnable Task
a) = Task -> Statement ann
forall a. Task -> Statement a
TaskEnable (Task -> Statement ann) -> Task -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Task -> Task
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Task
a
  mutExpr Expr -> Expr
f (SysTaskEnable Task
a) = Task -> Statement ann
forall a. Task -> Statement a
SysTaskEnable (Task -> Statement ann) -> Task -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Task -> Task
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Task
a
  mutExpr Expr -> Expr
f (CondStmnt Expr
a Maybe (Statement ann)
b Maybe (Statement ann)
c) = Expr
-> Maybe (Statement ann) -> Maybe (Statement ann) -> Statement ann
forall a.
Expr -> Maybe (Statement a) -> Maybe (Statement a) -> Statement a
CondStmnt (Expr -> Expr
f Expr
a) ((Expr -> Expr) -> Statement ann -> Statement ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f (Statement ann -> Statement ann)
-> Maybe (Statement ann) -> Maybe (Statement ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Statement ann)
b) (Maybe (Statement ann) -> Statement ann)
-> Maybe (Statement ann) -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Statement ann -> Statement ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f (Statement ann -> Statement ann)
-> Maybe (Statement ann) -> Maybe (Statement ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Statement ann)
c
  mutExpr Expr -> Expr
f (ForLoop Assign
a1 Expr
e Assign
a2 Statement ann
s) = Assign -> Expr -> Assign -> Statement ann -> Statement ann
forall a. Assign -> Expr -> Assign -> Statement a -> Statement a
ForLoop Assign
a1 Expr
e Assign
a2 (Statement ann -> Statement ann) -> Statement ann -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Statement ann -> Statement ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Statement ann
s
  mutExpr Expr -> Expr
f (StmntAnn ann
a Statement ann
s) = ann -> Statement ann -> Statement ann
forall a. a -> Statement a -> Statement a
StmntAnn ann
a (Statement ann -> Statement ann) -> Statement ann -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Statement ann -> Statement ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Statement ann
s
  mutExpr Expr -> Expr
f (StmntCase CaseType
t Expr
e [CasePair ann]
cp Maybe (Statement ann)
cd) = CaseType
-> Expr -> [CasePair ann] -> Maybe (Statement ann) -> Statement ann
forall a.
CaseType
-> Expr -> [CasePair a] -> Maybe (Statement a) -> Statement a
StmntCase CaseType
t (Expr -> Expr
f Expr
e) ((Expr -> Expr) -> [CasePair ann] -> [CasePair ann]
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f [CasePair ann]
cp) (Maybe (Statement ann) -> Statement ann)
-> Maybe (Statement ann) -> Statement ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Maybe (Statement ann) -> Maybe (Statement ann)
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Maybe (Statement ann)
cd

instance Mutate Parameter where
  mutExpr :: (Expr -> Expr) -> Parameter -> Parameter
mutExpr Expr -> Expr
_ = Parameter -> Parameter
forall a. a -> a
id

instance Mutate LocalParam where
  mutExpr :: (Expr -> Expr) -> LocalParam -> LocalParam
mutExpr Expr -> Expr
_ = LocalParam -> LocalParam
forall a. a -> a
id

instance Mutate (ModItem ann) where
  mutExpr :: (Expr -> Expr) -> ModItem ann -> ModItem ann
mutExpr Expr -> Expr
f (ModCA (ContAssign Identifier
a Expr
e)) = ContAssign -> ModItem ann
forall a. ContAssign -> ModItem a
ModCA (ContAssign -> ModItem ann)
-> (Expr -> ContAssign) -> Expr -> ModItem ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Expr -> ContAssign
ContAssign Identifier
a (Expr -> ModItem ann) -> Expr -> ModItem ann
forall a b. (a -> b) -> a -> b
$ Expr -> Expr
f Expr
e
  mutExpr Expr -> Expr
f (ModInst Identifier
a [ModConn]
params Identifier
b [ModConn]
conns) = Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem ann
forall a.
Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem a
ModInst Identifier
a ((Expr -> Expr) -> [ModConn] -> [ModConn]
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f [ModConn]
params) Identifier
b ([ModConn] -> ModItem ann) -> [ModConn] -> ModItem ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> [ModConn] -> [ModConn]
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f [ModConn]
conns
  mutExpr Expr -> Expr
f (Initial Statement ann
s) = Statement ann -> ModItem ann
forall a. Statement a -> ModItem a
Initial (Statement ann -> ModItem ann) -> Statement ann -> ModItem ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Statement ann -> Statement ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Statement ann
s
  mutExpr Expr -> Expr
f (Always Statement ann
s) = Statement ann -> ModItem ann
forall a. Statement a -> ModItem a
Always (Statement ann -> ModItem ann) -> Statement ann -> ModItem ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Statement ann -> Statement ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Statement ann
s
  mutExpr Expr -> Expr
f (ModItemAnn ann
a ModItem ann
s) = ann -> ModItem ann -> ModItem ann
forall a. a -> ModItem a -> ModItem a
ModItemAnn ann
a (ModItem ann -> ModItem ann) -> ModItem ann -> ModItem ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> ModItem ann -> ModItem ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f ModItem ann
s
  mutExpr Expr -> Expr
_ d :: ModItem ann
d@Decl {} = ModItem ann
d
  mutExpr Expr -> Expr
_ p :: ModItem ann
p@ParamDecl {} = ModItem ann
p
  mutExpr Expr -> Expr
_ l :: ModItem ann
l@LocalParamDecl {} = ModItem ann
l

instance Mutate (ModDecl ann) where
  mutExpr :: (Expr -> Expr) -> ModDecl ann -> ModDecl ann
mutExpr Expr -> Expr
f (ModDecl Identifier
a [Port]
b [Port]
c [ModItem ann]
d [Parameter]
e) =
    Identifier
-> [Port] -> [Port] -> [ModItem ann] -> [Parameter] -> ModDecl ann
forall a.
Identifier
-> [Port] -> [Port] -> [ModItem a] -> [Parameter] -> ModDecl a
ModDecl ((Expr -> Expr) -> Identifier -> Identifier
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Identifier
a) ((Expr -> Expr) -> [Port] -> [Port]
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f [Port]
b) ((Expr -> Expr) -> [Port] -> [Port]
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f [Port]
c) ((Expr -> Expr) -> [ModItem ann] -> [ModItem ann]
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f [ModItem ann]
d) ((Expr -> Expr) -> [Parameter] -> [Parameter]
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f [Parameter]
e)
  mutExpr Expr -> Expr
f (ModDeclAnn ann
a ModDecl ann
m) = ann -> ModDecl ann -> ModDecl ann
forall a. a -> ModDecl a -> ModDecl a
ModDeclAnn ann
a (ModDecl ann -> ModDecl ann) -> ModDecl ann -> ModDecl ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> ModDecl ann -> ModDecl ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f ModDecl ann
m

instance Mutate (Verilog ann) where
  mutExpr :: (Expr -> Expr) -> Verilog ann -> Verilog ann
mutExpr Expr -> Expr
f (Verilog [ModDecl ann]
a) = [ModDecl ann] -> Verilog ann
forall a. [ModDecl a] -> Verilog a
Verilog ([ModDecl ann] -> Verilog ann) -> [ModDecl ann] -> Verilog ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> [ModDecl ann] -> [ModDecl ann]
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f [ModDecl ann]
a

instance Mutate (SourceInfo ann) where
  mutExpr :: (Expr -> Expr) -> SourceInfo ann -> SourceInfo ann
mutExpr Expr -> Expr
f (SourceInfo Text
a Verilog ann
b) = Text -> Verilog ann -> SourceInfo ann
forall a. Text -> Verilog a -> SourceInfo a
SourceInfo Text
a (Verilog ann -> SourceInfo ann) -> Verilog ann -> SourceInfo ann
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> Verilog ann -> Verilog ann
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f Verilog ann
b

instance (Mutate a) => Mutate [a] where
  mutExpr :: (Expr -> Expr) -> [a] -> [a]
mutExpr Expr -> Expr
f [a]
a = (Expr -> Expr) -> a -> a
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f (a -> a) -> [a] -> [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [a]
a

instance (Mutate a) => Mutate (Maybe a) where
  mutExpr :: (Expr -> Expr) -> Maybe a -> Maybe a
mutExpr Expr -> Expr
f Maybe a
a = (Expr -> Expr) -> a -> a
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f (a -> a) -> Maybe a -> Maybe a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a
a

instance (Mutate a) => Mutate (GenVerilog a) where
  mutExpr :: (Expr -> Expr) -> GenVerilog a -> GenVerilog a
mutExpr Expr -> Expr
f (GenVerilog a
a) = a -> GenVerilog a
forall a. a -> GenVerilog a
GenVerilog (a -> GenVerilog a) -> a -> GenVerilog a
forall a b. (a -> b) -> a -> b
$ (Expr -> Expr) -> a -> a
forall a. Mutate a => (Expr -> Expr) -> a -> a
mutExpr Expr -> Expr
f a
a

-- | Return if the 'Identifier' is in a '(ModDecl ann)'.
inPort :: Identifier -> (ModDecl ann) -> Bool
inPort :: forall ann. Identifier -> ModDecl ann -> Bool
inPort Identifier
i ModDecl ann
m = Bool
inInput
  where
    inInput :: Bool
inInput =
      (Port -> Bool) -> [Port] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\Port
a -> Port
a Port -> Getting Identifier Port Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier Port Identifier
Lens' Port Identifier
portName Identifier -> Identifier -> Bool
forall a. Eq a => a -> a -> Bool
== Identifier
i) ([Port] -> Bool) -> [Port] -> Bool
forall a b. (a -> b) -> a -> b
$ ModDecl ann
m ModDecl ann -> Getting [Port] (ModDecl ann) [Port] -> [Port]
forall s a. s -> Getting a s a -> a
^. Getting [Port] (ModDecl ann) [Port]
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modInPorts [Port] -> [Port] -> [Port]
forall a. [a] -> [a] -> [a]
++ ModDecl ann
m ModDecl ann -> Getting [Port] (ModDecl ann) [Port] -> [Port]
forall s a. s -> Getting a s a -> a
^. Getting [Port] (ModDecl ann) [Port]
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modOutPorts

-- | Find the last assignment of a specific wire/reg to an expression, and
-- returns that expression.
findAssign :: Identifier -> [ModItem ann] -> Maybe Expr
findAssign :: forall ann. Identifier -> [ModItem ann] -> Maybe Expr
findAssign Identifier
i [ModItem ann]
items = ([Expr] -> Expr) -> [Expr] -> Maybe Expr
forall a b. ([a] -> b) -> [a] -> Maybe b
safe [Expr] -> Expr
forall a. HasCallStack => [a] -> a
last ([Expr] -> Maybe Expr)
-> ([Maybe Expr] -> [Expr]) -> [Maybe Expr] -> Maybe Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Maybe Expr] -> [Expr]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe Expr] -> Maybe Expr) -> [Maybe Expr] -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ ModItem ann -> Maybe Expr
forall {a}. ModItem a -> Maybe Expr
isAssign (ModItem ann -> Maybe Expr) -> [ModItem ann] -> [Maybe Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ModItem ann]
items
  where
    isAssign :: ModItem a -> Maybe Expr
isAssign (ModCA (ContAssign Identifier
val Expr
expr))
      | Identifier
val Identifier -> Identifier -> Bool
forall a. Eq a => a -> a -> Bool
== Identifier
i = Expr -> Maybe Expr
forall a. a -> Maybe a
Just Expr
expr
      | Bool
otherwise = Maybe Expr
forall a. Maybe a
Nothing
    isAssign ModItem a
_ = Maybe Expr
forall a. Maybe a
Nothing

-- | Transforms an expression by replacing an Identifier with an
-- expression. This is used inside 'transformOf' and 'traverseExpr' to replace
-- the 'Identifier' recursively.
idTrans :: Identifier -> Expr -> Expr -> Expr
idTrans :: Identifier -> Expr -> Expr -> Expr
idTrans Identifier
i Expr
expr (Id Identifier
id')
  | Identifier
id' Identifier -> Identifier -> Bool
forall a. Eq a => a -> a -> Bool
== Identifier
i = Expr
expr
  | Bool
otherwise = Identifier -> Expr
Id Identifier
id'
idTrans Identifier
_ Expr
_ Expr
e = Expr
e

-- | Replaces the identifier recursively in an expression.
replace :: Identifier -> Expr -> Expr -> Expr
replace :: Identifier -> Expr -> Expr -> Expr
replace = ((Expr -> Expr) -> Expr -> Expr
forall a. Plated a => (a -> a) -> a -> a
transform ((Expr -> Expr) -> Expr -> Expr)
-> (Expr -> Expr -> Expr) -> Expr -> Expr -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((Expr -> Expr -> Expr) -> Expr -> Expr -> Expr)
-> (Identifier -> Expr -> Expr -> Expr)
-> Identifier
-> Expr
-> Expr
-> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Expr -> Expr -> Expr
idTrans

-- | Nest expressions for a specific 'Identifier'. If the 'Identifier' is not
-- found, the AST is not changed.
--
-- This could be improved by instead of only using the last assignment to the
-- wire that one finds, to use the assignment to the wire before the current
-- expression. This would require a different approach though.
nestId :: Identifier -> (ModDecl ann) -> (ModDecl ann)
nestId :: forall ann. Identifier -> ModDecl ann -> ModDecl ann
nestId Identifier
i ModDecl ann
m
  | Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Identifier -> ModDecl ann -> Bool
forall ann. Identifier -> ModDecl ann -> Bool
inPort Identifier
i ModDecl ann
m =
    let expr :: Expr
expr = Expr -> Maybe Expr -> Expr
forall a. a -> Maybe a -> a
fromMaybe Expr
def (Maybe Expr -> Expr)
-> ([ModItem ann] -> Maybe Expr) -> [ModItem ann] -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> [ModItem ann] -> Maybe Expr
forall ann. Identifier -> [ModItem ann] -> Maybe Expr
findAssign Identifier
i ([ModItem ann] -> Expr) -> [ModItem ann] -> Expr
forall a b. (a -> b) -> a -> b
$ ModDecl ann
m ModDecl ann
-> Getting [ModItem ann] (ModDecl ann) [ModItem ann]
-> [ModItem ann]
forall s a. s -> Getting a s a -> a
^. Getting [ModItem ann] (ModDecl ann) [ModItem ann]
forall a (f :: * -> *).
Applicative f =>
([ModItem a] -> f [ModItem a]) -> ModDecl a -> f (ModDecl a)
modItems
     in ModDecl ann
m ModDecl ann -> (ModDecl ann -> ModDecl ann) -> ModDecl ann
forall a b. a -> (a -> b) -> b
& (Expr -> Identity Expr) -> ModDecl ann -> Identity (ModDecl ann)
forall {a}.
(Expr -> Identity Expr) -> ModDecl a -> Identity (ModDecl a)
get ((Expr -> Identity Expr) -> ModDecl ann -> Identity (ModDecl ann))
-> (Expr -> Expr) -> ModDecl ann -> ModDecl ann
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ Identifier -> Expr -> Expr -> Expr
replace Identifier
i Expr
expr
  | Bool
otherwise =
    ModDecl ann
m
  where
    get :: (Expr -> Identity Expr) -> ModDecl a -> Identity (ModDecl a)
get = ([ModItem a] -> Identity [ModItem a])
-> ModDecl a -> Identity (ModDecl a)
forall a (f :: * -> *).
Applicative f =>
([ModItem a] -> f [ModItem a]) -> ModDecl a -> f (ModDecl a)
modItems (([ModItem a] -> Identity [ModItem a])
 -> ModDecl a -> Identity (ModDecl a))
-> ((Expr -> Identity Expr) -> [ModItem a] -> Identity [ModItem a])
-> (Expr -> Identity Expr)
-> ModDecl a
-> Identity (ModDecl a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ModItem a -> Identity (ModItem a))
-> [ModItem a] -> Identity [ModItem a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((ModItem a -> Identity (ModItem a))
 -> [ModItem a] -> Identity [ModItem a])
-> ((Expr -> Identity Expr) -> ModItem a -> Identity (ModItem a))
-> (Expr -> Identity Expr)
-> [ModItem a]
-> Identity [ModItem a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ContAssign -> Identity ContAssign)
-> ModItem a -> Identity (ModItem a)
forall a (f :: * -> *).
Applicative f =>
(ContAssign -> f ContAssign) -> ModItem a -> f (ModItem a)
modContAssign ((ContAssign -> Identity ContAssign)
 -> ModItem a -> Identity (ModItem a))
-> ((Expr -> Identity Expr) -> ContAssign -> Identity ContAssign)
-> (Expr -> Identity Expr)
-> ModItem a
-> Identity (ModItem a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Expr -> Identity Expr) -> ContAssign -> Identity ContAssign
Lens' ContAssign Expr
contAssignExpr
    def :: Expr
def = Identifier -> Expr
Id Identifier
i

-- | Replaces an identifier by a expression in all the module declaration.
nestSource :: Identifier -> (Verilog ann) -> (Verilog ann)
nestSource :: forall ann. Identifier -> Verilog ann -> Verilog ann
nestSource Identifier
i Verilog ann
src = Verilog ann
src Verilog ann -> (Verilog ann -> Verilog ann) -> Verilog ann
forall a b. a -> (a -> b) -> b
& (ModDecl ann -> Identity (ModDecl ann))
-> Verilog ann -> Identity (Verilog ann)
forall a (f :: * -> *).
Applicative f =>
(ModDecl a -> f (ModDecl a)) -> Verilog a -> f (Verilog a)
getModule ((ModDecl ann -> Identity (ModDecl ann))
 -> Verilog ann -> Identity (Verilog ann))
-> (ModDecl ann -> ModDecl ann) -> Verilog ann -> Verilog ann
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ Identifier -> ModDecl ann -> ModDecl ann
forall ann. Identifier -> ModDecl ann -> ModDecl ann
nestId Identifier
i

-- | Nest variables in the format @w[0-9]*@ up to a certain number.
nestUpTo :: Int -> (Verilog ann) -> (Verilog ann)
nestUpTo :: forall ann. Int -> Verilog ann -> Verilog ann
nestUpTo Int
i Verilog ann
src =
  (Verilog ann -> Identifier -> Verilog ann)
-> Verilog ann -> [Identifier] -> Verilog ann
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl ((Identifier -> Verilog ann -> Verilog ann)
-> Verilog ann -> Identifier -> Verilog ann
forall a b c. (a -> b -> c) -> b -> a -> c
flip Identifier -> Verilog ann -> Verilog ann
forall ann. Identifier -> Verilog ann -> Verilog ann
nestSource) Verilog ann
src ([Identifier] -> Verilog ann) -> [Identifier] -> Verilog ann
forall a b. (a -> b) -> a -> b
$ Text -> Identifier
Identifier (Text -> Identifier) -> (Int -> Text) -> Int -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text
fromNode (Int -> Identifier) -> [Int] -> [Identifier]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Int
1 .. Int
i]

allVars :: (ModDecl ann) -> [Identifier]
allVars :: forall ann. ModDecl ann -> [Identifier]
allVars ModDecl ann
m =
  (ModDecl ann
m ModDecl ann
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
-> [Identifier]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. ([Port] -> Const (Endo [Identifier]) [Port])
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modOutPorts (([Port] -> Const (Endo [Identifier]) [Port])
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> [Port] -> Const (Endo [Identifier]) [Port])
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Port -> Const (Endo [Identifier]) Port)
-> [Port] -> Const (Endo [Identifier]) [Port]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Port -> Const (Endo [Identifier]) Port)
 -> [Port] -> Const (Endo [Identifier]) [Port])
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> Port -> Const (Endo [Identifier]) Port)
-> (Identifier -> Const (Endo [Identifier]) Identifier)
-> [Port]
-> Const (Endo [Identifier]) [Port]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Const (Endo [Identifier]) Identifier)
-> Port -> Const (Endo [Identifier]) Port
Lens' Port Identifier
portName)
    [Identifier] -> [Identifier] -> [Identifier]
forall a. Semigroup a => a -> a -> a
<> (ModDecl ann
m ModDecl ann
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
-> [Identifier]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. ([Port] -> Const (Endo [Identifier]) [Port])
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modInPorts (([Port] -> Const (Endo [Identifier]) [Port])
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> [Port] -> Const (Endo [Identifier]) [Port])
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Port -> Const (Endo [Identifier]) Port)
-> [Port] -> Const (Endo [Identifier]) [Port]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Port -> Const (Endo [Identifier]) Port)
 -> [Port] -> Const (Endo [Identifier]) [Port])
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> Port -> Const (Endo [Identifier]) Port)
-> (Identifier -> Const (Endo [Identifier]) Identifier)
-> [Port]
-> Const (Endo [Identifier]) [Port]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Const (Endo [Identifier]) Identifier)
-> Port -> Const (Endo [Identifier]) Port
Lens' Port Identifier
portName)

-- $setup
-- >>> import Verismith.Verilog.CodeGen
-- >>> let m = (ModDecl (Identifier "m") [Port Wire False 5 (Identifier "y")] [Port Wire False 5 "x"] [] [])
-- >>> let main = (ModDecl "main" [] [] [] [])

-- | Add a Module Instantiation using 'ModInst' from the first module passed to
-- it to the body of the second module. It first has to make all the inputs into
-- @reg@.
--
-- >>> render $ instantiateMod m main
-- module main;
--   wire [(3'h4):(1'h0)] y;
--   reg [(3'h4):(1'h0)] x;
--   m m1(y, x);
-- endmodule
-- <BLANKLINE>
-- <BLANKLINE>
instantiateMod :: (ModDecl ann) -> (ModDecl ann) -> (ModDecl ann)
instantiateMod :: forall ann. ModDecl ann -> ModDecl ann -> ModDecl ann
instantiateMod ModDecl ann
m ModDecl ann
main = ModDecl ann
main ModDecl ann -> (ModDecl ann -> ModDecl ann) -> ModDecl ann
forall a b. a -> (a -> b) -> b
& ([ModItem ann] -> Identity [ModItem ann])
-> ModDecl ann -> Identity (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([ModItem a] -> f [ModItem a]) -> ModDecl a -> f (ModDecl a)
modItems (([ModItem ann] -> Identity [ModItem ann])
 -> ModDecl ann -> Identity (ModDecl ann))
-> ([ModItem ann] -> [ModItem ann]) -> ModDecl ann -> ModDecl ann
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ (([ModItem ann]
forall {a}. [ModItem a]
out [ModItem ann] -> [ModItem ann] -> [ModItem ann]
forall a. [a] -> [a] -> [a]
++ [ModItem ann]
forall {a}. [ModItem a]
regIn [ModItem ann] -> [ModItem ann] -> [ModItem ann]
forall a. [a] -> [a] -> [a]
++ [ModItem ann
forall {a}. ModItem a
inst]) [ModItem ann] -> [ModItem ann] -> [ModItem ann]
forall a. [a] -> [a] -> [a]
++)
  where
    out :: [ModItem a]
out = Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
forall a. Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
Decl Maybe PortDir
forall a. Maybe a
Nothing (Port -> Maybe ConstExpr -> ModItem a)
-> [Port] -> [Maybe ConstExpr -> ModItem a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ModDecl ann
m ModDecl ann -> Getting [Port] (ModDecl ann) [Port] -> [Port]
forall s a. s -> Getting a s a -> a
^. Getting [Port] (ModDecl ann) [Port]
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modOutPorts [Maybe ConstExpr -> ModItem a] -> [Maybe ConstExpr] -> [ModItem a]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe ConstExpr -> [Maybe ConstExpr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ConstExpr
forall a. Maybe a
Nothing
    regIn :: [ModItem a]
regIn =
      Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
forall a. Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
Decl Maybe PortDir
forall a. Maybe a
Nothing
        (Port -> Maybe ConstExpr -> ModItem a)
-> [Port] -> [Maybe ConstExpr -> ModItem a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ModDecl ann
m ModDecl ann -> Getting [Port] (ModDecl ann) [Port] -> [Port]
forall s a. s -> Getting a s a -> a
^. Getting [Port] (ModDecl ann) [Port]
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modInPorts [Port] -> ([Port] -> [Port]) -> [Port]
forall a b. a -> (a -> b) -> b
& (Port -> Identity Port) -> [Port] -> Identity [Port]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Port -> Identity Port) -> [Port] -> Identity [Port])
-> ((PortType -> Identity PortType) -> Port -> Identity Port)
-> (PortType -> Identity PortType)
-> [Port]
-> Identity [Port]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PortType -> Identity PortType) -> Port -> Identity Port
Lens' Port PortType
portType ((PortType -> Identity PortType) -> [Port] -> Identity [Port])
-> PortType -> [Port] -> [Port]
forall s t a b. ASetter s t a b -> b -> s -> t
.~ PortType
Reg)
        [Maybe ConstExpr -> ModItem a] -> [Maybe ConstExpr] -> [ModItem a]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe ConstExpr -> [Maybe ConstExpr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ConstExpr
forall a. Maybe a
Nothing
    inst :: ModItem a
inst =
      Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem a
forall a.
Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem a
ModInst
        (ModDecl ann
m ModDecl ann
-> Getting Identifier (ModDecl ann) Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier (ModDecl ann) Identifier
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
modId)
        []
        (ModDecl ann
m ModDecl ann
-> Getting Identifier (ModDecl ann) Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier (ModDecl ann) Identifier
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
modId Identifier -> Identifier -> Identifier
forall a. Semigroup a => a -> a -> a
<> (Text -> Identifier
Identifier (Text -> Identifier) -> (Int -> Text) -> Int -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Text
forall a. Show a => a -> Text
showT (Int -> Identifier) -> Int -> Identifier
forall a b. (a -> b) -> a -> b
$ Int
count Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1))
        [ModConn]
conns
    count :: Int
count =
      [Identifier] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length
        ([Identifier] -> Int)
-> ([Identifier] -> [Identifier]) -> [Identifier] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Bool) -> [Identifier] -> [Identifier]
forall a. (a -> Bool) -> [a] -> [a]
filter (Identifier -> Identifier -> Bool
forall a. Eq a => a -> a -> Bool
== ModDecl ann
m ModDecl ann
-> Getting Identifier (ModDecl ann) Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier (ModDecl ann) Identifier
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
modId)
        ([Identifier] -> Int) -> [Identifier] -> Int
forall a b. (a -> b) -> a -> b
$ ModDecl ann
main
          ModDecl ann
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
-> [Identifier]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. ([ModItem ann] -> Const (Endo [Identifier]) [ModItem ann])
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([ModItem a] -> f [ModItem a]) -> ModDecl a -> f (ModDecl a)
modItems
            (([ModItem ann] -> Const (Endo [Identifier]) [ModItem ann])
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> [ModItem ann] -> Const (Endo [Identifier]) [ModItem ann])
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ModItem ann -> Const (Endo [Identifier]) (ModItem ann))
-> [ModItem ann] -> Const (Endo [Identifier]) [ModItem ann]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse
            ((ModItem ann -> Const (Endo [Identifier]) (ModItem ann))
 -> [ModItem ann] -> Const (Endo [Identifier]) [ModItem ann])
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> ModItem ann -> Const (Endo [Identifier]) (ModItem ann))
-> (Identifier -> Const (Endo [Identifier]) Identifier)
-> [ModItem ann]
-> Const (Endo [Identifier]) [ModItem ann]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Const (Endo [Identifier]) Identifier)
-> ModItem ann -> Const (Endo [Identifier]) (ModItem ann)
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModItem a -> f (ModItem a)
modInstId
    conns :: [ModConn]
conns = (Identifier -> Expr -> ModConn) -> (Identifier, Expr) -> ModConn
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Identifier -> Expr -> ModConn
ModConnNamed ((Identifier, Expr) -> ModConn)
-> ((Identifier, Identifier) -> (Identifier, Expr))
-> (Identifier, Identifier)
-> ModConn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Expr)
-> (Identifier, Identifier) -> (Identifier, Expr)
forall a b. (a -> b) -> (Identifier, a) -> (Identifier, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identifier -> Expr
Id ((Identifier, Identifier) -> ModConn)
-> [(Identifier, Identifier)] -> [ModConn]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Identifier] -> [Identifier] -> [(Identifier, Identifier)]
forall a b. [a] -> [b] -> [(a, b)]
zip (ModDecl ann -> [Identifier]
forall ann. ModDecl ann -> [Identifier]
allVars ModDecl ann
m) (ModDecl ann -> [Identifier]
forall ann. ModDecl ann -> [Identifier]
allVars ModDecl ann
m)

-- | Instantiate without adding wire declarations. It also does not count the
-- current instantiations of the same module.
--
-- >>> GenVerilog $ instantiateMod_ m
-- m m(y, x);
-- <BLANKLINE>
instantiateMod_ :: (ModDecl ann) -> (ModItem ann)
instantiateMod_ :: forall ann. ModDecl ann -> ModItem ann
instantiateMod_ ModDecl ann
m = Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem ann
forall a.
Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem a
ModInst (ModDecl ann
m ModDecl ann
-> Getting Identifier (ModDecl ann) Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier (ModDecl ann) Identifier
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
modId) [] (ModDecl ann
m ModDecl ann
-> Getting Identifier (ModDecl ann) Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier (ModDecl ann) Identifier
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
modId) [ModConn]
conns
  where
    conns :: [ModConn]
conns =
      Expr -> ModConn
ModConn
        (Expr -> ModConn) -> (Identifier -> Expr) -> Identifier -> ModConn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Expr
Id
        (Identifier -> ModConn) -> [Identifier] -> [ModConn]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ModDecl ann
m ModDecl ann
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
-> [Identifier]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. ([Port] -> Const (Endo [Identifier]) [Port])
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modOutPorts (([Port] -> Const (Endo [Identifier]) [Port])
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> [Port] -> Const (Endo [Identifier]) [Port])
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Port -> Const (Endo [Identifier]) Port)
-> [Port] -> Const (Endo [Identifier]) [Port]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Port -> Const (Endo [Identifier]) Port)
 -> [Port] -> Const (Endo [Identifier]) [Port])
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> Port -> Const (Endo [Identifier]) Port)
-> (Identifier -> Const (Endo [Identifier]) Identifier)
-> [Port]
-> Const (Endo [Identifier]) [Port]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Const (Endo [Identifier]) Identifier)
-> Port -> Const (Endo [Identifier]) Port
Lens' Port Identifier
portName)
          [Identifier] -> [Identifier] -> [Identifier]
forall a. [a] -> [a] -> [a]
++ (ModDecl ann
m ModDecl ann
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
-> [Identifier]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. ([Port] -> Const (Endo [Identifier]) [Port])
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modInPorts (([Port] -> Const (Endo [Identifier]) [Port])
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> [Port] -> Const (Endo [Identifier]) [Port])
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Port -> Const (Endo [Identifier]) Port)
-> [Port] -> Const (Endo [Identifier]) [Port]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Port -> Const (Endo [Identifier]) Port)
 -> [Port] -> Const (Endo [Identifier]) [Port])
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> Port -> Const (Endo [Identifier]) Port)
-> (Identifier -> Const (Endo [Identifier]) Identifier)
-> [Port]
-> Const (Endo [Identifier]) [Port]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Const (Endo [Identifier]) Identifier)
-> Port -> Const (Endo [Identifier]) Port
Lens' Port Identifier
portName)

-- | Instantiate without adding wire declarations. It also does not count the
-- current instantiations of the same module.
--
-- >>> GenVerilog $ instantiateModSpec_ "_" m
-- m m(.y(y), .x(x));
-- <BLANKLINE>
instantiateModSpec_ :: Bool -> Text -> (ModDecl ann) -> (ModItem ann)
instantiateModSpec_ :: forall ann. Bool -> Text -> ModDecl ann -> ModItem ann
instantiateModSpec_ Bool
named Text
outChar ModDecl ann
m = Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem ann
forall a.
Identifier -> [ModConn] -> Identifier -> [ModConn] -> ModItem a
ModInst (ModDecl ann
m ModDecl ann
-> Getting Identifier (ModDecl ann) Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier (ModDecl ann) Identifier
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
modId) [] (ModDecl ann
m ModDecl ann
-> Getting Identifier (ModDecl ann) Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier (ModDecl ann) Identifier
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
modId) [ModConn]
conns
  where
    conns :: [ModConn]
conns = (if Bool
named then (Identifier -> Expr -> ModConn)
-> [Identifier] -> [Expr] -> [ModConn]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Identifier -> Expr -> ModConn
ModConnNamed [Identifier]
ids else (Expr -> ModConn) -> [Expr] -> [ModConn]
forall a b. (a -> b) -> [a] -> [b]
map Expr -> ModConn
ModConn) (Identifier -> Expr
Id (Identifier -> Expr) -> [Identifier] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Identifier]
instIds)
    ids :: [Identifier]
ids = Text -> [Identifier] -> [Identifier]
filterChar Text
outChar ((([Port] -> Const (Endo [Identifier]) [Port])
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> [Identifier]
forall {t :: * -> *}.
Traversable t =>
((t Port -> Const (Endo [Identifier]) (t Port))
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> [Identifier]
name ([Port] -> Const (Endo [Identifier]) [Port])
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modOutPorts) [Identifier] -> [Identifier] -> [Identifier]
forall a. Semigroup a => a -> a -> a
<> (([Port] -> Const (Endo [Identifier]) [Port])
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> [Identifier]
forall {t :: * -> *}.
Traversable t =>
((t Port -> Const (Endo [Identifier]) (t Port))
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> [Identifier]
name ([Port] -> Const (Endo [Identifier]) [Port])
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modInPorts
    instIds :: [Identifier]
instIds = (([Port] -> Const (Endo [Identifier]) [Port])
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> [Identifier]
forall {t :: * -> *}.
Traversable t =>
((t Port -> Const (Endo [Identifier]) (t Port))
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> [Identifier]
name ([Port] -> Const (Endo [Identifier]) [Port])
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modOutPorts [Identifier] -> [Identifier] -> [Identifier]
forall a. Semigroup a => a -> a -> a
<> (([Port] -> Const (Endo [Identifier]) [Port])
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> [Identifier]
forall {t :: * -> *}.
Traversable t =>
((t Port -> Const (Endo [Identifier]) (t Port))
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> [Identifier]
name ([Port] -> Const (Endo [Identifier]) [Port])
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modInPorts
    name :: ((t Port -> Const (Endo [Identifier]) (t Port))
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> [Identifier]
name (t Port -> Const (Endo [Identifier]) (t Port))
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
v = ModDecl ann
m ModDecl ann
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
-> [Identifier]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. (t Port -> Const (Endo [Identifier]) (t Port))
-> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann)
v ((t Port -> Const (Endo [Identifier]) (t Port))
 -> ModDecl ann -> Const (Endo [Identifier]) (ModDecl ann))
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> t Port -> Const (Endo [Identifier]) (t Port))
-> Getting (Endo [Identifier]) (ModDecl ann) Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Port -> Const (Endo [Identifier]) Port)
-> t Port -> Const (Endo [Identifier]) (t Port)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b)
traverse ((Port -> Const (Endo [Identifier]) Port)
 -> t Port -> Const (Endo [Identifier]) (t Port))
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> Port -> Const (Endo [Identifier]) Port)
-> (Identifier -> Const (Endo [Identifier]) Identifier)
-> t Port
-> Const (Endo [Identifier]) (t Port)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Const (Endo [Identifier]) Identifier)
-> Port -> Const (Endo [Identifier]) Port
Lens' Port Identifier
portName

filterChar :: Text -> [Identifier] -> [Identifier]
filterChar :: Text -> [Identifier] -> [Identifier]
filterChar Text
t [Identifier]
ids =
  [Identifier]
ids [Identifier] -> ([Identifier] -> [Identifier]) -> [Identifier]
forall a b. a -> (a -> b) -> b
& (Identifier -> Identity Identifier)
-> [Identifier] -> Identity [Identifier]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((Identifier -> Identity Identifier)
 -> [Identifier] -> Identity [Identifier])
-> ((Text -> Identity Text) -> Identifier -> Identity Identifier)
-> (Text -> Identity Text)
-> [Identifier]
-> Identity [Identifier]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped Identifier -> Identity (Unwrapped Identifier))
-> Identifier -> Identity Identifier
(Text -> Identity Text) -> Identifier -> Identity Identifier
forall s t. Rewrapping s t => Iso s t (Unwrapped s) (Unwrapped t)
Iso
  Identifier Identifier (Unwrapped Identifier) (Unwrapped Identifier)
_Wrapped ((Text -> Identity Text) -> [Identifier] -> Identity [Identifier])
-> (Text -> Text) -> [Identifier] -> [Identifier]
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ (\Text
x -> Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
x (Maybe Text -> Text) -> ([Text] -> Maybe Text) -> [Text] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Text) -> [Text] -> Maybe Text
forall a b. ([a] -> b) -> [a] -> Maybe b
safe [Text] -> Text
forall a. HasCallStack => [a] -> a
head ([Text] -> Text) -> [Text] -> Text
forall a b. (a -> b) -> a -> b
$ HasCallStack => Text -> Text -> [Text]
Text -> Text -> [Text]
T.splitOn Text
t Text
x)

-- | Initialise all the inputs and outputs to a module.
--
-- >>> GenVerilog $ initMod m
-- module m(y, x);
--   output wire [(3'h4):(1'h0)] y;
--   input wire [(3'h4):(1'h0)] x;
-- endmodule
-- <BLANKLINE>
-- <BLANKLINE>
initMod :: (ModDecl ann) -> (ModDecl ann)
initMod :: forall ann. ModDecl ann -> ModDecl ann
initMod ModDecl ann
m = ModDecl ann
m ModDecl ann -> (ModDecl ann -> ModDecl ann) -> ModDecl ann
forall a b. a -> (a -> b) -> b
& ([ModItem ann] -> Identity [ModItem ann])
-> ModDecl ann -> Identity (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([ModItem a] -> f [ModItem a]) -> ModDecl a -> f (ModDecl a)
modItems (([ModItem ann] -> Identity [ModItem ann])
 -> ModDecl ann -> Identity (ModDecl ann))
-> ([ModItem ann] -> [ModItem ann]) -> ModDecl ann -> ModDecl ann
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ (([ModItem ann]
forall {a}. [ModItem a]
out [ModItem ann] -> [ModItem ann] -> [ModItem ann]
forall a. [a] -> [a] -> [a]
++ [ModItem ann]
forall {a}. [ModItem a]
inp) [ModItem ann] -> [ModItem ann] -> [ModItem ann]
forall a. [a] -> [a] -> [a]
++)
  where
    out :: [ModItem a]
out = Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
forall a. Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
Decl (PortDir -> Maybe PortDir
forall a. a -> Maybe a
Just PortDir
PortOut) (Port -> Maybe ConstExpr -> ModItem a)
-> [Port] -> [Maybe ConstExpr -> ModItem a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ModDecl ann
m ModDecl ann -> Getting [Port] (ModDecl ann) [Port] -> [Port]
forall s a. s -> Getting a s a -> a
^. Getting [Port] (ModDecl ann) [Port]
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modOutPorts) [Maybe ConstExpr -> ModItem a] -> [Maybe ConstExpr] -> [ModItem a]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe ConstExpr -> [Maybe ConstExpr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ConstExpr
forall a. Maybe a
Nothing
    inp :: [ModItem a]
inp = Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
forall a. Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
Decl (PortDir -> Maybe PortDir
forall a. a -> Maybe a
Just PortDir
PortIn) (Port -> Maybe ConstExpr -> ModItem a)
-> [Port] -> [Maybe ConstExpr -> ModItem a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ModDecl ann
m ModDecl ann -> Getting [Port] (ModDecl ann) [Port] -> [Port]
forall s a. s -> Getting a s a -> a
^. Getting [Port] (ModDecl ann) [Port]
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modInPorts) [Maybe ConstExpr -> ModItem a] -> [Maybe ConstExpr] -> [ModItem a]
forall a b. [a -> b] -> [a] -> [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe ConstExpr -> [Maybe ConstExpr]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ConstExpr
forall a. Maybe a
Nothing

-- | Make an 'Identifier' from and existing Identifier and an object with a
-- 'Show' instance to make it unique.
makeIdFrom :: (Show a) => a -> Identifier -> Identifier
makeIdFrom :: forall a. Show a => a -> Identifier -> Identifier
makeIdFrom a
a Identifier
i = (Identifier
i Identifier -> Identifier -> Identifier
forall a. Semigroup a => a -> a -> a
<>) (Identifier -> Identifier)
-> (Text -> Identifier) -> Text -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Identifier
Identifier (Text -> Identifier) -> (Text -> Text) -> Text -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text
"_" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Identifier) -> Text -> Identifier
forall a b. (a -> b) -> a -> b
$ a -> Text
forall a. Show a => a -> Text
showT a
a

-- | Make top level module for equivalence verification. Also takes in how many
-- modules to instantiate.
makeTop :: Bool -> Int -> (ModDecl ann) -> (ModDecl ann)
makeTop :: forall ann. Bool -> Int -> ModDecl ann -> ModDecl ann
makeTop Bool
named Int
i ModDecl ann
m = Identifier
-> [Port] -> [Port] -> [ModItem ann] -> [Parameter] -> ModDecl ann
forall a.
Identifier
-> [Port] -> [Port] -> [ModItem a] -> [Parameter] -> ModDecl a
ModDecl (ModDecl ann
m ModDecl ann
-> Getting Identifier (ModDecl ann) Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier (ModDecl ann) Identifier
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
modId) [Port]
ys (ModDecl ann
m ModDecl ann -> Getting [Port] (ModDecl ann) [Port] -> [Port]
forall s a. s -> Getting a s a -> a
^. Getting [Port] (ModDecl ann) [Port]
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modInPorts) [ModItem ann]
modIt []
  where
    ys :: [Port]
ys = Identifier -> Port
yPort (Identifier -> Port) -> (Int -> Identifier) -> Int -> Port
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Identifier -> Identifier)
-> Identifier -> Int -> Identifier
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> Identifier -> Identifier
forall a. Show a => a -> Identifier -> Identifier
makeIdFrom Identifier
"y" (Int -> Port) -> [Int] -> [Port]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Int
1 .. Int
i]
    modIt :: [ModItem ann]
modIt = Bool -> Text -> ModDecl ann -> ModItem ann
forall ann. Bool -> Text -> ModDecl ann -> ModItem ann
instantiateModSpec_ Bool
named Text
"_" (ModDecl ann -> ModItem ann)
-> (Int -> ModDecl ann) -> Int -> ModItem ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ModDecl ann
forall {a}. Show a => a -> ModDecl ann
modN (Int -> ModItem ann) -> [Int] -> [ModItem ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Int
1 .. Int
i]
    modN :: a -> ModDecl ann
modN a
n =
      ModDecl ann
m ModDecl ann -> (ModDecl ann -> ModDecl ann) -> ModDecl ann
forall a b. a -> (a -> b) -> b
& (Identifier -> Identity Identifier)
-> ModDecl ann -> Identity (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
(Identifier -> f Identifier) -> ModDecl a -> f (ModDecl a)
modId ((Identifier -> Identity Identifier)
 -> ModDecl ann -> Identity (ModDecl ann))
-> (Identifier -> Identifier) -> ModDecl ann -> ModDecl ann
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ a -> Identifier -> Identifier
forall a. Show a => a -> Identifier -> Identifier
makeIdFrom a
n ModDecl ann -> (ModDecl ann -> ModDecl ann) -> ModDecl ann
forall a b. a -> (a -> b) -> b
& ([Port] -> Identity [Port])
-> ModDecl ann -> Identity (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([Port] -> f [Port]) -> ModDecl a -> f (ModDecl a)
modOutPorts (([Port] -> Identity [Port])
 -> ModDecl ann -> Identity (ModDecl ann))
-> [Port] -> ModDecl ann -> ModDecl ann
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [Identifier -> Port
yPort (a -> Identifier -> Identifier
forall a. Show a => a -> Identifier -> Identifier
makeIdFrom a
n Identifier
"y")]

-- | Make a top module with an assert that requires @y_1@ to always be equal to
-- @y_2@, which can then be proven using a formal verification tool.
makeTopAssert :: (ModDecl ann) -> (ModDecl ann)
makeTopAssert :: forall ann. ModDecl ann -> ModDecl ann
makeTopAssert = (([ModItem ann] -> Identity [ModItem ann])
-> ModDecl ann -> Identity (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([ModItem a] -> f [ModItem a]) -> ModDecl a -> f (ModDecl a)
modItems (([ModItem ann] -> Identity [ModItem ann])
 -> ModDecl ann -> Identity (ModDecl ann))
-> ([ModItem ann] -> [ModItem ann]) -> ModDecl ann -> ModDecl ann
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ ([ModItem ann] -> [ModItem ann] -> [ModItem ann]
forall a. [a] -> [a] -> [a]
++ [ModItem ann
forall {a}. ModItem a
assert])) (ModDecl ann -> ModDecl ann)
-> (ModDecl ann -> ModDecl ann) -> ModDecl ann -> ModDecl ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int -> ModDecl ann -> ModDecl ann
forall ann. Bool -> Int -> ModDecl ann -> ModDecl ann
makeTop Bool
False Int
2
  where
    assert :: ModItem a
assert =
      Statement a -> ModItem a
forall a. Statement a -> ModItem a
Always (Statement a -> ModItem a)
-> (Statement a -> Statement a) -> Statement a -> ModItem a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Event -> Maybe (Statement a) -> Statement a
forall a. Event -> Maybe (Statement a) -> Statement a
EventCtrl Event
e (Maybe (Statement a) -> Statement a)
-> (Statement a -> Maybe (Statement a))
-> Statement a
-> Statement a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Statement a -> Maybe (Statement a)
forall a. a -> Maybe a
Just (Statement a -> ModItem a) -> Statement a -> ModItem a
forall a b. (a -> b) -> a -> b
$
        [Statement a] -> Statement a
forall a. [Statement a] -> Statement a
SeqBlock
          [Task -> Statement a
forall a. Task -> Statement a
TaskEnable (Task -> Statement a) -> Task -> Statement a
forall a b. (a -> b) -> a -> b
$ Identifier -> [Expr] -> Task
Task Identifier
"assert" [Expr -> BinaryOperator -> Expr -> Expr
BinOp (Identifier -> Expr
Id Identifier
"y_1") BinaryOperator
BinEq (Identifier -> Expr
Id Identifier
"y_2")]]
    e :: Event
e = Identifier -> Event
EPosEdge Identifier
"clk"

-- | Provide declarations for all the ports that are passed to it. If they are
-- registers, it should assign them to 0.
declareMod :: [Port] -> (ModDecl ann) -> (ModDecl ann)
declareMod :: forall ann. [Port] -> ModDecl ann -> ModDecl ann
declareMod [Port]
ports = ModDecl ann -> ModDecl ann
forall ann. ModDecl ann -> ModDecl ann
initMod (ModDecl ann -> ModDecl ann)
-> (ModDecl ann -> ModDecl ann) -> ModDecl ann -> ModDecl ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([ModItem ann] -> Identity [ModItem ann])
-> ModDecl ann -> Identity (ModDecl ann)
forall a (f :: * -> *).
Applicative f =>
([ModItem a] -> f [ModItem a]) -> ModDecl a -> f (ModDecl a)
modItems (([ModItem ann] -> Identity [ModItem ann])
 -> ModDecl ann -> Identity (ModDecl ann))
-> ([ModItem ann] -> [ModItem ann]) -> ModDecl ann -> ModDecl ann
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ ((Port -> ModItem ann) -> [Port] -> [ModItem ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Port -> ModItem ann
forall {a}. Port -> ModItem a
decl [Port]
ports [ModItem ann] -> [ModItem ann] -> [ModItem ann]
forall a. [a] -> [a] -> [a]
++))
  where
    decl :: Port -> ModItem a
decl p :: Port
p@(Port PortType
Reg Bool
_ Range
_ Identifier
_) = Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
forall a. Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
Decl Maybe PortDir
forall a. Maybe a
Nothing Port
p (ConstExpr -> Maybe ConstExpr
forall a. a -> Maybe a
Just ConstExpr
0)
    decl Port
p = Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
forall a. Maybe PortDir -> Port -> Maybe ConstExpr -> ModItem a
Decl Maybe PortDir
forall a. Maybe a
Nothing Port
p Maybe ConstExpr
forall a. Maybe a
Nothing

-- | Simplify an 'Expr' by using constants to remove 'BinaryOperator' and
-- simplify expressions. To make this work effectively, it should be run until
-- no more changes were made to the expression.
--
-- >>> GenVerilog . simplify $ (Id "x") + 0
-- x
--
-- >>> GenVerilog . simplify $ (Id "y") + (Id "x")
-- (y + x)
simplify :: Expr -> Expr
simplify :: Expr -> Expr
simplify (BinOp (Number (BitVec Int
_ Integer
1)) BinaryOperator
BinAnd Expr
e) = Expr
e
simplify (BinOp Expr
e BinaryOperator
BinAnd (Number (BitVec Int
_ Integer
1))) = Expr
e
simplify (BinOp (Number (BitVec Int
_ Integer
0)) BinaryOperator
BinAnd Expr
_) = BitVec -> Expr
Number BitVec
0
simplify (BinOp Expr
_ BinaryOperator
BinAnd (Number (BitVec Int
_ Integer
0))) = BitVec -> Expr
Number BitVec
0
simplify (BinOp Expr
e BinaryOperator
BinPlus (Number (BitVec Int
_ Integer
0))) = Expr
e
simplify (BinOp (Number (BitVec Int
_ Integer
0)) BinaryOperator
BinPlus Expr
e) = Expr
e
simplify (BinOp Expr
e BinaryOperator
BinMinus (Number (BitVec Int
_ Integer
0))) = Expr
e
simplify (BinOp (Number (BitVec Int
_ Integer
0)) BinaryOperator
BinMinus Expr
e) = Expr
e
simplify (BinOp Expr
e BinaryOperator
BinTimes (Number (BitVec Int
_ Integer
1))) = Expr
e
simplify (BinOp (Number (BitVec Int
_ Integer
1)) BinaryOperator
BinTimes Expr
e) = Expr
e
simplify (BinOp Expr
_ BinaryOperator
BinTimes (Number (BitVec Int
_ Integer
0))) = BitVec -> Expr
Number BitVec
0
simplify (BinOp (Number (BitVec Int
_ Integer
0)) BinaryOperator
BinTimes Expr
_) = BitVec -> Expr
Number BitVec
0
simplify (BinOp Expr
e BinaryOperator
BinOr (Number (BitVec Int
_ Integer
0))) = Expr
e
simplify (BinOp (Number (BitVec Int
_ Integer
0)) BinaryOperator
BinOr Expr
e) = Expr
e
simplify (BinOp Expr
e BinaryOperator
BinLSL (Number (BitVec Int
_ Integer
0))) = Expr
e
simplify (BinOp (Number (BitVec Int
_ Integer
0)) BinaryOperator
BinLSL Expr
e) = Expr
e
simplify (BinOp Expr
e BinaryOperator
BinLSR (Number (BitVec Int
_ Integer
0))) = Expr
e
simplify (BinOp (Number (BitVec Int
_ Integer
0)) BinaryOperator
BinLSR Expr
e) = Expr
e
simplify (BinOp Expr
e BinaryOperator
BinASL (Number (BitVec Int
_ Integer
0))) = Expr
e
simplify (BinOp (Number (BitVec Int
_ Integer
0)) BinaryOperator
BinASL Expr
e) = Expr
e
simplify (BinOp Expr
e BinaryOperator
BinASR (Number (BitVec Int
_ Integer
0))) = Expr
e
simplify (BinOp (Number (BitVec Int
_ Integer
0)) BinaryOperator
BinASR Expr
e) = Expr
e
simplify (UnOp UnaryOperator
UnPlus Expr
e) = Expr
e
simplify Expr
e = Expr
e

-- | Remove all 'Identifier' that do not appeare in the input list from an
-- 'Expr'. The identifier will be replaced by @1'b0@, which can then later be
-- simplified further.
--
-- >>> GenVerilog . removeId ["x"] $ Id "x" + Id "y"
-- (x + (1'h0))
removeId :: [Identifier] -> Expr -> Expr
removeId :: [Identifier] -> Expr -> Expr
removeId [Identifier]
i = (Expr -> Expr) -> Expr -> Expr
forall a. Plated a => (a -> a) -> a -> a
transform Expr -> Expr
trans
  where
    trans :: Expr -> Expr
trans (Id Identifier
ident)
      | Identifier
ident Identifier -> [Identifier] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Identifier]
i = BitVec -> Expr
Number BitVec
0
      | Bool
otherwise = Identifier -> Expr
Id Identifier
ident
    trans Expr
e = Expr
e

combineAssigns :: Port -> [ModItem ann] -> [ModItem ann]
combineAssigns :: forall ann. Port -> [ModItem ann] -> [ModItem ann]
combineAssigns Port
p [ModItem ann]
a =
  [ModItem ann]
a
    [ModItem ann] -> [ModItem ann] -> [ModItem ann]
forall a. Semigroup a => a -> a -> a
<> [ ContAssign -> ModItem ann
forall a. ContAssign -> ModItem a
ModCA
           (ContAssign -> ModItem ann)
-> ([Expr] -> ContAssign) -> [Expr] -> ModItem ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Expr -> ContAssign
ContAssign (Port
p Port -> Getting Identifier Port Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier Port Identifier
Lens' Port Identifier
portName)
           (Expr -> ContAssign) -> ([Expr] -> Expr) -> [Expr] -> ContAssign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnXor
           (Expr -> Expr) -> ([Expr] -> Expr) -> [Expr] -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Expr] -> Expr
forall m. Monoid m => [m] -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold
           ([Expr] -> ModItem ann) -> [Expr] -> ModItem ann
forall a b. (a -> b) -> a -> b
$ Identifier -> Expr
Id
             (Identifier -> Expr) -> [Identifier] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Identifier]
assigns
       ]
  where
    assigns :: [Identifier]
assigns = [ModItem ann]
a [ModItem ann]
-> Getting (Endo [Identifier]) [ModItem ann] Identifier
-> [Identifier]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. (ModItem ann -> Const (Endo [Identifier]) (ModItem ann))
-> [ModItem ann] -> Const (Endo [Identifier]) [ModItem ann]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((ModItem ann -> Const (Endo [Identifier]) (ModItem ann))
 -> [ModItem ann] -> Const (Endo [Identifier]) [ModItem ann])
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> ModItem ann -> Const (Endo [Identifier]) (ModItem ann))
-> Getting (Endo [Identifier]) [ModItem ann] Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ContAssign -> Const (Endo [Identifier]) ContAssign)
-> ModItem ann -> Const (Endo [Identifier]) (ModItem ann)
forall a (f :: * -> *).
Applicative f =>
(ContAssign -> f ContAssign) -> ModItem a -> f (ModItem a)
modContAssign ((ContAssign -> Const (Endo [Identifier]) ContAssign)
 -> ModItem ann -> Const (Endo [Identifier]) (ModItem ann))
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> ContAssign -> Const (Endo [Identifier]) ContAssign)
-> (Identifier -> Const (Endo [Identifier]) Identifier)
-> ModItem ann
-> Const (Endo [Identifier]) (ModItem ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Const (Endo [Identifier]) Identifier)
-> ContAssign -> Const (Endo [Identifier]) ContAssign
Lens' ContAssign Identifier
contAssignNetLVal

combineAssigns_ :: Bool -> Port -> [Port] -> (ModItem ann)
combineAssigns_ :: forall ann. Bool -> Port -> [Port] -> ModItem ann
combineAssigns_ Bool
comb Port
p [Port]
ps =
  ContAssign -> ModItem ann
forall a. ContAssign -> ModItem a
ModCA
    (ContAssign -> ModItem ann)
-> ([Expr] -> ContAssign) -> [Expr] -> ModItem ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> Expr -> ContAssign
ContAssign (Port
p Port -> Getting Identifier Port Identifier -> Identifier
forall s a. s -> Getting a s a -> a
^. Getting Identifier Port Identifier
Lens' Port Identifier
portName)
    (Expr -> ContAssign) -> ([Expr] -> Expr) -> [Expr] -> ContAssign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (if Bool
comb then UnaryOperator -> Expr -> Expr
UnOp UnaryOperator
UnXor else Expr -> Expr
forall a. a -> a
id)
    (Expr -> Expr) -> ([Expr] -> Expr) -> [Expr] -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Expr] -> Expr
forall m. Monoid m => [m] -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold
    ([Expr] -> ModItem ann) -> [Expr] -> ModItem ann
forall a b. (a -> b) -> a -> b
$ Identifier -> Expr
Id
      (Identifier -> Expr) -> [Identifier] -> [Expr]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Port]
ps
        [Port]
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> [Port] -> Const (Endo [Identifier]) [Port])
-> [Identifier]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. (Port -> Const (Endo [Identifier]) Port)
-> [Port] -> Const (Endo [Identifier]) [Port]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse
          ((Port -> Const (Endo [Identifier]) Port)
 -> [Port] -> Const (Endo [Identifier]) [Port])
-> ((Identifier -> Const (Endo [Identifier]) Identifier)
    -> Port -> Const (Endo [Identifier]) Port)
-> (Identifier -> Const (Endo [Identifier]) Identifier)
-> [Port]
-> Const (Endo [Identifier]) [Port]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Identifier -> Const (Endo [Identifier]) Identifier)
-> Port -> Const (Endo [Identifier]) Port
Lens' Port Identifier
portName

fromPort :: Port -> Identifier
fromPort :: Port -> Identifier
fromPort (Port PortType
_ Bool
_ Range
_ Identifier
i) = Identifier
i