blob: e8283d93af3756cb936e99ed4eaa05497ae57d39 (
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
|
// See LICENSE for license details.
package firrtl
import firrtl.ir._
// TODO: Implement remaining mappers and recursive mappers
object Mappers {
// ********** Stmt Mappers **********
private trait StmtMagnet {
def map(stmt: Statement): Statement
}
private object StmtMagnet {
implicit def forStmt(f: Statement => Statement): StmtMagnet = new StmtMagnet {
override def map(stmt: Statement): Statement = stmt mapStmt f
}
implicit def forExp(f: Expression => Expression): StmtMagnet = new StmtMagnet {
override def map(stmt: Statement): Statement = stmt mapExpr f
}
implicit def forType(f: Type => Type): StmtMagnet = new StmtMagnet {
override def map(stmt: Statement) : Statement = stmt mapType f
}
implicit def forString(f: String => String): StmtMagnet = new StmtMagnet {
override def map(stmt: Statement): Statement = stmt mapString f
}
implicit def forInfo(f: Info => Info): StmtMagnet = new StmtMagnet {
override def map(stmt: Statement): Statement = stmt mapInfo f
}
}
implicit class StmtMap(val _stmt: Statement) extends AnyVal {
// Using implicit types to allow overloading of function type to map, see StmtMagnet above
def map[T](f: T => T)(implicit magnet: (T => T) => StmtMagnet): Statement = magnet(f).map(_stmt)
}
// ********** Expression Mappers **********
private trait ExprMagnet {
def map(expr: Expression): Expression
}
private object ExprMagnet {
implicit def forExpr(f: Expression => Expression): ExprMagnet = new ExprMagnet {
override def map(expr: Expression): Expression = expr mapExpr f
}
implicit def forType(f: Type => Type): ExprMagnet = new ExprMagnet {
override def map(expr: Expression): Expression = expr mapType f
}
implicit def forWidth(f: Width => Width): ExprMagnet = new ExprMagnet {
override def map(expr: Expression): Expression = expr mapWidth f
}
}
implicit class ExprMap(val _expr: Expression) extends AnyVal {
def map[T](f: T => T)(implicit magnet: (T => T) => ExprMagnet): Expression = magnet(f).map(_expr)
}
// ********** Type Mappers **********
private trait TypeMagnet {
def map(tpe: Type): Type
}
private object TypeMagnet {
implicit def forType(f: Type => Type): TypeMagnet = new TypeMagnet {
override def map(tpe: Type): Type = tpe mapType f
}
implicit def forWidth(f: Width => Width): TypeMagnet = new TypeMagnet {
override def map(tpe: Type): Type = tpe mapWidth f
}
}
implicit class TypeMap(val _tpe: Type) extends AnyVal {
def map[T](f: T => T)(implicit magnet: (T => T) => TypeMagnet): Type = magnet(f).map(_tpe)
}
// ********** Width Mappers **********
private trait WidthMagnet {
def map(width: Width): Width
}
private object WidthMagnet {
implicit def forWidth(f: Width => Width): WidthMagnet = new WidthMagnet {
override def map(width: Width): Width = width match {
case mapable: HasMapWidth => mapable mapWidth f // WIR
case other => other // Standard IR nodes
}
}
}
implicit class WidthMap(val _width: Width) extends AnyVal {
def map[T](f: T => T)(implicit magnet: (T => T) => WidthMagnet): Width = magnet(f).map(_width)
}
// ********** Module Mappers **********
private trait ModuleMagnet {
def map(module: DefModule): DefModule
}
private object ModuleMagnet {
implicit def forStmt(f: Statement => Statement): ModuleMagnet = new ModuleMagnet {
override def map(module: DefModule): DefModule = module mapStmt f
}
implicit def forPorts(f: Port => Port): ModuleMagnet = new ModuleMagnet {
override def map(module: DefModule): DefModule = module mapPort f
}
implicit def forString(f: String => String): ModuleMagnet = new ModuleMagnet {
override def map(module: DefModule): DefModule = module mapString f
}
implicit def forInfo(f: Info => Info): ModuleMagnet = new ModuleMagnet {
override def map(module: DefModule): DefModule = module mapInfo f
}
}
implicit class ModuleMap(val _module: DefModule) extends AnyVal {
def map[T](f: T => T)(implicit magnet: (T => T) => ModuleMagnet): DefModule = magnet(f).map(_module)
}
// ********** Circuit Mappers **********
private trait CircuitMagnet {
def map(module: Circuit): Circuit
}
private object CircuitMagnet {
implicit def forModules(f: DefModule => DefModule): CircuitMagnet = new CircuitMagnet {
override def map(circuit: Circuit): Circuit = circuit mapModule f
}
implicit def forString(f: String => String): CircuitMagnet = new CircuitMagnet {
override def map(circuit: Circuit): Circuit = circuit mapString f
}
implicit def forInfo(f: Info => Info): CircuitMagnet = new CircuitMagnet {
override def map(circuit: Circuit): Circuit = circuit mapInfo f
}
}
implicit class CircuitMap(val _circuit: Circuit) extends AnyVal {
def map[T](f: T => T)(implicit magnet: (T => T) => CircuitMagnet): Circuit = magnet(f).map(_circuit)
}
}
|
