updated self aliases, for-comprehensions

7 files changed, 191 insertions, 196 deletions

diff --git a/src/library/scala/util/automata/SubsetConstruction.scala b/src/library/scala/util/automata/SubsetConstruction.scala
index 8786ada85c..46d4c916f5 100644
--- a/src/library/scala/util/automata/SubsetConstruction.scala
+++ b/src/library/scala/util/automata/SubsetConstruction.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -9,28 +9,26 @@
 // $Id$
 
 
-package scala.util.automata ;
+package scala.util.automata
 
 
 class SubsetConstruction[T <: AnyRef](val nfa: NondetWordAutom[T]) {
-  //import nfa.{ _labelT, labels };
-  import nfa.labels ;
-  import scala.collection.{immutable, mutable, Map} ;
-
-  import immutable.{ BitSet, TreeMap, TreeSet } ;
+  import nfa.labels
+  import scala.collection.{immutable, mutable, Map}
+  import immutable.{BitSet, TreeMap, TreeSet}
 
   implicit def toOrdered(bs: BitSet): Ordered[BitSet] = new Ordered[BitSet] {
-    def compare (that: BitSet): Int = {
-        val it1 = bs.elements;
-        val it2 = that.elements;
-        var res = 0;
+    def compare(that: BitSet): Int = {
+        val it1 = bs.elements
+        val it2 = that.elements
+        var res = 0
         while((0 == res) && it1.hasNext) {
           while((0 == res) && it2.hasNext) {
             if (!it1.hasNext)
               res = -1
             else {
-              val i1 = it1.next;
-              val i2 = it2.next;
+              val i1 = it1.next
+              val i2 = it2.next
               if (i1 < i2)
                 res = -1
               else if (i1 > i2)
@@ -41,7 +39,7 @@ class SubsetConstruction[T <: AnyRef](val nfa: NondetWordAutom[T]) {
             res = 1
         }
         if (it2.hasNext)
-          res = -1;
+          res = -1
         res
     }
 
@@ -50,111 +48,108 @@ class SubsetConstruction[T <: AnyRef](val nfa: NondetWordAutom[T]) {
 
   /** the set {0} */
   final val _initialBitSet = {
-    val rbs = new mutable.BitSet(1);
-    rbs += 0;
-    rbs.toImmutable;
+    val rbs = new mutable.BitSet(1)
+    rbs += 0
+    rbs.toImmutable
   }
 
   /** the set {} */
-  final val _sinkBitSet = new mutable.BitSet(1).toImmutable;
+  final val _sinkBitSet = new mutable.BitSet(1).toImmutable
 
-  final val _emptyBitSet = new scala.collection.mutable.BitSet(1).toImmutable;
+  final val _emptyBitSet = new scala.collection.mutable.BitSet(1).toImmutable
 
-  def selectTag(Q:BitSet, finals:Array[Int]) = {
-    val it = Q.elements;
-    var mintag = compat.Math.MAX_INT;
-    while(it.hasNext) {
-      val tag = finals(it.next);
-      if((0 < tag) && (tag < mintag))
+  def selectTag(Q: BitSet, finals: Array[Int]) = {
+    val it = Q.elements
+    var mintag = compat.Math.MAX_INT
+    while (it.hasNext) {
+      val tag = finals(it.next)
+      if ((0 < tag) && (tag < mintag))
         mintag = tag
     }
     mintag
   }
 
-  def determinize: DetWordAutom[ T ] = {
+  def determinize: DetWordAutom[T] = {
 
     // for assigning numbers to bitsets
-    var indexMap    = new TreeMap[ BitSet, Int ];
-    var invIndexMap = new TreeMap[ Int, BitSet ];
-    var ix = 0;
+    var indexMap    = new TreeMap[BitSet, Int]
+    var invIndexMap = new TreeMap[Int, BitSet]
+    var ix = 0
 
     // we compute the dfa with states = bitsets
-    var states   = new TreeSet[BitSet]();
+    var states   = new TreeSet[BitSet]()
     val delta    = new mutable.HashMap[BitSet,
-                                       mutable.HashMap[T, BitSet]];
-    var deftrans = new TreeMap[BitSet, BitSet];
-    var finals   = new TreeMap[BitSet, Int];
+                                       mutable.HashMap[T, BitSet]]
+    var deftrans = new TreeMap[BitSet, BitSet]
+    var finals   = new TreeMap[BitSet, Int]
 
-    val q0 = _initialBitSet;
-    states = states + q0;
+    val q0 = _initialBitSet
+    states = states + q0
 
-    val sink = _emptyBitSet;
-    states = states + sink;
+    val sink = _emptyBitSet
+    states = states + sink
 
     deftrans = deftrans.update(q0,sink);
     deftrans = deftrans.update(sink,sink);
 
     val rest = new mutable.Stack[BitSet]();
 
-    def add(Q: BitSet): Unit = {
-      if(!states.contains(Q)) {
-        states = states + Q;
-        rest.push(Q);
-          if(nfa.containsFinal(Q))
-            finals = finals.update(Q, selectTag(Q,nfa.finals));
+    def add(Q: BitSet) {
+      if (!states.contains(Q)) {
+        states = states + Q
+        rest.push(Q)
+        if (nfa.containsFinal(Q))
+          finals = finals.update(Q, selectTag(Q,nfa.finals));
       }
-   }
-    rest.push( sink );
-    val sinkIndex = 1;
-    rest.push( q0 );
-    while(!rest.isEmpty) {
+    }
+    rest.push(sink)
+    val sinkIndex = 1
+    rest.push(q0)
+    while (!rest.isEmpty) {
       // assign a number to this bitset
-      val P = rest.pop;
-      indexMap = indexMap.update(P,ix);
-      invIndexMap = invIndexMap.update(ix,P);
-      ix = ix + 1;
+      val P = rest.pop
+      indexMap = indexMap.update(P,ix)
+      invIndexMap = invIndexMap.update(ix,P)
+      ix += 1
 
       // make transitiion map
-      val Pdelta = new mutable.HashMap[T, BitSet];
-      delta.update( P, Pdelta );
+      val Pdelta = new mutable.HashMap[T, BitSet]
+      delta.update(P, Pdelta)
 
       val it = labels.elements; while(it.hasNext) {
-        val label = it.next;
-
-        val Q = nfa.next(P,label);
-
-	Pdelta.update( label, Q );
-
-        add(Q);
+        val label = it.next
+        val Q = nfa.next(P,label)
+	Pdelta.update(label, Q)
+        add(Q)
       }
 
       // collect default transitions
-      val Pdef = nfa.nextDefault(P);
-      deftrans = deftrans.update(P,Pdef);
-      add(Pdef);
+      val Pdef = nfa.nextDefault(P)
+      deftrans = deftrans.update(P, Pdef)
+      add(Pdef)
     };
 
     // create DetWordAutom, using indices instead of sets
-    val nstatesR = states.size;
-    val deltaR = new Array[Map[T,Int]](nstatesR);
-    val defaultR = new Array[Int](nstatesR);
-    val finalsR = new Array[Int](nstatesR);
-
-    for(val w <- states) {
-      val Q = w;
-      val q = indexMap(Q);
-      val trans = delta(Q);
-      val transDef = deftrans(Q);
-      val qDef = indexMap(transDef);
-      val ntrans = new mutable.HashMap[T,Int]();
+    val nstatesR = states.size
+    val deltaR = new Array[Map[T,Int]](nstatesR)
+    val defaultR = new Array[Int](nstatesR)
+    val finalsR = new Array[Int](nstatesR)
+
+    for (w <- states) {
+      val Q = w
+      val q = indexMap(Q)
+      val trans = delta(Q)
+      val transDef = deftrans(Q)
+      val qDef = indexMap(transDef)
+      val ntrans = new mutable.HashMap[T,Int]()
       val it = trans.keys; while(it.hasNext) {
-        val label = it.next;
-        val p = indexMap(trans(label));
-        if( p != qDef )
+        val label = it.next
+        val p = indexMap(trans(label))
+        if (p != qDef)
           ntrans.update(label, p)
       }
-      deltaR.update(q, ntrans);
-      defaultR.update(q, qDef);
+      deltaR.update(q, ntrans)
+      defaultR.update(q, qDef)
 
       //cleanup? leave to garbage collector?
       //delta.remove(Q);
@@ -162,17 +157,14 @@ class SubsetConstruction[T <: AnyRef](val nfa: NondetWordAutom[T]) {
 
     }
 
-    for(val fQ <- finals.keys) {
-      finalsR(indexMap(fQ)) = finals(fQ);
-    }
-
-    new DetWordAutom [ T ] {
+    for (fQ <- finals.keys) finalsR(indexMap(fQ)) = finals(fQ)
 
+    new DetWordAutom [T] {
       //type _labelT = SubsetConstruction.this.nfa._labelT;
-      val nstates = nstatesR;
-      val delta = deltaR;
-      val default = defaultR;
-      val finals = finalsR;
+      val nstates = nstatesR
+      val delta = deltaR
+      val default = defaultR
+      val finals = finalsR
     }
   }
 }
diff --git a/src/library/scala/util/automata/WordBerrySethi.scala b/src/library/scala/util/automata/WordBerrySethi.scala
index ee031d67c6..a268344557 100644
--- a/src/library/scala/util/automata/WordBerrySethi.scala
+++ b/src/library/scala/util/automata/WordBerrySethi.scala
@@ -278,7 +278,7 @@ abstract class WordBerrySethi extends BaseBerrySethi {
    System.out.println("#positions:" + pos);
    System.out.println("posMap:");
 
-   for( Iterator it = this.posMap.keySet().iterator();
+   for (Iterator it = this.posMap.keySet().iterator();
    it.hasNext(); ) {
    Tree t = (Tree) it.next();
                   switch(t) {
@@ -289,7 +289,7 @@ abstract class WordBerrySethi extends BaseBerrySethi {
                   }
             }
             System.out.println("\nfollow: ");
-            for( int j = 1; j < pos; j++ ) {
+            for (int j = 1; j < pos; j++ ) {
                   TreeSet fol = (TreeSet) this.follow.get(new Integer(j));
                   System.out.print("("+j+" -> "+fol.toString()+") ");
                   //debugPrint( fol );
diff --git a/src/library/scala/xml/PrettyPrinter.scala b/src/library/scala/xml/PrettyPrinter.scala
index ad3f26c2ed..8f92149c18 100644
--- a/src/library/scala/xml/PrettyPrinter.scala
+++ b/src/library/scala/xml/PrettyPrinter.scala
@@ -187,9 +187,9 @@ class PrettyPrinter( width:Int, step:Int ) {
              val sq:Seq[String] = stg.split(" ");
              val it = sq.elements;
              it.next;
-             for(c <- it) {
-               makeBox( ind+len2-2, c );
-               makeBreak();
+             for (c <- it) {
+               makeBox(ind+len2-2, c)
+               makeBreak()
              }
              }*/
             makeBox(ind, stg.substring(len2, stg.length()))
diff --git a/src/library/scala/xml/dtd/ContentModel.scala b/src/library/scala/xml/dtd/ContentModel.scala
index d1113b15b7..8b0b6e7ae3 100644
--- a/src/library/scala/xml/dtd/ContentModel.scala
+++ b/src/library/scala/xml/dtd/ContentModel.scala
@@ -11,19 +11,18 @@
 
 package scala.xml.dtd
 
-import compat.StringBuilder
 import scala.util.regexp.WordExp
-import scala.util.automata._
+import scala.util.automata.{DetWordAutom, SubsetConstruction, WordBerrySethi}
 
-object ContentModel extends WordExp  {
+object ContentModel extends WordExp {
   type _labelT = ElemName
   type _regexpT = RegExp
 
-  object Translator extends WordBerrySethi  {
+  object Translator extends WordBerrySethi {
 
-    override val lang: ContentModel.this.type = ContentModel.this;
-    import lang._ ;
-    //val re  = Sequ(Star(Letter(IntConst( 3 ))));
+    override val lang: ContentModel.this.type = ContentModel.this
+    import lang._
+    //val re  = Sequ(Star(Letter(IntConst( 3 ))))
     //val aut = automatonFrom(re, 7)
   }
 
@@ -32,21 +31,20 @@ object ContentModel extends WordExp  {
     override def toString() = "ElemName(\""+name+"\")"
   }
 
-  def isMixed(cm: ContentModel) = cm.isInstanceOf[MIXED];
+  def isMixed(cm: ContentModel) = cm.isInstanceOf[MIXED]
   def containsText(cm: ContentModel) = (cm == PCDATA) || isMixed(cm)
 
   def parse(s: String): ContentModel = ContentModelParser.parse(s)
 
   def getLabels(r: RegExp): scala.collection.Set[String] = {
     val s = new scala.collection.mutable.HashSet[String]()
-    def traverse1(xs: Seq[RegExp]): Unit = {
-      val it = xs.elements;
-      while( it.hasNext )
-        traverse( it.next );
-      }
-    def traverse(r: RegExp): Unit = {
+    def traverse1(xs: Seq[RegExp]) {
+      val it = xs.elements
+      while (it.hasNext) traverse(it.next)
+    }
+    def traverse(r: RegExp) {
       r match {
-        case Letter(ElemName( name )) => s += name;
+        case Letter(ElemName(name)) => s += name
         case Star(  x @ _  ) => traverse( x ) // bug if x@_*
         case Sequ( xs @ _* ) => traverse1(xs)
         case Alt(  xs @ _* ) => traverse1(xs)
@@ -63,12 +61,11 @@ object ContentModel extends WordExp  {
   }
 
   /* precond: rs.length >= 1 */
-  private def toString(rs: Seq[RegExp], sb: StringBuilder, sep: Char): Unit = {
-
+  private def toString(rs: Seq[RegExp], sb: StringBuilder, sep: Char) {
     val it = rs.elements
     val fst = it.next
     toString(fst, sb)
-    for(val z <- it) {
+    for (z <- it) {
       sb.append(sep)
       toString(z, sb)
     }
@@ -112,24 +109,24 @@ sealed abstract class ContentModel {
   def toString(sb:StringBuilder): StringBuilder;
   /*
   def validate(cs: NodeSeq): Boolean = this.match {
-    case ANY         => true ;
-    case EMPTY       => cs.length == 0;
+    case ANY         => true
+    case EMPTY       => cs.length == 0
     case PCDATA      => cs.length == 0
-                     || (cs.length == 1 && cs(0).isInstanceOf[Text]);
-    case m@MIXED(r)    => m.runDFA(cs);
-    case e@ELEMENTS(r) => e.runDFA(cs);
+                     || (cs.length == 1 && cs(0).isInstanceOf[Text])
+    case m@MIXED(r)    => m.runDFA(cs)
+    case e@ELEMENTS(r) => e.runDFA(cs)
   }
   */
 }
 
 case object PCDATA extends ContentModel {
-  override def toString(sb:StringBuilder): StringBuilder = sb.append("(#PCDATA)")
+  override def toString(sb: StringBuilder): StringBuilder = sb.append("(#PCDATA)")
 }
 case object EMPTY extends ContentModel {
-  override def toString(sb:StringBuilder): StringBuilder = sb.append("EMPTY")
+  override def toString(sb: StringBuilder): StringBuilder = sb.append("EMPTY")
 }
 case object ANY extends ContentModel {
-  override def toString(sb:StringBuilder): StringBuilder = sb.append("ANY")
+  override def toString(sb: StringBuilder): StringBuilder = sb.append("ANY")
 }
 sealed abstract class DFAContentModel extends ContentModel {
   import ContentModel.ElemName
@@ -145,7 +142,7 @@ sealed abstract class DFAContentModel extends ContentModel {
   }
 }
 case class MIXED(r:ContentModel.RegExp) extends DFAContentModel {
-  import ContentModel.{ Alt, Eps, RegExp };
+  import ContentModel.{Alt, Eps, RegExp}
   /*
   def getIterator(ns:NodeSeq) = new Iterator[String] {
     def cond(n:Node) =
@@ -167,7 +164,7 @@ Console.println("ns = "+ns);
     }
   }
   */
-  override def toString(sb:StringBuilder): StringBuilder =  {
+  override def toString(sb: StringBuilder): StringBuilder =  {
     sb.append("(#PCDATA|");
     //r match {
     //  case Alt(Eps, rs@_*) => ContentModel.toString(Alt(rs:_*):RegExp, sb);
diff --git a/src/library/scala/xml/dtd/DTD.scala b/src/library/scala/xml/dtd/DTD.scala
index d1907fd5c0..0ca74a7926 100644
--- a/src/library/scala/xml/dtd/DTD.scala
+++ b/src/library/scala/xml/dtd/DTD.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2002-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -9,44 +9,46 @@
 // $Id$
 
 
-package scala.xml.dtd;
+package scala.xml.dtd
 
-import scala.collection.mutable.{ HashMap, Map }
+import scala.collection.mutable.{HashMap, Map}
 
-/** a document type declaration */
+/** A document type declaration.
+ *
+ *  @author Burak Emir
+ */
 abstract class DTD {
 
-  var externalID: ExternalID = null;
+  var externalID: ExternalID = null
 
-  def notations: Seq[NotationDecl] = Nil;
+  def notations: Seq[NotationDecl] = Nil
 
-  def unparsedEntities: Seq[EntityDecl] = Nil;
+  def unparsedEntities: Seq[EntityDecl] = Nil
 
-  var elem: Map[String, ElemDecl]    = new HashMap[String, ElemDecl]();
+  var elem: Map[String, ElemDecl]    = new HashMap[String, ElemDecl]()
 
-  var attr: Map[String, AttListDecl] = new HashMap[String, AttListDecl]();
+  var attr: Map[String, AttListDecl] = new HashMap[String, AttListDecl]()
 
-  var ent:  Map[String, EntityDecl]  = new HashMap[String, EntityDecl]();
+  var ent:  Map[String, EntityDecl]  = new HashMap[String, EntityDecl]()
 
-  var decls: List[Decl] = Nil;
+  var decls: List[Decl] = Nil
 
-  //def getElemDecl(elem:String): ElemDecl;
+  //def getElemDecl(elem:String): ElemDecl
 
-  //def getAttribDecl(elem: String, attr: String): AttrDecl;
+  //def getAttribDecl(elem: String, attr: String): AttrDecl
 
   override def toString() = {
-    val sb = new compat.StringBuilder();
-    sb.append("DTD [\n");
-    if(null != externalID)
-      sb.append(externalID.toString()).append('\n');
-    for(val d <- decls)
-      sb.append(d.toString()).append('\n');
+    val sb = new StringBuilder("DTD [\n")
+    if (null != externalID)
+      sb.append(externalID.toString()).append('\n')
+    for (d <- decls)
+      sb.append(d.toString()).append('\n')
     sb.append("]").toString()
   }
 
   /*
   def initializeEntities() = {
-    for(val x <- decls) x match {
+    for (x <- decls) x match {
       case y @ ParsedEntityDecl(name, _)      => ent.update(name, y);
       case y @ UnparsedEntityDecl(name, _, _) => ent.update(name, y);
       case y @ ParameterEntityDecl(name, _)   => ent.update(name, y);
diff --git a/src/library/scala/xml/dtd/DocType.scala b/src/library/scala/xml/dtd/DocType.scala
index e31f43990f..aa80a685e1 100644
--- a/src/library/scala/xml/dtd/DocType.scala
+++ b/src/library/scala/xml/dtd/DocType.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -9,39 +9,37 @@
 // $Id$
 
 
-package scala.xml.dtd;
+package scala.xml.dtd
 
-
-/** an XML node for document type declaration
+/** An XML node for document type declaration.
  *
- * @author Burak Emir
- * @param  target name of this DOCTYPE
- * @param  extID  None, or Some(external ID of this doctype)
- * @param  intSubset sequence of internal subset declarations
-**/
-
-case class DocType( name:String, extID:ExternalID, intSubset:Seq[dtd.Decl]) {
+ *  @author Burak Emir
+ *
+ *  @param  target name of this DOCTYPE
+ *  @param  extID  None, or Some(external ID of this doctype)
+ *  @param  intSubset sequence of internal subset declarations
+ */
+case class DocType(name: String, extID: ExternalID, intSubset: Seq[dtd.Decl]) {
 
-  if( !Utility.isName( name ) )
+  if (!Utility.isName(name))
     throw new IllegalArgumentException(name+" must be an XML Name");
 
   /** hashcode for this processing instruction */
-  final override def hashCode() = name.hashCode() + 7 * extID.hashCode() + 41*intSubset.toList.hashCode();
+  final override def hashCode() =
+    name.hashCode() + 7 * extID.hashCode() + 41*intSubset.toList.hashCode();
 
   /** returns "&lt;!DOCTYPE + name + extID? + ("["+intSubSet+"]")? >" */
   final override def toString() = {
-    val sb = new compat.StringBuilder().append("<!DOCTYPE ");
-    sb.append( name );
-    sb.append(' ');
-    sb.append(extID.toString());
-    if( intSubset.length > 0 ) {
-      sb.append('[');
-      for( val d <- intSubset ) {
-        sb.append( d.toString() );
-      }
-      sb.append(']');
+    val sb = new StringBuilder("<!DOCTYPE ")
+    sb.append(name)
+    sb.append(' ')
+    sb.append(extID.toString())
+    if (intSubset.length > 0) {
+      sb.append('[')
+      for (d <- intSubset) sb.append(d.toString())
+      sb.append(']')
     }
-    sb.append('>');
-    sb.toString();
+    sb.append('>')
+    sb.toString()
   }
 }
diff --git a/src/library/scala/xml/factory/Binder.scala b/src/library/scala/xml/factory/Binder.scala
index d6b6b3d08e..937f051bb0 100644
--- a/src/library/scala/xml/factory/Binder.scala
+++ b/src/library/scala/xml/factory/Binder.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2002-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -9,47 +9,53 @@
 // $Id$
 
 
-package scala.xml.factory;
+package scala.xml.factory
 
 
-import scala.xml.parsing.ValidatingMarkupHandler;
+import scala.xml.parsing.ValidatingMarkupHandler
 
+/**
+ *  @author Burak Emir
+ */
 abstract class Binder(val preserveWS: Boolean) extends ValidatingMarkupHandler {
 
-  var result: NodeBuffer = new NodeBuffer();
+  var result: NodeBuffer = new NodeBuffer()
 
   def reportSyntaxError(pos:Int, str:String) = {}
 
-  final def procInstr(pos: Int, target: String, txt: String ) =
-    ProcInstr(target, txt);
+  final def procInstr(pos: Int, target: String, txt: String) =
+    ProcInstr(target, txt)
 
-  final def comment(pos: Int, txt: String ) =
-    Comment( txt );
+  final def comment(pos: Int, txt: String) =
+    Comment(txt)
 
   final def entityRef(pos: Int, n: String) =
-    EntityRef( n );
+    EntityRef(n)
 
-  final def text(pos: Int, txt:String) =
-    Text( txt );
+  final def text(pos: Int, txt: String) =
+    Text(txt)
 
   final def traverse(n:Node): Unit = n match {
-    case x:ProcInstr => result &+ procInstr(0, x.target, x.text)
-    case x:Comment   => result &+ comment(0, x.text)
-    case x:Text      => result &+ text(0, x.data)
-    case x:EntityRef => result &+ entityRef(0, x.entityName)
+    case x:ProcInstr =>
+      result &+ procInstr(0, x.target, x.text)
+    case x:Comment   =>
+      result &+ comment(0, x.text)
+    case x:Text      =>
+      result &+ text(0, x.data)
+    case x:EntityRef =>
+      result &+ entityRef(0, x.entityName)
     case _ =>
-      elemStart(0, n.prefix, n.label, n.attributes, n.scope);
-      val old = result;
-      result = new NodeBuffer();
-      for(val m <- n.child)
-        traverse(m);
+      elemStart(0, n.prefix, n.label, n.attributes, n.scope)
+      val old = result
+      result = new NodeBuffer()
+      for (m <- n.child) traverse(m)
       result = old &+ elem(0, n.prefix, n.label, n.attributes, n.scope, NodeSeq.fromSeq(result)).toList;
-      elemEnd(0, n.prefix, n.label);
+      elemEnd(0, n.prefix, n.label)
   }
 
-  final def validate(n:Node): Node = {
-    this.rootLabel = n.label;
-    traverse(n);
+  final def validate(n: Node): Node = {
+    this.rootLabel = n.label
+    traverse(n)
     result(0)
   }
 }