modified xml parsing

Author: buraq

sources/scala/xml/Attribute.scala

@@ -19,6 +19,8 @@ package scala.xml ;
  */
 case class Attribute(namespace:String, key:String, value:String) with Ordered[Attribute] {
 
+  def intValue: Int = Integer.parseInt(value);
+
   def compareTo [b >: Attribute <% Ordered[b]](that: b): int = that match {
     case z:Attribute =>
       val i = key.compareTo( z.key );
@@ -27,3 +29,8 @@ case class Attribute(namespace:String, key:String, value:String) with Ordered[At
   }
 
 }
+
+class IntAttribute(namespace:String, key:String, theIntValue:Int)
+extends Attribute(namespace, key, theIntValue.toString()) {
+  final override def intValue = theIntValue;
+}

sources/scala/xml/parsing/ConstructingHandler.scala

@@ -6,21 +6,24 @@ import scala.collection.mutable ;
 /** */
 class ConstructingHandler extends MarkupHandler[Node] {
 
-  def attributeCDataValue(pos: int, str:String) = CDataValue(str);
+  //def attributeCDataValue(pos: int, str:String) = CDataValue(str);
 
-  def attributeNamespaceDecl(pos: int, uri: String) = NamespaceDecl(uri);
+  //def attributeNamespaceDecl(pos: int, uri: String) = NamespaceDecl(uri);
 
-  def element(pos: int, uri: String, label: String, attrMap1: mutable.Map[Pair[String,String],AttribValue], args: mutable.Buffer[Node]) = {
+  def element(pos: int, uri: String, label: String, attrMap1: mutable.Map[Pair[String,String],Attribute], args: mutable.Buffer[Node]) = {
 
     var attrs = new Array[Attribute](attrMap1.size);
     {
       var i = 0;
       val it = attrMap1.elements;
       while( it.hasNext ) {
-        val Pair(Pair(uri:String, key:String), va: AttribValue) = it.next;
+        val Pair(Pair(uri:String, key:String), va: Attribute) = it.next;
+        attrs( i ) = va;
+        /*
         va match {
           case CDataValue(str) => attrs( i ) = Attribute(uri, key, str);
         }
+        */
         i = i + 1;
       }
     }

sources/scala/xml/parsing/MarkupHandler.scala

@@ -27,46 +27,18 @@ abstract class MarkupHandler[A] {
     if( i != -1 ) Some( name.substring(0, i) ) else None
   }
 
-  /** removes xmlns attributes from attr as a side effect, and returns a prefix
-   *  map resulting from them
-   * /
-  final def namespaceDecl1(aMap: mutable.Map[String, AttribValue]): Map[String, String] = {
-    val setNS = new mutable.HashMap[String, String];
-    / * DEBUG * /
-    val attrIt = aMap.keys;
-    while( attrIt.hasNext ) {
-      val z = attrIt.next;
-      if( z.startsWith("xmlns") ) {
-        val uri = aMap( z ) match {
-          case NamespaceDecl(uri1) => uri1;
-          case _                   => throw FatalError("bad namespace declaration");
-        }
-        val i = z.indexOf(':');
-        if( i == -1 )
-          setNS.update("", uri );
-        else {
-          val zz = z.substring( i+1, z.length() );
-          setNS.update( zz, uri );
-        }
-        aMap -= z;
-      }
-    }
-    setNS;
-  }
-  */
-
   /** removes xmlns attributes from attr as a side effect, and returns a prefix
    *  map resulting from them
    */
   final def internal_namespaceDecl(prefix:String, uri:String): Unit = {
     tmpPrefix.update(prefix, uri);
   }
 
-  def attributeCDataValue(pos: int, str:String): AttribValue;
-  def attributeNamespaceDecl(pos: int, uri: String): AttribValue;
+  //def attributeCDataValue(pos: int, str:String): Attribute;
+  //def attributeNamespaceDecl(pos: int, uri: String): Attribute;
 
-  def attribute(pos: int, uri: String, key: String, value:String): AttribValue =
-    attributeCDataValue(pos, value);
+  def attribute(pos: int, uri: String, key: String, value:String) =
+    Attribute(uri,key,value);
 
   /** be careful to copy everything from attrMap1, as it will change
    *  @param pos      the position in the sourcefile
@@ -75,7 +47,7 @@ abstract class MarkupHandler[A] {
    *  @param attrMap1 the attribute map, from Pair(uri,label) to target
    *  @param args     the children of this element
    */
-  def element(pos: int, uri: String, label: String, attrMap1: mutable.Map[Pair[String,String],AttribValue], args: mutable.Buffer[A]): Iterable[A];
+  def element(pos: int, uri: String, label: String, attrMap1: mutable.Map[Pair[String,String],Attribute], args: mutable.Buffer[A]): Iterable[A];
 
   def charData(pos: Int, txt: String ): Iterable[A];
   def procInstr(pos: Int, target: String, txt: String): Iterable[A];

sources/scala/xml/parsing/MarkupParser.scala

@@ -9,6 +9,7 @@
 
 package scala.xml.parsing;
 
+import scala.xml.Attribute;
 import scala.collection.{ mutable, Map };
 import scala.collection.immutable.ListMap;
 
@@ -39,10 +40,10 @@ abstract class MarkupParser[MarkupType] {
   /** append Unicode character to name buffer*/
   protected def putChar(c: Char) = cbuf.append(c);
 
-  protected var aMap: mutable.Map[String,AttribValue] = _;
+  protected var aMap: mutable.Map[String,Attribute] = _;
 
   final val noChildren = new mutable.ListBuffer[MarkupType];
-  final val noAttribs  = new mutable.HashMap[Pair[String,String], AttribValue];
+  final val noAttribs  = new mutable.HashMap[Pair[String,String], Attribute];
 
   //var xEmbeddedBlock = false;
 
@@ -132,7 +133,7 @@ abstract class MarkupParser[MarkupType] {
     }
     // @todo, iterate over attributes, replace prefix, call handleAttribute.
     handle.internal_startPrefixMapping;
-    val aMap1 = new mutable.HashMap[Pair[String,String],AttribValue];
+    val aMap1 = new mutable.HashMap[Pair[String,String],Attribute];
     val it = aMap.elements;
     while( it.hasNext ) {
       val x @ Pair(Pair(pref,key),Pair(pos,value)) = it.next;
@@ -169,11 +170,11 @@ abstract class MarkupParser[MarkupType] {
    *  [40] STag         ::= '<' Name { S Attribute } [S]
    *  [44] EmptyElemTag ::= '<' Name { S Attribute } [S]
    */
-  protected def xTag: Pair[String, mutable.Map[Pair[String,String],AttribValue]] = {
+  protected def xTag: Pair[String, mutable.Map[Pair[String,String],Attribute]] = {
     val elemqName = xName;
 
     xSpaceOpt;
-    val aMap: mutable.Map[Pair[String,String],AttribValue] =
+    val aMap: mutable.Map[Pair[String,String],Attribute] =
       if(xml.Parsing.isNameStart( ch )) {
         xAttributes;
       } else {