Starting some cleanup deeper in scala.xml in th...

Starting some cleanup deeper in scala.xml in the hopes of reducing the
number of XML-related dependencies.

3 files changed, 44 insertions, 115 deletions

diff --git a/src/library/scala/xml/dtd/ContentModel.scala b/src/library/scala/xml/dtd/ContentModel.scala
index 085d33f56a..4972ee6eaf 100644
--- a/src/library/scala/xml/dtd/ContentModel.scala
+++ b/src/library/scala/xml/dtd/ContentModel.scala
@@ -14,7 +14,9 @@ package dtd
 
 import scala.util.regexp.WordExp
 import scala.util.automata.{DetWordAutom, SubsetConstruction, WordBerrySethi}
+import scala.collection.mutable.HashSet
 import Utility.sbToString
+import PartialFunction._
 
 object ContentModel extends WordExp {
   type _labelT = ElemName
@@ -28,27 +30,21 @@ object ContentModel extends WordExp {
     override def toString() = "ElemName(\""+name+"\")"
   }
 
-  def isMixed(cm: ContentModel) = cm.isInstanceOf[MIXED]
+  def isMixed(cm: ContentModel) = cond(cm) { case _: MIXED => true }
   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]) {
-      val it = xs.iterator
-      while (it.hasNext) traverse(it.next)
-    }
-    def traverse(r: RegExp) {
-      r match { // !!! check for match translation problem
-        case Letter(ElemName(name)) => s += name
-        case Star(  x @ _  ) => traverse( x ) // bug if x@_*
-        case Sequ( xs @ _* ) => traverse1(xs)
-        case Alt(  xs @ _* ) => traverse1(xs)
-      }
+    val s = new HashSet[String]()
+
+    def traverse(r: RegExp): Unit = r match { // !!! check for match translation problem
+      case Letter(ElemName(name)) => s += name
+      case Star(  x @ _  ) => traverse( x ) // bug if x@_*
+      case Sequ( xs @ _* ) => xs foreach traverse
+      case Alt(  xs @ _* ) => xs foreach traverse
     }
     traverse(r)
-    return s
+    s
   }
 
   def buildString(r: RegExp): String = sbToString(buildString(r, _))
