clean up WIR.scala

1 files changed, 86 insertions, 118 deletions

diff --git a/src/main/scala/firrtl/WIR.scala b/src/main/scala/firrtl/WIR.scala
index eddd723b..9583175e 100644
--- a/src/main/scala/firrtl/WIR.scala
+++ b/src/main/scala/firrtl/WIR.scala
@@ -88,33 +88,29 @@ case object Dshlw extends PrimOp { override def toString = "dshlw" }
 case object Shlw extends PrimOp { override def toString = "shlw" }
 
 object WrappedExpression {
-   def apply (e:Expression) = new WrappedExpression(e)
-   def we (e:Expression) = new WrappedExpression(e)
-   def weq (e1:Expression,e2:Expression) = we(e1) == we(e2)
-}
-class WrappedExpression (val e1:Expression) {
-   override def equals (we:Any) = {
-      we match {
-         case (we:WrappedExpression) => {
-            (e1,we.e1) match {
-               case (e1:UIntLiteral,e2:UIntLiteral) => if (e1.value == e2.value) eqw(e1.width,e2.width) else false
-               case (e1:SIntLiteral,e2:SIntLiteral) => if (e1.value == e2.value) eqw(e1.width,e2.width) else false
-               case (e1:WRef,e2:WRef) => e1.name equals e2.name
-               case (e1:WSubField,e2:WSubField) => (e1.name equals e2.name) && weq(e1.exp,e2.exp)
-               case (e1:WSubIndex,e2:WSubIndex) => (e1.value == e2.value) && weq(e1.exp,e2.exp)
-               case (e1:WSubAccess,e2:WSubAccess) => weq(e1.index,e2.index) && weq(e1.exp,e2.exp)
-               case (e1:WVoid,e2:WVoid) => true
-               case (e1:WInvalid,e2:WInvalid) => true
-               case (e1:DoPrim,e2:DoPrim) => e1.op == e2.op &&
-                  ((e1.consts zip e2.consts) forall {case (x, y) => x == y}) &&
-                  ((e1.args zip e2.args) forall {case (x, y) => weq(x, y)})
-               case (e1:Mux,e2:Mux) => weq(e1.cond,e2.cond) && weq(e1.tval,e2.tval) && weq(e1.fval,e2.fval)
-               case (e1:ValidIf,e2:ValidIf) => weq(e1.cond,e2.cond) && weq(e1.value,e2.value)
-               case (e1,e2) => false
-            }
-         }
-         case _ => false
-      }
+   def apply(e: Expression) = new WrappedExpression(e)
+   def we(e: Expression) = new WrappedExpression(e)
+   def weq(e1: Expression, e2: Expression) = we(e1) == we(e2)
+}
+class WrappedExpression (val e1: Expression) {
+   override def equals (we: Any) = we match {
+     case (we:WrappedExpression) => (e1,we.e1) match {
+       case (e1: UIntLiteral, e2: UIntLiteral) => e1.value == e2.value && eqw(e1.width, e2.width)
+       case (e1: SIntLiteral, e2: SIntLiteral) => e1.value == e2.value && eqw(e1.width, e2.width)
+       case (e1: WRef, e2: WRef) => e1.name equals e2.name
+       case (e1: WSubField, e2: WSubField) => (e1.name equals e2.name) && weq(e1.exp,e2.exp)
+       case (e1: WSubIndex, e2: WSubIndex) => (e1.value == e2.value) && weq(e1.exp,e2.exp)
+       case (e1: WSubAccess, e2: WSubAccess) => weq(e1.index,e2.index) && weq(e1.exp,e2.exp)
+       case (e1: WVoid, e2: WVoid) => true
+       case (e1: WInvalid, e2: WInvalid) => true
+       case (e1: DoPrim, e2: DoPrim) => e1.op == e2.op &&
+          ((e1.consts zip e2.consts) forall {case (x, y) => x == y}) &&
+          ((e1.args zip e2.args) forall {case (x, y) => weq(x, y)})
+       case (e1: Mux, e2: Mux) => weq(e1.cond,e2.cond) && weq(e1.tval,e2.tval) && weq(e1.fval,e2.fval)
+       case (e1: ValidIf, e2: ValidIf) => weq(e1.cond,e2.cond) && weq(e1.value,e2.value)
+       case (e1, e2) => false
+     }
+     case _ => false
    }
    override def hashCode = e1.serialize.hashCode
    override def toString = e1.serialize
@@ -141,107 +137,79 @@ case class ExpWidth(arg1: Width) extends Width {
 }
 
 object WrappedType {
-   def apply (t:Type) = new WrappedType(t)
-   def wt (t:Type) = apply(t)
-}
-class WrappedType (val t:Type) {
-   def wt (tx:Type) = new WrappedType(tx)
-   override def equals (o:Any) : Boolean = {
-      o match {
-         case (t2:WrappedType) => {
-            (t,t2.t) match {
-               case (t1:UIntType,t2:UIntType) => true
-               case (t1:SIntType,t2:SIntType) => true
-               case (ClockType, ClockType) => true
-               case (t1:VectorType,t2:VectorType) =>
-                 t1.size == t2.size && wt(t1.tpe) == wt(t2.tpe)
-               case (t1:BundleType,t2:BundleType) =>
-                  t1.fields.size == t2.fields.size && (
-                  (t1.fields zip t2.fields) forall {case (f1, f2) =>
-                    f1.flip == f2.flip && f1.name == f2.name && wt(f1.tpe) == wt(f2.tpe)
-                  })
-               case (t1,t2) => false
-            }
-         }
-         case _ => false
-      }
-   }
+  def apply (t:Type) = new WrappedType(t)
+  def wt (t:Type) = apply(t)
+}
+class WrappedType(val t: Type) {
+  def wt(tx: Type) = new WrappedType(tx)
+  override def equals(o:Any): Boolean = o match {
+    case (t2: WrappedType) => (t, t2.t) match {
+      case (_: UIntType, _: UIntType) => true
+      case (_: SIntType, _: SIntType) => true
+      case (ClockType, ClockType) => true
+      case (t1: VectorType, t2: VectorType) =>
+        t1.size == t2.size && wt(t1.tpe) == wt(t2.tpe)
+      case (t1:BundleType,t2:BundleType) =>
+        t1.fields.size == t2.fields.size && (
+        (t1.fields zip t2.fields) forall {case (f1, f2) =>
+          f1.flip == f2.flip && f1.name == f2.name
+        }) && ((t1.fields zip t2.fields) forall {case (f1, f2) =>
+          wt(f1.tpe) == wt(f2.tpe)
+        })
+      case _ => false
+    }
+    case _ => false
+  }
 }
 
 object WrappedWidth {
-   def eqw (w1:Width,w2:Width) : Boolean = {
-      (new WrappedWidth(w1)) == (new WrappedWidth(w2))
-   }
+  def eqw(w1: Width, w2: Width): Boolean = new WrappedWidth(w1) == new WrappedWidth(w2)
 }
    
-class WrappedWidth (val w:Width) {
-   override def toString = {
-      w match {
-         case (w:VarWidth) => w.name
-         case (w:MaxWidth) => "max(" + w.args.map(_.toString).reduce(_ + _) + ")"
-         case (w:MinWidth) => "min(" + w.args.map(_.toString).reduce(_ + _) + ")"
-         case (w:PlusWidth) => "(" + w.arg1 + " + " + w.arg2 + ")"
-         case (w:MinusWidth) => "(" + w.arg1 + " - " + w.arg2 + ")"
-         case (w:ExpWidth) => "exp(" + w.arg1 + ")"
-         case (w:IntWidth) => w.width.toString
-         case UnknownWidth => "?"
-      }
-   }
-   def ww (w:Width) : WrappedWidth = new WrappedWidth(w)
-   override def equals (o:Any) : Boolean = {
-      o match {
-         case (w2:WrappedWidth) => {
-            (w,w2.w) match {
-               case (w1:VarWidth,w2:VarWidth) => w1.name.equals(w2.name)
-               case (w1:MaxWidth,w2:MaxWidth) => {
-                  var ret = true
-                  if (w1.args.size != w2.args.size) ret = false
-                  else {
-                     for (a1 <- w1.args) {
-                        var found = false
-                        for (a2 <- w2.args) { if (eqw(a1,a2)) found = true }
-                        if (found == false) ret = false
-                     }
-                  }
-                  ret
-               }
-               case (w1:MinWidth,w2:MinWidth) => {
-                  var ret = true
-                  if (w1.args.size != w2.args.size) ret = false
-                  else {
-                     for (a1 <- w1.args) {
-                        var found = false
-                        for (a2 <- w2.args) { if (eqw(a1,a2)) found = true }
-                        if (found == false) ret = false
-                     }
-                  }
-                  ret
-               }
-               case (w1:IntWidth,w2:IntWidth) => w1.width == w2.width
-               case (w1:PlusWidth,w2:PlusWidth) => 
-                  (ww(w1.arg1) == ww(w2.arg1) && ww(w1.arg2) == ww(w2.arg2)) || (ww(w1.arg1) == ww(w2.arg2) && ww(w1.arg2) == ww(w2.arg1))
-               case (w1:MinusWidth,w2:MinusWidth) => 
-                  (ww(w1.arg1) == ww(w2.arg1) && ww(w1.arg2) == ww(w2.arg2)) || (ww(w1.arg1) == ww(w2.arg2) && ww(w1.arg2) == ww(w2.arg1))
-               case (w1:ExpWidth,w2:ExpWidth) => ww(w1.arg1) == ww(w2.arg1)
-               case (UnknownWidth, UnknownWidth) => true
-               case (w1,w2) => false
-            }
-         }
-         case _ => false
-      }
-   }
+class WrappedWidth (val w: Width) {
+  def ww(w: Width): WrappedWidth = new WrappedWidth(w)
+  override def toString = w match {
+    case (w: VarWidth) => w.name
+    case (w: MaxWidth) => s"max(${w.args.mkString})"
+    case (w: MinWidth) => s"min(${w.args.mkString})"
+    case (w: PlusWidth) => s"(${w.arg1} + ${w.arg2})"
+    case (w: MinusWidth) => s"(${w.arg1} -${w.arg2})"
+    case (w: ExpWidth) => s"exp(${w.arg1})"
+    case (w: IntWidth) => w.width.toString
+    case UnknownWidth => "?"
+  }
+  override def equals(o: Any): Boolean = o match {
+    case (w2: WrappedWidth) => (w, w2.w) match {
+      case (w1: VarWidth, w2: VarWidth) => w1.name.equals(w2.name)
+      case (w1: MaxWidth, w2: MaxWidth) => w1.args.size == w2.args.size &&
+        (w1.args forall (a1 => w2.args exists (a2 => eqw(a1, a2))))
+      case (w1: MinWidth, w2: MinWidth) => w1.args.size == w2.args.size &&
+        (w1.args forall (a1 => w2.args exists (a2 => eqw(a1, a2))))
+      case (w1: IntWidth, w2: IntWidth) => w1.width == w2.width
+      case (w1: PlusWidth, w2: PlusWidth) => 
+        (ww(w1.arg1) == ww(w2.arg1) && ww(w1.arg2) == ww(w2.arg2)) ||
+        (ww(w1.arg1) == ww(w2.arg2) && ww(w1.arg2) == ww(w2.arg1))
+      case (w1: MinusWidth,w2: MinusWidth) => 
+        (ww(w1.arg1) == ww(w2.arg1) && ww(w1.arg2) == ww(w2.arg2)) ||
+        (ww(w1.arg1) == ww(w2.arg2) && ww(w1.arg2) == ww(w2.arg1))
+      case (w1: ExpWidth, w2: ExpWidth) => ww(w1.arg1) == ww(w2.arg1)
+      case (UnknownWidth, UnknownWidth) => true
+      case _ => false
+    }
+    case _ => false
+  }
 }
 
 trait Constraint
-class WGeq(val loc:Width,val exp:Width) extends Constraint {
-   override def toString = {
-      val wloc = new WrappedWidth(loc)
-      val wexp = new WrappedWidth(exp)
-      wloc.toString + " >= " + wexp.toString
-   }
+class WGeq(val loc: Width, val exp: Width) extends Constraint {
+  override def toString = {
+    val wloc = new WrappedWidth(loc)
+    val wexp = new WrappedWidth(exp)
+    wloc.toString + " >= " + wexp.toString
+  }
 }
 object WGeq {
-   def apply (loc:Width,exp:Width) = new WGeq(loc,exp)
+  def apply(loc: Width, exp: Width) = new WGeq(loc, exp)
 }
 
 abstract class MPortDir extends FirrtlNode