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
|
// SPDX-License-Identifier: Apache-2.0
package firrtlTests
import org.scalatest._
import firrtl.ir._
import firrtl.{Parser, Utils}
import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers
object SerializerSpec {
case class WrapStmt(stmt: Statement) extends Statement {
def serialize: String = s"wrap(${stmt.serialize})"
def foreachExpr(f: Expression => Unit): Unit = stmt.foreachExpr(f)
def foreachInfo(f: Info => Unit): Unit = stmt.foreachInfo(f)
def foreachStmt(f: Statement => Unit): Unit = stmt.foreachStmt(f)
def foreachString(f: String => Unit): Unit = stmt.foreachString(f)
def foreachType(f: Type => Unit): Unit = stmt.foreachType(f)
def mapExpr(f: Expression => Expression): Statement = this.copy(stmt.mapExpr(f))
def mapInfo(f: Info => Info): Statement = this.copy(stmt.mapInfo(f))
def mapStmt(f: Statement => Statement): Statement = this.copy(stmt.mapStmt(f))
def mapString(f: String => String): Statement = this.copy(stmt.mapString(f))
def mapType(f: Type => Type): Statement = this.copy(stmt.mapType(f))
}
case class WrapExpr(expr: Expression) extends Expression {
def serialize: String = s"wrap(${expr.serialize})"
def tpe: Type = expr.tpe
def foreachExpr(f: Expression => Unit): Unit = expr.foreachExpr(f)
def foreachType(f: Type => Unit): Unit = expr.foreachType(f)
def foreachWidth(f: Width => Unit): Unit = expr.foreachWidth(f)
def mapExpr(f: Expression => Expression): Expression = this.copy(expr.mapExpr(f))
def mapType(f: Type => Type): Expression = this.copy(expr.mapType(f))
def mapWidth(f: Width => Width): Expression = this.copy(expr.mapWidth(f))
}
private def tab(s: String): String = {
// Careful to only tab non-empty lines
s.split("\n")
.map { line =>
if (line.nonEmpty) Serializer.Indent + line else line
}
.mkString("\n")
}
val testModule: String =
"""module test :
| input in : UInt<8>
| output out : UInt<8>
|
| inst c of child
| c.in <= in
| out <= c.out""".stripMargin
val testModuleTabbed: String = tab(testModule)
val childModule: String =
"""extmodule child :
| input in : UInt<8>
| output out : UInt<8>
| defname = child""".stripMargin
val childModuleTabbed: String = tab(childModule)
val simpleCircuit: String =
s"FIRRTL version ${Serializer.version.serialize}\ncircuit test :\n" + childModuleTabbed + "\n\n" + testModuleTabbed + "\n"
}
class SerializerSpec extends AnyFlatSpec with Matchers {
import SerializerSpec._
"ir.Serializer" should "support custom Statements" in {
val stmt = WrapStmt(DefWire(NoInfo, "myWire", Utils.BoolType))
val ser = "wrap(wire myWire : UInt<1>)"
Serializer.serialize(stmt) should be(ser)
}
it should "support custom Expression" in {
val expr = WrapExpr(Reference("foo"))
val ser = "wrap(foo)"
Serializer.serialize(expr) should be(ser)
}
it should "support nested custom Statements and Expressions" in {
val expr = SubField(WrapExpr(Reference("foo")), "bar")
val stmt = WrapStmt(DefNode(NoInfo, "n", expr))
val stmts = Block(stmt :: Nil)
val ser = "wrap(node n = wrap(foo).bar)"
Serializer.serialize(stmts) should be(ser)
}
it should "support emitting circuits" in {
val parsed = Parser.parse(simpleCircuit)
val serialized = Serializer.serialize(parsed)
serialized should be(simpleCircuit)
}
it should "support emitting individual modules" in {
val parsed = Parser.parse(simpleCircuit)
val m = parsed.modules.find(_.name == "test").get
val serialized = Serializer.serialize(m)
serialized should be(testModule)
}
it should "support emitting indented individual modules" in {
val parsed = Parser.parse(simpleCircuit)
val m = parsed.modules.find(_.name == "test").get
val serialized = Serializer.serialize(m, 1)
serialized should be(testModuleTabbed)
}
it should "support emitting indented individual extmodules" in {
val parsed = Parser.parse(simpleCircuit)
val m = parsed.modules.find(_.name == "child").get
val serialized = Serializer.serialize(m, 1)
serialized should be(childModuleTabbed)
}
it should "emit whens with empty Blocks correctly" in {
val when = Conditionally(NoInfo, Reference("cond"), Block(Seq()), EmptyStmt)
val serialized = Serializer.serialize(when, 1)
serialized should be(" when cond :\n skip\n")
}
}
|
