fix spaces in WIR.scala

1 files changed, 31 insertions, 31 deletions

diff --git a/src/main/scala/firrtl/WIR.scala b/src/main/scala/firrtl/WIR.scala
index 06b5be48..3db1c250 100644
--- a/src/main/scala/firrtl/WIR.scala
+++ b/src/main/scala/firrtl/WIR.scala
@@ -113,32 +113,32 @@ 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)
+  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 (WVoid, WVoid) => true
-       case (WInvalid, 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
+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 (WVoid, WVoid) => true
+      case (WInvalid, 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
 }
 
 private[firrtl] sealed trait HasMapWidth {
@@ -170,23 +170,23 @@ case class ExpWidth(arg1: Width) extends Width with HasMapWidth {
 }
 
 object WrappedType {
-  def apply (t:Type) = new WrappedType(t)
-  def wt (t:Type) = apply(t)
+  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 {
+  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) =>
+      case (t1: BundleType, t2: BundleType) =>
         t1.fields.size == t2.fields.size && (
-        (t1.fields zip t2.fields) forall {case (f1, f2) =>
+        (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) =>
+        }) && ((t1.fields zip t2.fields) forall { case (f1, f2) =>
           wt(f1.tpe) == wt(f2.tpe)
         })
       case _ => false