xml lib

5 files changed, 37 insertions, 30 deletions

diff --git a/sources/scala/xml/parsing/AttribValue.scala b/sources/scala/xml/parsing/AttribValue.scala
index 7dc25f2238..3557e49bf3 100644
--- a/sources/scala/xml/parsing/AttribValue.scala
+++ b/sources/scala/xml/parsing/AttribValue.scala
@@ -1,8 +1,17 @@
 package scala.xml.parsing ;
 
 /** a container for attribute values */
-trait AttribValue;
+trait AttribValue {
+  def asString: String = this match {
+    case CDataValue(value) => value;
+  }
+  def asInt: Int = this match {
+    case IntValue(value) => value;
+  }
+};
 
 case class NamespaceDecl(uri: String) extends AttribValue;
 case class CDataValue(value: String) extends AttribValue;
 case class CustomValue[A](value:A) extends AttribValue;
+
+case class IntValue(value: Int) extends AttribValue;
diff --git a/sources/scala/xml/parsing/ConstructingHandler.scala b/sources/scala/xml/parsing/ConstructingHandler.scala
index 2b7a1b7bb0..f58dac7b21 100644
--- a/sources/scala/xml/parsing/ConstructingHandler.scala
+++ b/sources/scala/xml/parsing/ConstructingHandler.scala
@@ -4,7 +4,7 @@ import scala.collection.immutable.Map ;
 import scala.collection.mutable ;
 
 /** */
-class ConstructingHandler extends MarkupHandler[Node,String] {
+class ConstructingHandler extends MarkupHandler[Node] {
 
   def attributeCDataValue(pos: int, str:String) = CDataValue(str);
 
@@ -35,7 +35,7 @@ class ConstructingHandler extends MarkupHandler[Node,String] {
       }
     }
     val ch: Seq[Node] = nodes;
-    Elem(uri, label, AttributeSeq.fromAttrs(attrSeq:_*), ch:_*);
+    Some(Elem(uri, label, AttributeSeq.fromAttrs(attrSeq:_*), ch:_*));
   };
 
   def charData(pos: Int, txt: String ) =
diff --git a/sources/scala/xml/parsing/ConstructingParser.scala b/sources/scala/xml/parsing/ConstructingParser.scala
index cfa92a89f8..bac49c06e3 100644
--- a/sources/scala/xml/parsing/ConstructingParser.scala
+++ b/sources/scala/xml/parsing/ConstructingParser.scala
@@ -3,7 +3,7 @@ package scala.xml.parsing ;
 
 /** an xml parser. parses XML and invokes callback methods of a MarkupHandler
  */
