cleanup and slight extension to xml literal par...

cleanup and slight extension to xml literal parsing

3 files changed, 93 insertions, 87 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
index 17ed08ae6c..0e9d96b330 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
@@ -232,6 +232,60 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean
     }
   }
 
+
+  /** adds entity/character to to ts as side-effect
+   *  @precond ch == '&'
+   */
+  def content_AMP(ts:mutable.ArrayBuffer[Tree]): Unit = {
+    nextch;
+    ch match {
+    case '#' => // CharacterRef
+      nextch;
+      val theChar = handle.text( tmppos, xCharRef );
+      xToken(';');
+      ts.append( theChar );
+    case _ => // EntityRef
+      val n = xName ;
+      xToken(';');
+      ts.append( handle.entityRef( tmppos, n ) );
+    }
+  }
+
+  /**
+   *  @precond ch == '{'
+   *  @postcond: xEmbeddedBlock == false!
+   */
+  def content_BRACE(p:Int, ts:mutable.ArrayBuffer[Tree]): Unit = {
+    if( xCheckEmbeddedBlock ) {
+      ts.append(xEmbeddedExpr);
+    } else {
+      val str = new StringBuffer("{");
+      str.append( xText );
+      appendText(p, ts, str.toString());
+    }
+  }
+
+  /** returns true if it encounters an end tag (without consuming it), appends trees to ts as side-effect
+   */
+  def content_LT(ts:mutable.ArrayBuffer[Tree]): Boolean = {
+    ch match {
+      case '/' =>
+        return true                  // end tag
+      case '!' =>
+        nextch;
+        if( '[' == ch )           // CDATA
+          ts.append( xCharData );
+        else                      // comment
+          ts.append( xComment );
+      case '?' =>                 // PI
+        nextch;
+        ts.append( xProcInstr );
+      case _   =>
+        ts.append( element );     // child node
+    }
+    return false
+  }
+
   /*[Duplicate]*/ def content: mutable.Buffer[Tree] = {
     var ts = new mutable.ArrayBuffer[Tree];
     var exit = false;
@@ -241,47 +295,14 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean
       } else {
         tmppos = pos;
         ch match {
-          case '<' => // another tag
-            nextch;
-            ch match {
-              case '/' =>
-                exit = true;                    // end tag
-              case '!' =>
-                nextch;
-                if( '[' == ch )                 // CDATA
-                  ts.append( xCharData );
-                else                            // comment
-                  ts.append( xComment );
-              case '?' =>                       // PI
-                nextch;
-                ts.append( xProcInstr );
-              case _   =>
-                ts.append( element );     // child
-            }
-
-          case '{' =>
-            if( xCheckEmbeddedBlock ) {
-              ts.append(xEmbeddedExpr);
-            } else {
-              val str = new StringBuffer("{");
-              str.append( xText );
-              appendText(tmppos, ts, str.toString());
-            }
-          // postcond: xEmbeddedBlock == false!
+          case '<' => // end tag, cdata, comment, pi or child node
+            nextch
+            exit = content_LT(ts)
+          case '{' => // either the character '{' or an embedded scala block
+            content_BRACE(tmppos, ts)
           case '&' => // EntityRef or CharRef
-            nextch;
-            ch match {
-              case '#' => // CharacterRef
-                nextch;
-              val theChar = handle.text( tmppos, xCharRef );
-              xToken(';');
-              ts.append( theChar );
-              case _ => // EntityRef
-                val n = xName ;
-                xToken(';');
-                ts.append( handle.entityRef( tmppos, n ) );
-            }
-          case _ => // text content
+            content_AMP(ts)
+          case _ =>  // text content
             appendText(tmppos, ts, xText);
           // here xEmbeddedBlock might be true
         }
@@ -410,33 +431,41 @@ class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, presWS: boolean
    * precondition: s.xStartsXML == true
   */
   def xLiteral: Tree = try {
-    init;
-    handle.isPattern = false;
-    val pos = s.currentPos;
-    var lastend = 0;
-    var lastch  = ch;
-    var tree = element;
-    lastend = s.in.bp;
-    lastch  = s.in.ch;
+    //Console.println("entering xLiteral!!")
+    init
+    handle.isPattern = false
+    val pos = s.currentPos
+    var lastend = 0
+    var lastch  = ch
+    //var tree = element;
+    var tree:Tree = null
+    val ts = new mutable.ArrayBuffer[Tree]()
+    content_LT(ts)
+    //Console.println("xLiteral:ts = "+ts.toList)
+    lastend = s.in.bp
+    lastch  = s.in.ch
     //if (settings.debug.value) {
     //  Console.println("DEBUG 1: I am getting char '"+ch+"' at lastend "+lastend+" pos = "+pos); // DEBUG
     //}
-    xSpaceOpt;
+    xSpaceOpt
     // parse more XML ?
     if (ch == '<') {
-      val ts = new mutable.ArrayBuffer[Tree]();
-      ts.append( tree );
+      //val ts = new mutable.ArrayBuffer[Tree]();
+      //ts.append( tree );
       while( ch == '<' ) {
-        nextch;
-        ts.append( element );
-	lastend = s.in.bp;
-	lastch  = s.in.ch;
-        xSpaceOpt;
+        nextch
+        ts.append( element )
+	lastend = s.in.bp
+	lastch  = s.in.ch
+        xSpaceOpt
       }
-      tree = handle.makeXMLseq( pos, ts );
+      tree = handle.makeXMLseq( pos, ts )
+    } else {
+      assert(ts.length == 1)
+      tree = ts(0)
     }
-    s.in.bp = lastend; // ugly hack
-    s.in.ch = lastch;
+    s.in.bp = lastend // ugly hack
+    s.in.ch = lastch
     //if (settings.debug.value) {
     //  Console.println("DEBUG 2: restoring char '"+lastch+"' at lastend "+lastend+" pos = "+pos); // DEBUG
     //}
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala
index f329bcbc36..be75af64b3 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala
@@ -236,7 +236,7 @@ trait Scanners requires SyntaxAnalyzer {
               val last = in.last
               in.next
               last match {
-                case ' '|'\t'|'\n'|'{'|'('|'>' if xml.Parsing.isNameStart(in.ch) =>
+                case ' '|'\t'|'\n'|'{'|'('|'>' if xml.Parsing.isNameStart(in.ch) || in.ch == '!' || in.ch == '?' =>
                   token = XMLSTART
                 case _ =>
                   // Console.println("found '<', but last is '"+in.last+"'"); // DEBUG
diff --git a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
index b4a1b07809..b61ea79017 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/SymbolicXMLBuilder.scala
@@ -44,7 +44,6 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
    _toList              ,
    _xml                 ,
    _Comment             ,
-   _CharData            ,
    _Node                ,
    _ProcInstr           ,
    _Text                ,
@@ -71,7 +70,6 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
   private def _scala_xml_NodeBuffer         = _scala_xml( _NodeBuffer );
   private def _scala_xml_EntityRef          = _scala_xml( _EntityRef );
   private def _scala_xml_Comment            = _scala_xml( _Comment );
-  private def _scala_xml_CharData           = _scala_xml( _CharData );
   private def _scala_xml_ProcInstr          = _scala_xml( _ProcInstr );
   private def _scala_xml_Text               = _scala_xml( _Text );
   private def _scala_xml_Elem               = _scala_xml( _Elem );
@@ -127,7 +125,9 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
 
   // create scala.xml.Text here <: scala.xml.Node
   def makeTextPat(txt:Tree ) = Apply(_scala_xml_Text, List(txt));
-  def makeText1(txt:Tree )   = New( _scala_xml_Text, LL( txt ));
+  def makeText1(txt:Tree )   = {
+    New( _scala_xml_Text, LL( txt ));
+  }
 
   // create
   def comment( pos: int, text: String ):Tree =
@@ -135,13 +135,12 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
 
   // create
   def charData( pos: int, txt: String ):Tree =
-    atPos(pos) { CharData( Literal(Constant(txt))) };
+    atPos(pos) { makeText1(Literal(Constant(txt))) }; //{ CharData( Literal(Constant(txt))) };
 
   // create scala.xml.Text here <: scala.xml.Node
   def procInstr( pos: int, target: String, txt: String ) =
     atPos(pos) { ProcInstr(Literal(Constant(target)), Literal(Constant(txt))) };
 
-  protected def CharData(txt: Tree) = New( _scala_xml_CharData, LL(txt));
   protected def Comment(txt: Tree)  = New( _scala_xml_Comment, LL(txt));
   protected def ProcInstr(target: Tree, txt: Tree) =
     New(_scala_xml_ProcInstr, LL( target, txt ));
@@ -201,28 +200,6 @@ abstract class SymbolicXMLBuilder(make: TreeBuilder, p: Parsers # Parser, preser
     if( i != -1 ) Some( name.substring(0, i) ) else None
   }
 
-  /** splits */
-  protected def qualifiedAttr( pos:Int, namespace:String, name:String ):Pair[String,String] = {
-    getPrefix( name ) match {
-      case Some( pref ) =>
-        val newLabel = name.substring( pref.length()+1, name.length() );
-        // if( newLabel.indexOf(':') != -1 )  syntaxError
-        Pair( "namespace$"+pref, newLabel );
-      case None =>
-        Pair( namespace, name );
-    }
-  }
-  protected def qualified( pos:Int, name:String ):Pair[String,String] =
-    getPrefix( name ) match {
-      case Some( pref ) =>
-        val newLabel = name.substring( pref.length()+1, name.length() );
-        // if( newLabel.indexOf(':') != -1 )  syntaxError
-        Pair( "namespace$"+pref, newLabel );
-      case None =>
-        Pair( "namespace$default", name );
-    }
-
-
   /** 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+")");