xml improvements for 2.2.1 (see changes)

3 files changed, 74 insertions, 14 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala
index 916736bda4..9f9ce71c7e 100644
--- a/src/compiler/scala/tools/nsc/ast/TreePrinters.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreePrinters.scala
@@ -280,7 +280,7 @@ abstract class TreePrinters {
           print("this")
 
         case Select(qual @ New(tpe), name) =>
-          assert(tree.symbol == null || tree.symbol.isConstructor)
+          assert(tree.symbol == null || tree.symbol.isConstructor || phase.prev.name == "parser")
           print(qual)
 
         case Select(qualifier, name) =>
diff --git a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
index f2e31ed6ce..0adf872a81 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
@@ -91,7 +91,14 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean
           nextch
           val tmp = xAttributeValue(delim)
           nextch
-          Literal(Constant(tmp))
+          try {
+            handle.parseAttribute(pos1, tmp)
+          } catch {
+            case e =>
+              reportSyntaxError("error parsing attribute value")
+              p.errorTermTree
+          }
+
         case '{'  =>
           nextch
           xEmbeddedExpr
@@ -181,6 +188,34 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean
     Predef.error("this cannot happen")
   }
 
+  def xUnparsed: Tree = {
+    val pos1 = pos
+    val sb: StringBuffer = new StringBuffer()
+    while (true) {
+      if (ch=='<' &&
+         { sb.append(ch); nextch; ch == '/' } &&
+         { sb.append(ch); nextch; ch == 'x' } &&
+         { sb.append(ch); nextch; ch == 'm' } &&
+         { sb.append(ch); nextch; ch == 'l' } &&
+         { sb.append(ch); nextch; ch == ':' } &&
+         { sb.append(ch); nextch; ch == 'u' } &&
+         { sb.append(ch); nextch; ch == 'n' } &&
+         { sb.append(ch); nextch; ch == 'p' } &&
+         { sb.append(ch); nextch; ch == 'a' } &&
+         { sb.append(ch); nextch; ch == 'r' } &&
+         { sb.append(ch); nextch; ch == 's' } &&
+         { sb.append(ch); nextch; ch == 'e' } &&
+         { sb.append(ch); nextch; ch == 'd' } &&
+         { sb.append(ch); nextch; ch == '>' }) {
+        sb.setLength(sb.length - "</xml:unparsed".length)
+        nextch
+        return handle.unparsed(pos1, sb.toString())
+      } else sb.append(ch)
+      nextch
+    }
+    Predef.error("this cannot happen")
+  }
+
   /** CharRef ::= "&#" '0'..'9' {'0'..'9'} ";"
    *            | "&#x" '0'..'9'|'A'..'F'|'a'..'f' { hexdigit } ";"
    *
@@ -339,14 +374,17 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean
     }
     else { // handle content
       xToken('>')
+      if(qname == "xml:unparsed")
+        return xUnparsed
+
       debugLastStartElement.push(Pair(pos1, qname))
       val ts = content
       xEndTag(qname)
       debugLastStartElement.pop
-      if(qname=="xml:group")
-        handle.group(pos1, ts)
-      else
-        handle.element(pos1, qname, attrMap, ts)
+      qname match {
+        case "xml:group"   => handle.group(pos1, ts)
+        case _ => handle.element(pos1, qname, attrMap, ts)
+      }
     }
   }
 
diff --git a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
index 3a14035312..1d6b1319a7 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
@@ -9,7 +9,7 @@ package scala.tools.nsc.ast.parser
 import scala.collection.immutable.{Map, ListMap}
 import scala.collection.mutable
 import scala.tools.nsc.util.Position
-import scala.xml.{Text, TextBuffer}
+import scala.xml.{EntityRef, Text, TextBuffer}
 import symtab.Flags.MUTABLE
 
 /** This class builds instance of Tree that represent XML.
@@ -37,6 +37,7 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
   def _UnprefixedAttribute = global.newTypeName("UnprefixedAttribute")
   def _Elem                = global.newTypeName("Elem")
   def _Group               = global.newTypeName("Group")
+  def _Unparsed            = global.newTypeName("Unparsed")
   def _Seq                 = global.newTypeName("Seq")
   def _immutable           = global.newTermName("immutable")
   def _mutable             = global.newTermName("mutable")
@@ -79,6 +80,7 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
   private def _scala_xml_Elem               = _scala_xml(_Elem)
   private def _scala_xml_Attribute          = _scala_xml(_Attribute)
   private def _scala_xml_Group              = _scala_xml(_Group)
+  private def _scala_xml_Unparsed           = _scala_xml(_Unparsed)
 
   /*
   private def bufferToArray(buf: mutable.Buffer[Tree]): Array[Tree] = {
@@ -99,11 +101,10 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
 
   protected def mkXML(pos: int, isPattern: boolean, pre: Tree, label: Tree, attrs: /*Array[*/Tree/*]*/ , scope:Tree, children: mutable.Buffer[Tree]): Tree = {
     if (isPattern) {
-      //val ts = new mutable.ArrayBuffer[Tree]()
       convertToTextPat(children)
-      atPos (pos) {
+      atPos (pos) { //@todo maybe matching on attributes, scope?
         Apply( _scala_xml_Elem, List(
-          pre, label, Ident( nme.WILDCARD ) /* attributes? */ , Ident( nme.WILDCARD )) /* scope? */ ::: children.toList )
+          pre, label, Ident( nme.WILDCARD ) /* md */ , Ident( nme.WILDCARD )) /* scope */ ::: children.toList )
       }
     } else {
       var ab = List(pre, label, attrs, scope);
@@ -167,6 +168,20 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
     case _ => t
   }
 