-abstract class ConstructingParser extends MarkupParser[Node, String] {
+abstract class ConstructingParser extends MarkupParser[Node] {
 
   val handle = new ConstructingHandler();
 
diff --git a/sources/scala/xml/parsing/MarkupHandler.scala b/sources/scala/xml/parsing/MarkupHandler.scala
index 9b6348ac54..945f053a8e 100644
--- a/sources/scala/xml/parsing/MarkupHandler.scala
+++ b/sources/scala/xml/parsing/MarkupHandler.scala
@@ -4,8 +4,8 @@ import scala.collection.immutable ;
 import scala.collection.mutable ;
 import scala.collection.Map ;
 
-/** @todo: make ConstructingMarkupHandler */
-abstract class MarkupHandler[MarkupType, AVType] {
+/** class that handles markup - provides callback methods to MarkupParser */
+abstract class MarkupHandler[MarkupType] {
 
   /** a stack of prefix namespace mappings */
   protected val prefixStack =
@@ -51,25 +51,23 @@ abstract class MarkupHandler[MarkupType, AVType] {
   def attributeCDataValue(pos: int, str:String): AttribValue;
   def attributeNamespaceDecl(pos: int, uri: String): AttribValue;
 
-  final def attribute(pos: int, key: String, value:String): AttribValue =
+  def attribute(pos: int, key: String, value:String): AttribValue =
     if( key.startsWith("xmlns"))
       attributeNamespaceDecl(pos, value);
     else
       attributeCDataValue(pos, value);
 
-
-
   /** be careful to copy everything from attrMap1, as it will change
    *  @param attrMap1 the attribute map.
    */
-  def element(pos: int, uri: String, label: String, attrMap1: mutable.Map[String,AttribValue], args: mutable.Buffer[MarkupType]): MarkupType;
+  def element(pos: int, uri: String, label: String, attrMap1: mutable.Map[String,AttribValue], args: mutable.Buffer[MarkupType]): Iterable[MarkupType];
 
-  def charData(pos: Int, txt: String ): MarkupType;
-  def procInstr(pos: Int, target: String, txt: String): MarkupType;
-  def comment(pos: Int, comment: String ): MarkupType;
-  def entityRef(pos: Int, n: String): MarkupType;
+  def charData(pos: Int, txt: String ): Iterable[MarkupType];
+  def procInstr(pos: Int, target: String, txt: String): Iterable[MarkupType];
+  def comment(pos: Int, comment: String ): Iterable[MarkupType];
+  def entityRef(pos: Int, n: String): Iterable[MarkupType];
 
-  def text(pos: Int, txt:String): MarkupType;
+  def text(pos: Int, txt:String): Iterable[MarkupType];
 
 
   def internal_startPrefixMapping(pref: Map[String, String]) = {
diff --git a/sources/scala/xml/parsing/MarkupParser.scala b/sources/scala/xml/parsing/MarkupParser.scala
index e92a78d696..e5982a6930 100644
--- a/sources/scala/xml/parsing/MarkupParser.scala
+++ b/sources/scala/xml/parsing/MarkupParser.scala
@@ -16,10 +16,10 @@ import scala.collection.immutable.ListMap;
  *  and returns whatever the markup handler returns. Use ConstructingParser
  *  if you just want to parse XML to construct instances of scala.xml.Node.
  */
-abstract class MarkupParser[MarkupType, AVType] {
+abstract class MarkupParser[MarkupType] {
 
   /** the handler of the markup */
-  val handle: MarkupHandler[MarkupType, AVType];
+  val handle: MarkupHandler[MarkupType];
 
   /** if true, does not remove surplus whitespace */
   val preserveWS: Boolean;
@@ -159,7 +159,7 @@ abstract class MarkupParser[MarkupType, AVType] {
    *
    * see [15]
    */
-  def xCharData: MarkupType = {
+  def xCharData: Iterable[MarkupType] = {
     xToken('[');
     xToken('C');
     xToken('D');
@@ -215,7 +215,7 @@ abstract class MarkupParser[MarkupType, AVType] {
    *
    * see [15]
    */
-  def xComment: MarkupType = {
+  def xComment: Iterable[MarkupType] = {
     val sb: StringBuffer = new StringBuffer();
     xToken('-');
     xToken('-');
@@ -234,10 +234,10 @@ abstract class MarkupParser[MarkupType, AVType] {
   def appendText(pos: Int, ts: mutable.Buffer[MarkupType], txt: String): Unit = {
     if (!preserveWS)
       for (val t <- TextBuffer.fromString(txt).toText) {
-        ts.append(handle.text(pos, t.text));
+        ts.appendAll(handle.text(pos, t.text));
       }
     else
-      ts.append(handle.text(pos, txt));
+      ts.appendAll(handle.text(pos, txt));
   }
 
   def content: mutable.Buffer[MarkupType] = {
@@ -257,19 +257,19 @@ abstract class MarkupParser[MarkupType, AVType] {
               case '!' =>
                 nextch;
                 if ('[' == ch)                 // CDATA
-                  ts.append(xCharData);
+                  ts.appendAll(xCharData);
                 else                            // comment
-                  ts.append(xComment);
+                  ts.appendAll(xComment);
               case '?' =>                       // PI
                 nextch;
-                ts.append(xProcInstr);
+                ts.appendAll(xProcInstr);
               case _   =>
-                ts.append(element);     // child
+                ts.appendAll(element);     // child
             }
 
           case '{' =>
 /*            if( xCheckEmbeddedBlock ) {
-              ts.append(xEmbeddedExpr);
+              ts.appendAll(xEmbeddedExpr);
             } else {*/
               val str = new StringBuffer("{");
               str.append(xText);
@@ -283,11 +283,11 @@ abstract class MarkupParser[MarkupType, AVType] {
                 nextch;
               val theChar = handle.text( tmppos, xCharRef );
               xToken(';');
-              ts.append( theChar );
+              ts.appendAll( theChar );
               case _ => // EntityRef
                 val n = xName ;
                 xToken(';');
-                ts.append( handle.entityRef( tmppos, n ) );
+                ts.appendAll( handle.entityRef( tmppos, n ) );
             }
           case _ => // text content
             appendText(tmppos, ts, xText);
@@ -301,7 +301,7 @@ abstract class MarkupParser[MarkupType, AVType] {
   /** '&lt;' element ::= xmlTag1 '&gt;'  { xmlExpr | '{' simpleExpr '}' } ETag
    *               | xmlTag1 '/' '&gt;'
    */
-  def element: MarkupType = {
+  def element: Iterable[MarkupType] = {
     xSpaceOpt; // @todo: move this to init
     xToken('<');
     var pref: Map[String, String] = _;
@@ -378,7 +378,7 @@ abstract class MarkupParser[MarkupType, AVType] {
    *
    * see [15]
    */
-  def xProcInstr: MarkupType = {
+  def xProcInstr: Iterable[MarkupType] = {
     val sb:StringBuffer = new StringBuffer();
     val n = xName;
     if( xml.Parsing.isSpace( ch ) ) {