</p/>

12 files changed, 660 insertions, 670 deletions

diff --git a/src/actors/scala/actors/Debug.scala b/src/actors/scala/actors/Debug.scala
index 9807f2b620..89efe5db62 100644
--- a/src/actors/scala/actors/Debug.scala
+++ b/src/actors/scala/actors/Debug.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2005-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2005-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -14,33 +14,33 @@ package scala.actors
  * @author Philipp Haller
  */
 object Debug {
-  var lev = 2
+  private var lev = 2
 
   def level = lev
-  def level_= (lev: int) = {
-    this.lev = lev
-  }
+  def level_= (lev: int) = { this.lev = lev }
 
   def info(s: String) =
     if (lev > 2) System.out.println("Info: " + s)
+
   def warning(s: String) =
     if (lev > 1) System.err.println("Warning: " + s)
+
   def error(s: String) =
     if (lev > 0) System.err.println("Error: " + s)
 }
 
 class Debug(tag: String) {
-  var lev = 2
+  private var lev = 2
 
   def level = lev
-  def level_= (lev: int) = {
-    this.lev = lev
-  }
+  def level_= (lev: int) = { this.lev = lev }
 
   def info(s: String) =
     if (lev > 2) System.out.println(tag + " (info): " + s)
+
   def warning(s: String) =
     if (lev > 1) System.err.println(tag + " (warn): " + s)
+
   def error(s: String) =
     if (lev > 0) System.err.println(tag + " (erro): " + s)
 }
diff --git a/src/actors/scala/actors/InputChannel.scala b/src/actors/scala/actors/InputChannel.scala
index 21ade395e6..ab1841cb83 100644
--- a/src/actors/scala/actors/InputChannel.scala
+++ b/src/actors/scala/actors/InputChannel.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2005-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2005-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
diff --git a/src/actors/scala/actors/OutputChannel.scala b/src/actors/scala/actors/OutputChannel.scala
index 978ea90a96..78fd193452 100644
--- a/src/actors/scala/actors/OutputChannel.scala
+++ b/src/actors/scala/actors/OutputChannel.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2005-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2005-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
diff --git a/src/actors/scala/actors/remote/FreshNameCreator.scala b/src/actors/scala/actors/remote/FreshNameCreator.scala
index b5d343c6a7..1ca6c16089 100644
--- a/src/actors/scala/actors/remote/FreshNameCreator.scala
+++ b/src/actors/scala/actors/remote/FreshNameCreator.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2005-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2005-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -26,11 +26,11 @@ object FreshNameCreator {
       case None => 0
     }
     counters.update(prefix, count)
-    new Symbol(prefix + count)
+    Symbol(prefix + count)
   }
 
   def newName(): Symbol = {
-    counter = counter + 1
-    new Symbol("$" + counter + "$")
+    counter += 1
+    Symbol("$" + counter + "$")
   }
 }
diff --git a/src/actors/scala/actors/remote/JavaSerializer.scala b/src/actors/scala/actors/remote/JavaSerializer.scala
index 80c9266c63..85d4952d90 100644
--- a/src/actors/scala/actors/remote/JavaSerializer.scala
+++ b/src/actors/scala/actors/remote/JavaSerializer.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2005-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2005-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -13,6 +13,9 @@ package scala.actors.remote
 import java.io.{ByteArrayInputStream, ByteArrayOutputStream,
                 ObjectInputStream, ObjectOutputStream}
 
