make Node.toString stack safe

Author: lrytz

shared/src/main/scala/scala/xml/Utility.scala

@@ -13,6 +13,7 @@
 package scala
 package xml
 
+import scala.annotation.tailrec
 import scala.collection.mutable
 import scala.language.implicitConversions
 import scala.collection.Seq
@@ -191,9 +192,8 @@ object Utility extends AnyRef with parsing.TokenTests {
     decodeEntities: Boolean = true,
     preserveWhitespace: Boolean = false,
     minimizeTags: Boolean = false
-  ): StringBuilder = {
+  ): StringBuilder =
     serialize(x, pscope, sb, stripComments, decodeEntities, preserveWhitespace, if (minimizeTags) MinimizeMode.Always else MinimizeMode.Never)
-  }
 
   /**
    * Serialize an XML Node to a StringBuilder.
@@ -212,32 +212,64 @@ object Utility extends AnyRef with parsing.TokenTests {
     preserveWhitespace: Boolean = false,
     minimizeTags: MinimizeMode.Value = MinimizeMode.Default
   ): StringBuilder = {
-    x match {
-      case c: Comment                   => if (!stripComments) c.buildString(sb); sb
-      case s: SpecialNode               => s.buildString(sb)
-      case g: Group                     =>
-        for (c <- g.nodes) serialize(c, g.scope, sb, stripComments, decodeEntities, preserveWhitespace, minimizeTags); sb
-      case el: Elem =>
-        // print tag with namespace declarations
-        sb.append('<')
-        el.nameToString(sb)
-        if (el.attributes.ne(null)) el.attributes.buildString(sb)
-        el.scope.buildString(sb, pscope)
-        if (el.child.isEmpty &&
-          (minimizeTags == MinimizeMode.Always ||
-            (minimizeTags == MinimizeMode.Default && el.minimizeEmpty))) {
-          // no children, so use short form: <xyz .../>
-          sb.append("/>")
-        } else {
-          // children, so use long form: <xyz ...>...</xyz>
-          sb.append('>')
-          sequenceToXML(el.child, el.scope, sb, stripComments, decodeEntities, preserveWhitespace, minimizeTags)
+    serializeImpl(List(x), pscope, false, stripComments, minimizeTags, sb)
+    sb
+  }
+
+  private def serializeImpl(
+    ns: Seq[Node],
+    pscope: NamespaceBinding,
+    spaced: Boolean,
+    stripComments: Boolean,
+    minimizeTags: MinimizeMode.Value,
+    sb: StringBuilder
+  ): Unit = {
+    @tailrec def ser(nss: List[Seq[Node]], pscopes: List[NamespaceBinding], spaced: List[Boolean], toClose: List[Node]): Unit = nss match {
+      case List(ns) if ns.isEmpty =>
+      case ns :: rests if ns.isEmpty =>
+        if (toClose.head != null) {
           sb.append("</")
-          el.nameToString(sb)
+          toClose.head.nameToString(sb)
           sb.append('>')
         }
-      case _ => throw new IllegalArgumentException("Don't know how to serialize a " + x.getClass.getName)
+        ser(rests, pscopes.tail, spaced.tail, toClose.tail)
+      case ns1 :: r =>
+        val (n, ns) = (ns1.head, ns1.tail)
+        def sp(): Unit = if (ns.nonEmpty && spaced.head) sb.append(' ')
+        n match {
+          case c: Comment =>
+            if (!stripComments) {
+              c.buildString(sb)
+              sp()
+            }
+            ser(ns :: r, pscopes, spaced, toClose)
+          case s: SpecialNode =>
+            s.buildString(sb)
+            sp()
+            ser(ns :: r, pscopes, spaced, toClose)
+          case g: Group =>
+            ser(g.nodes :: ns :: r, g.scope :: pscopes, false :: spaced, null :: toClose)
+          case e: Elem =>
+            sb.append('<')
+            e.nameToString(sb)
+            if (e.attributes.ne(null)) e.attributes.buildString(sb)
+            e.scope.buildString(sb, pscopes.head)
+            if (e.child.isEmpty &&
+              (minimizeTags == MinimizeMode.Always ||
+                (minimizeTags == MinimizeMode.Default && e.minimizeEmpty))) {
+              // no children, so use short form: <xyz .../>
+              sb.append("/>")
+              sp()
+              ser(ns :: r, pscopes, spaced, toClose)
+            } else {
+              sb.append('>')
+              val csp = e.child.forall(isAtomAndNotText)
+              ser(e.child :: ns :: r, e.scope :: pscopes, csp :: spaced, e :: toClose)
+            }
+          case n => throw new IllegalArgumentException("Don't know how to serialize a " + n.getClass.getName)
+        }
     }
+    ser(List(ns), List(pscope), List(spaced), Nil)
   }
 
   def sequenceToXML(
@@ -248,18 +280,9 @@ object Utility extends AnyRef with parsing.TokenTests {
     decodeEntities: Boolean = true,
     preserveWhitespace: Boolean = false,
     minimizeTags: MinimizeMode.Value = MinimizeMode.Default
-  ): Unit = {
-    if (children.isEmpty) ()
-    else if (children.forall(isAtomAndNotText)) { // add space
-      val it: Iterator[Node] = children.iterator
-      val f: Node = it.next()
-      serialize(f, pscope, sb, stripComments, decodeEntities, preserveWhitespace, minimizeTags)
-      while (it.hasNext) {
-        val x: Node = it.next()
-        sb.append(' ')
-        serialize(x, pscope, sb, stripComments, decodeEntities, preserveWhitespace, minimizeTags)
-      }
-    } else children.foreach { serialize(_, pscope, sb, stripComments, decodeEntities, preserveWhitespace, minimizeTags) }
+  ): Unit = if (children.nonEmpty) {
+    val spaced = children.forall(isAtomAndNotText)
+    serializeImpl(children, pscope, spaced, stripComments, minimizeTags, sb)
   }
 
   def splitName(name: String): (Option[String], String) = {

shared/src/test/scala/scala/xml/UtilityTest.scala

@@ -230,4 +230,10 @@ class UtilityTest {
     assertEquals("", result)
   }
 
+  @Test
+  def toStringStackSafe(): Unit = {
+    val xml = (1 to 5000).foldRight(<x/>) { case (_, n) => <x>{n}</x>}
+    xml.toString
+  }
+
 }