@@ -66,14 +62,10 @@ object ContentModel extends WordExp {
   }
 
   def buildString(c: ContentModel, sb: StringBuilder): StringBuilder = c match {
-    case ANY =>
-      sb.append("ANY")
-    case EMPTY =>
-      sb.append("EMPTY")
-    case PCDATA =>
-      sb.append("(#PCDATA)")
-    case ELEMENTS( _ ) | MIXED( _ ) =>
-      c.buildString(sb)
+    case ANY                    => sb append "ANY"
+    case EMPTY                  => sb append "EMPTY"
+    case PCDATA                 => sb append "(#PCDATA)"
+    case ELEMENTS(_) | MIXED(_) => c buildString sb
   }
 
   def buildString(r: RegExp, sb:StringBuilder): StringBuilder = r match {  // !!! check for match translation problem
@@ -91,21 +83,10 @@ object ContentModel extends WordExp {
 
 }
 
-sealed abstract class ContentModel {
-
+sealed abstract class ContentModel
+{
   override def toString(): String = sbToString(buildString)
-
-  def buildString(sb:StringBuilder): StringBuilder;
-  /*
-  def validate(cs: NodeSeq): Boolean = this.match {
-    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)
-  }
-  */
+  def buildString(sb: StringBuilder): StringBuilder
 }
 
 case object PCDATA extends ContentModel {
diff --git a/src/library/scala/xml/dtd/ContentModelParser.scala b/src/library/scala/xml/dtd/ContentModelParser.scala
index a7c1f3b4e1..a98e75ee02 100644
--- a/src/library/scala/xml/dtd/ContentModelParser.scala
+++ b/src/library/scala/xml/dtd/ContentModelParser.scala
@@ -80,30 +80,12 @@ object ContentModelParser extends Scanner { // a bit too permissive concerning #
 
   //                      (' S? mixed ::= '#PCDATA' S? ')'
   //                                    | '#PCDATA' (S? '|' S? atom)* S? ')*'
-  /*
-  def mixed = {
-    accept( TOKEN_PCDATA );
-    sOpt;
-    if( token == RPAREN )
-      PCDATA_
-    else {
-      val t = choiceRest( PCDATA_ );
-      if( !isMixed( t ) )
-        error("mixed content models must be like (#PCDATA.|.|.|.)*");
-      accept( RPAREN );
-      // lax: (workaround for buggy Java XML parser in JDK1.4.2)
-      if( token == STAR ) accept( STAR );
-      // strict:
-      // accept( STAR );
-      Star( t )
-    }
-  }
-*/
+
   //       '(' S? regexp ::= cp S? [seqRest|choiceRest] ')' [ '+' | '*' | '?' ]
   def regexp: RegExp = {
     val p = particle;
     sOpt;
-    maybeSuffix( token match {
+    maybeSuffix(token match {
       case RPAREN  => nextToken; p
       case CHOICE  => val q = choiceRest( p );accept( RPAREN ); q
       case COMMA   => val q = seqRest( p );   accept( RPAREN ); q
diff --git a/src/library/scala/xml/parsing/MarkupHandler.scala b/src/library/scala/xml/parsing/MarkupHandler.scala
index 62a87f286c..95f7f90ec2 100644
--- a/src/library/scala/xml/parsing/MarkupHandler.scala
+++ b/src/library/scala/xml/parsing/MarkupHandler.scala
@@ -28,37 +28,26 @@ import scala.xml.dtd._
  */
 abstract class MarkupHandler extends Logged
 {
-  // impl. of Logged
-  //def log(msg:String) = {}
-
-  /** returns true is this markup handler is validing */
+  /** returns true is this markup handler is validating */
   val isValidating: Boolean = false
 
   var decls: List[Decl] = Nil
-
   var ent: Map[String, EntityDecl] = new HashMap[String, EntityDecl]()
 
-  def lookupElemDecl(Label: String): ElemDecl =  {
-    def lookup(xs:List[Decl]): ElemDecl = xs match {
-      case (z @ ElemDecl(Label, _)) :: zs => return z
-      case _::zs                        => lookup(zs)
-      case _                            => return null
-    }
-    lookup(decls)
-  }
+  def lookupElemDecl(Label: String): ElemDecl = {
+    for (z @ ElemDecl(Label, _) <- decls)
+      return z
 
-  def replacementText(entityName: String): Source = ent.get(entityName) match {
-    case Some(ParsedEntityDecl(_, IntDef(value))) =>
-      Source.fromString(value)
-    case Some(ParameterEntityDecl(_, IntDef(value))) =>
-      Source.fromString(" "+value+" ")
-    case Some(_) =>
-      Source.fromString("<!-- "+entityName+"; -->")
-    case None =>
-      Source.fromString("<!-- unknown entity "+entityName+"; -->")
+    null
   }
 
- //def checkChildren(pos:int, pre: String, label:String,ns:NodeSeq): Unit = {}
+  def replacementText(entityName: String): Source =
+    Source fromString ((ent get entityName) match {
+      case Some(ParsedEntityDecl(_, IntDef(value)))     => value
+      case Some(ParameterEntityDecl(_, IntDef(value)))  => " %s " format value
+      case Some(_)                                      => "<!-- %s; -->" format entityName
+      case None                                         => "<!-- unknown entity %s; -->" format entityName
+    })
 
   def endDTD(n: String): Unit = ()
 
@@ -93,19 +82,10 @@ abstract class MarkupHandler extends Logged
   def elem(pos: Int, pre: String, label: String, attrs: MetaData, scope: NamespaceBinding, args: NodeSeq): NodeSeq
 
   /** callback method invoked by MarkupParser after parsing PI.
-   *
-   *  @param pos      the position in the source file
-   *  @param target   ...
-   *  @param txt      ...
-   *  @return         ...
    */
   def procInstr(pos: Int, target: String, txt: String): NodeSeq
 
   /** callback method invoked by MarkupParser after parsing comment.
-   *
-   *  @param pos      the position in the source file
-   *  @param comment  ...
-   *  @return         ...
    */
   def comment(pos: Int, comment: String): NodeSeq
 
@@ -124,37 +104,23 @@ abstract class MarkupHandler extends Logged
 
   def attListDecl(name: String, attList: List[AttrDecl]): Unit = ()
 
-  def parameterEntityDecl(name: String, edef: EntityDef) {
-    //log("parameterEntityDecl("+name+","+edef+")");
+  private def someEntityDecl(name: String, edef: EntityDef, f: (String, EntityDef) => EntityDecl): Unit =
     edef match {
-      case _:ExtDef if !isValidating =>
-        ; // ignore (cf REC-xml 4.4.1)
-      case _ =>
-        val y =  ParameterEntityDecl(name, edef)
-        decls = y :: decls
+      case _: ExtDef if !isValidating =>  // ignore (cf REC-xml 4.4.1)
+      case _  =>
+        val y = f(name, edef)
+        decls ::= y
         ent.update(name, y)
-        //log("ent.get(..) = "+ent.get(name))
     }
-  }
 
-  def parsedEntityDecl(name: String, edef: EntityDef): Unit = edef match {
-    case _:ExtDef if !isValidating =>
-      ; // ignore (cf REC-xml 4.8 and 4.4.1)
-    case _ =>
-      val y = ParsedEntityDecl(name, edef)
-      decls = y :: decls
-      ent.update(name, y)
-  }
+  def parameterEntityDecl(name: String, edef: EntityDef): Unit =
+    someEntityDecl(name, edef, ParameterEntityDecl.apply _)
 
-  def unparsedEntityDecl(name: String, extID: ExternalID, notat: String): Unit =
-    {}
+  def parsedEntityDecl(name: String, edef: EntityDef): Unit =
+    someEntityDecl(name, edef, ParsedEntityDecl.apply _)
 
+  def peReference(name: String) { decls ::= PEReference(name) }
+  def unparsedEntityDecl(name: String, extID: ExternalID, notat: String): Unit = ()
   def notationDecl(notat: String, extID: ExternalID): Unit = ()
-
-  def peReference(name: String) { decls = PEReference(name) :: decls }
-
-  /** report a syntax error */
   def reportSyntaxError(pos: Int, str: String): Unit
-
-}
-
+}
\ No newline at end of file