blob: e06891f2eb8990f36a2dc112b6cc71845b841cdc (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
{-|
Module : Test.VeriFuzz.CodeGen
Description : Code generation for Verilog AST.
Copyright : (c) Yann Herklotz Grave 2018
License : GPL-3
Maintainer : ymherklotz@gmail.com
Stability : experimental
Portability : POSIX
This module generates the code from the Verilog AST defined in
"Test.VeriFuzz.VerilogAST".
-}
module Test.VeriFuzz.CodeGen where
import Control.Lens
import Data.Maybe (fromMaybe)
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Test.VeriFuzz.Internal.Shared
import Test.VeriFuzz.VerilogAST
showT :: (Show a) => a -> Text
showT = T.pack . show
defMap :: Maybe Statement -> Text
defMap stat = fromMaybe ";\n" $ genStatement <$> stat
-- | Convert the 'SourceText' type to 'Text' so that it can be rendered.
genSourceText :: SourceText -> Text
genSourceText source =
fromList $ genDescription <$> source ^. getSourceText
-- | Generate the 'Description' to 'Text'.
genDescription :: Description -> Text
genDescription desc =
genModuleDecl $ desc ^. getDescription
-- | Generate the 'ModDecl' for a module and convert it to 'Text'.
genModuleDecl :: ModDecl -> Text
genModuleDecl mod =
"module " <> mod ^. moduleId . getIdentifier
<> ports <> ";\n"
<> modItems
<> "endmodule\n"
where
ports
| null $ mod ^. modPorts = ""
| otherwise = "(\n" <> (sep ",\n" $ genPort <$> mod ^. modPorts) <> "\n)"
modItems = fromList $ genModuleItem <$> mod ^. moduleItems
-- | Generate the 'Port' description.
genPort :: Port -> Text
genPort port =
dir <> t <> name
where
dir = fromMaybe "" $ (<>" ") . genPortDir <$> port ^. portDir
t = fromMaybe "wire " $ (<>" ") . genPortType <$> port ^. portType
name = port ^. portName . getIdentifier
-- | Convert the 'PortDir' type to 'Text'.
genPortDir :: PortDir -> Text
genPortDir Input = "input"
genPortDir Output = "output"
genPortDir InOut = "inout"
-- | Generate a 'ModItem'.
genModuleItem :: ModItem -> Text
genModuleItem (ModCA ca) = genContAssign ca
genModuleItem (ModInst (Identifier id) (Identifier name) conn) =
id <> " " <> name <> "(" <> sep ", " (genExpr . _modConn <$> conn) <> ")" <> ";\n"
genModuleItem (Initial stat) = "initial " <> genStatement stat
genModuleItem (Always stat) = "always " <> genStatement stat
genModuleItem (Decl port) = genPort port <> ";\n"
-- | Generate continuous assignment
genContAssign :: ContAssign -> Text
genContAssign (ContAssign val e) =
" assign " <> name <> " = " <> expr <> ";\n"
where
name = val ^. getIdentifier
expr = genExpr $ e
-- | Generate 'Expression' to 'Text'.
genExpr :: Expression -> Text
genExpr (OpExpr exprRhs bin exprLhs) =
"(" <> genExpr exprRhs <> genBinaryOperator bin <> genExpr exprLhs <> ")"
genExpr (PrimExpr prim) = genPrimary prim
genExpr (UnPrimExpr u e) =
"(" <> genUnaryOperator u <> genPrimary e <> ")"
genExpr (CondExpr l t f) =
"(" <> genExpr l <> " ? " <> genExpr t <> " : " <> genExpr f <> ")"
genExpr (ExprStr t) = "\"" <> t <> "\""
-- | Generate a 'PrimaryExpression' to 'Text'.
genPrimary :: Primary -> Text
genPrimary (PrimNum num) =
"(" <> neg <> sh (num ^. numSize) <> "'d" <> (sh . abs) n <> ")"
where
sh = T.pack . show
abs x = if x <= 0 then -x else x
n = num ^. numVal
neg = if n <= 0 then "-" else ""
genPrimary (PrimId ident) = ident ^. getIdentifier
-- | Convert 'BinaryOperator' to 'Text'.
genBinaryOperator :: BinaryOperator -> Text
genBinaryOperator BinPlus = " + "
genBinaryOperator BinMinus = " - "
genBinaryOperator BinTimes = " * "
genBinaryOperator BinDiv = " / "
genBinaryOperator BinMod = " % "
genBinaryOperator BinEq = " == "
genBinaryOperator BinNEq = " != "
genBinaryOperator BinCEq = " === "
genBinaryOperator BinCNEq = " !== "
genBinaryOperator BinLAnd = " && "
genBinaryOperator BinLOr = " || "
genBinaryOperator BinLT = " < "
genBinaryOperator BinLEq = " <= "
genBinaryOperator BinGT = " > "
genBinaryOperator BinGEq = " >= "
genBinaryOperator BinAnd = " & "
genBinaryOperator BinOr = " | "
genBinaryOperator BinXor = " ^ "
genBinaryOperator BinXNor = " ^~ "
genBinaryOperator BinXNorInv = " ~^ "
genBinaryOperator BinPower = " ** "
genBinaryOperator BinLSL = " << "
genBinaryOperator BinLSR = " >> "
genBinaryOperator BinASL = " <<< "
genBinaryOperator BinASR = " >>> "
genUnaryOperator :: UnaryOperator -> Text
genUnaryOperator UnPlus = "+"
genUnaryOperator UnMinus = "-"
genUnaryOperator UnNot = "!"
genUnaryOperator UnAnd = "&"
genUnaryOperator UnNand = "~&"
genUnaryOperator UnOr = "|"
genUnaryOperator UnNor = "~|"
genUnaryOperator UnXor = "^"
genUnaryOperator UnNxor = "~^"
genUnaryOperator UnNxorInv = "^~"
genNet :: Net -> Text
genNet Wire = "wire"
genNet Tri = "tri"
genNet Tri1 = "tri1"
genNet Supply0 = "supply0"
genNet Wand = "wand"
genNet TriAnd = "triand"
genNet Tri0 = "tri0"
genNet Supply1 = "supply1"
genNet Wor = "wor"
genNet Trior = "trior"
genEvent :: Event -> Text
genEvent (EId id) = "@(" <> id ^. getIdentifier <> ")"
genEvent (EExpr expr) = "@(" <> genExpr expr <> ")"
genEvent EAll = "@*"
genDelay :: Delay -> Text
genDelay (Delay i) = "#" <> showT i
genRegLVal :: RegLVal -> Text
genRegLVal (RegId id) = id ^. getIdentifier
genRegLVal (RegExpr id expr) =
id ^. getIdentifier <> " [" <> genExpr expr <> "]"
genRegLVal (RegSize id msb lsb) =
id ^. getIdentifier <> " [" <> genConstExpr msb <> ":" <> genConstExpr lsb <> "]"
genConstExpr :: ConstExpr -> Text
genConstExpr (ConstExpr num) = showT num
genPortType :: PortType -> Text
genPortType (PortNet net) = genNet net
genPortType (Reg signed)
| signed = " reg signed "
| otherwise = " reg "
genAssign :: Text -> Assign -> Text
genAssign op (Assign r d e) =
genRegLVal r <> op <> fromMaybe "" (genDelay <$> d) <> genExpr e
genStatement :: Statement -> Text
genStatement (TimeCtrl d stat) = genDelay d <> " " <> defMap stat
genStatement (EventCtrl e stat) = genEvent e <> " " <> defMap stat
genStatement (SeqBlock s) =
"begin\n" <> fromList (genStatement <$> s) <> "end\n"
genStatement (BlockAssign a) = genAssign " = " a <> ";\n"
genStatement (NonBlockAssign a) = genAssign " <= " a <> ";\n"
genStatement (StatCA a) = genContAssign a
genStatement (TaskEnable task) = genTask task <> ";\n"
genStatement (SysTaskEnable task) = "$" <> genTask task <> ";\n"
genTask :: Task -> Text
genTask (Task name expr)
| null expr = id
| otherwise = id <> "(" <> sep ", " (genExpr <$> expr) <> ")"
where
id = name ^. getIdentifier
-- | Render the 'Text' to 'IO'. This is equivalent to 'putStrLn'.
render :: Text -> IO ()
render = T.putStrLn
|
