Some more XML cleanups.

compiler dependency on scala.util.automata.

4 files changed, 46 insertions, 88 deletions

diff --git a/src/library/scala/util/automata/DetWordAutom.scala b/src/library/scala/util/automata/DetWordAutom.scala
index 07ffdaf21b..cf78accbef 100644
--- a/src/library/scala/util/automata/DetWordAutom.scala
+++ b/src/library/scala/util/automata/DetWordAutom.scala
@@ -31,23 +31,9 @@ abstract class DetWordAutom[T <: AnyRef] {
   val delta: Array[Map[T,Int]]
   val default: Array[Int]
 
-  /**
-   *  @param q ...
-   *  @return  ...
-   */
   def isFinal(q: Int) = finals(q) != 0
-
-  /**
-   *  @param q ...
-   *  @return  ...
-   */
   def isSink(q: Int) = delta(q).isEmpty && default(q) == q
 
-  /**
-   *  @param q     ...
-   *  @param label ...
-   *  @return      ...
-   */
   def next(q: Int, label: T) = {
     delta(q).get(label) match {
       case Some(p) => p
@@ -59,25 +45,15 @@ abstract class DetWordAutom[T <: AnyRef] {
     val sb = new StringBuilder("[DetWordAutom  nstates=")
     sb.append(nstates)
     sb.append(" finals=")
-    var map = scala.collection.immutable.Map[Int,Int]()
-    var j = 0; while( j < nstates ) {
-      if (j < finals.length)
-        map = map.updated(j, finals(j))
-      j += 1
-    }
+    val map = Map(finals.zipWithIndex map (_.swap): _*)
     sb.append(map.toString())
     sb.append(" delta=\n")
+
     for (i <- 0 until nstates) {
-      sb.append( i )
-      sb.append("->")
-      sb.append(delta(i).toString())
-      sb.append('\n')
-      if (i < default.length) {
-        sb.append("_>")
-        sb.append(default(i).toString())
-        sb.append('\n')
-      }
+      sb append "%d->%s\n".format(i, delta(i))
+      if (i < default.length)
+        sb append "_>%s\n".format(default(i))
     }
-    sb.toString()
+    sb.toString
   }
 }
diff --git a/src/library/scala/xml/dtd/ContentModel.scala b/src/library/scala/xml/dtd/ContentModel.scala
index d5d45bdaa0..eed8a24dbd 100644
--- a/src/library/scala/xml/dtd/ContentModel.scala
+++ b/src/library/scala/xml/dtd/ContentModel.scala
@@ -51,11 +51,9 @@ object ContentModel extends WordExp {
 
   /* precond: rs.length >= 1 */
   private def buildString(rs: Seq[RegExp], sb: StringBuilder, sep: Char) {
-    val it = rs.iterator
-    val fst = it.next
-    buildString(fst, sb)
-    for (z <- it) {
-      sb.append(sep)
+    buildString(rs.head, sb)
+    for (z <- rs.tail) {
+      sb append sep
       buildString(z, sb)
     }
     sb
@@ -121,7 +119,7 @@ case class MIXED(r: ContentModel.RegExp) extends DFAContentModel {
   }
 }
 
-case class  ELEMENTS(r: ContentModel.RegExp) extends DFAContentModel {
+case class ELEMENTS(r: ContentModel.RegExp) extends DFAContentModel {
   override def buildString(sb: StringBuilder): StringBuilder =
     ContentModel.buildString(r, sb)
 }
diff --git a/src/library/scala/xml/dtd/ElementValidator.scala b/src/library/scala/xml/dtd/ElementValidator.scala
index 8c375ca1c8..8b24104ce0 100644
--- a/src/library/scala/xml/dtd/ElementValidator.scala
+++ b/src/library/scala/xml/dtd/ElementValidator.scala
@@ -14,22 +14,26 @@ package dtd
 
 import PartialFunction._
 import ContentModel.ElemName
+import MakeValidationException._    // @todo other exceptions
+
 import scala.util.automata._
+import scala.collection.mutable.BitSet
 
 /** validate children and/or attributes of an element
  *  exceptions are created but not thrown.
  */
 class ElementValidator() extends Function1[Node,Boolean] {
 
-  var exc: List[ValidationException] = Nil
+  private var exc: List[ValidationException] = Nil
 
   protected var contentModel: ContentModel           = _
   protected var dfa:          DetWordAutom[ElemName] = _
   protected var adecls:       List[AttrDecl]         = _
 
   /** set content model, enabling element validation */
-  def setContentModel(cm:ContentModel) = {
-    contentModel = cm; cm match {
+  def setContentModel(cm: ContentModel) = {
+    contentModel = cm
+    cm match {
       case ELEMENTS(r) =>
         val nfa = ContentModel.Translator.automatonFrom(r, 1)
         dfa = new SubsetConstruction(nfa).determinize
@@ -43,7 +47,7 @@ class ElementValidator() extends Function1[Node,Boolean] {
   /** set meta data, enabling attribute validation */
   def setMetaData(adecls: List[AttrDecl]) { this.adecls = adecls }
 
-  def getIterator(nodes: Seq[Node], skipPCDATA: Boolean): Iterator[ElemName] = {
+  def getIterable(nodes: Seq[Node], skipPCDATA: Boolean): Iterable[ElemName] = {
     def isAllWhitespace(a: Atom[_]) = cond(a.data) { case s: String if s.trim.isEmpty  => true }
 
     nodes.filter {
@@ -52,57 +56,41 @@ class ElementValidator() extends Function1[Node,Boolean] {
         case _                                => !skipPCDATA
       }
       case x                                  => x.namespace eq null
-    } . map (x => ElemName(x.label)) iterator
+    } . map (x => ElemName(x.label))
   }
 
   /** check attributes, return true if md corresponds to attribute declarations in adecls.
    */
   def check(md: MetaData): Boolean = {
-    //@todo other exceptions
-    import MakeValidationException._;
-    val len: Int = exc.length;
-    var j = 0;
-    var ok = new scala.collection.mutable.BitSet(adecls.length);
-    def find(Key:String): AttrDecl = {
-      var attr: AttrDecl = null;
-      val jt = adecls.iterator; while(j < adecls.length) {
-        jt.next match {
-          case a @ AttrDecl(Key, _, _) => attr = a; ok += j; j = adecls.length;
-          case _                       => j = j + 1;
+    val len: Int = exc.length
+    var ok = new BitSet(adecls.length)
+
+    for (attr <- md) {
+      def attrStr = attr.value.toString
+      def find(Key: String): Option[AttrDecl] = {
+        adecls.zipWithIndex find {
+          case (a @ AttrDecl(Key, _, _), j) => ok += j ; return Some(a)
+          case _                            => false
         }
+        None
       }
-      attr
-    }
-    val it = md.iterator; while(it.hasNext) {
-      val attr = it.next
-      j = 0
-      find(attr.key) match {
 
-        case null =>
-          //Console.println("exc");
-          exc = fromUndefinedAttribute( attr.key ) :: exc;
-
-        case AttrDecl(_, tpe, DEFAULT(true, fixedValue)) if attr.value.toString != fixedValue =>
-          exc = fromFixedAttribute( attr.key, fixedValue, attr.value.toString) :: exc;
+      find(attr.key) match {
+        case None =>
+          exc ::= fromUndefinedAttribute(attr.key)
 
-        case s =>
-          //Console.println("s: "+s);
+        case Some(AttrDecl(_, tpe, DEFAULT(true, fixedValue))) if attrStr != fixedValue =>
+          exc ::= fromFixedAttribute(attr.key, fixedValue, attrStr)
 
+        case _ =>
       }
     }
 
-    //val missing = ok.toSet(false); FIXME: it doesn't seem to be used anywhere
-    j = 0
-    var kt = adecls.iterator
-    while (kt.hasNext) {
-      kt.next match {
-        case AttrDecl(key, tpe, REQUIRED) if !ok(j) =>
-          exc = fromMissingAttribute( key, tpe ) :: exc;
-          j = j + 1;
-        case _ =>
-          j = j + 1;
-      }
+    adecls.zipWithIndex foreach {
+      case (AttrDecl(key, tpe, REQUIRED), j) if !ok(j) => exc ::= fromMissingAttribute(key, tpe)
+      case _ =>
     }
+
     exc.length == len //- true if no new exception
   }
 
@@ -111,28 +99,24 @@ class ElementValidator() extends Function1[Node,Boolean] {
    */
   def check(nodes: Seq[Node]): Boolean = contentModel match {
     case ANY    => true
-    case EMPTY  => !getIterator(nodes, false).hasNext
-    case PCDATA => !getIterator(nodes, true).hasNext
+    case EMPTY  => getIterable(nodes, false).isEmpty
+    case PCDATA => getIterable(nodes, true).isEmpty
     case MIXED(ContentModel.Alt(branches @ _*))  =>   // @todo
       val j = exc.length
       def find(Key: String): Boolean =
         branches exists { case ContentModel.Letter(ElemName(Key)) => true ; case _ => false }
 
-      getIterator(nodes, true) map (_.name) filterNot find foreach {
+      getIterable(nodes, true) map (_.name) filterNot find foreach {
         exc ::= MakeValidationException fromUndefinedElement _
       }
       (exc.length == j)   // - true if no new exception
 
     case _: ELEMENTS =>
-      var q = 0
-      getIterator(nodes, false) foreach { e =>
-        (dfa delta q get e) match {
-          case Some(p)  => q = p
-          case _        => throw ValidationException("element %s not allowed here" format e)
+      dfa isFinal {
+        getIterable(nodes, false).foldLeft(0) { (q, e) =>
+          (dfa delta q get e) getOrElse (throw ValidationException("element %s not allowed here" format e))
         }
       }
-
-      dfa isFinal q       // - true if arrived in final state
   }
 
   /** applies various validations - accumulates error messages in exc
diff --git a/src/library/scala/xml/parsing/MarkupParser.scala b/src/library/scala/xml/parsing/MarkupParser.scala
index 846895a21b..06fb313255 100644
--- a/src/library/scala/xml/parsing/MarkupParser.scala
+++ b/src/library/scala/xml/parsing/MarkupParser.scala
@@ -364,7 +364,7 @@ trait MarkupParser extends AnyRef with TokenTests
    *  [40] STag         ::= '&lt;' Name { S Attribute } [S]
    *  [44] EmptyElemTag ::= '&lt;' Name { S Attribute } [S]
    */
-  protected def xTag(pscope:NamespaceBinding): Tuple3[String, MetaData, NamespaceBinding] = {
+  protected def xTag(pscope:NamespaceBinding): (String, MetaData, NamespaceBinding) = {
     val qname = xName
 
     xSpaceOpt