SI-6811 Move scala.util.{automata,regexp} ...

... to scala.xml.dtd.impl and make it private[dtd]

Author: soc

src/library/scala/xml/dtd/ContentModel.scala

@@ -11,8 +11,7 @@
 package scala.xml
 package dtd
 
-import scala.util.regexp.WordExp
-import scala.util.automata._
+import scala.xml.dtd.impl._
 import scala.xml.Utility.sbToString
 import PartialFunction._
 

src/library/scala/xml/dtd/DocType.scala

@@ -18,8 +18,7 @@ package dtd
  *  @param  extID  NoExternalID or the external ID of this doctype
  *  @param  intSubset sequence of internal subset declarations
  */
-case class DocType(name: String, extID: ExternalID, intSubset: Seq[dtd.Decl])
-{
+case class DocType(name: String, extID: ExternalID, intSubset: Seq[dtd.Decl]) {
   if (!Utility.isName(name))
     throw new IllegalArgumentException(name+" must be an XML Name")
 
@@ -33,8 +32,7 @@ case class DocType(name: String, extID: ExternalID, intSubset: Seq[dtd.Decl])
   }
 }
 
-object DocType
-{
+object DocType {
   /** Creates a doctype with no external id, nor internal subset declarations. */
   def apply(name: String): DocType = apply(name, NoExternalID, Nil)
 }

src/library/scala/xml/dtd/ElementValidator.scala

@@ -12,10 +12,12 @@ package scala.xml
 package dtd
 
 import PartialFunction._
+import scala.collection.mutable
+
 import ContentModel.ElemName
 import MakeValidationException._    // @todo other exceptions
-import scala.util.automata._
-import scala.collection.mutable
+
+import impl._
 
 /** validate children and/or attributes of an element
  *  exceptions are created but not thrown.

src/library/scala/xml/dtd/ExternalID.scala

@@ -14,8 +14,7 @@ package dtd
  *
  *  @author Burak Emir
  */
-abstract class ExternalID extends parsing.TokenTests
-{
+abstract class ExternalID extends parsing.TokenTests {
   def quoted(s: String) = {
     val c = if (s contains '"') '\'' else '"'
     c + s + c

src/library/scala/xml/dtd/impl/Base.scala

@@ -0,0 +1,66 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+
+
+package scala.xml.dtd.impl
+
+/** Basic regular expressions.
+ *
+ *  @author  Burak Emir
+ *  @version 1.0
+ */
+
+@deprecated("This class will be removed", "2.10.0")
+private[dtd] abstract class Base {
+  type _regexpT <: RegExp
+
+  abstract class RegExp {
+    val isNullable: Boolean
+  }
+
+  object Alt {
+    /** `Alt( R,R,R* )`. */
+    def apply(rs: _regexpT*) =
+      if (rs.size < 2) throw new SyntaxError("need at least 2 branches in Alt")
+      else new Alt(rs: _*)
+    // Can't enforce that statically without changing the interface
+    // def apply(r1: _regexpT, r2: _regexpT, rs: _regexpT*) = new Alt(Seq(r1, r2) ++ rs: _*)
+    def unapplySeq(x: Alt) = Some(x.rs)
+  }
+
+  class Alt private (val rs: _regexpT*) extends RegExp {
+    final val isNullable = rs exists (_.isNullable)
+  }
+
+  object Sequ {
+    /** Sequ( R,R* ) */
+    def apply(rs: _regexpT*) = if (rs.isEmpty) Eps else new Sequ(rs: _*)
+    def unapplySeq(x: Sequ) = Some(x.rs)
+  }
+
+  class Sequ private (val rs: _regexpT*) extends RegExp {
+    final val isNullable = rs forall (_.isNullable)
+  }
+
+  case class Star(r: _regexpT) extends RegExp {
+    final lazy val isNullable = true
+  }
+
+  // The empty Sequ.
+  case object Eps extends RegExp {
+    final lazy val isNullable = true
+    override def toString() = "Eps"
+  }
+
+  /** this class can be used to add meta information to regexps. */
+  class Meta(r1: _regexpT) extends RegExp {
+    final val isNullable = r1.isNullable
+    def r = r1
+  }
+}

src/library/scala/xml/dtd/impl/BaseBerrySethi.scala

@@ -0,0 +1,97 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.xml.dtd.impl
+
+import scala.collection.{ mutable, immutable }
+
+// todo: replace global variable pos with acc
+
+/** This class turns a regular expression over `A` into a
+  * [[scala.util.automata.NondetWordAutom]] over `A` using the celebrated
+  * position automata construction (also called ''Berry-Sethi'' or ''Glushkov'').
+  */
+@deprecated("This class will be removed", "2.10.0")
+private[dtd] abstract class BaseBerrySethi {
+  val lang: Base
+  import lang.{ Alt, Eps, Meta, RegExp, Sequ, Star }
+
+  protected var pos = 0
+
+  // results which hold all info for the NondetWordAutomaton
+  protected var follow: mutable.HashMap[Int, Set[Int]] = _
+
+  protected var finalTag: Int = _
+
+  protected var finals: immutable.Map[Int, Int] = _     // final states
+
+  // constants --------------------------
+
+  final val emptySet: Set[Int] = Set()
+
+  private def doComp(r: RegExp, compFunction: RegExp => Set[Int]) = r match {
+    case x: Alt   => (x.rs map compFirst).foldLeft(emptySet)(_ ++ _)
+    case Eps      => emptySet
+    case x: Meta  => compFunction(x.r)
+    case x: Sequ  =>
+      val (l1, l2) = x.rs span (_.isNullable)
+      ((l1 ++ (l2 take 1)) map compFunction).foldLeft(emptySet)(_ ++ _)
+    case Star(t)  => compFunction(t)
+    case _        => throw new IllegalArgumentException("unexpected pattern " + r.getClass)
+  }
+
+  /** Computes `first(r)` for the word regexp `r`. */
+  protected def compFirst(r: RegExp): Set[Int] = doComp(r, compFirst)
+
+  /** Computes `last(r)` for the regexp `r`. */
+  protected def compLast(r: RegExp): Set[Int] = doComp(r, compLast)
+
+  /** Starts from the right-to-left
+   *  precondition: pos is final
+   *               pats are successor patterns of a Sequence node
+   */
+  protected def compFollow(rs: Seq[RegExp]): Set[Int] = {
+    follow(0) =
+      if (rs.isEmpty) emptySet
+      else rs.foldRight(Set(pos))((p, fol) => {
+        val first = compFollow1(fol, p)
+
+        if (p.isNullable) fol ++ first
+        else first
+      })
+
+    follow(0)
+  }
+
+  /** Returns the first set of an expression, setting the follow set along the way.
+   */
+  protected def compFollow1(fol1: Set[Int], r: RegExp): Set[Int] = r match {
+    case x: Alt     => Set((x.rs reverseMap (compFollow1(fol1, _))).flatten: _*)
+    case x: Meta    => compFollow1(fol1, x.r)
+    case x: Star    => compFollow1(fol1 ++ compFirst(x.r), x.r)
+    case x: Sequ    =>
+      x.rs.foldRight(fol1) { (p, fol) =>
+        val first = compFollow1(fol, p)
+
+        if (p.isNullable) fol ++ first
+        else first
+      }
+    case _          => throw new IllegalArgumentException("unexpected pattern: " + r.getClass)
+  }
+
+  /** Returns the "Sethi-length" of a pattern, creating the set of position along the way.
+   */
+  protected def traverse(r: RegExp): Unit = r match {
+    // (is tree automaton stuff, more than Berry-Sethi)
+    case x: Alt  => x.rs foreach traverse
+    case x: Sequ => x.rs foreach traverse
+    case x: Meta => traverse(x.r)
+    case Star(t) => traverse(t)
+    case _       => throw new IllegalArgumentException("unexp pattern " + r.getClass)
+  }
+}

src/library/scala/xml/dtd/impl/DetWordAutom.scala

@@ -0,0 +1,49 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.xml.dtd.impl
+
+import scala.collection.{ mutable, immutable }
+
+/** A deterministic automaton. States are integers, where
+ *  0 is always the only initial state. Transitions are represented
+ *  in the delta function. A default transitions is one that
+ *  is taken when no other transition can be taken.
+ *  All states are reachable. Accepting states are those for which
+ *  the partial function 'finals' is defined.
+ *
+ *  @author Burak Emir
+ *  @version 1.0
+ */
+@deprecated("This class will be removed", "2.10.0")
+private[dtd] abstract class DetWordAutom[T <: AnyRef] {
+  val nstates: Int
+  val finals: Array[Int]
+  val delta: Array[mutable.Map[T, Int]]
+  val default: Array[Int]
+
+  def isFinal(q: Int)        = finals(q) != 0
+  def isSink(q: Int)         = delta(q).isEmpty && default(q) == q
+  def next(q: Int, label: T) = delta(q).getOrElse(label, default(q))
+
+  override def toString() = {
+    val sb = new StringBuilder("[DetWordAutom  nstates=")
+    sb.append(nstates)
+    sb.append(" finals=")
+    val map = Map(finals.zipWithIndex map (_.swap): _*)
+    sb.append(map.toString())
+    sb.append(" delta=\n")
+
+    for (i <- 0 until nstates) {
+      sb append "%d->%s\n".format(i, delta(i))
+      if (i < default.length)
+        sb append "_>%s\n".format(default(i))
+    }
+    sb.toString
+  }
+}

src/library/scala/xml/dtd/impl/Inclusion.scala

@@ -0,0 +1,69 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+
+
+package scala.xml.dtd.impl
+
+
+/** A fast test of language inclusion between minimal automata.
+ *  inspired by the ''AMoRE automata library''.
+ *
+ *  @author Burak Emir
+ *  @version 1.0
+ */
+@deprecated("This class will be removed", "2.10.0")
+private[dtd] trait Inclusion[A <: AnyRef] {
+
+  val labels: Seq[A]
+
+  /** Returns true if `dfa1` is included in `dfa2`.
+   */
+  def inclusion(dfa1: DetWordAutom[A], dfa2: DetWordAutom[A]) = {
+
+    def encode(q1: Int, q2: Int) = 1 + q1 + q2 * dfa1.nstates
+    def decode2(c: Int) = (c-1) / (dfa1.nstates) //integer division
+    def decode1(c: Int) = (c-1) % (dfa1.nstates)
+
+    var q1 = 0 //dfa1.initstate; // == 0
+    var q2 = 0 //dfa2.initstate; // == 0
+
+    val max = 1 + dfa1.nstates * dfa2.nstates
+    val mark = new Array[Int](max)
+
+    var result = true
+    var current = encode(q1, q2)
+    var last = current
+    mark(last) = max // mark (q1,q2)
+    while (current != 0 && result) {
+      //Console.println("current = [["+q1+" "+q2+"]] = "+current);
+      for (letter <- labels) {
+        val r1 = dfa1.next(q1,letter)
+        val r2 = dfa2.next(q2,letter)
+        if (dfa1.isFinal(r1) && !dfa2.isFinal(r2))
+	  result = false
+        val test = encode(r1, r2)
+        //Console.println("test = [["+r1+" "+r2+"]] = "+test);
+        if (mark(test) == 0) {
+	  mark(last) = test
+	  mark(test) = max
+	  last = test
+        }
+      }
+      val ncurrent = mark(current)
+      if( ncurrent != max ) {
+        q1 = decode1(ncurrent)
+        q2 = decode2(ncurrent)
+        current = ncurrent
+      } else {
+        current = 0
+      }
+    }
+    result
+  }
+}

src/library/scala/xml/dtd/impl/NondetWordAutom.scala

@@ -0,0 +1,59 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala.xml.dtd.impl
+
+import scala.collection.{ immutable, mutable }
+
+/** A nondeterministic automaton. States are integers, where
+ *  0 is always the only initial state. Transitions are represented
+ *  in the delta function. Default transitions are transitions that
+ *  are taken when no other transitions can be applied.
+ *  All states are reachable. Accepting states are those for which
+ *  the partial function `finals` is defined.
+ */
+@deprecated("This class will be removed", "2.10.0")
+private[dtd] abstract class NondetWordAutom[T <: AnyRef] {
+  val nstates: Int
+  val labels: Seq[T]
+  val finals: Array[Int] // 0 means not final
+  val delta: Array[mutable.Map[T, immutable.BitSet]]
+  val default: Array[immutable.BitSet]
+
+  /** @return true if the state is final */
+  final def isFinal(state: Int) = finals(state) > 0
+
+  /** @return tag of final state */
+  final def finalTag(state: Int) = finals(state)
+
+  /** @return true if the set of states contains at least one final state */
+  final def containsFinal(Q: immutable.BitSet): Boolean = Q exists isFinal
+
+  /** @return true if there are no accepting states */
+  final def isEmpty = (0 until nstates) forall (x => !isFinal(x))
+
+  /** @return a immutable.BitSet with the next states for given state and label */
+  def next(q: Int, a: T): immutable.BitSet = delta(q).getOrElse(a, default(q))
+
+  /** @return a immutable.BitSet with the next states for given state and label */
+  def next(Q: immutable.BitSet, a: T): immutable.BitSet = next(Q, next(_, a))
+  def nextDefault(Q: immutable.BitSet): immutable.BitSet = next(Q, default)
+
+  private def next(Q: immutable.BitSet, f: (Int) => immutable.BitSet): immutable.BitSet =
+    (Q map f).foldLeft(immutable.BitSet.empty)(_ ++ _)
+
+  private def finalStates = 0 until nstates filter isFinal
+  override def toString = {
+
+    val finalString = Map(finalStates map (j => j -> finals(j)) : _*).toString
+    val deltaString = (0 until nstates) 
+      .map(i => "   %d->%s\n    _>%s\n".format(i, delta(i), default(i))).mkString
+
+    "[NondetWordAutom  nstates=%d  finals=%s  delta=\n%s".format(nstates, finalString, deltaString)
+  }
+}