refactoring, less dependency XML parser and Sca...

refactoring, less dependency XML parser and Scala parser

3 files changed, 362 insertions, 349 deletions

diff --git a/sources/scala/tools/scalac/ast/parser/MarkupParser.scala b/sources/scala/tools/scalac/ast/parser/MarkupParser.scala
index fd2085e7d3..f8799e4f66 100644
--- a/sources/scala/tools/scalac/ast/parser/MarkupParser.scala
+++ b/sources/scala/tools/scalac/ast/parser/MarkupParser.scala
@@ -17,17 +17,16 @@ import scala.tools.scalac.util.NewArray;
 import scala.collection.immutable.ListMap ;
 import scala.collection.mutable.Buffer;
 import scala.xml.{Text,TextBuffer};
-import scalac.util.Name;
 
 package scala.tools.scalac.ast.parser {
 
-class MarkupParser( unit: CompilationUnit, s:Scanner, p:Parser, preserveWS:boolean ) {
+class MarkupParser(unit: CompilationUnit, s: Scanner, p: Parser, trimWS: boolean ) {
 
   import Tokens.{EMPTY, LBRACE, RBRACE} ;
   import scala.tools.scalac.ast.{TreeList => myTreeList}
 
   /** the XML tree factory */
-  val mk = new SymbolicXMLBuilder( unit.global.make, unit.global.treeGen, p, preserveWS );
+  val mk = new SymbolicXMLBuilder( unit.global.make, unit.global.treeGen, p, trimWS );
 
   /** the XML tree builder */
   val gen = unit.global.treeGen ;
@@ -36,22 +35,92 @@ class MarkupParser( unit: CompilationUnit, s:Scanner, p:Parser, preserveWS:boole
   final val PATTERN = true;
   final val EXPR    = false;
 
+  val cbuf = new StringBuffer();
+
+  /** append Unicode character to name buffer*/
+  private def putChar(c: char) = cbuf.append( c );
+
   /** xLiteral = xExpr { xExpr }
    * @return Scala representation of this xml literal
    * precondition: s.xStartsXML == true
   */
-  def xLiteral:Tree = {
+  def xLiteral: Tree = {
+    init;
     mode = EXPR;
     val pos = s.pos;
-    var tree = xExpr; s.token = EMPTY; s.nextToken();
-    if( s.xStartsXML )  {
+    var tree = xExpr; xSpaceOpt;
+    if( ch=='<' )  {
       val ts = new myTreeList(); ts.append( tree );
-      while( s.xStartsXML ) { ts.append( xExpr ); s.nextToken(); }
+      while( ch == '<' ) {
+        nextch;
+        ts.append( xExpr );
+        xSpaceOpt;
+      }
       tree = mk.makeXMLseq( pos, ts.toArray() );
     }
+    //Console.println("out of xLiteral, parsed:"+tree.toString());
+    s.xSync2;
     tree
   }
 
+  /** @see xmlPattern. resynchronizes after succesful parse
+   * @return this xml pattern
+   * precondition: s.xStartsXML == true
+  */
+  def xLiteralPattern:Tree = {
+    init;
+    val oldMode = mode;
+    mode = PATTERN;
+    val pos = s.pos;
+    var tree = xPattern; xSpaceOpt;
+    if( ch == '<' )  {
+      val ts = new myTreeList(); ts.append( tree );
+      while( ch == '<' && lookahead != '-' ) {
+        nextch;
+        ts.append( xPattern );
+        xSpaceOpt;
+      }
+      tree = mk.makeXMLseqPat( pos, ts.toArray() );
+    }
+    mode = oldMode;
+    //Console.println("out of xLiteralPattern, parsed:"+tree.toString());
+    s.xSync2;
+    tree
+  }
+
+  def xScalaExpr:Tree = {
+    sync;
+    val b = p.expr(true,false);
+    if(s.token != RBRACE)
+      xSyntaxError(" expected end of Scala block");
+    init;
+    //Console.println("[out of xScalaExpr s.ch = "+s.ch+" ch="+ch+"]");
+    return b
+  }
+
+  /** xScalaPatterns  ::= patterns
+   */
+  def xScalaPatterns:Array[Tree] = {
+    sync;
+    val b = p.patterns();
+    if( s.token != RBRACE )
+      xSyntaxError(" expected end of Scala patterns");
+    init;
+    return b
+  }
+
+  var ch: Char = _;
+
+  /** this method assign the next character to ch and advances in input */
+  def nextch: Unit = { s.xNext; ch = s.ch; }
+
+  def lookahead = { s.xLookahead }
+
+  def init: Unit = {
+    ch = s.ch;
+    //Console.println("\ninit! ch = "+ch);
+  }
+
   /** parse attribute and add it to listmap
    *  [41] Attributes    ::= { S Name Eq AttValue }
    *       AttValue     ::= `'` { _  } `'`
@@ -60,42 +129,62 @@ class MarkupParser( unit: CompilationUnit, s:Scanner, p:Parser, preserveWS:boole
   */
   def xAttributes = {
     var aMap = new ListMap[String, Tree];
-    while( xml.Parsing.isNameStart( s.ch )) {
-      val key = s.xName.toString();
-      s.xEQ;
-      val delim = s.ch;
-      val value:Tree = s.ch match {
+    while( xml.Parsing.isNameStart( ch )) {
+      val key = xName;
+      xEQ;
+      val delim = ch;
+      val value:Tree = ch match {
         case '"' | '\'' =>
           val pos = s.pos;
-          s.xNext;
-          val tmp = s.xAttributeValue( delim );
-          s.xNext;
+          nextch;
+          val tmp = xAttributeValue( delim );
+          nextch;
           gen.mkStringLit( pos, tmp )
         case '{' =>
-          s.xNext;
+          nextch;
           xScalaExpr;
         case _ =>
-	  s.xSyntaxError( "' or \" delimited attribute value or '{' scala-expr '}' expected" );
+	  xSyntaxError( "' or \" delimited attribute value or '{' scala-expr '}' expected" );
           gen.mkStringLit( s.pos, "<syntax-error>" )
       };
       // well-formedness constraint: unique attribute names
       if( aMap.contains( key ))
-        s.xSyntaxError( "attribute "+key+" may only be defined once" );
+        xSyntaxError( "attribute "+key+" may only be defined once" );
       aMap = aMap.update( key, value );
-      if(( s.ch != '/' )&&( s.ch != '>' ))
-        s.xSpace;
+      if(( ch != '/' )&&( ch != '>' ))
+        xSpace;
     };
    aMap
   }
 
+
+  /** attribute value, terminated by either ' or ". value may not contain <.
+   *  @param endch either ' or "
+   */
+  def xAttributeValue( endch:char ):String = {
+    while ( ch != endch ) {
+      putChar( ch );
+      nextch;
+    };
+    val str = cbuf.toString();
+    cbuf.setLength( 0 );
+    // @todo: normalize attribute value
+    // well-formedness constraint
+    if( str.indexOf('<') != -1 ) {
+      xSyntaxError( "'<' not allowed in attrib value" ); ""
+    } else {
+      str
+    }
+  }
+
   /** parse a start or empty tag.
    *  [40] STag         ::= '<' Name { S Attribute } [S]
    *  [44] EmptyElemTag ::= '<' Name { S Attribute } [S]
    */
   def xTag = {
-    val elemName = s.xName;
-    s.xSpaceOpt;
-    val aMap = if(xml.Parsing.isNameStart( s.ch )) {
+    val elemName = xName;
+    xSpaceOpt;
+    val aMap = if(xml.Parsing.isNameStart( ch )) {
       xAttributes;
     } else {
       ListMap.Empty[String,Tree];
@@ -103,85 +192,117 @@ class MarkupParser( unit: CompilationUnit, s:Scanner, p:Parser, preserveWS:boole
     Tuple2( elemName, aMap );
   }
 
+  /** munch expected XML token, report syntax error for unexpected
+  */
+  def xToken(that: Char): Unit = {
+    if( ch == that )
+      nextch;
+    else
+      xSyntaxError("'" + that + "' expected instead of '" + ch + "'");
+  }
+
   /* [42]  '<' xmlEndTag ::=  '<' '/' Name S? '>'                 */
-  def xEndTag( n:Name ) = {
-    s.xToken('/');
-    val m = s.xName;
-    if(n != m) s.xSyntaxError( "expected closing tag of " + n/* +", not "+m*/);
-    s.xSpaceOpt;
-    s.xToken('>')
+  def xEndTag(n: String) = {
+    xToken('/');
+    val m = xName;
+    if(n != m) xSyntaxError( "expected closing tag of " + n/* +", not "+m*/);
+    xSpaceOpt;
+    xToken('>')
   }
 
-  def xScalaExpr:Tree = {
+  def xSyntaxError(str:String) = {
+    throw new RuntimeException();
+    /* //DEBUG
+    s.syntaxError("in XML literal: "+str);
+    nextch;
+    */
+  }
+
+  def sync: Unit = {
+    xScalaBlock = false;
     s.xSync;
-    val b = p.expr(true,false);
-    if(s.token != RBRACE)
-      s.xSyntaxError(" expected end of Scala block");
-    return b
+  }
+
+  /* move forward one char
+   *
+   * @return true if next character  starts a scala block
+   */
+  def xxNext:boolean = {
+    nextch;
+    xCheckScalaBlock
+  }
+
+  var xScalaBlock = false;
+
+  /** checks whether next character starts a Scala block, if yes, skip it.
+   * @return true if next character starts a scala block
+   */
+  def xCheckScalaBlock:Boolean = {
+    xScalaBlock = ( ch == '{' ) && { nextch;( ch != '{' ) };
+    return xScalaBlock;
   }
 
   /** '<' xExpr ::= xmlTag1 '>'  { xmlExpr | '{' simpleExpr '}' } ETag
    *               | xmlTag1 '/' '>'
-   *  the caller has to resynchronize with s.token = EMPTY; s.nextToken;
    */
   def xExpr:Tree = {
     var pos = s.pos;
-    val Tuple2(qname:Name, attrMap:ListMap[String,Tree]) = xTag;
-    if(s.ch == '/') { // empty element
-      s.xToken('/');
-      s.xToken('>');
+    val Tuple2(qname: String, attrMap: ListMap[String,Tree]) = xTag;
+    if(ch == '/') { // empty element
+      xToken('/');
+      xToken('>');
       mk.makeXML( pos, qname, attrMap, Tree.EMPTY_ARRAY );
     } else { // handle content
-      s.xToken('>');
+      xToken('>');
       val ts = new myTreeList();
       var exit = false;
       while( !exit ) {
-        if( s.xScalaBlock ) {
+        if( xScalaBlock ) {
           ts.append( xScalaExpr );
         } else {
           pos = s.pos;
-          s.ch match {
+          ch match {
             case '<' => // another tag
-              s.xNext;
-              s.ch match {
+              nextch;
+              ch match {
                 case '/' => exit = true;            // end tag
                 case '!' =>
-                  s.xNext;
-                  if( '[' == s.ch )                 // CDATA
-                    ts.append( mk.CharData( pos, s.xCharData ));
+                  nextch;
+                  if( '[' == ch )                 // CDATA
+                    ts.append( mk.CharData( pos, xCharData ));
                   else                              // comment
-                    ts.append( mk.Comment( pos, s.xComment ));
+                    ts.append( mk.Comment( pos, xComment ));
                 case '?' =>                         // PI
-                  s.xNext;
-                  ts.append( mk.ProcInstr( pos, s.xProcInstr ));
+                  nextch;
+                  ts.append( mk.ProcInstr( pos, xProcInstr ));
                 case _   => ts.append( xExpr );     // child
               }
 
             case '{' =>
-              if( s.xCheckScalaBlock ) {
+              if( xCheckScalaBlock ) {
                 ts.append( xScalaExpr );
               } else {
                 val str = new StringBuffer("{");
-                str.append( s.xText );
+                str.append( xText );
                 mk.appendTrimmed( pos, mode, ts, str.toString() )
               }
-            // postcond: s.xScalaBlock == false!
+            // postcond: xScalaBlock == false!
             case '&' => // EntityRef or CharRef
-              s.xNext;
-              s.ch match {
+              nextch;
+              ch match {
                 case '#' => // CharacterRef
-                  s.xNext;
-                  val theChar = mk.makeText( s.pos, false, s.xCharRef );
-                  s.xToken(';');
+                  nextch;
+                  val theChar = mk.makeText( s.pos, false, xCharRef );
+                  xToken(';');
                   ts.append( theChar );
                 case _ => // EntityRef
-                  val n = s.xName ;
-                  s.xToken(';');
+                  val n = xName ;
+                  xToken(';');
                   ts.append( mk.EntityRef( pos, n ));
               }
             case _ => // text content
-              mk.appendTrimmed( pos, mode, ts, s.xText );
-            // here s.xScalaBlock might be true
+              mk.appendTrimmed( pos, mode, ts, xText );
+            // here xScalaBlock might be true
 
           }
         }
@@ -191,41 +312,6 @@ class MarkupParser( unit: CompilationUnit, s:Scanner, p:Parser, preserveWS:boole
     }
   }
 
-  /** @see xmlPattern. resynchronizes after succesful parse
-  def xLiteralPattern = {
-    val t = xPattern; s.nextToken(); t
-  }
-  */
-
-  /** @see xmlPattern. resynchronizes after succesful parse
-   * @return this xml pattern
-   * precondition: s.xStartsXML == true
-  */
-  def xLiteralPattern:Tree = {
-    val oldMode = mode;
-    mode = PATTERN;
-    val pos = s.pos;
-    var tree = xPattern; s.token = EMPTY; s.nextToken();
-    if( s.xStartsXML )  {
-      val ts = new myTreeList(); ts.append( tree );
-      while( s.xStartsXML ) { ts.append( xPattern ); s.nextToken(); }
-      tree = mk.makeXMLseqPat( pos, ts.toArray() );
-    }
-    mode = oldMode;
-    tree
-  }
-
-
-  /** xScalaPatterns  ::= patterns
-   */
-  def xScalaPatterns:Array[Tree] = {
-    s.xSync;
-    val b = p.patterns();
-    if( s.token != RBRACE )
-      s.xSyntaxError(" expected end of Scala patterns");
-    return b
-  }
-
 
   /** '<' xPattern  ::= Name [S] { xmlPattern | '{' pattern3 '}' } ETag
    *                  | Name [S] '/' '>'
@@ -233,47 +319,202 @@ class MarkupParser( unit: CompilationUnit, s:Scanner, p:Parser, preserveWS:boole
   def xPattern:Tree = {
     //Console.println("xPattern");
     val pos = s.pos;
-    val qname = s.xName;
-    s.xSpaceOpt;
-    if( s.ch == '/' ) { // empty tag
-      s.xNext;
-      s.xToken('>');
+    val qname = xName;
+    xSpaceOpt;
+    if( ch == '/' ) { // empty tag
+      nextch;
+      xToken('>');
       return mk.makeXMLpat( pos, qname, Tree.EMPTY_ARRAY );
     };
 
      // else: tag with content
-    s.xToken('>');
+    xToken('>');
     val ts = new myTreeList();
     var exit = false;
     while( !exit ) {
-      if( s.xScalaBlock ) {
+      if( xScalaBlock ) {
         ts.append( xScalaPatterns );
       } else
-        s.ch match {
+        ch match {
           case '<' => { // tag
-            s.xNext;
-            if( s.ch != '/' ) { //child
+            nextch;
+            if( ch != '/' ) { //child
               ts.append( xPattern );
             } else {
               exit = true
             }
           }
           case '{' => // embedded Scala patterns
-            while( s.ch == '{' ) {
+            while( ch == '{' ) {
               s.nextch();
               ts.append( xScalaPatterns );
             }
-            // postcond: s.xScalaBlock = false;
-          if( s.xScalaBlock ) throw new ApplicationError(); // assert
+            // postcond: xScalaBlock = false;
+          if( xScalaBlock ) throw new ApplicationError(); // assert
           case _ => // text
-            mk.appendTrimmed( pos, mode, ts, s.xText );
-          // here  s.xScalaBlock might be true;
-          //if( s.xScalaBlock ) throw new ApplicationError("after:"+text); // assert
+            mk.appendTrimmed( pos, mode, ts, xText );
+          // here  xScalaBlock might be true;
+          //if( xScalaBlock ) throw new ApplicationError("after:"+text); // assert
 	}
     }
     xEndTag( qname );
     mk.makeXMLpat( pos, qname, ts.toArray() );
   }
 
+  /** '<! CharData ::= [CDATA[ ( {char} - {char}"]]>"{char} ) ']]>'
+   *
+   * see [15]
+   */
+  def xCharData:scala.xml.CharData = {
+    xToken('[');
+    xToken('C');
+    xToken('D');
+    xToken('A');
+    xToken('T');
+    xToken('A');
+    xToken('[');
+    val sb:StringBuffer = new StringBuffer();
+    while (true) {
+      if( ch==']'  &&
+         { sb.append( ch ); nextch; ch == ']' } &&
+         { sb.append( ch ); nextch; ch == '>' } ) {
+        sb.setLength( sb.length() - 2 );
+        nextch;
+        return scala.xml.CharData( sb.toString() );
+      } else sb.append( ch );
+      nextch;
+    }
+    return null; // this cannot happen;
+  };
+
+  /** CharRef ::= "&#" '0'..'9' {'0'..'9'} ";"
+   *            | "&#x" '0'..'9'|'A'..'F'|'a'..'f' { hexdigit } ";"
+   *
+   * see [66]
+   */
+  def xCharRef:String = {
+    val hex  = ( ch == 'x' ) && { nextch; true };
+    val base = if (hex) 16 else 10;
+    var i = 0;
+    while( ch != ';' ) {
+      ch match {
+        case '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' =>
+          i = i * base + Character.digit( ch, base );
+        case 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
+           | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' =>
+          if( !hex )
+            xSyntaxError("hex char not allowed in decimal char ref\n"
+                         +"Did you mean to write &#x ?");
+          else
+            i = i * base + Character.digit( ch, base );
+        case _ =>
+          xSyntaxError("character '"+ch+" not allowed in char ref\n");
+      }
+      nextch;
+    }
+    new String( Predef.Array[char]( i.asInstanceOf[char] ))
+  }
+
+  /** Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
+   *
+   * see [15]
+   */
+  def xComment:scala.xml.Comment = {
+    val sb:StringBuffer = new StringBuffer();
+    xToken('-');
+    xToken('-');
+    while (true) {
+      if( ch=='-'  && { sb.append( ch ); nextch; ch == '-' } ) {
+        sb.setLength( sb.length() - 1 );
+        nextch;
+        xToken('>');
+        return scala.xml.Comment( sb.toString() );
+      } else sb.append( ch );
+      nextch;
+    }
+    return null; // this cannot happen;
+  };
+
+
+  /** Name ::= (Letter | '_' | ':') (NameChar)*
+   *
+   *  see  [5] of XML 1.0 specification
+   */
+  def xName: String = {
+    if( xml.Parsing.isNameStart( ch ) ) {
+      do {
+        putChar( ch );
+        nextch;
+      } while( xml.Parsing.isNameChar( ch ) );
+      val n = cbuf.toString().intern();
+      cbuf.setLength( 0 );
+      n
+    } else {
+      xSyntaxError( "name expected" );
+      new String();
+    }
+  }
+
+
+  /** scan [S] '=' [S]*/
+  def xEQ = { xSpaceOpt; xToken('='); xSpaceOpt }
+
+  /** skip optional space S? */
+  def xSpaceOpt = { while( xml.Parsing.isSpace( ch ) ) { nextch; }}
+
+  /** scan [3] S ::= (#x20 | #x9 | #xD | #xA)+ */
+  def xSpace = {
+    if( xml.Parsing.isSpace( ch ) ) {
+      nextch; xSpaceOpt
+    } else {
+      xSyntaxError("whitespace expected");
+    }
+  }
+
+  /** '<?' ProcInstr ::= Name [S ({Char} - ({Char}'>?' {Char})]'?>'
+   *
+   * see [15]
+   */
+  def xProcInstr:scala.xml.ProcInstr = {
+    val sb:StringBuffer = new StringBuffer();
+    val n = xName;
+    if( xml.Parsing.isSpace( ch ) ) {
+      xSpace;
+      while( true ) {
+        if( ch=='?' && { sb.append( ch ); nextch; ch == '>' } ) {
+          sb.setLength( sb.length() - 1 );
+          nextch;
+          return scala.xml.ProcInstr( n.toString(), Some(sb.toString()) );
+        } else
+          sb.append( ch );
+        nextch;
+      }
+    };
+    xToken('?');
+    xToken('>');
+   scala.xml.ProcInstr( n.toString(), None );
+  }
+
+  /** parse character data.
+  *   precondition: xScalaBlock == false (we are not in a scala block)
+  */
+  def xText:String = {
+    if( xScalaBlock ) throw new ApplicationError(); // assert
+
+    if( xCheckScalaBlock )
+      return ""
+    else {
+      var exit = false;
+      while( !exit ) {
+        putChar( ch );
+        exit = xxNext || ( ch == '<' ) || ( ch == '&' );
+      }
+      val str = cbuf.toString();
+      cbuf.setLength( 0 );
+      str
+    }
+  }
+
+
 } /* class MarkupParser */
 }
diff --git a/sources/scala/tools/scalac/ast/parser/Scanner.scala b/sources/scala/tools/scalac/ast/parser/Scanner.scala
index 007403b169..049699ee92 100644
--- a/sources/scala/tools/scalac/ast/parser/Scanner.scala
+++ b/sources/scala/tools/scalac/ast/parser/Scanner.scala
@@ -8,7 +8,6 @@
 
 import scalac._;
 import scalac.util.Name;
-import scalac.util.Names;
 import scalac.util.SourceRepresentation;
 
 package scala.tools.scalac.ast.parser {
@@ -897,20 +896,15 @@ class Scanner(_unit: CompilationUnit) extends TokenData {
   /** calls nextToken, starting the scanning of Scala tokens,
   *   after XML tokens.
   */
-
   def xSync = {
     token = SEMI; // avoid getting SEMI from nextToken if last was RBRACE
-    xScalaBlock = false;
     //nextch();
     nextToken();
   }
 
-  def xSyntaxError(s:String) = {
-    syntaxError("in XML literal: "+s);
-    xNext;
-  }
+  def xSync2 = fetchToken();
 
-  var xScalaBlock = false;
+  def xLookahead = srcIterator.lookahead1;
 
   /** read the next character. do not skip whitespace.
   *   treat CR LF as single LF. update ccol and cline
@@ -934,12 +928,7 @@ class Scanner(_unit: CompilationUnit) extends TokenData {
         //Console.print(ch.asInstanceOf[char]); // DEBUG
     }
     pos = Position.encode(cline, ccol);
-  }
-
-  /** scan [S] '=' [S]
-  */
-  def xEQ = {
-    xSpaceOpt; xToken('='); xSpaceOpt
+    //Console.print(ch);
   }
 
   final val LT   = Name.fromString("<");
@@ -948,222 +937,6 @@ class Scanner(_unit: CompilationUnit) extends TokenData {
     /* unit.global.xmlMarkup && */ ( token == IDENTIFIER )&&( name == LT );
   }
 
-  /** skip optional space S? */
-  def xSpaceOpt = {
-    while( xml.Parsing.isSpace( ch ) ) { xNext; }
-  }
-
-  /** scan [3] S ::= (#x20 | #x9 | #xD | #xA)+ */
-  def xSpace = {
-    if( xml.Parsing.isSpace( ch ) ) {
-      xNext; xSpaceOpt
-    } else {
-      xSyntaxError("whitespace expected");
-    }
-  }
-
-  /** Name ::= (Letter | '_' | ':') (NameChar)*
-   *
-   *  see  [5] of XML 1.0 specification
-   */
-  def xName:Name = {
-    if( xml.Parsing.isNameStart( ch ) ) {
-      do {
-        putChar( ch );
-        xNext;
-      } while( xml.Parsing.isNameChar( ch ) );
-      val n = Name.fromString( cbuf.toString() );
-      cbuf.setLength( 0 );
-      n
-    } else {
-      xSyntaxError( "name expected" );
-      Names.EMPTY
-    }
-  }
-
-
-  /** returns string up to next character endch.
-   *
-   *  @param endch the character to which we skip
-   */
-  def xSkipToNext( endch:char ):String = {
-    lastpos = pos;
-    while (( ch != endch )&&( ch != '{' )) {
-      putChar( ch );
-      xNext;
-    };
-    val s = cbuf.toString();
-    cbuf.setLength( 0 );
-    s
-  }
-
-  /** attribute value, terminated by either ' or ". value may not contain <.
-   *  @param endch either ' or "
-   */
-  def xAttributeValue( endch:char ):String = {
-    while ( ch != endch ) {
-      putChar( ch );
-      xNext;
-    };
-    val s = cbuf.toString();
-    cbuf.setLength( 0 );
-    // @todo: normalize attribute value
-    // well-formedness constraint
-    if( s.indexOf('<') != -1 ) {
-      xSyntaxError( "'<' not allowed in attrib value" ); ""
-    } else {
-      s
-    }
-  }
-
-  /* move forward one char
-   *
-   * @return true if next character  starts a scala block
-   */
-  def xxNext:boolean = {
-    xNext;
-    xCheckScalaBlock
-  }
-
-  /* checks whether next character starts a Scala block, if yes, skip it.
-   *
-   * @return true if next character starts a scala block
-   */
-  def xCheckScalaBlock:boolean = {
-    xScalaBlock = ( ch == '{' ) && { xNext;( ch != '{' ) };
-    return xScalaBlock;
-  }
-
-  /** parse character data.
-  *   precondition: xScalaBlock == false (we are not in a scala block)
-  */
-  def xText:String = {
-    if( xScalaBlock ) throw new ApplicationError(); // assert
-
-    if( xCheckScalaBlock )
-      return ""
-    else {
-      lastpos = pos;
-      var exit = false;
-      while( !exit ) {
-        putChar( ch );
-        exit = xxNext || ( ch == '<' ) || ( ch == '&' );
-      }
-      val s = cbuf.toString();
-      cbuf.setLength( 0 );
-      s
-    }
-  }
-
-
-  /** CharRef ::= "&#" '0'..'9' {'0'..'9'} ";"
-   *            | "&#x" '0'..'9'|'A'..'F'|'a'..'f' { hexdigit } ";"
-   *
-   * see [66]
-   */
-  def xCharRef:String = {
-    val hex  = ( ch == 'x' ) && { xNext; true };
-    val base = if (hex) 16 else 10;
-    var i = 0;
-    while( ch != ';' ) {
-      ch match {
-        case '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' =>
-          i = i * base + Character.digit( ch, base );
-        case 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
-           | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' =>
-          if( !hex )
-            xSyntaxError("hex char not allowed in decimal char ref\n"
-                         +"Did you mean to write &#x ?");
-          else
-            i = i * base + Character.digit( ch, base );
-        case _ =>
-          xSyntaxError("character '"+ch+" not allowed in char ref\n");
-      }
-      xNext;
-    }
-    new String( Predef.Array[char]( i.asInstanceOf[char] ))
-  }
-
-  /** '<! CharData ::= [CDATA[ ( {char} - {char}"]]>"{char} ) ']]>'
-   *
-   * see [15]
-   */
-  def xCharData:scala.xml.CharData = {
-    xToken('[');
-    xToken('C');
-    xToken('D');
-    xToken('A');
-    xToken('T');
-    xToken('A');
-    xToken('[');
-    val sb:StringBuffer = new StringBuffer();
-    while (true) {
-      if( ch==']'  &&
-         { sb.append( ch ); xNext; ch == ']' } &&
-         { sb.append( ch ); xNext; ch == '>' } ) {
-        sb.setLength( sb.length() - 2 );
-        xNext;
-        return scala.xml.CharData( sb.toString() );
-      } else sb.append( ch );
-      xNext;
-    }
-    return null; // this cannot happen;
-  };
-
-
-  /** Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
-   *
-   * see [15]
-   */
-  def xComment:scala.xml.Comment = {
-    val sb:StringBuffer = new StringBuffer();
-    xToken('-');
-    xToken('-');
-    while (true) {
-      if( ch=='-'  && { sb.append( ch ); xNext; ch == '-' } ) {
-        sb.setLength( sb.length() - 1 );
-        xNext;
-        xToken('>');
-        return scala.xml.Comment( sb.toString() );
-      } else sb.append( ch );
-      xNext;
-    }
-    return null; // this cannot happen;
-  };
-
-  /** '<?' ProcInstr ::= Name [S ({Char} - ({Char}'>?' {Char})]'?>'
-   *
-   * see [15]
-   */
-  def xProcInstr:scala.xml.ProcInstr = {
-    val sb:StringBuffer = new StringBuffer();
-    val n = xName;
-    if( xml.Parsing.isSpace( ch ) ) {
-      xSpace;
-      while( true ) {
-        if( ch=='?' && { sb.append( ch ); xNext; ch == '>' } ) {
-          sb.setLength( sb.length() - 1 );
-          xNext;
-          return scala.xml.ProcInstr( n.toString(), Some(sb.toString()) );
-        } else
-          sb.append( ch );
-        xNext;
-      }
-    };
-    xToken('?');
-    xToken('>');
-   scala.xml.ProcInstr( n.toString(), None );
-  }
-
-  /** munch expected XML token, report syntax error for unexpected
-  */
-  def xToken(that:char):unit = {
-    if( ch == that )
-      xNext;
-    else
-      xSyntaxError("'" + that + "' expected instead of '" + ch + "'");
-  }
-
   // end XML tokenizing
 
 
diff --git a/sources/scala/tools/scalac/ast/parser/SymbolicXMLBuilder.scala b/sources/scala/tools/scalac/ast/parser/SymbolicXMLBuilder.scala
index 377250495c..9634f2559d 100644
--- a/sources/scala/tools/scalac/ast/parser/SymbolicXMLBuilder.scala
+++ b/sources/scala/tools/scalac/ast/parser/SymbolicXMLBuilder.scala
@@ -191,10 +191,10 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS:
     }
   }
 
-  final def EntityRef( pos:int, n:Name ) = {
+  final def EntityRef( pos:int, n: String ) = {
     val constr = make.Apply( pos,
                             _scala_xml_EntityRef( pos ),
-                            Predef.Array[Tree]( gen.mkStringLit( pos, n.toString() )));
+                            Predef.Array[Tree]( gen.mkStringLit( pos, n )));
 
     make.New( pos, constr );
   };
@@ -312,11 +312,11 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS:
   }
 
   /** @todo: attributes */
-  def makeXMLpat(pos: int, n: Name, args: Array[Tree]): Tree =
+  def makeXMLpat(pos: int, n: String, args: Array[Tree]): Tree =
     mkXML(pos,
           true,
           new Tree$Ident( Names.PATTERN_WILDCARD ):Tree,
-          gen.mkStringLit( pos, n.toString() ):Tree,
+          gen.mkStringLit( pos, n ):Tree,
           Tree.EMPTY_ARRAY:Array[Tree],
           args:Array[Tree]);
 
@@ -404,8 +404,7 @@ class SymbolicXMLBuilder(make: TreeFactory, gen: TreeGen, p: Parser, preserveWS:
     }
 
   /** makes an element */
-  def makeXML(pos: int, labeln: Name, attrMap1: ListMap[String,Tree], args: Array[Tree]): Tree={
-    var label = labeln.toString();
+  def makeXML(pos: int, label: String, attrMap1: ListMap[String,Tree], args: Array[Tree]): Tree={
     var setNS = ListMap.Empty[String, Tree];
     var attrMap = attrMap1;