aboutsummaryrefslogtreecommitdiff
path: root/src/main/scala/firrtl/Mappers.scala
diff options
context:
space:
mode:
Diffstat (limited to 'src/main/scala/firrtl/Mappers.scala')
-rw-r--r--src/main/scala/firrtl/Mappers.scala70
1 files changed, 35 insertions, 35 deletions
diff --git a/src/main/scala/firrtl/Mappers.scala b/src/main/scala/firrtl/Mappers.scala
index 335bc4aa..c00ca855 100644
--- a/src/main/scala/firrtl/Mappers.scala
+++ b/src/main/scala/firrtl/Mappers.scala
@@ -27,46 +27,47 @@ MODIFICATIONS.
package firrtl
+import firrtl.ir._
+
// TODO: Implement remaining mappers and recursive mappers
object Mappers {
// ********** Stmt Mappers **********
private trait StmtMagnet {
- def map(stmt: Stmt): Stmt
+ def map(stmt: Statement): Statement
}
private object StmtMagnet {
- implicit def forStmt(f: Stmt => Stmt) = new StmtMagnet {
- override def map(stmt: Stmt): Stmt = {
+ implicit def forStmt(f: Statement => Statement) = new StmtMagnet {
+ override def map(stmt: Statement): Statement = {
stmt match {
case s: Conditionally => Conditionally(s.info, s.pred, f(s.conseq), f(s.alt))
case s: Begin => Begin(s.stmts.map(f))
- case s: Stmt => s
+ case s: Statement => s
}
}
}
implicit def forExp(f: Expression => Expression) = new StmtMagnet {
- override def map(stmt: Stmt): Stmt = {
+ override def map(stmt: Statement): Statement = {
stmt match {
case s: DefRegister => DefRegister(s.info, s.name, s.tpe, f(s.clock), f(s.reset), f(s.init))
case s: DefNode => DefNode(s.info, s.name, f(s.value))
- case s: Connect => Connect(s.info, f(s.loc), f(s.exp))
- case s: BulkConnect => BulkConnect(s.info, f(s.loc), f(s.exp))
+ case s: Connect => Connect(s.info, f(s.loc), f(s.expr))
+ case s: PartialConnect => PartialConnect(s.info, f(s.loc), f(s.expr))
case s: Conditionally => Conditionally(s.info, f(s.pred), s.conseq, s.alt)
- case s: IsInvalid => IsInvalid(s.info, f(s.exp))
+ case s: IsInvalid => IsInvalid(s.info, f(s.expr))
case s: Stop => Stop(s.info, s.ret, f(s.clk), f(s.en))
case s: Print => Print(s.info, s.string, s.args.map(f), f(s.clk), f(s.en))
case s: CDefMPort => CDefMPort(s.info,s.name,s.tpe,s.mem,s.exps.map(f),s.direction)
- case s: Stmt => s
+ case s: Statement => s
}
}
}
implicit def forType(f: Type => Type) = new StmtMagnet {
- override def map(stmt: Stmt) : Stmt = {
+ override def map(stmt: Statement) : Statement = {
stmt match {
- case s:DefPoison => DefPoison(s.info,s.name,f(s.tpe))
case s:DefWire => DefWire(s.info,s.name,f(s.tpe))
case s:DefRegister => DefRegister(s.info,s.name,f(s.tpe),s.clock,s.reset,s.init)
- case s:DefMemory => DefMemory(s.info,s.name, f(s.data_type), s.depth, s.write_latency, s.read_latency, s.readers, s.writers, s.readwriters)
+ case s:DefMemory => DefMemory(s.info,s.name, f(s.dataType), s.depth, s.writeLatency, s.readLatency, s.readers, s.writers, s.readwriters)
case s:CDefMemory => CDefMemory(s.info,s.name, f(s.tpe), s.size, s.seq)
case s:CDefMPort => CDefMPort(s.info,s.name, f(s.tpe), s.mem, s.exps,s.direction)
case s => s
@@ -74,12 +75,11 @@ object Mappers {
}
}
implicit def forString(f: String => String) = new StmtMagnet {
- override def map(stmt: Stmt): Stmt = {
+ override def map(stmt: Statement): Statement = {
stmt match {
case s: DefWire => DefWire(s.info,f(s.name),s.tpe)
- case s: DefPoison => DefPoison(s.info,f(s.name),s.tpe)
case s: DefRegister => DefRegister(s.info,f(s.name), s.tpe, s.clock, s.reset, s.init)
- case s: DefMemory => DefMemory(s.info,f(s.name), s.data_type, s.depth, s.write_latency, s.read_latency, s.readers, s.writers, s.readwriters)
+ case s: DefMemory => DefMemory(s.info,f(s.name), s.dataType, s.depth, s.writeLatency, s.readLatency, s.readers, s.writers, s.readwriters)
case s: DefNode => DefNode(s.info,f(s.name),s.value)
case s: DefInstance => DefInstance(s.info,f(s.name), s.module)
case s: WDefInstance => WDefInstance(s.info,f(s.name), s.module,s.tpe)
@@ -90,9 +90,9 @@ object Mappers {
}
}
}
- implicit class StmtMap(stmt: Stmt) {
+ implicit class StmtMap(stmt: Statement) {
// 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): Stmt = magnet(f).map(stmt)
+ def map[T](f: T => T)(implicit magnet: (T => T) => StmtMagnet): Statement = magnet(f).map(stmt)
}
// ********** Expression Mappers **********
@@ -103,9 +103,9 @@ object Mappers {
implicit def forExp(f: Expression => Expression) = new ExpMagnet {
override def map(exp: Expression): Expression = {
exp match {
- case e: SubField => SubField(f(e.exp), e.name, e.tpe)
- case e: SubIndex => SubIndex(f(e.exp), e.value, e.tpe)
- case e: SubAccess => SubAccess(f(e.exp), f(e.index), e.tpe)
+ case e: SubField => SubField(f(e.expr), e.name, e.tpe)
+ case e: SubIndex => SubIndex(f(e.expr), e.value, e.tpe)
+ case e: SubAccess => SubAccess(f(e.expr), f(e.index), e.tpe)
case e: Mux => Mux(f(e.cond), f(e.tval), f(e.fval), e.tpe)
case e: ValidIf => ValidIf(f(e.cond), f(e.value), e.tpe)
case e: DoPrim => DoPrim(e.op, e.args.map(f), e.consts, e.tpe)
@@ -133,8 +133,8 @@ object Mappers {
implicit def forWidth(f: Width => Width) = new ExpMagnet {
override def map(exp: Expression): Expression = {
exp match {
- case e: UIntValue => UIntValue(e.value,f(e.width))
- case e: SIntValue => SIntValue(e.value,f(e.width))
+ case e: UIntLiteral => UIntLiteral(e.value,f(e.width))
+ case e: SIntLiteral => SIntLiteral(e.value,f(e.width))
case e => e
}
}
@@ -196,36 +196,36 @@ object Mappers {
// ********** Module Mappers **********
private trait ModuleMagnet {
- def map(module: Module): Module
+ def map(module: DefModule): DefModule
}
private object ModuleMagnet {
- implicit def forStmt(f: Stmt => Stmt) = new ModuleMagnet {
- override def map(module: Module): Module = {
+ implicit def forStmt(f: Statement => Statement) = new ModuleMagnet {
+ override def map(module: DefModule): DefModule = {
module match {
- case m: InModule => InModule(m.info, m.name, m.ports, f(m.body))
- case m: ExModule => m
+ case m: Module => Module(m.info, m.name, m.ports, f(m.body))
+ case m: ExtModule => m
}
}
}
implicit def forPorts(f: Port => Port) = new ModuleMagnet {
- override def map(module: Module): Module = {
+ override def map(module: DefModule): DefModule = {
module match {
- case m: InModule => InModule(m.info, m.name, m.ports.map(f), m.body)
- case m: ExModule => ExModule(m.info, m.name, m.ports.map(f))
+ case m: Module => Module(m.info, m.name, m.ports.map(f), m.body)
+ case m: ExtModule => ExtModule(m.info, m.name, m.ports.map(f))
}
}
}
implicit def forString(f: String => String) = new ModuleMagnet {
- override def map(module: Module): Module = {
+ override def map(module: DefModule): DefModule = {
module match {
- case m: InModule => InModule(m.info, f(m.name), m.ports, m.body)
- case m: ExModule => ExModule(m.info, f(m.name), m.ports)
+ case m: Module => Module(m.info, f(m.name), m.ports, m.body)
+ case m: ExtModule => ExtModule(m.info, f(m.name), m.ports)
}
}
}
}
- implicit class ModuleMap(module: Module) {
- def map[T](f: T => T)(implicit magnet: (T => T) => ModuleMagnet): Module = magnet(f).map(module)
+ implicit class ModuleMap(module: DefModule) {
+ def map[T](f: T => T)(implicit magnet: (T => T) => ModuleMagnet): DefModule = magnet(f).map(module)
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-04 20:43:01 +0000