+  def parseAttribute(pos: Int, s: String): Tree = {
+    val ns = xml.Utility.parseAttributeValue(s)
+    val ts:collection.mutable.ListBuffer[Tree] = new collection.mutable.ListBuffer
+    val it = ns.elements
+    while(it.hasNext) it.next match {
+      case Text(s)      => ts += text(pos, s) // makeText1(Literal(Constant(s)))
+      case EntityRef(s) => ts += entityRef(pos, s)
+    }
+    ts.length match {
+      case 0 => gen.mkNil
+      case 1 => val t = ts(0); ts.clear; t
+      case _ => makeXMLseq(pos, ts)
+    }
+  }
   protected def convertToTextPat(buf: mutable.Buffer[Tree]): Unit = {
     var i = 0; while (i < buf.length) {
       val t1 = buf(i)
@@ -208,6 +223,12 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
     atPos(pos) { New( _scala_xml_Group, LL( makeXMLseq(pos, args))) }
   }
 
+  /** code that constructs an unparsed node
+  */
+  def unparsed(pos: int, str: String): Tree = {
+    atPos(pos) { New( _scala_xml_Unparsed, LL( Literal(Constant(str)))) }
+  }
+
   /** makes an element */
   def element(pos: int, qname: String, attrMap: mutable.Map[String,Tree], args: mutable.Buffer[Tree]): Tree = {
     //Console.println("SymbolicXMLBuilder::element("+pos+","+qname+","+attrMap+","+args+")");
@@ -216,10 +237,11 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
     var tlist: List[Tree] = List()
 
     /* pre can be null */
-    def handleNamespaceBinding(pre:String , uri:Tree): Unit = {
-      val t = Assign(Ident(_tmpscope), New( _scala_xml_NamespaceBinding,
-        LL(Literal(Constant(pre)), uri, Ident( _tmpscope))));
-      tlist = t :: tlist
+    def handleNamespaceBinding(pre:String , uri1: Tree): Unit = uri1 match {
+      case Apply(_,List(uri @ Literal(Constant(_)))) => //text
+        val t = Assign(Ident(_tmpscope), New( _scala_xml_NamespaceBinding,
+                                             LL(Literal(Constant(pre)), uri, Ident( _tmpscope))));
+        tlist = t :: tlist
       //Console.println("SymbolicXMLBuilder::handleNamespaceBinding:");
       //Console.println(t.toString());
     }