+/**
+ *  @author Philipp Haller
+ */
 class JavaSerializer(serv: Service) extends Serializer(serv) {
 
   def serialize(o: AnyRef): Array[Byte] = {
diff --git a/src/actors/scala/actors/remote/NetKernel.scala b/src/actors/scala/actors/remote/NetKernel.scala
index db622cc72f..45c7ae7c9e 100644
--- a/src/actors/scala/actors/remote/NetKernel.scala
+++ b/src/actors/scala/actors/remote/NetKernel.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2005-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2005-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -14,6 +14,9 @@ import scala.collection.mutable.{HashMap, HashSet}
 
 case class NamedSend(senderName: Symbol, receiver: Symbol, data: Array[Byte])
 
+/**
+ *  @author Philipp Haller
+ */
 class NetKernel(service: Service) {
 
   def sendToNode(node: Node, msg: AnyRef) = {
@@ -21,18 +24,17 @@ class NetKernel(service: Service) {
     service.send(node, bytes)
   }
 
-  def namedSend(node: Node, senderName: Symbol, receiver: Symbol, msg: AnyRef): Unit = {
+  def namedSend(node: Node, senderName: Symbol, receiver: Symbol, msg: AnyRef) {
     val bytes = service.serializer.serialize(msg)
     sendToNode(node, NamedSend(senderName, receiver, bytes))
   }
 
-  def send(node: Node, name: Symbol, msg: AnyRef): Unit = {
+  def send(node: Node, name: Symbol, msg: AnyRef) {
     val senderName = names.get(Actor.self) match {
-      case None => {
+      case None =>
         val freshName = FreshNameCreator.newName("remotesender")
         register(freshName, Actor.self)
         freshName
-      }
       case Some(name) =>
         name
     }
@@ -43,11 +45,11 @@ class NetKernel(service: Service) {
     msg match {
       case NamedSend(senderName, receiver, data) =>
         actors.get(receiver) match {
-          case Some(a) => {
+          case Some(a) =>
             val msg = service.serializer.deserialize(data)
             val senderProxy = new Actor {
               def act() = { a ! msg }
-              override def !(msg: Any): Unit = {
+              override def !(msg: Any) {
                 msg match {
                   case refmsg: AnyRef =>
                     namedSend(senderNode, receiver, senderName, refmsg)
@@ -55,7 +57,6 @@ class NetKernel(service: Service) {
               }
             }
             senderProxy.start()
-          }
           case None =>
             // message is lost
         }
diff --git a/src/actors/scala/actors/remote/TcpService.scala b/src/actors/scala/actors/remote/TcpService.scala
index d17f072ecc..a3721bc40d 100644
--- a/src/actors/scala/actors/remote/TcpService.scala
+++ b/src/actors/scala/actors/remote/TcpService.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2005-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2005-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -53,12 +53,12 @@ class TcpService(port: Int) extends Thread with Service {
   def send(node: Node, data: Array[byte]): unit = synchronized {
     // retrieve worker thread (if any) that already has connection
     getConnection(node) match {
-      case None => {
+      case None =>
         // we are not connected, yet
         val newWorker = connect(node)
         newWorker transmit data
-      }
-      case Some(worker) => worker transmit data
+      case Some(worker) =>
+        worker transmit data
     }
   }
 
@@ -172,7 +172,7 @@ class TcpServiceWorker(parent: TcpService, so: Socket) extends Thread {
     running = false
   }
 
-  override def run(): Unit = {
+  override def run() {
     try {
       while (running) {
         if (in.available() > 0) {
diff --git a/src/compiler/scala/tools/nsc/Properties.scala b/src/compiler/scala/tools/nsc/Properties.scala
index 277cc0a36c..f9f9734c9d 100644
--- a/src/compiler/scala/tools/nsc/Properties.scala
+++ b/src/compiler/scala/tools/nsc/Properties.scala
@@ -33,7 +33,7 @@ object Properties {
   }
 
   val copyrightString: String = {
-    val defaultString = "(c) 2002-2006 LAMP/EPFL"
+    val defaultString = "(c) 2002-2007 LAMP/EPFL"
     props.getProperty("copyright.string", defaultString)
   }
 
diff --git a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
index f70eeac08a..8e1196a798 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/MarkupParsers.scala
@@ -6,7 +6,6 @@
 
 package scala.tools.nsc.ast.parser
 
-import scala.collection.immutable.ListMap
 import scala.collection.mutable
 import scala.tools.nsc.util.Position
 import scala.xml.{Text, TextBuffer}
@@ -22,659 +21,649 @@ trait MarkupParsers {
   import global._
   //import posAssigner.atPos
 
-class MarkupParser(p: UnitParser, presWS: boolean) /*with scala.xml.parsing.MarkupParser[Tree,Tree] */{
+  class MarkupParser(p: UnitParser, presWS: boolean) /*with scala.xml.parsing.MarkupParser[Tree,Tree] */{
 
-  import Tokens.{EMPTY, LBRACE, RBRACE}
+    import Tokens.{EMPTY, LBRACE, RBRACE}
 
-  final val preserveWS = presWS
+    final val preserveWS = presWS
 
-  import p.{symbXMLBuilder => handle}
-  def s = p.in
-  import p.in.g2p
-  import p.in.p2g
-  import p.in.token
+    import p.{symbXMLBuilder => handle}
+    def s = p.in
+    import p.in.g2p
+    import p.in.p2g
+    import p.in.token
 
-  /** holds the position in the source file */
-  /*[Duplicate]*/ var pos: Position = _
+    /** holds the position in the source file */
+    /*[Duplicate]*/ var pos: Position = _
 
-  /** holds temporary values of pos */
-  /*[Duplicate]*/ var tmppos: Position = _
+    /** holds temporary values of pos */
+    /*[Duplicate]*/ var tmppos: Position = _
 
-  /** holds the next character */
-  /*[Duplicate]*/ var ch: Char = _
+    /** holds the next character */
+    /*[Duplicate]*/ var ch: Char = _
 
-  /** character buffer, for names */
-  /*[Duplicate]*/ protected val cbuf = new StringBuilder()
+    /** character buffer, for names */
+    /*[Duplicate]*/ protected val cbuf = new StringBuilder()
 
-  /** append Unicode character to name buffer*/
-  /*[Duplicate]*/ protected def putChar(c: char) = cbuf.append(c)
+    /** append Unicode character to name buffer*/
+    /*[Duplicate]*/ protected def putChar(c: char) = cbuf.append(c)
 
-  /*[Duplicate]*/ var xEmbeddedBlock = false
+    /*[Duplicate]*/ var xEmbeddedBlock = false
 
-  /** munch expected XML token, report syntax error for unexpected.
-   *
-   *  @param that ...
-   */
-  /*[Duplicate]*/ def xToken(that: Char): Unit =
-    if (ch == that)
-      nextch
-    else
-      reportSyntaxError("'" + that + "' expected instead of '" + ch + "'")
-
-  var debugLastStartElement = new mutable.Stack[(Position, String)]
-
-  /** checks whether next character starts a Scala block, if yes, skip it.
-   * @return true if next character starts a scala block
-   */
-  /*[Duplicate]*/ def xCheckEmbeddedBlock:Boolean = {
-    // attentions, side-effect, used in xText
-    xEmbeddedBlock = ( ch == '{' ) && { nextch;( ch != '{' ) }
-    //Console.println("pos = "+pos+" xEmbeddedBlock returns "+xEmbeddedBlock)
-    return xEmbeddedBlock;
-  }
-
-  /** parse attribute and add it to listmap
-   *  [41] Attributes    ::= { S Name Eq AttValue }
-   *       AttValue     ::= `'` { _  } `'`
-   *                      | `"` { _ } `"`
-   *                      | `{` scalablock `}`
-  */
-  /*[Duplicate]*/ def xAttributes = {
-    var aMap = new mutable.HashMap[String, Tree]()
-    while (xml.Parsing.isNameStart(ch)) {
-      val key = xName
-      xEQ
-      val delim = ch
-      val pos1 = pos
-      val value: /* AttribValue[*/Tree/*]*/ = ch match {
-        case '"' | '\'' =>
-          nextch
-          val tmp = xAttributeValue(delim)
-          nextch
-          try {
-            handle.parseAttribute(pos1, tmp)
-          } catch {
-            case e =>
-              reportSyntaxError("error parsing attribute value")
-              p.errorTermTree
-          }
+    /** munch expected XML token, report syntax error for unexpected.
+     *
+     *  @param that ...
+     */
+    /*[Duplicate]*/ def xToken(that: Char) {
+      if (ch == that) nextch
+      else reportSyntaxError("'" + that + "' expected instead of '" + ch + "'")
+    }
 
-        case '{'  =>
-          nextch
-          xEmbeddedExpr
-        case _ =>
-          reportSyntaxError("' or \" delimited attribute value" +
-                            " or '{' scala-expr '}' expected" )
-          Literal(Constant("<syntax-error>"))
+    var debugLastStartElement = new mutable.Stack[(Position, String)]
+
+    /** checks whether next character starts a Scala block, if yes, skip it.
+     * @return true if next character starts a scala block
+     */
+    /*[Duplicate]*/ def xCheckEmbeddedBlock: Boolean = {
+      // attentions, side-effect, used in xText
+      xEmbeddedBlock = (ch == '{') && { nextch; (ch != '{') }
+      //Console.println("pos = "+pos+" xEmbeddedBlock returns "+xEmbeddedBlock)
+      xEmbeddedBlock
+    }
+
+    /** parse attribute and add it to listmap
+     *  [41] Attributes   ::= { S Name Eq AttValue }
+     *       AttValue     ::= `'` { _  } `'`
+     *                      | `"` { _ } `"`
+     *                      | `{` scalablock `}`
+     */
+    /*[Duplicate]*/ def xAttributes = {
+      var aMap = new mutable.HashMap[String, Tree]()
+      while (xml.Parsing.isNameStart(ch)) {
+        val key = xName
+        xEQ
+        val delim = ch
+        val pos1 = pos
+        val value: /* AttribValue[*/Tree/*]*/ = ch match {
+          case '"' | '\'' =>
+            nextch
+            val tmp = xAttributeValue(delim)
+            nextch
+            try {
+              handle.parseAttribute(pos1, tmp)
+            } catch {
+              case e =>
+                reportSyntaxError("error parsing attribute value")
+                p.errorTermTree
+            }
+
+          case '{'  =>
+            nextch
+            xEmbeddedExpr
+          case _ =>
+            reportSyntaxError("' or \" delimited attribute value" +
+                              " or '{' scala-expr '}' expected" )
+            Literal(Constant("<syntax-error>"))
+        }
+        // well-formedness constraint: unique attribute names
+        if (aMap.contains(key)) {
+          reportSyntaxError( "attribute "+key+" may only be defined once" )
+        }
+        aMap.update(key, value)
+        if ((ch != '/') && (ch != '>')) {
+          xSpace
+        }
       }
-      // well-formedness constraint: unique attribute names
-      if (aMap.contains(key)) {
-        reportSyntaxError( "attribute "+key+" may only be defined once" )
+      aMap
+    }
+
+    /** attribute value, terminated by either ' or ". value may not contain <.
+     *  @param endch either ' or "
+     */
+    /*[Duplicate]*/ def xAttributeValue(endCh: char): String = {
+      while (ch != endCh) {
+        putChar(ch)
+        nextch
       }
-      aMap.update(key, value)
-      if ((ch != '/') && (ch != '>')) {
-        xSpace
+      val str = cbuf.toString()
+      cbuf.setLength(0)
+      // @todo: normalize attribute value
+      // well-formedness constraint
+      if (str.indexOf('<') != -1) {
+        reportSyntaxError( "'<' not allowed in attrib value" ); ""
+      } else {
+        str
       }
     }
-   aMap
-  }
-
-  /** attribute value, terminated by either ' or ". value may not contain <.
-   *  @param endch either ' or "
-   */
-  /*[Duplicate]*/ 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) {
-      reportSyntaxError( "'<' 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]
+     */
+    /*[Duplicate]*/ def xTag: (String, mutable.Map[String, Tree]) = {
+      val elemName = xName
+      xSpaceOpt
+      val aMap =
+        if (xml.Parsing.isNameStart(ch)) xAttributes
+        else new mutable.HashMap[String, Tree]()
+      (elemName, aMap)
+    }
+
+    /** [42]  '<' xmlEndTag ::=  '<' '/' Name S? '>'
+     */
+    /*[Duplicate]*/ def xEndTag(startName: String) {
+      xToken('/')
+      val endName = xName
+      if (endName != startName) {
+        reportSyntaxError("expected closing tag of " + startName)
+      }
+      xSpaceOpt
+      xToken('>')
     }
-  }
-
- /** parse a start or empty tag.
-   *  [40] STag         ::= '<' Name { S Attribute } [S]
-   *  [44] EmptyElemTag ::= '<' Name { S Attribute } [S]
-   */
-  /*[Duplicate]*/ def xTag: (String, mutable.Map[String, Tree]) = {
-    val elemName = xName
-    xSpaceOpt
-    val aMap =
-      if (xml.Parsing.isNameStart(ch)) xAttributes
-      else new mutable.HashMap[String, Tree]()
-    Tuple2(elemName, aMap)
-  }
-
-  /* [42]  '<' xmlEndTag ::=  '<' '/' Name S? '>'                 */
-  /*[Duplicate]*/ def xEndTag(n: String) = {
-    xToken('/')
-    val m = xName
-    if (n != m)
-      reportSyntaxError( "expected closing tag of " + n/* +", not "+m*/);
-    xSpaceOpt
-    xToken('>')
-  }
-
- /** '<! CharData ::= [CDATA[ ( {char} - {char}"]]>"{char} ) ']]>'
-   *
-   * see [15]
-   */
-  /*[Duplicate]*/ def xCharData: Tree = {
-    xToken('[')
-    xToken('C')
-    xToken('D')
-    xToken('A')
-    xToken('T')
-    xToken('A')
-    xToken('[')
-    val pos1 = pos
-    val sb: StringBuilder = new StringBuilder()
-    while (true) {
-      if (ch==']' &&
-         { sb.append(ch); nextch; ch == ']' } &&
-         { sb.append(ch); nextch; ch == '>' }) {
-        sb.setLength(sb.length() - 2)
+
+    /** '<! CharData ::= [CDATA[ ( {char} - {char}"]]>"{char} ) ']]>'
+     *
+     * see [15]
+     */
+    /*[Duplicate]*/ def xCharData: Tree = {
+      xToken('[')
+      xToken('C')
+      xToken('D')
+      xToken('A')
+      xToken('T')
+      xToken('A')
+      xToken('[')
+      val pos1 = pos
+      val sb: StringBuilder = new StringBuilder()
+      while (true) {
+        if (ch==']' &&
+           { sb.append(ch); nextch; ch == ']' } &&
+           { sb.append(ch); nextch; ch == '>' }) {
+          sb.setLength(sb.length() - 2)
+          nextch
+          return handle.charData(pos1, sb.toString())
+        } else
+          sb.append(ch)
         nextch
-        return handle.charData(pos1, sb.toString())
-      } else sb.append(ch)
-      nextch
+      }
+      Predef.error("this cannot happen")
     }
-    Predef.error("this cannot happen")
-  }
-
-  def xUnparsed: Tree = {
-    val pos1 = pos
-    val sb: StringBuilder = new StringBuilder()
-    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)
+
+    def xUnparsed: Tree = {
+      val pos1 = pos
+      val sb: StringBuilder = new StringBuilder()
+      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
-        return handle.unparsed(pos1, sb.toString())
-      } else sb.append(ch)
-      nextch
+      }
+      Predef.error("this cannot happen")
     }
-    Predef.error("this cannot happen")
-  }
-
-  /** CharRef ::= "&#" '0'..'9' {'0'..'9'} ";"
-   *            | "&#x" '0'..'9'|'A'..'F'|'a'..'f' { hexdigit } ";"
-   *
-   * see [66]
-   */
-  /*[Duplicate]*/ 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 + ch.asDigit
-        case 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
-           | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' =>
-          if (!hex)
-            reportSyntaxError("hex char not allowed in decimal char ref\n"
-                         +"Did you mean to write &#x ?");
-          else
+
+    /** CharRef ::= "&#" '0'..'9' {'0'..'9'} ";"
+     *            | "&#x" '0'..'9'|'A'..'F'|'a'..'f' { hexdigit } ";"
+     *
+     * see [66]
+     */
+    /*[Duplicate]*/ 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 + ch.asDigit
-        case _ =>
-          reportSyntaxError("character '"+ch+" not allowed in char ref\n")
+          case 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
+             | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' =>
+            if (!hex)
+              reportSyntaxError("hex char not allowed in decimal char ref\n"
+                           +"Did you mean to write &#x ?");
+            else
+              i = i * base + ch.asDigit
+          case _ =>
+            reportSyntaxError("character '"+ch+" not allowed in char ref\n")
+        }
+        nextch
       }
-      nextch
+      new String(Array(i.asInstanceOf[char]))
     }
-    new String(Array(i.asInstanceOf[char]))
-  }
-
-  /** Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
-   *
-   * see [15]
-   */
-  /*[Duplicate]*/ def xComment: Tree = {
-    val sb: StringBuilder = new StringBuilder()
-    xToken('-')
-    xToken('-')
-    while (true) {
-      if( ch=='-'  && { sb.append(ch); nextch; ch == '-' } ) {
-        sb.setLength(sb.length() - 1)
+
+    /** Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
+     *
+     * see [15]
+     */
+    /*[Duplicate]*/ def xComment: Tree = {
+      val sb: StringBuilder = new StringBuilder()
+      xToken('-')
+      xToken('-')
+      while (true) {
+        if (ch=='-'  && { sb.append(ch); nextch; ch == '-' }) {
+          sb.setLength(sb.length() - 1)
+          nextch
+          xToken('>')
+          return handle.comment(pos, sb.toString())
+        } else sb.append(ch)
         nextch
-        xToken('>')
-        return handle.comment(pos, sb.toString())
-      } else sb.append(ch)
+      }
+      Predef.error("this cannot happen")
+    }
+
+    /**
+     *  @param pos ...
+     *  @param ts  ...
+     *  @param txt ...
+     */
+    /*[Duplicate]*/ def appendText(pos: Position, ts: mutable.Buffer[Tree],
+                                   txt: String): Unit =
+      if (!preserveWS) {
+        for (t <- TextBuffer.fromString(txt).toText) {
+          ts.append(handle.text(pos, t.text))
+        }
+      }
+      else
+        ts.append( handle.text(pos, txt))
+
+    /** adds entity/character to to ts as side-effect
+     *  @precond ch == '&amp;'
+     */
+    def content_AMP(ts: mutable.ArrayBuffer[Tree]) {
       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))
+      }
     }
-    Predef.error("this cannot happen")
-  }
-
-  /**
-   *  @param pos ...
-   *  @param ts  ...
-   *  @param txt ...
-   */
-  /*[Duplicate]*/ def appendText(pos: Position, ts: mutable.Buffer[Tree],
-                                 txt: String): Unit =
-    if (!preserveWS) {
-      for (t <- TextBuffer.fromString(txt).toText) {
-        ts.append(handle.text(pos, t.text))
+
+    /**
+     *  @precond ch == '{'
+     *  @postcond: xEmbeddedBlock == false!
+     */
+    def content_BRACE(p: Position, ts:mutable.ArrayBuffer[Tree]) {
+      if (xCheckEmbeddedBlock)
+        ts.append(xEmbeddedExpr)
+      else {
+        appendText(p, ts, xText)/*
+        val str = new StringBuilder("{")
+        str.append(xText)
+        nextch
+        appendText(p, ts, str.toString())*/
       }
     }
-    else
-      ts.append( handle.text(pos, txt))
-
-  /** adds entity/character to to ts as side-effect
-   *  @precond ch == '&amp;'
-   */
-  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))
+
+    /** Returns true if it encounters an end tag (without consuming it),
+     *  appends trees to ts as side-effect.
+     *
+     *  @param ts ...
+     *  @return   ...
+     */
+    private def content_LT(ts: mutable.ArrayBuffer[Tree]): Boolean = {
+      ch match {
+        case '/' =>
+          return true               // end tag
+        case '!' =>
+          nextch                    // CDATA or Comment
+          ts.append(if ('[' == ch) xCharData else xComment)
+        case '?' =>                 // PI
+          nextch
+          ts.append(xProcInstr)
+        case _   =>
+          ts.append(element)        // child node
+      }
+      false
     }
-  }
-
-  /**
-   *  @precond ch == '{'
-   *  @postcond: xEmbeddedBlock == false!
-   */
-  def content_BRACE(p: Position, ts:mutable.ArrayBuffer[Tree]): Unit = {
-    if (xCheckEmbeddedBlock)
-      ts.append(xEmbeddedExpr)
-    else {
-      appendText(p, ts, xText)/*
-      val str = new StringBuilder("{")
-      str.append(xText)
-      nextch
-      appendText(p, ts, str.toString())*/
+
+    /*[Duplicate]*/ def content: mutable.Buffer[Tree] = {
+      var ts = new mutable.ArrayBuffer[Tree]
+      var exit = false
+      while (!exit) {
+        if (xEmbeddedBlock)
+          ts.append(xEmbeddedExpr)
+        else {
+          tmppos = pos
+          ch match {
+            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
+              content_AMP(ts)
+            case _ =>  // text content
+              appendText(tmppos, ts, xText)
+              // here xEmbeddedBlock might be true
+          }
+        }
+      }
+      ts
     }
-  }
-
-  /** Returns true if it encounters an end tag (without consuming it),
-   *  appends trees to ts as side-effect.
-   *
-   *  @param ts ...
-   *  @return   ...
-   */
-  def content_LT(ts: mutable.ArrayBuffer[Tree]): Boolean = {
-    ch match {
-      case '/' =>
-        return true               // end tag
-      case '!' =>
-        nextch                    // CDATA or Comment
-        ts.append(if ('[' == ch) xCharData else xComment)
-      case '?' =>                 // PI
+
+    /** '<' element ::= xmlTag1 '>'  { xmlExpr | '{' simpleExpr '}' } ETag
+     *                | xmlTag1 '/' '>'
+     */
+    /*[Duplicate]*/ def element: Tree = {
+      val pos1 = pos
+      val (qname, attrMap) = xTag
+      if (ch == '/') { // empty element
+        xToken('/')
+        xToken('>')
+        handle.element(pos1, qname, attrMap, new mutable.ListBuffer[Tree])
+      }
+      else { // handle content
+        xToken('>')
+        if (qname == "xml:unparsed")
+          return xUnparsed
+
+        debugLastStartElement.push((pos1, qname))
+        val ts = content
+        xEndTag(qname)
+        debugLastStartElement.pop
+        qname match {
+          case "xml:group" => handle.group(pos1, ts)
+          case _ => handle.element(pos1, qname, attrMap, ts)
+        }
+      }
+    }
+
+    /** actually, Name ::= (Letter | '_' | ':') (NameChar)*  but starting with ':' cannot happen
+     *  Name ::= (Letter | '_') (NameChar)*
+     *
+     *  see  [5] of XML 1.0 specification
+     *
+     *  pre-condition:  ch != ':' // assured by definition of XMLSTART token
+     *  post-condition: name does neither start, nor end in ':'
+     */
+    /*[Duplicate]*/   def xName: String = {
+      if ( !xml.Parsing.isNameStart(ch)) {
+        reportSyntaxError("name expected, but char '"+ch+"' cannot start a name")
+        return ""
+      }
+      do {
+        putChar(ch)
         nextch
-        ts.append(xProcInstr)
-      case _   =>
-        ts.append(element)        // child node
+      } while (xml.Parsing.isNameChar(ch))
+      if (':' == cbuf.charAt(cbuf.length-1)) {
+        reportSyntaxError( "name cannot end in ':'" )
+        cbuf.setLength(cbuf.length-1)
+      }
+      val n = cbuf.toString().intern()
+      cbuf.setLength(0)
+      n
     }
-    false
-  }
-
-  /*[Duplicate]*/ def content: mutable.Buffer[Tree] = {
-    var ts = new mutable.ArrayBuffer[Tree]
-    var exit = false
-    while (!exit) {
-      if (xEmbeddedBlock)
-        ts.append(xEmbeddedExpr)
-      else {
-        tmppos = pos;
-        ch match {
-          case '<' => // end tag, cdata, comment, pi or child node
+
+    /** scan [S] '=' [S]*/
+    /*[Duplicate]*/   def xEQ = { xSpaceOpt; xToken('='); xSpaceOpt }
+
+    /** skip optional space S? */
+    /*[Duplicate]*/   def xSpaceOpt = { while (xml.Parsing.isSpace(ch)) { nextch }}
+
+    /** scan [3] S ::= (#x20 | #x9 | #xD | #xA)+ */
+    /*[Duplicate]*/ def xSpace =
+      if (xml.Parsing.isSpace(ch)) { nextch; xSpaceOpt }
+      else reportSyntaxError("whitespace expected")
+
+    /** '<?' ProcInstr ::= Name [S ({Char} - ({Char}'>?' {Char})]'?>'
+     *
+     * see [15]
+     */
+    /*[Duplicate]*/ def xProcInstr: Tree = {
+      val sb: StringBuilder = new StringBuilder()
+      val n = xName
+      if (xml.Parsing.isSpace(ch)) {
+        xSpace
+        while (true) {
+          if (ch == '?' && { sb.append(ch); nextch; ch == '>' }) {
+            sb.setLength(sb.length() - 1)
             nextch
-            exit = content_LT(ts)
-          case '{' => // either the character '{' or an embedded scala block
-            content_BRACE(tmppos, ts)
-          case '&' => // EntityRef or CharRef
-            content_AMP(ts)
-          case _ =>  // text content
-            appendText(tmppos, ts, xText)
-          // here xEmbeddedBlock might be true
+            return handle.procInstr(tmppos, n.toString(), sb.toString())
+          } else
+            sb.append(ch);
+          nextch
         }
       }
-    }
-    ts
-  } /* end content */
-
-  /** '<' element ::= xmlTag1 '>'  { xmlExpr | '{' simpleExpr '}' } ETag
-   *               | xmlTag1 '/' '>'
-   */
-  /*[Duplicate]*/ def element: Tree = {
-    val pos1 = pos
-    val Tuple2(qname, attrMap) = xTag
-    //Console.println("MarkupParser::element("+qname+","+attrMap+")");
-    if (ch == '/') { // empty element
-      xToken('/')
+      xToken('?')
       xToken('>')
-      handle.element(pos1, qname, attrMap, new mutable.ListBuffer[Tree])
+      handle.procInstr(tmppos, n.toString(), sb.toString())
     }
-    else { // handle content
-      xToken('>')
-      if(qname == "xml:unparsed")
-        return xUnparsed
 
-      debugLastStartElement.push((pos1, qname))
-      val ts = content
-      xEndTag(qname)
-      debugLastStartElement.pop
-      qname match {
-        case "xml:group"   => handle.group(pos1, ts)
-        case _ => handle.element(pos1, qname, attrMap, ts)
-      }
+    /** parse character data.
+     *  precondition: xEmbeddedBlock == false (we are not in a scala block)
+     */
+    /*[Duplicate]*/ def xText: String = {
+      if (xEmbeddedBlock) Predef.error("internal error: encountered embedded block"); // assert
+      //Console.println("xText ch now "+ch)
+      //if( xCheckEmbeddedBlock ) {
+      //  return ""
+      //} else {
+        var exit = false
+        while (!exit) {
+          putChar(ch)
+          val expectRBRACE = ch == '}'
+          // TODO check for "}}"
+          nextch
+          if (expectRBRACE) {
+            if (ch == '}')
+              nextch
+            else
+              reportSyntaxError("in XML content, please use '}}' to express '}'")
+          }
+          exit = xCheckEmbeddedBlock ||(ch == '<') || (ch == '&')
+        }
+        val str = cbuf.toString()
+        cbuf.setLength(0)
+        str
+      //}
     }
-  }
-
-
-  /** actually, Name ::= (Letter | '_' | ':') (NameChar)*  but starting with ':' cannot happen
-   ** Name ::= (Letter | '_') (NameChar)*
-   *
-   *  see  [5] of XML 1.0 specification
-   *
-   *  pre-condition:  ch != ':' // assured by definition of XMLSTART token
-   *  post-condition: name does neither start, nor end in ':'
-   */
-  /*[Duplicate]*/   def xName: String = {
-    if( !xml.Parsing.isNameStart( ch ) ) {
-      reportSyntaxError( "name expected, but char '"+ch+"' cannot start a name" )
-      return ""
+
+    //val cbuf = new StringBuilder()
+
+    /** append Unicode character to name buffer*/
+    //private def putChar(c: char) = cbuf.append(c)
+
+    /** xLiteral = element { element }
+     *  @return Scala representation of this xml literal
+     *  precondition: s.xStartsXML == true
+     */
+    def xLiteral: Tree = try {
+      init; pushScannerState
+      handle.isPattern = false
+      val pos = s.currentPos
+      var lastend = 0
+      var lastch = ch
+      var tree:Tree = null
+      val ts = new mutable.ArrayBuffer[Tree]()
+      tmppos = pos    // Iuli: added this line, as it seems content_LT uses tmppos when creating trees
+      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
+      // parse more XML ?
+      if (ch == '<') {
+        //val ts = new mutable.ArrayBuffer[Tree]();
+        //ts.append( tree );
+        while (ch == '<') {
+          nextch
+          ts.append(element)
+          lastend = s.in.bp
+          lastch  = s.in.ch
+          xSpaceOpt
+        }
+        tree = handle.makeXMLseq((pos), ts)
+      } else {
+        assert(ts.length == 1)
+        tree = ts(0)
+      }
+      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
+      //}
+      //Console.println("out of xLiteral, parsed:"+tree.toString());
+      s.next.token = Tokens.EMPTY;
+      s.nextToken
+      popScannerState
+      tree
     }
-    do {
-        putChar( ch )
-        nextch
-    } while( xml.Parsing.isNameChar( ch ) )
-	if(':' == cbuf.charAt(cbuf.length-1)) {
-      reportSyntaxError( "name cannot end in ':'" )
-      cbuf.setLength(cbuf.length-1)
-	}
-    val n = cbuf.toString().intern()
-    cbuf.setLength( 0 )
-    n
-  }
-
-
-  /** scan [S] '=' [S]*/
-  /*[Duplicate]*/   def xEQ = { xSpaceOpt; xToken('='); xSpaceOpt }
-
-  /** skip optional space S? */
-  /*[Duplicate]*/   def xSpaceOpt = { while( xml.Parsing.isSpace( ch ) ) { nextch; }}
-
-  /** scan [3] S ::= (#x20 | #x9 | #xD | #xA)+ */
-  /*[Duplicate]*/ def xSpace = {
-    if (xml.Parsing.isSpace(ch)) {
-      nextch; xSpaceOpt
+    catch {
+      case _:ArrayIndexOutOfBoundsException =>
+        s.syntaxError((debugLastStartElement.top._1),
+                      "missing end tag in XML literal for <"
+                      +debugLastStartElement.top._2+">");
+        EmptyTree
     }
-    else {
-      reportSyntaxError("whitespace expected");
+
+    /** @see xmlPattern. resynchronizes after successful parse
+     *  @return this xml pattern
+     *  precondition: s.xStartsXML == true
+     */
+    def xLiteralPattern: Tree = try {
+      init; pushScannerState
+      val oldMode = handle.isPattern;
+      handle.isPattern = true
+      var tree = xPattern; xSpaceOpt;
+      handle.isPattern = oldMode;
+      s.next.token = Tokens.EMPTY;
+      s.nextToken
+      popScannerState
+      tree
+    } catch {
+      case _:ArrayIndexOutOfBoundsException =>
+        s.syntaxError((debugLastStartElement.top._1),
+                      "missing end tag in XML literal for <"
+                      +debugLastStartElement.top._2+">");
+        EmptyTree
     }
-  }
-
-/** '<?' ProcInstr ::= Name [S ({Char} - ({Char}'>?' {Char})]'?>'
-   *
-   * see [15]
-   */
-  /*[Duplicate]*/   def xProcInstr: Tree = {
-    val sb:StringBuilder = new StringBuilder();
-    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 handle.procInstr(tmppos, n.toString(), sb.toString());
-        } else
-          sb.append( ch );
-        nextch;
-      }
-    };
-    xToken('?');
-    xToken('>');
-    return handle.procInstr(tmppos, n.toString(), sb.toString());
-  }
-
-  /** parse character data.
-  *   precondition: xEmbeddedBlock == false (we are not in a scala block)
-  */
-  /*[Duplicate]*/ def xText: String = {
-    if( xEmbeddedBlock ) Predef.error("internal error: encountered embedded block"); // assert
-    //Console.println("xText ch now "+ch)
-    //if( xCheckEmbeddedBlock ) {
-    //  return ""
-    //} else {
-      var exit = false;
-      while( !exit ) {
-        putChar( ch );
-        val expectRBRACE = ch == '}'
-        // TODO check for "}}"
-        nextch
-        if(expectRBRACE) {
-          if(ch == '}')
-            nextch
-          else
-            reportSyntaxError("in XML content, please use '}}' to express '}'")
-        }
-        exit = xCheckEmbeddedBlock ||( ch == '<' ) || ( ch == '&' );
+
+    def xEmbeddedExpr: Tree = {
+      sync
+      val b = p.block() //p.expr(true,false);
+      if (/*s.*/token != RBRACE) {
+        reportSyntaxError(" expected end of Scala block")
       }
-      val str = cbuf.toString();
-      cbuf.setLength( 0 );
-      str
-    //}
-  }
-
-  //val cbuf = new StringBuilder();
-
-  /** append Unicode character to name buffer*/
-  //private def putChar(c: char) = cbuf.append( c );
-
-  /** xLiteral = element { element }
-   * @return Scala representation of this xml literal
-   * precondition: s.xStartsXML == true
-  */
-  def xLiteral: Tree = try {
-    //Console.println("entering xLiteral!!")
-    init; pushScannerState
-    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]()
-    tmppos = pos    // Iuli: added this line, as it seems content_LT uses tmppos when creating trees
-    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
-    // parse more XML ?
-    if (ch == '<') {
-      //val ts = new mutable.ArrayBuffer[Tree]();
-      //ts.append( tree );
-      while( ch == '<' ) {
-        nextch
-        ts.append( element )
-        lastend = s.in.bp
-        lastch  = s.in.ch
-        xSpaceOpt
+      init
+      b
+    }
+
+    /** xScalaPatterns  ::= patterns
+     */
+    def xScalaPatterns: List[Tree] = {
+      sync
+      val b = p.patterns(true)
+      if (/*s.*/token != RBRACE) {
+        reportSyntaxError(" expected end of Scala patterns")
       }
-      tree = handle.makeXMLseq((pos), ts )
-    } else {
-      assert(ts.length == 1)
-      tree = ts(0)
+      init
+      b
     }
-    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
-    //}
-    //Console.println("out of xLiteral, parsed:"+tree.toString());
-    s.next.token = Tokens.EMPTY;
-    s.nextToken
-    popScannerState
-    tree
-  }
-  catch {
-    case _:ArrayIndexOutOfBoundsException =>
-      s.syntaxError((debugLastStartElement.top._1),
-                    "missing end tag in XML literal for <"
-                    +debugLastStartElement.top._2+">");
-      EmptyTree;
-  }
-
-  /** @see xmlPattern. resynchronizes after succesful parse
-   * @return this xml pattern
-   * precondition: s.xStartsXML == true
-  */
-  def xLiteralPattern:Tree = try {
-    init; pushScannerState
-    val oldMode = handle.isPattern;
-    handle.isPattern = true
-    var tree = xPattern; xSpaceOpt;
-    handle.isPattern = oldMode;
-    s.next.token = Tokens.EMPTY;
-    s.nextToken
-    popScannerState
-    tree
-  } catch {
-    case _:ArrayIndexOutOfBoundsException =>
-      s.syntaxError((debugLastStartElement.top._1),
-                    "missing end tag in XML literal for <"
-                    +debugLastStartElement.top._2+">");
-      EmptyTree;
-  }
-
-  def xEmbeddedExpr: Tree = {
-    sync
-    val b = p.block() //p.expr(true,false);
-    if(/*s.*/token != RBRACE) {
-      reportSyntaxError(" expected end of Scala block")
+
+    //var ch: Char = _;
+
+    /** this method assign the next character to ch and advances in input */
+    def nextch { s.in.next; /*s.xNext;*/ ch = s.in.ch ; pos = s.in.cpos }
+
+    //def lookahead = { s.xLookahead }
+    var scannerState: List[List[Int]] = Nil
+
+    private def pushScannerState {
+      scannerState = s.sepRegions :: scannerState
+      s.sepRegions = Nil
     }
-    init
-    return b
-  }
-
-  /** xScalaPatterns  ::= patterns
-   */
-  def xScalaPatterns: List[Tree] = {
-    sync;
-    val b = p.patterns(true);
-    if (/*s.*/token != RBRACE) {
-      reportSyntaxError(" expected end of Scala patterns")
+
+    private def popScannerState {
+      s.sepRegions = scannerState.head
+      scannerState = scannerState.tail
     }
-    init
-    return b
-  }
-
-  //var ch: Char = _;
-
-  /** this method assign the next character to ch and advances in input */
-  def nextch: Unit = { s.in.next; /*s.xNext;*/ ch = s.in.ch ; pos = s.in.cpos; }
-
-  //def lookahead = { s.xLookahead }
-  var scannerState: List[List[Int]] = Nil
-
-  def pushScannerState {
-    scannerState = s.sepRegions::scannerState
-    s.sepRegions = Nil
-  }
-  def popScannerState  {
-    s.sepRegions = scannerState.head;
-    scannerState = scannerState.tail
-  }
-
-  def init: Unit = {
-    ch = s.in.ch;
-    pos = s.in.cpos;
-    //Console.println("\ninit! ch = "+ch);
-  }
-
-  def reportSyntaxError(str: String) = {
-    s.syntaxError(pos-1, "in XML literal: " + str)
-    nextch
-  }
-
-  def sync: Unit = {
-    xEmbeddedBlock = false
-    s.xSync
-  }
-
-  /** '<' xPattern  ::= Name [S] { xmlPattern | '{' pattern3 '}' } ETag
-   *                  | Name [S] '/' '>'
-   */
-  def xPattern:Tree = {
-    //Console.println("xPattern")
-    val pos1 = pos
-    val qname = xName
-    debugLastStartElement.push((pos1, qname))
-    xSpaceOpt
-    if (ch == '/') { // empty tag
+
+    private def init {
+      ch = s.in.ch
+      pos = s.in.cpos
+    }
+
+    def reportSyntaxError(str: String) = {
+      s.syntaxError(pos-1, "in XML literal: " + str)
       nextch
-      xToken('>')
-      return handle.makeXMLpat(pos1, qname, new mutable.ArrayBuffer[Tree]())
     }
 
-     // else: tag with content
-    xToken('>')
-    var ts = new mutable.ArrayBuffer[Tree]
-    var exit = false
-    while (! exit) {
-      val pos2 = pos
-      if (xEmbeddedBlock) {
-        ts ++ xScalaPatterns
-      } else
-        ch match {
-          case '<' => { // tag
-            nextch
-            if (ch != '/') { //child
-              ts.append(xPattern)
-            } else {
-              exit = true
-            }
+    private def sync {
+      xEmbeddedBlock = false
+      s.xSync
+    }
+
+    /** '<' xPattern  ::= Name [S] { xmlPattern | '{' pattern3 '}' } ETag
+     *                  | Name [S] '/' '>'
+     */
+    def xPattern: Tree = {
+      val pos1 = pos
+      val qname = xName
+      debugLastStartElement.push((pos1, qname))
+      xSpaceOpt
+      if (ch == '/') { // empty tag
+        nextch
+        xToken('>')
+        return handle.makeXMLpat(pos1, qname, new mutable.ArrayBuffer[Tree]())
+      }
+
+      // else: tag with content
+      xToken('>')
+      var ts = new mutable.ArrayBuffer[Tree]
+      var exit = false
+      while (! exit) {
+        val pos2 = pos
+        if (xEmbeddedBlock) {
+          ts ++ xScalaPatterns
+        } else
+          ch match {
+            case '<' => // tag
+              nextch
+              if (ch != '/') { //child
+                ts.append(xPattern)
+              } else {
+                exit = true
+              }
+            case '{' => // embedded Scala patterns
+              while (ch == '{') {
+                s.in.next
+                ts ++ xScalaPatterns
+              }
+              // postcond: xEmbeddedBlock = false;
+              if (xEmbeddedBlock) Predef.error("problem with embedded block"); // assert
+            case _ => // teMaxt
+              appendText(pos2, ts, xText)
+              // here  xEmbeddedBlock might be true;
+              //if( xEmbeddedBlock ) throw new ApplicationError("after:"+text); // assert
           }
-          case '{' => // embedded Scala patterns
-            while( ch == '{' ) {
-              s.in.next;
-              ts ++ xScalaPatterns;
-            }
-            // postcond: xEmbeddedBlock = false;
-          if (xEmbeddedBlock) Predef.error("problem with embedded block"); // assert
-          case _ => // teMaxt
-            appendText( pos2, ts, xText );
-          // here  xEmbeddedBlock might be true;
-          //if( xEmbeddedBlock ) throw new ApplicationError("after:"+text); // assert
-        }
+      }
+      xEndTag(qname)
+      debugLastStartElement.pop
+      handle.makeXMLpat(pos1, qname, ts)
     }
-    xEndTag(qname)
-    debugLastStartElement.pop
-    handle.makeXMLpat(pos1, qname, ts)
-  }
 
-} /* class MarkupParser */
+  } /* class MarkupParser */
 }
diff --git a/src/library/scala/xml/Parsing.scala b/src/library/scala/xml/Parsing.scala
index 17bf4567b4..9f2934a7b5 100644
--- a/src/library/scala/xml/Parsing.scala
+++ b/src/library/scala/xml/Parsing.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
diff --git a/src/library/scala/xml/ProcInstr.scala b/src/library/scala/xml/ProcInstr.scala
index 3ff1f9b82c..b204466a15 100644
--- a/src/library/scala/xml/ProcInstr.scala
+++ b/src/library/scala/xml/ProcInstr.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -9,47 +9,43 @@
 // $Id$
 
 
-package scala.xml;
-
-
-import compat.StringBuilder
+package scala.xml
 
 /** an XML node for processing instructions (PI)
  *
  * @author Burak Emir
  * @param  target target name of this PI
  * @param  text   text contained in this node, may not contain "?>"
-**/
-
+ */
 case class ProcInstr(target:String, proctext:String) extends SpecialNode {
 
-  if( !Utility.isName( target ) )
-    throw new IllegalArgumentException(target+" must be an XML Name");
-  else if( text.indexOf("?>" ) != -1 )
-    throw new IllegalArgumentException(proctext+" may not contain \"?>\"");
+  if (!Utility.isName(target))
+    throw new IllegalArgumentException(target+" must be an XML Name")
+  else if (text.indexOf("?>") != -1)
+    throw new IllegalArgumentException(proctext+" may not contain \"?>\"")
 
-  final override def typeTag$:Int = -2;
+  final override def typeTag$: Int = -2
 
   (target: Seq[Char]) match {
     case Seq('X'|'x','M'|'m','L'|'l') =>
-      throw new IllegalArgumentException(target+" is reserved");
+      throw new IllegalArgumentException(target+" is reserved")
     case _ =>
   }
 
   /** structural equality */
   override def equals(x: Any): Boolean = x match {
-    case ProcInstr(x,y) => x.equals(target) && y.equals(proctext);
+    case ProcInstr(x, y) => x.equals(target) && y.equals(proctext)
     case _ => false
   }
 
   /** the constant "#PI" */
-  final def label    = "#PI";
+  final def label = "#PI"
 
   /** hashcode for this PI */
-  override def hashCode() = target.hashCode() * 7 + proctext.hashCode();
+  override def hashCode() = target.hashCode() * 7 + proctext.hashCode()
 
 
-  override def text = "";
+  override def text = ""
 
   /** appends &quot;&lt;?&quot; target (&quot; &quot;+text)?+&quot;?&gt;&quot;
    *  to this stringbuffer.
@@ -58,11 +54,11 @@ case class ProcInstr(target:String, proctext:String) extends SpecialNode {
     sb
     .append("<?")
     .append(target);
-    if( proctext.length() > 0 ) {
+    if (proctext.length() > 0) {
       sb
       .append(' ')
       .append(proctext);
-    };
-    sb.append("?>");
+    }
+    sb.append("?>")
   }
 }
diff --git a/src/library/scala/xml/XML.scala b/src/library/scala/xml/XML.scala
index e9e51ca520..675d4dcbb7 100644
--- a/src/library/scala/xml/XML.scala
+++ b/src/library/scala/xml/XML.scala
@@ -1,7 +1,7 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2003-2006, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2007, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
@@ -25,7 +25,7 @@ import java.io.{InputStream, Reader, StringReader, Writer}
  *  @author  Burak Emir
  *  @version 1.0, 25/04/2005
  */
-object XML  {
+object XML {
 
   val xml       = "xml"
   val xmlns     = "xmlns"
@@ -33,6 +33,7 @@ object XML  {
   val preserve  = "preserve"
   val space     = "space"
   val lang      = "lang"
+  val encoding  = "ISO-8859-1"
 
   // functions for generic xml loading, saving
 
@@ -89,7 +90,7 @@ object XML  {
    *  @param node     ...
    */
   final def save(filename: String, node: Node): Unit =
-    save(filename, node, "ISO-8859-1")
+    save(filename, node, encoding)
 
   /** saves XML to filename with given encoding, without xml-decl without
    *  <code>doctype</code>.
@@ -110,7 +111,7 @@ object XML  {
    *  @param doctype  if not null, write doctype declaration
    */
   final def saveFull(filename: String, node: Node, xmlDecl: Boolean, doctype: dtd.DocType): Unit =
-    saveFull(filename, node, "ISO-8859-1", xmlDecl, doctype)
+    saveFull(filename, node, encoding, xmlDecl, doctype)
 
   /** Saves a node to a file with given filename using given encoding
    *  optionally with xmldecl and doctype declaration.
@@ -122,7 +123,7 @@ object XML  {
    *  @param doctype  if not null, write doctype declaration
    */
 
-  final def saveFull(filename: String, node: Node, enc: String, xmlDecl: Boolean, doctype: dtd.DocType): Unit = {
+  final def saveFull(filename: String, node: Node, enc: String, xmlDecl: Boolean, doctype: dtd.DocType) {
     var fos: FileOutputStream = null
     var w: Writer = null
     try {
@@ -148,7 +149,7 @@ object XML  {
    *  @param xmlDecl  if true, write xml declaration
    *  @param doctype  if not null, write doctype declaration
    */
-  final def write(w: java.io.Writer, node: Node, enc: String, xmlDecl: Boolean, doctype: dtd.DocType): Unit = {
+  final def write(w: java.io.Writer, node: Node, enc: String, xmlDecl: Boolean, doctype: dtd.DocType) {
     /* TODO: optimize by giving writer parameter to toXML*/
     if (xmlDecl) w.write("<?xml version='1.0' encoding='" + enc + "'?>\n")
     if (doctype ne null) w.write( doctype.toString() + "\n")