3rd round of clean ups (see r25285, r25292)

73 files changed, 592 insertions, 769 deletions

diff --git a/src/actors/scala/actors/Actor.scala b/src/actors/scala/actors/Actor.scala
index 57e107538c..ba4d90f0b3 100644
--- a/src/actors/scala/actors/Actor.scala
+++ b/src/actors/scala/actors/Actor.scala
@@ -6,39 +6,35 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
 import scala.util.control.ControlThrowable
 import java.util.{Timer, TimerTask}
 
 /**
- * Provides functions for the definition of
- * actors, as well as actor operations, such as
- * <code>receive</code>, <code>react</code>, <code>reply</code>,
- * etc.
+ * Provides functions for the definition of actors, as well as actor
+ * operations, such as `receive`, `react`, `reply`, etc.
  *
  * @author Philipp Haller
  */
 object Actor extends Combinators {
 
   /** State of an actor.
-   *  <ul>
-   *    <li><b>New</b> -
-   *      Not yet started</li>
-   *    <li><b>Runnable</b> -
-   *      Executing</li>
-   *    <li><b>Suspended</b> -
-   *      Suspended, waiting in a `react`</li>
-   *    <li><b>TimedSuspended</b> -
-   *      Suspended, waiting in a `reactWithin` </li>
-   *    <li><b>Blocked</b> -
-   *      Blocked waiting in a `receive` </li>
-   *    <li><b>TimedBlocked</b> -
-   *      Blocked waiting in a `receiveWithin` </li>
-   *    <li><b>Terminated</b> -
-   *      Actor has terminated </li>
-   *  </ul>
+   *
+   *  - '''New''' -
+   *      Not yet started
+   *  - '''Runnable''' -
+   *      Executing
+   *  - '''Suspended''' -
+   *      Suspended, waiting in a `react`
+   *  - '''TimedSuspended''' -
+   *      Suspended, waiting in a `reactWithin`
+   *  - '''Blocked''' -
+   *      Blocked waiting in a `receive`
+   *  - '''TimedBlocked''' -
+   *      Blocked waiting in a `receiveWithin`
+   *  - '''Terminated''' -
+   *      Actor has terminated
    */
   object State extends Enumeration {
     val New,
@@ -59,8 +55,7 @@ object Actor extends Combinators {
 
   /**
    * Returns the currently executing actor. Should be used instead
-   * of <code>this</code> in all blocks of code executed by
-   * actors.
+   * of `'''this'''` in all blocks of code executed by actors.
    *
    * @return returns the currently executing actor.
    */
@@ -89,11 +84,11 @@ object Actor extends Combinators {
 
   /**
    * Resets an actor proxy associated with the current thread.
-   * It replaces the implicit <code>ActorProxy</code> instance
+   * It replaces the implicit `ActorProxy` instance
    * of the current thread (if any) with a new instance.
    *
    * This permits to re-use the current thread as an actor
-   * even if its <code>ActorProxy</code> has died for some reason.
+   * even if its `ActorProxy` has died for some reason.
    */
   def resetProxy() {
     val a = tl.get
@@ -102,16 +97,15 @@ object Actor extends Combinators {
   }
 
   /**
-   * Removes any reference to an <code>Actor</code> instance
+   * Removes any reference to an `Actor` instance
    * currently stored in thread-local storage.
    *
-   * This allows to release references from threads that are
-   * potentially long-running or being re-used (e.g. inside
-   * a thread pool). Permanent references in thread-local storage
-   * are a potential memory leak.
+   * This allows to release references from threads that are potentially
+   * long-running or being re-used (e.g. inside a thread pool). Permanent
+   * references in thread-local storage are a potential memory leak.
    */
   def clearSelf() {
-    tl.set(null)
+    tl set null
   }
 
   /**
@@ -168,15 +162,13 @@ object Actor extends Combinators {
   }
 
   /**
-   * Receives the next message from the mailbox of the current actor
-   * <code>self</code>.
+   * Receives the next message from the mailbox of the current actor `self`.
    */
   def ? : Any = self.?
 
   /**
-   * Receives a message from the mailbox of
-   * <code>self</code>. Blocks if no message matching any of the
-   * cases of <code>f</code> can be received.
+   * Receives a message from the mailbox of `self`. Blocks if no message
+   * matching any of the cases of `f` can be received.
    *
    * @example {{{
    * receive {
@@ -193,12 +185,10 @@ object Actor extends Combinators {
     self.receive(f)
 
   /**
-   * Receives a message from the mailbox of
-   * <code>self</code>. Blocks at most <code>msec</code>
-   * milliseconds if no message matching any of the cases of
-   * <code>f</code> can be received. If no message could be
-   * received the <code>TIMEOUT</code> action is executed if
-   * specified.
+   * Receives a message from the mailbox of `self`. Blocks at most `msec`
+   * milliseconds if no message matching any of the cases of `f` can be
+   * received. If no message could be received the `TIMEOUT` action is
+   * executed if specified.
    *
    * @param  msec the time span before timeout
    * @param  f    a partial function specifying patterns and actions
@@ -208,11 +198,10 @@ object Actor extends Combinators {
     self.receiveWithin(msec)(f)
 
   /**
-   * Lightweight variant of <code>receive</code>.
+   * Lightweight variant of `receive`.
    *
-   * Actions in <code>f</code> have to contain the rest of the
-   * computation of <code>self</code>, as this method will never
-   * return.
+   * Actions in `f` have to contain the rest of the computation of `self`,
+   * as this method will never return.
    *
    * A common method of continuting the computation is to send a message
    * to another actor:
@@ -241,11 +230,10 @@ object Actor extends Combinators {
     rawSelf.react(f)
 
   /**
-   * Lightweight variant of <code>receiveWithin</code>.
+   * Lightweight variant of `receiveWithin`.
    *
-   * Actions in <code>f</code> have to contain the rest of the
-   * computation of <code>self</code>, as this method will never
-   * return.
+   * Actions in `f` have to contain the rest of the computation of `self`,
+   * as this method will never return.
    *
    * @param  msec the time span before timeout
    * @param  f    a partial function specifying patterns and actions
@@ -274,23 +262,21 @@ object Actor extends Combinators {
     rawSelf.sender
 
   /**
-   * Sends <code>msg</code> to the actor waiting in a call to
-   * <code>!?</code>.
+   * Sends `msg` to the actor waiting in a call to `!?`.
    */
   def reply(msg: Any): Unit =
     rawSelf.reply(msg)
 
   /**
-   * Sends <code>()</code> to the actor waiting in a call to
-   * <code>!?</code>.
+   * Sends `()` to the actor waiting in a call to `!?`.
    */
   def reply(): Unit =
     rawSelf.reply(())
 
   /**
-   * Returns the number of messages in <code>self</code>'s mailbox
+   * Returns the number of messages in `self`'s mailbox
    *
-   * @return the number of messages in <code>self</code>'s mailbox
+   * @return the number of messages in `self`'s mailbox
    */
   def mailboxSize: Int = rawSelf.mailboxSize
 
@@ -321,7 +307,7 @@ object Actor extends Combinators {
   }
 
   /**
-   * Links <code>self</code> to actor <code>to</code>.
+   * Links `self` to actor `to`.
    *
    * @param  to the actor to link to
    * @return    the parameter actor
@@ -329,7 +315,7 @@ object Actor extends Combinators {
   def link(to: AbstractActor): AbstractActor = self.link(to)
 
   /**
-   * Links <code>self</code> to the actor defined by <code>body</code>.
+   * Links `self` to the actor defined by `body`.
    *
    * @param body the body of the actor to link to
    * @return     the parameter actor
@@ -337,107 +323,78 @@ object Actor extends Combinators {
   def link(body: => Unit): Actor = self.link(body)
 
   /**
-   * Unlinks <code>self</code> from actor <code>from</code>.
+   * Unlinks `self` from actor `from`.
    *
    * @param from the actor to unlink from
    */
   def unlink(from: AbstractActor): Unit = self.unlink(from)
 
   /**
-   * <p>
-   *   Terminates execution of <code>self</code> with the following
-   *   effect on linked actors:
-   * </p>
-   * <p>
-   *   For each linked actor <code>a</code> with
-   *   <code>trapExit</code> set to <code>true</code>, send message
-   *   <code>Exit(self, reason)</code> to <code>a</code>.
-   * </p>
-   * <p>
-   *   For each linked actor <code>a</code> with
-   *   <code>trapExit</code> set to <code>false</code> (default),
-   *   call <code>a.exit(reason)</code> if
-   *   <code>reason != 'normal</code>.
-   * </p>
+   * Terminates execution of `self` with the following effect on
+   * linked actors:
+   *
+   * For each linked actor `a` with `trapExit` set to `'''true'''`,
+   * send message `Exit(self, reason)` to `a`.
+   *
+   * For each linked actor `a` with `trapExit` set to `'''false'''`
+   * (default), call `a.exit(reason)` if `reason != 'normal`.
    */
   def exit(reason: AnyRef): Nothing = self.exit(reason)
 
   /**
-   * <p>
-   *   Terminates execution of <code>self</code> with the following
-   *   effect on linked actors:
-   * </p>
-   * <p>
-   *   For each linked actor <code>a</code> with
-   *   <code>trapExit</code> set to <code>true</code>, send message
-   *   <code>Exit(self, 'normal)</code> to <code>a</code>.
-   * </p>
+   * Terminates execution of `self` with the following effect on
+   * linked actors:
+   *
+   * For each linked actor `a` with `trapExit` set to `'''true'''`,
+   * send message `Exit(self, 'normal)` to `a`.
    */
   def exit(): Nothing = rawSelf.exit()
 
 }
 
-/**
- * <p>
- *   Provides lightweight, concurrent actors. Actors are
- *   created by extending the `Actor` trait (alternatively, one of the
- *   factory methods in its companion object can be used).  The
- *   behavior of an `Actor` subclass is defined by implementing its
- *   `act` method:
- *
- *   {{{
- *   class MyActor extends Actor {
- *     def act() {
- *       // actor behavior goes here
- *     }
- *   }
- *   }}}
+/** Provides lightweight, concurrent actors. Actors are created by extending
+ *  the `Actor` trait (alternatively, one of the factory methods in its
+ *  companion object can be used).  The behavior of an `Actor` subclass is
+ *  defined by implementing its `act` method:
+ *  {{{
+ *  class MyActor extends Actor {
+ *    def act() {
+ *      // actor behavior goes here
+ *    }
+ *  }
+ *  }}}
+ *  A new `Actor` instance is started by invoking its `start` method.
  *
- *   A new `Actor` instance is started by invoking its `start` method.
+ *  '''Note:''' care must be taken when invoking thread-blocking methods other
+ *  than those provided by the `Actor` trait or its companion object (such as
+ *  `receive`). Blocking the underlying thread inside an actor may lead to
+ *  starvation of other actors. This also applies to actors hogging their
+ *  thread for a long time between invoking `receive`/`react`.
  *
- *   '''Note:''' care must be taken when invoking thread-blocking methods
- *   other than those provided by the `Actor` trait or its companion
- *   object (such as `receive`). Blocking the underlying thread inside
- *   an actor may lead to starvation of other actors. This also
- *   applies to actors hogging their thread for a long time between
- *   invoking `receive`/`react`.
+ *  If actors use blocking operations (for example, methods for blocking I/O),
+ *  there are several options:
  *
- *   If actors use blocking operations (for example, methods for
- *   blocking I/O), there are several options:
- *   <ul>
- *     <li>The run-time system can be configured to use a larger thread pool size
- *     (for example, by setting the `actors.corePoolSize` JVM property).</li>
+ *  - The run-time system can be configured to use a larger thread pool size
+ *    (for example, by setting the `actors.corePoolSize` JVM property).
+ *  - The `scheduler` method of the `Actor` trait can be overridden to return a
+ *    `ResizableThreadPoolScheduler`, which resizes its thread pool to
+ *    avoid starvation caused by actors that invoke arbitrary blocking methods.
+ *  - The `actors.enableForkJoin` JVM property can be set to `false`, in which
+ *    case a `ResizableThreadPoolScheduler` is used by default to execute actors.
  *
- *     <li>The `scheduler` method of the `Actor` trait can be overridden to return a
- *     `ResizableThreadPoolScheduler`, which resizes its thread pool to
- *     avoid starvation caused by actors that invoke arbitrary blocking methods.</li>
+ *  The main ideas of the implementation are explained in the two papers
  *
- *     <li>The `actors.enableForkJoin` JVM property can be set to `false`, in which
- *     case a `ResizableThreadPoolScheduler` is used by default to execute actors.</li>
- *   </ul>
- * </p>
- * <p>
- * The main ideas of the implementation are explained in the two papers
- * <ul>
- *   <li>
- *     <a href="http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf">
- *     <span style="font-weight:bold; white-space:nowrap;">Event-Based
- *     Programming without Inversion of Control</span></a>,
- *     Philipp Haller and Martin Odersky, <i>Proc. JMLC 2006</i>, and
- *   </li>
- *   <li>
- *     <a href="http://lamp.epfl.ch/~phaller/doc/haller07coord.pdf">
- *     <span style="font-weight:bold; white-space:nowrap;">Actors that
- *     Unify Threads and Events</span></a>,
- *     Philipp Haller and Martin Odersky, <i>Proc. COORDINATION 2007</i>.
- *   </li>
- * </ul>
- * </p>
+ *  - [[http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf Event-Based
+ *    Programming without Inversion of Control]],
+ *    Philipp Haller and Martin Odersky, ''Proc. JMLC 2006'', and
+ *  - [[http://lamp.epfl.ch/~phaller/doc/haller07coord.pdf Actors that
+ *    Unify Threads and Events]],
+ *    Philipp Haller and Martin Odersky, ''Proc. COORDINATION 2007''.
  *
- * @author Philipp Haller
+ *  @author Philipp Haller
  *
- * @define actor actor
- * @define channel actor's mailbox
+ *  @define actor actor
+ *  @define channel actor's mailbox
  */
 @SerialVersionUID(-781154067877019505L)
 trait Actor extends AbstractActor with ReplyReactor with ActorCanReply with InputChannel[Any] with Serializable {
@@ -729,7 +686,7 @@ trait Actor extends AbstractActor with ReplyReactor with ActorCanReply with Inpu
   private[actors] var links: List[AbstractActor] = Nil
 
   /**
-   * Links <code>self</code> to actor <code>to</code>.
+   * Links `self` to actor `to`.
    *
    * @param to the actor to link to
    * @return   the parameter actor
@@ -742,7 +699,7 @@ trait Actor extends AbstractActor with ReplyReactor with ActorCanReply with Inpu
   }
 
   /**
-   * Links <code>self</code> to the actor defined by <code>body</code>.
+   * Links `self` to the actor defined by `body`.
    *
    * @param body the body of the actor to link to
    * @return     the parameter actor
@@ -763,7 +720,7 @@ trait Actor extends AbstractActor with ReplyReactor with ActorCanReply with Inpu
   }
 
   /**
-   * Unlinks <code>self</code> from actor <code>from</code>.
+   * Unlinks `self` from actor `from`.
    */
   def unlink(from: AbstractActor) {
     assert(Actor.self(scheduler) == this, "unlink called on actor different from self")
@@ -783,21 +740,14 @@ trait Actor extends AbstractActor with ReplyReactor with ActorCanReply with Inpu
   private[actors] var shouldExit = false
 
   /**
-   * <p>
-   *   Terminates execution of <code>self</code> with the following
-   *   effect on linked actors:
-   * </p>
-   * <p>
-   *   For each linked actor <code>a</code> with
-   *   <code>trapExit</code> set to <code>true</code>, send message
-   *   <code>Exit(self, reason)</code> to <code>a</code>.
-   * </p>
-   * <p>
-   *   For each linked actor <code>a</code> with
-   *   <code>trapExit</code> set to <code>false</code> (default),
-   *   call <code>a.exit(reason)</code> if
-   *   <code>reason != 'normal</code>.
-   * </p>
+   * Terminates execution of `self` with the following effect on
+   * linked actors:
+   *
+   * For each linked actor `a` with `trapExit` set to `'''true'''`,
+   * send message `Exit(self, reason)` to `a`.
+   *
+   * For each linked actor `a` with `trapExit` set to `'''false'''`
+   * (default), call `a.exit(reason)` if `reason != 'normal`.
    */
   protected[actors] def exit(reason: AnyRef): Nothing = {
     synchronized {
@@ -807,7 +757,7 @@ trait Actor extends AbstractActor with ReplyReactor with ActorCanReply with Inpu
   }
 
   /**
-   * Terminates with exit reason <code>'normal</code>.
+   * Terminates with exit reason `'normal`.
    */
   protected[actors] override def exit(): Nothing = {
     val todo = synchronized {
@@ -879,7 +829,7 @@ trait Actor extends AbstractActor with ReplyReactor with ActorCanReply with Inpu
       }
   }
 
-  /* Requires qualified private, because <code>RemoteActor</code> must
+  /** Requires qualified private, because `RemoteActor` must
    * register a termination handler.
    */
   private[actors] def onTerminate(f: => Unit) {
@@ -907,9 +857,8 @@ trait Actor extends AbstractActor with ReplyReactor with ActorCanReply with Inpu
 case object TIMEOUT
 
 
-/** Sent to an actor
- *  with `trapExit` set to `true` whenever one of its linked actors
- *  terminates.
+/** Sent to an actor with `trapExit` set to `'''true'''` whenever one of its
+ *  linked actors terminates.
  *
  *  @param from   the actor that terminated
  *  @param reason the reason that caused the actor to terminate
diff --git a/src/actors/scala/actors/ActorProxy.scala b/src/actors/scala/actors/ActorProxy.scala
index d4381ab706..d18e28bea3 100644
--- a/src/actors/scala/actors/ActorProxy.scala
+++ b/src/actors/scala/actors/ActorProxy.scala
@@ -12,8 +12,7 @@ package scala.actors
 import java.lang.Thread
 
 /**
- * Provides a dynamic actor proxy for normal
- * Java threads.
+ * Provides a dynamic actor proxy for normal Java threads.
  *
  * @author Philipp Haller
  */
@@ -22,7 +21,7 @@ private[actors] class ActorProxy(t: Thread, override final val scheduler: ISched
   def act() {}
 
   /**
-   * Terminates with exit reason <code>'normal</code>.
+   * Terminates with exit reason `'normal`.
    */
   override def exit(): Nothing = {
     shouldExit = false
diff --git a/src/actors/scala/actors/CanReply.scala b/src/actors/scala/actors/CanReply.scala
index de2c91d747..5053f43e94 100644
--- a/src/actors/scala/actors/CanReply.scala
+++ b/src/actors/scala/actors/CanReply.scala
@@ -21,8 +21,7 @@ trait CanReply[-T, +R] {
   type Future[+P] <: () => P
 
   /**
-   * Sends <code>msg</code> to this $actor and
-   * awaits reply (synchronous).
+   * Sends `msg` to this $actor and awaits reply (synchronous).
    *
    * @param  msg the message to be sent
    * @return     the reply
@@ -30,20 +29,19 @@ trait CanReply[-T, +R] {
   def !?(msg: T): R
 
   /**
-   * Sends <code>msg</code> to this $actor and
-   * awaits reply (synchronous) within <code>msec</code>
-   * milliseconds.
+   * Sends `msg` to this $actor and awaits reply (synchronous) within
+   * `msec` milliseconds.
    *
    * @param  msec the time span before timeout
    * @param  msg  the message to be sent
-   * @return      <code>None</code> in case of timeout, otherwise
-   *              <code>Some(x)</code> where <code>x</code> is the reply
+   * @return      `None` in case of timeout, otherwise
+   *              `Some(x)` where `x` is the reply
    */
   def !?(msec: Long, msg: T): Option[R]
 
   /**
-   * Sends <code>msg</code> to this $actor and
-   * immediately returns a future representing the reply value.
+   * Sends `msg` to this $actor and immediately returns a future representing
+   * the reply value.
    *
    * @param  msg the message to be sent
    * @return     the future
@@ -51,11 +49,10 @@ trait CanReply[-T, +R] {
   def !!(msg: T): Future[R]
 
   /**
-   * Sends <code>msg</code> to this $actor and
-   * immediately returns a future representing the reply value.
-   * The reply is post-processed using the partial function
-   * <code>handler</code>. This also allows to recover a more
-   * precise type for the reply value.
+   * Sends `msg` to this $actor and immediately returns a future representing
+   * the reply value. The reply is post-processed using the partial function
+   * `handler`. This also allows to recover a more precise type for the reply
+   * value.
    *
    * @param      msg the message to be sent
    * @param  handler the function to be applied to the response
diff --git a/src/actors/scala/actors/Channel.scala b/src/actors/scala/actors/Channel.scala
index f4898775fc..62331239e8 100644
--- a/src/actors/scala/actors/Channel.scala
+++ b/src/actors/scala/actors/Channel.scala
@@ -6,15 +6,13 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
 import scala.concurrent.SyncVar
 
 /**
- *  Used to pattern match on values that were sent
- *  to some channel <code>Chan<sub>n</sub></code> by the current
- *  actor <code>self</code>.
+ * Used to pattern match on values that were sent to some channel `Chan,,n,,`
+ * by the current actor `self`.
  *
  *  @example {{{
  *  receive {
@@ -28,9 +26,8 @@ import scala.concurrent.SyncVar
 case class ! [a](ch: Channel[a], msg: a)
 
 /**
- * Provides a means for typed communication among
- * actors. Only the actor creating an instance of a
- * <code>Channel</code> may receive from it.
+ * Provides a means for typed communication among actors. Only the
+ * actor creating an instance of a `Channel` may receive from it.
  *
  * @author Philipp Haller
  *
diff --git a/src/actors/scala/actors/DaemonActor.scala b/src/actors/scala/actors/DaemonActor.scala
index ad26bab652..48256106bd 100644
--- a/src/actors/scala/actors/DaemonActor.scala
+++ b/src/actors/scala/actors/DaemonActor.scala
@@ -12,8 +12,9 @@ import scheduler.DaemonScheduler
 
 /**
  * Base trait for actors with daemon semantics.
- * Unlike a regular <code>Actor</code>, an active <code>DaemonActor</code> will
- * not prevent an application terminating, much like a daemon thread.
+ *
+ * Unlike a regular `Actor`, an active `DaemonActor` will not
+ * prevent an application terminating, much like a daemon thread.
  *
  * @author Erik Engbrecht
  */
diff --git a/src/actors/scala/actors/IScheduler.scala b/src/actors/scala/actors/IScheduler.scala
index 2bb90a5fa7..bf108133e2 100644
--- a/src/actors/scala/actors/IScheduler.scala
+++ b/src/actors/scala/actors/IScheduler.scala
@@ -10,12 +10,10 @@
 package scala.actors
 
 /**
- * A common interface
- * for all schedulers used to execute actor tasks.
+ * A common interface for all schedulers used to execute actor tasks.
  *
- * Subclasses of <code>Actor</code> that override its
- * <code>scheduler</code> member must provide
- * an <code>IScheduler</code> implementation.
+ * Subclasses of `Actor` that override its `scheduler` member must provide
+ * an `IScheduler` implementation.
  *
  * @author Philipp Haller
  */
@@ -27,7 +25,7 @@ trait IScheduler {
    */
   def execute(fun: => Unit): Unit
 
-  /** Submits a <code>Runnable</code> for execution.
+  /** Submits a `Runnable` for execution.
    *
    *  @param  task  the task to be executed
    */
diff --git a/src/actors/scala/actors/MessageQueue.scala b/src/actors/scala/actors/MessageQueue.scala
index 777735df23..e96f3d787f 100644
--- a/src/actors/scala/actors/MessageQueue.scala
+++ b/src/actors/scala/actors/MessageQueue.scala
@@ -6,12 +6,10 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
 /**
- * This class is used by our efficient message queue
- * implementation.
+ * This class is used by our efficient message queue implementation.
  *
  * @author Philipp Haller
  */
@@ -28,10 +26,9 @@ private[actors] class MQueueElement[Msg >: Null](val msg: Msg, val session: Outp
 }
 
 /**
- * The class <code>MessageQueue</code> provides an efficient
- * implementation of a message queue specialized for this actor
- * library. Classes in this package are supposed to be the only
- * clients of this class.
+ * The class `MessageQueue` provides an efficient implementation of a message
+ * queue specialized for this actor library. Classes in this package are
+ * supposed to be the only clients of this class.
  *
  * @author Philipp Haller
  */
@@ -107,7 +104,7 @@ private[actors] class MQueue[Msg >: Null](protected val label: String) {
     acc
   }
 
-  /** Returns the n-th message that satisfies the predicate <code>p</code>
+  /** Returns the n-th message that satisfies the predicate `p`
    *  without removing it.
    */
   def get(n: Int)(p: Msg => Boolean): Option[Msg] = {
@@ -129,8 +126,8 @@ private[actors] class MQueue[Msg >: Null](protected val label: String) {
   def remove(n: Int)(p: (Msg, OutputChannel[Any]) => Boolean): Option[(Msg, OutputChannel[Any])] =
     removeInternal(n)(p) map (x => (x.msg, x.session))
 
-  /** Extracts the first message that satisfies the predicate <code>p</code>
-   *  or <code>null</code> if <code>p</code> fails for all of them.
+  /** Extracts the first message that satisfies the predicate `p`
+   *  or `'''null'''` if `p` fails for all of them.
    */
   def extractFirst(p: (Msg, OutputChannel[Any]) => Boolean): MQueueElement[Msg] =
     removeInternal(0)(p) orNull
diff --git a/src/actors/scala/actors/OutputChannel.scala b/src/actors/scala/actors/OutputChannel.scala
index 35a95c3762..089b3d0981 100644
--- a/src/actors/scala/actors/OutputChannel.scala
+++ b/src/actors/scala/actors/OutputChannel.scala
@@ -6,7 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
 /**
@@ -19,14 +18,14 @@ package scala.actors
 trait OutputChannel[-Msg] {
 
   /**
-   * Sends <code>msg</code> to this $actor (asynchronous).
+   * Sends `msg` to this $actor (asynchronous).
    *
    * @param  msg      the message to send
    */
   def !(msg: Msg): Unit
 
   /**
-   * Sends <code>msg</code> to this $actor (asynchronous) supplying
+   * Sends `msg` to this $actor (asynchronous) supplying
    * explicit reply destination.
    *
    * @param  msg      the message to send
@@ -35,14 +34,14 @@ trait OutputChannel[-Msg] {
   def send(msg: Msg, replyTo: OutputChannel[Any]): Unit
 
   /**
-   * Forwards <code>msg</code> to this $actor (asynchronous).
+   * Forwards `msg` to this $actor (asynchronous).
    *
    * @param  msg      the message to forward
    */
   def forward(msg: Msg): Unit
 
   /**
-   * Returns the <code>Actor</code> that is receiving from this $actor.
+   * Returns the `Actor` that is receiving from this $actor.
    */
   def receiver: Actor
 }
diff --git a/src/actors/scala/actors/ReactChannel.scala b/src/actors/scala/actors/ReactChannel.scala
index 9b6c1c5c77..fccde34272 100644
--- a/src/actors/scala/actors/ReactChannel.scala
+++ b/src/actors/scala/actors/ReactChannel.scala
@@ -26,8 +26,8 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Sends a message to this <code>ReactChannel</code>
-   * (asynchronous) supplying explicit reply destination.
+   * Sends a message to this `ReactChannel` (asynchronous) supplying
+   * explicit reply destination.
    *
    * @param  msg     the message to send
    * @param  replyTo the reply destination
@@ -37,17 +37,17 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Forwards <code>msg</code> to <code>this</code> keeping the
-   * last sender as sender instead of <code>self</code>.
+   * Forwards `msg` to `'''this'''` keeping the last sender as sender
+   * instead of `self`.
    */
   def forward(msg: Msg) {
     receiver forward SendToReactor(this, msg)
   }
 
   /**
-   * Receives a message from this <code>ReactChannel</code>.
-   * <p>
-   * This method never returns. Therefore, the rest of the computation
+   * Receives a message from this `ReactChannel`.
+   *
+   * This method ''never'' returns. Therefore, the rest of the computation
    * has to be contained in the actions of the partial function.
    *
    * @param  f    a partial function with message patterns and actions
@@ -61,10 +61,9 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Receives a message from this <code>ReactChannel</code> within
-   * a certain time span.
-   * <p>
-   * This method never returns. Therefore, the rest of the computation
+   * Receives a message from this `ReactChannel` within a certain time span.
+   *
+   * This method ''never'' returns. Therefore, the rest of the computation
    * has to be contained in the actions of the partial function.
    *
    * @param  msec the time span before timeout
@@ -81,7 +80,7 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Receives a message from this <code>ReactChannel</code>.
+   * Receives a message from this `ReactChannel`.
    *
    * @param  f    a partial function with message patterns and actions
    * @return      result of processing the received value
@@ -96,8 +95,7 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Receives a message from this <code>ReactChannel</code> within a certain
-   * time span.
+   * Receives a message from this `ReactChannel` within a certain time span.
    *
    * @param  msec the time span before timeout
    * @param  f    a partial function with message patterns and actions
@@ -114,7 +112,7 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Receives the next message from this <code>ReactChannel</code>.
+   * Receives the next message from this `ReactChannel`.
    */
   def ? : Msg = receive {
     case x => x
diff --git a/src/actors/scala/actors/ReplyReactor.scala b/src/actors/scala/actors/ReplyReactor.scala
index 85ef0d38d3..0e5ce00c91 100644
--- a/src/actors/scala/actors/ReplyReactor.scala
+++ b/src/actors/scala/actors/ReplyReactor.scala
@@ -6,16 +6,16 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
 import java.util.{Timer, TimerTask}
 
 /**
- * Extends the [[scala.actors.Reactor]]
- *    trait with methods to reply to the sender of a message.
- *    Sending a message to a <code>ReplyReactor</code> implicitly
- *    passes a reference to the sender together with the message.
+ * Extends the [[scala.actors.Reactor]] trait with methods to reply to the
+ * sender of a message.
+ *
+ * Sending a message to a `ReplyReactor` implicitly passes a reference to
+ * the sender together with the message.
  *
  *  @author Philipp Haller
  *
@@ -43,7 +43,7 @@ trait ReplyReactor extends Reactor[Any] with ReactorCanReply {
   protected[actors] def sender: OutputChannel[Any] = senders.head
 
   /**
-   * Replies with <code>msg</code> to the sender.
+   * Replies with `msg` to the sender.
    */
   protected[actors] def reply(msg: Any) {
     sender ! msg
diff --git a/src/actors/scala/actors/Scheduler.scala b/src/actors/scala/actors/Scheduler.scala
index 7fe492cae2..0729ff5bc8 100644
--- a/src/actors/scala/actors/Scheduler.scala
+++ b/src/actors/scala/actors/Scheduler.scala
@@ -38,7 +38,7 @@ object Scheduler extends DelegatingScheduler {
     sched
   }
 
-  /* Only <code>ForkJoinScheduler</code> implements this method.
+  /* Only `ForkJoinScheduler` implements this method.
    */
   @deprecated("snapshot will be removed", "2.8.0")
   def snapshot() {
@@ -48,7 +48,7 @@ object Scheduler extends DelegatingScheduler {
       sys.error("scheduler does not implement snapshot")
   }
 
-  /* Only <code>ForkJoinScheduler</code> implements this method.
+  /* Only `ForkJoinScheduler` implements this method.
    */
   @deprecated("restart will be removed", "2.8.0")
   def restart() {
diff --git a/src/actors/scala/actors/remote/TcpService.scala b/src/actors/scala/actors/remote/TcpService.scala
index be34e93cdd..9d86a97f2d 100644
--- a/src/actors/scala/actors/remote/TcpService.scala
+++ b/src/actors/scala/actors/remote/TcpService.scala
@@ -77,7 +77,7 @@ class TcpService(port: Int, cl: ClassLoader) extends Thread with Service {
 
   /**
    * Sends a byte array to another node on the network.
-   * If the node is not yet up, up to <code>TcpService.BufSize</code>
+   * If the node is not yet up, up to `TcpService.BufSize`
    * messages are buffered.
    */
   def send(node: Node, data: Array[Byte]): Unit = synchronized {
diff --git a/src/actors/scala/actors/scheduler/ActorGC.scala b/src/actors/scala/actors/scheduler/ActorGC.scala
index 41ec401dbf..e1eaf86607 100644
--- a/src/actors/scala/actors/scheduler/ActorGC.scala
+++ b/src/actors/scala/actors/scheduler/ActorGC.scala
@@ -19,9 +19,9 @@ import scala.collection.mutable
  * either been explicitly terminated or garbage collected.
  *
  * When an actor is started, it is registered with the ActorGC via the
- * <code>newActor</code> method, and when an actor is knowingly terminated
+ * `newActor` method, and when an actor is knowingly terminated
  * (e.g. act method finishes, exit explicitly called, an exception is thrown),
- * the ActorGC is informed via the <code>terminated</code> method.
+ * the ActorGC is informed via the `terminated` method.
  */
 trait ActorGC extends TerminationMonitor {
   self: IScheduler =>
@@ -31,8 +31,8 @@ trait ActorGC extends TerminationMonitor {
 
   /**
    * This is a set of references to all the actors registered with
-   * this ActorGC. It is maintained so that the WeakReferences will not be GC'd
-   * before the actors to which they point.
+   * this ActorGC. It is maintained so that the WeakReferences will
+   * not be GC'd before the actors to which they point.
    */
   private val refSet = new mutable.HashSet[Reference[t] forSome { type t <: TrackedReactor }]
 
diff --git a/src/actors/scala/actors/scheduler/QuitControl.scala b/src/actors/scala/actors/scheduler/QuitControl.scala
index 9560a0e8b8..935e2a8e11 100644
--- a/src/actors/scala/actors/scheduler/QuitControl.scala
+++ b/src/actors/scala/actors/scheduler/QuitControl.scala
@@ -11,8 +11,8 @@ package scala.actors.scheduler
 import scala.util.control.ControlThrowable
 
 /**
- * The <code>QuitControl</code> class is used to manage control flow
- * of certain schedulers.
+ * The `QuitControl` class is used to manage control flow of certain
+ * schedulers.
  *
  * @author Philipp Haller
  */
diff --git a/src/actors/scala/actors/scheduler/ResizableThreadPoolScheduler.scala b/src/actors/scala/actors/scheduler/ResizableThreadPoolScheduler.scala
index f6c14e3462..2429fe749e 100644
--- a/src/actors/scala/actors/scheduler/ResizableThreadPoolScheduler.scala
+++ b/src/actors/scala/actors/scheduler/ResizableThreadPoolScheduler.scala
@@ -6,7 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors.scheduler
 
 import scala.actors.threadpool.{ThreadPoolExecutor, TimeUnit, LinkedBlockingQueue,
@@ -15,13 +14,11 @@ import scala.actors.{Debug, IScheduler}
 import scala.concurrent.ManagedBlocker
 
 /**
- * This scheduler class uses a <code>ThreadPoolExecutor</code>
- * to execute <code>Actor</code>s.
+ * This scheduler class uses a `ThreadPoolExecutor` to execute `Actor`s.
  *
  * The scheduler attempts to shut down itself and the underlying
- * <code>ThreadPoolExecutor</code> only if <code>terminate</code>
- * is set to true. Otherwise, the scheduler must be shut down
- * explicitly.
+ * `ThreadPoolExecutor` only if `terminate` is set to true. Otherwise,
+ * the scheduler must be shut down explicitly.
  *
  * @author Philipp Haller
  */
@@ -176,7 +173,7 @@ class ResizableThreadPoolScheduler(protected val terminate: Boolean,
   }
 
   /** Resumes the execution of the scheduler if it was previously
-   *  suspended using <code>snapshot</code>.
+   *  suspended using `snapshot`.
    */
   def restart() {
     synchronized {
diff --git a/src/library/scala/collection/JavaConverters.scala b/src/library/scala/collection/JavaConverters.scala
index d5baacedf8..94f7e9701b 100755
--- a/src/library/scala/collection/JavaConverters.scala
+++ b/src/library/scala/collection/JavaConverters.scala
@@ -172,7 +172,8 @@ object JavaConverters {
    * returned.
    *
    * @param b The `Buffer` to be converted.
-   * @return An object with an `asJava` method that returns a Java <code>List</code> view of the argument.
+   * @return An object with an `asJava` method that returns a Java `List` view
+   *         of the argument.
    */
   implicit def bufferAsJavaListConverter[A](b : mutable.Buffer[A]): AsJava[ju.List[A]] =
     new AsJava(bufferAsJavaList(b))
@@ -234,8 +235,9 @@ object JavaConverters {
    * call of `asSet(java.util.Set)` then the original Java `Set` will be
    * returned.
    *
-   * @param s The <code>Set</code> to be converted.
-   * @return An object with an `asJava` method that returns a Java <code>Set</code> view of the argument.
+   * @param s The `Set` to be converted.
+   * @return An object with an `asJava` method that returns a Java `Set` view
+   *         of the argument.
    */
   implicit def mutableSetAsJavaSetConverter[A](s : mutable.Set[A]): AsJava[ju.Set[A]] =
     new AsJava(mutableSetAsJavaSet(s))
@@ -252,8 +254,8 @@ object JavaConverters {
    * the Scala interface and vice versa.
    *
    * If the Scala `Set` was previously obtained from an implicit or explicit
-   * call of <code>asSet(java.util.Set)</code> then the original Java `Set`
-   * will be returned.
+   * call of `asSet(java.util.Set)` then the original Java `Set` will be
+   * returned.
    *
    * @param s The `Set` to be converted.
    * @return An object with an `asJava` method that returns a Java `Set` view
@@ -299,7 +301,7 @@ object JavaConverters {
    * explicit call of `asMap(java.util.Dictionary)` then the original
    * Java `Dictionary` will be returned.
    *
-   * @param m The <code>Map</code> to be converted.
+   * @param m The `Map` to be converted.
    * @return An object with an `asJavaDictionary` method that returns a
    *         Java `Dictionary` view of the argument.
    */
@@ -386,17 +388,20 @@ object JavaConverters {
     new AsScala(enumerationAsScalaIterator(i))
 
   /**
-   * Adds an `asScala` method that implicitly converts a Java <code>Iterable</code> to a Scala <code>Iterable</code>.
-   * The returned Scala <code>Iterable</code> is backed by the provided Java
-   * <code>Iterable</code> and any side-effects of using it via the Scala interface will
-   * be visible via the Java interface and vice versa.
-   * <p>
-   * If the Java <code>Iterable</code> was previously obtained from an implicit or
-   * explicit call of <code>asIterable(scala.collection.Iterable)</code> then the original
-   * Scala <code>Iterable</code> will be returned.
+   * Adds an `asScala` method that implicitly converts a Java `Iterable` to
+   * a Scala `Iterable`.
    *
-   * @param i The <code>Iterable</code> to be converted.
-   * @return An object with an `asScala` method that returns a Scala <code>Iterable</code> view of the argument.
+   * The returned Scala `Iterable` is backed by the provided Java `Iterable`
+   * and any side-effects of using it via the Scala interface will be visible
+   * via the Java interface and vice versa.
+   *
+   * If the Java `Iterable` was previously obtained from an implicit or
+   * explicit call of `asIterable(scala.collection.Iterable)` then the original
+   * Scala `Iterable` will be returned.
+   *
+   * @param i The `Iterable` to be converted.
+   * @return An object with an `asScala` method that returns a Scala `Iterable`
+   *         view of the argument.
    */
   implicit def iterableAsScalaIterableConverter[A](i : jl.Iterable[A]): AsScala[Iterable[A]] =
     new AsScala(iterableAsScalaIterable(i))
@@ -405,14 +410,16 @@ object JavaConverters {
   def asScalaIterableConverter[A](i : jl.Iterable[A]): AsScala[Iterable[A]] = iterableAsScalaIterableConverter(i)
 
   /**
-   * Adds an `asScala` method that implicitly converts a Java <code>Collection</code> to an Scala <code>Iterable</code>.
-   * <p>
-   * If the Java <code>Collection</code> was previously obtained from an implicit or
-   * explicit call of <code>asCollection(scala.collection.SizedIterable)</code> then
-   * the original Scala <code>SizedIterable</code> will be returned.
-   *
-   * @param i The <code>Collection</code> to be converted.
-   * @return An object with an `asScala` method that returns a Scala <code>SizedIterable</code> view of the argument.
+   * Adds an `asScala` method that implicitly converts a Java `Collection` to
+   * an Scala `Iterable`.
+   *
+   * If the Java `Collection` was previously obtained from an implicit or
+   * explicit call of `asCollection(scala.collection.SizedIterable)` then
+   * the original Scala `SizedIterable` will be returned.
+   *
+   * @param i The `Collection` to be converted.
+   * @return An object with an `asScala` method that returns a Scala
+   *        `SizedIterable` view of the argument.
    */
   implicit def collectionAsScalaIterableConverter[A](i : ju.Collection[A]): AsScala[Iterable[A]] =
     new AsScala(collectionAsScalaIterable(i))
diff --git a/src/library/scala/collection/MapProxy.scala b/src/library/scala/collection/MapProxy.scala
index 9b755d6516..de1be37f86 100644
--- a/src/library/scala/collection/MapProxy.scala
+++ b/src/library/scala/collection/MapProxy.scala
@@ -6,12 +6,9 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.collection
 
-/** This is a simple wrapper class for <a href="Map.html"
- *  target="contentFrame"><code>scala.collection.Map</code></a>.
+/** This is a simple wrapper class for [[scala.collection.Map]].
  *  It is most useful for assembling customized map abstractions
  *  dynamically using object composition and forwarding.
  *
diff --git a/src/library/scala/collection/SeqLike.scala b/src/library/scala/collection/SeqLike.scala
index 08db419c03..237a53ee58 100644
--- a/src/library/scala/collection/SeqLike.scala
+++ b/src/library/scala/collection/SeqLike.scala
@@ -683,9 +683,8 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] with GenSeqLike[A, Repr]
   def equalsWith[B](that: Seq[B])(f: (A,B) => Boolean): Boolean = corresponds(that)(f)
 
  /**
-   * returns a projection that can be used to call non-strict <code>filter</code>,
-   * <code>map</code>, and <code>flatMap</code> methods that build projections
-   * of the collection.
+   * returns a projection that can be used to call non-strict `filter`,
+   * `map`, and `flatMap` methods that build projections of the collection.
    */
   @deprecated("use `view` instead", "2.8.0")
   override def projection = view
@@ -781,7 +780,7 @@ object SeqLike {
   }
 
   /** Finds a particular index at which one sequence occurs in another sequence.
-   *  Like indexOf, but finds the latest occurrence rather than earliest.
+   *  Like `indexOf`, but finds the latest occurrence rather than earliest.
    *
    *  @see  SeqLike#indexOf
    */
diff --git a/src/library/scala/collection/SetProxy.scala b/src/library/scala/collection/SetProxy.scala
index 5260a0c9dd..0448d64cb2 100644
--- a/src/library/scala/collection/SetProxy.scala
+++ b/src/library/scala/collection/SetProxy.scala
@@ -6,12 +6,9 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.collection
 
-/** This is a simple wrapper class for <a href="Set.html"
- *  target="contentFrame"><code>scala.collection.Set</code></a>.
+/** This is a simple wrapper class for [[scala.collection.Set]].
  *  It is most useful for assembling customized set abstractions
  *  dynamically using object composition and forwarding.
  *
@@ -19,5 +16,4 @@ package scala.collection
  *  @author  Martin Odersky
  *  @version 2.0, 01/01/2007
  */
-
 trait SetProxy[A] extends Set[A] with SetProxyLike[A, Set[A]]
diff --git a/src/library/scala/collection/generic/Sorted.scala b/src/library/scala/collection/generic/Sorted.scala
index 99eb68065c..7a3a220683 100644
--- a/src/library/scala/collection/generic/Sorted.scala
+++ b/src/library/scala/collection/generic/Sorted.scala
@@ -6,7 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.collection
 package generic
 
@@ -31,17 +30,19 @@ trait Sorted[K, +This <: Sorted[K, This]] {
   def lastKey: K
 
   /** Comparison function that orders keys. */
-  def compare(k0: K, k1: K): Int = ordering.compare(k0, k1);
+  def compare(k0: K, k1: K): Int = ordering.compare(k0, k1)
 
   /** Creates a ranged projection of this collection. Any mutations in the
-   *  ranged projection will update this collection and vice versa.  Note: keys
-   *  are not garuanteed to be consistent between this collection and the projection.
-   *  This is the case for buffers where indexing is relative to the projection.
+   *  ranged projection will update this collection and vice versa.
+   *
+   *  Note: keys are not garuanteed to be consistent between this collection
+   *  and the projection. This is the case for buffers where indexing is
+   *  relative to the projection.
    *
    *  @param from  The lower-bound (inclusive) of the ranged projection.
-   *               <code>None</code> if there is no lower bound.
+   *               `None` if there is no lower bound.
    *  @param until The upper-bound (exclusive) of the ranged projection.
-   *               <code>None</code> if there is no upper bound.
+   *               `None` if there is no upper bound.
    */
   def rangeImpl(from: Option[K], until: Option[K]): This
 
diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala
index edee4a9922..05a1cd2e8c 100644
--- a/src/library/scala/collection/immutable/ListMap.scala
+++ b/src/library/scala/collection/immutable/ListMap.scala
@@ -63,11 +63,9 @@ class ListMap[A, +B] extends Map[A, B] with MapLike[A, B, ListMap[A, B]] with Se
    */
   def get(key: A): Option[B] = None
 
-  /** This method allows one to create a new map with an
-   *  additional mapping from <code>key</code>
-   *  to <code>value</code>. If the map contains already a
-   *  mapping for <code>key</code>, it will be overridden by this
-   *  function.
+  /** This method allows one to create a new map with an additional mapping
+   *  from `key` to `value`. If the map contains already a mapping for `key`,
+   *  it will be overridden by this function.
    *
    *  @param key  the key element of the updated entry.
    *  @param value the value element of the updated entry.
@@ -103,7 +101,7 @@ class ListMap[A, +B] extends Map[A, B] with MapLike[A, B, ListMap[A, B]] with Se
   @bridge def ++[B1 >: B](xs: TraversableOnce[(A, B1)]): ListMap[A, B1] =
     ++(xs: GenTraversableOnce[(A, B1)])
 
-  /** This creates a new mapping without the given <code>key</code>.
+  /** This creates a new mapping without the given `key`.
    *  If the map does not contain a mapping for the given key, the
    *  method returns the same map.
    *
@@ -157,7 +155,7 @@ class ListMap[A, +B] extends Map[A, B] with MapLike[A, B, ListMap[A, B]] with Se
 
     @tailrec private def apply0(cur: ListMap[A, B1], k: A): B1 = if (k == cur.key) cur.value else apply0(cur.next, k)
 
-    /** Checks if this map maps <code>key</code> to a value and return the
+    /** Checks if this map maps `key` to a value and return the
      *  value if it exists.
      *
      *  @param  key the key of the mapping of interest
@@ -181,7 +179,7 @@ class ListMap[A, +B] extends Map[A, B] with MapLike[A, B, ListMap[A, B]] with Se
       new m.Node[B2](k, v)
     }
 
-    /** Creates a new mapping without the given <code>key</code>.
+    /** Creates a new mapping without the given `key`.
      *  If the map does not contain a mapping for the given key, the
      *  method returns the same map.
      *
diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala
index a298c629be..22e614dd75 100644
--- a/src/library/scala/collection/immutable/ListSet.scala
+++ b/src/library/scala/collection/immutable/ListSet.scala
@@ -6,8 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.collection
 package immutable
 
@@ -78,10 +76,10 @@ class ListSet[A] extends Set[A]
   override def size: Int = 0
   override def isEmpty: Boolean = true;
 
-  /** Checks if this set contains element <code>elem</code>.
+  /** Checks if this set contains element `elem`.
    *
    *  @param  elem    the element to check for membership.
-   *  @return true, iff <code>elem</code> is contained in this set.
+   *  @return `'''true'''`, iff `elem` is contained in this set.
    */
   def contains(elem: A): Boolean = false
 
@@ -158,10 +156,10 @@ class ListSet[A] extends Set[A]
      */
     override def isEmpty: Boolean = false
 
-    /** Checks if this set contains element <code>elem</code>.
+    /** Checks if this set contains element `elem`.
      *
      *  @param  elem    the element to check for membership.
-     *  @return true, iff <code>elem</code> is contained in this set.
+     *  @return `'''true'''`, iff `elem` is contained in this set.
      */
     override def contains(e: A) = containsInternal(this, e)
     @tailrec private def containsInternal(n: ListSet[A], e: A): Boolean =
@@ -171,8 +169,7 @@ class ListSet[A] extends Set[A]
      */
     override def +(e: A): ListSet[A] = if (contains(e)) this else new Node(e)
 
-    /** <code>-</code> can be used to remove a single element from
-     *  a set.
+    /** `-` can be used to remove a single element from a set.
      */
     override def -(e: A): ListSet[A] = if (e == elem) self else {
       val tail = self - e; new tail.Node(elem)
diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala
index 66d1562884..4cb7fc43d1 100644
--- a/src/library/scala/collection/immutable/Stream.scala
+++ b/src/library/scala/collection/immutable/Stream.scala
@@ -6,8 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.collection
 package immutable
 
@@ -166,8 +164,8 @@ self =>
    *  `f` to each element of this stream.
    *
    *  @param f function to apply to each element.
-   *  @return  <code>f(a<sub>0</sub>), ..., f(a<sub>n</sub>)</code> if this
-   *           sequence is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>.
+   *  @return  `f(a,,0,,), ..., f(a,,n,,)` if this
+   *           sequence is `a,,0,,, ..., a,,n,,`.
    */
   override final def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That = {
     if (isStreamBuilder(bf)) asThat(
@@ -198,8 +196,8 @@ self =>
    *
    *  @param f  the function to apply on each element.
    *  @param bf $bfinfo
-   *  @return  <code>f(a<sub>0</sub>) ::: ... ::: f(a<sub>n</sub>)</code> if
-   *           this stream is <code>[a<sub>0</sub>, ..., a<sub>n</sub>]</code>.
+   *  @return  `f(a,,0,,) ::: ... ::: f(a,,n,,)` if
+   *           this stream is `[a,,0,,, ..., a,,n,,]`.
    */
   override final def flatMap[B, That](f: A => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Stream[A], B, That]): That =
     // we assume there is no other builder factory on streams and therefore know that That = Stream[B]
@@ -224,10 +222,10 @@ self =>
     else super.flatMap(f)(bf)
 
   /** Returns all the elements of this stream that satisfy the
-   *  predicate <code>p</code>. The order of the elements is preserved.
+   *  predicate `p`. The order of the elements is preserved.
    *
    *  @param p the predicate used to filter the stream.
-   *  @return the elements of this stream satisfying <code>p</code>.
+   *  @return the elements of this stream satisfying `p`.
    */
   override def filter(p: A => Boolean): Stream[A] = {
     // optimization: drop leading prefix of elems for which f returns false
@@ -276,7 +274,7 @@ self =>
   /** A lazier Iterator than LinearSeqLike's. */
   override def iterator: Iterator[A] = new StreamIterator(self)
 
-  /** Apply the given function <code>f</code> to each element of this linear sequence
+  /** Apply the given function `f` to each element of this linear sequence
    *  (while respecting the order of the elements).
    *
    *  @param f the treatment to apply to each element.
@@ -319,22 +317,24 @@ self =>
   }
 
   /** Returns all the elements of this stream that satisfy the
-   *  predicate <code>p</code>. The order of the elements is preserved.
+   *  predicate `p`. The order of the elements is preserved.
    *
    *  @param p the predicate used to filter the stream.
-   *  @return the elements of this stream satisfying <code>p</code>.
+   *  @return the elements of this stream satisfying `p`.
    */
   override def partition(p: A => Boolean): (Stream[A], Stream[A]) = (filter(p(_)), filterNot(p(_)))
 
   /** Returns a stream formed from this stream and the specified stream
-   *  <code>that</code> by associating each element of the former with
-   *  the element at the same position in the latter.
-   *  If one of the two streams is longer than the other, its remaining elements are ignored.
+   *  `that` by associating each element of the former with the element at
+   *  the same position in the latter.
+   *
+   *  If one of the two streams is longer than the other, its remaining
+   *  elements are ignored.
    *
-   *  @return     <code>Stream({a<sub>0</sub>,b<sub>0</sub>}, ...,
-   *              {a<sub>min(m,n)</sub>,b<sub>min(m,n)</sub>)}</code> when
-   *              <code>Stream(a<sub>0</sub>, ..., a<sub>m</sub>)
-   *              zip Stream(b<sub>0</sub>, ..., b<sub>n</sub>)</code> is invoked.
+   *  @return     `Stream({a,,0,,,b,,0,,}, ...,
+   *              {a,,min(m,n),,,b,,min(m,n),,)}` when
+   *              `Stream(a,,0,,, ..., a,,m,,)
+   *              zip Stream(b,,0,,, ..., b,,n,,)` is invoked.
    */
   override final def zip[A1 >: A, B, That](that: collection.GenIterable[B])(implicit bf: CanBuildFrom[Stream[A], (A1, B), That]): That =
     // we assume there is no other builder factory on streams and therefore know that That = Stream[(A1, B)]
@@ -351,11 +351,11 @@ self =>
     this.zip[A1, Int, That](Stream.from(0))
 
   /** Write all defined elements of this iterable into given string builder.
-   *  The written text begins with the string <code>start</code> and is finished by the string
-   *  <code>end</code>. Inside, the string representations of defined elements (w.r.t.
-   *  the method <code>toString()</code>) are separated by the string
-   *  <code>sep</code>. The method will not force evaluation of undefined elements. A
-   *  tail of such elements will be represented by a "?" instead.
+   *  The written text begins with the string `start` and is finished by the string
+   *  `end`. Inside, the string representations of defined elements (w.r.t.
+   *  the method `toString()`) are separated by the string `sep`. The method will
+   *  not force evaluation of undefined elements. A tail of such elements will be
+   * represented by a `"?"` instead.
    */
   override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = {
     def loop(pre: String, these: Stream[A]) {
@@ -381,11 +381,11 @@ self =>
 
   override def splitAt(n: Int): (Stream[A], Stream[A]) = (take(n), drop(n))
 
-  /** Returns the <code>n</code> first elements of this stream, or else the whole
-   *  stream, if it has less than <code>n</code> elements.
+  /** Returns the `n` first elements of this stream, or else the whole
+   *  stream, if it has less than `n` elements.
    *
    *  @param n the number of elements to take.
-   *  @return the <code>n</code> first elements of this stream.
+   *  @return the `n` first elements of this stream.
    */
   override def take(n: Int): Stream[A] =
     if (n <= 0 || isEmpty) Stream.empty
@@ -409,14 +409,14 @@ self =>
   }
 
   /** The stream without its last element.
-   *  @throws Predef.UnsupportedOperationException if the stream is empty.
+   *  @throws `Predef.UnsupportedOperationException` if the stream is empty.
    */
   override def init: Stream[A] =
     if (isEmpty) super.init
     else if (tail.isEmpty) Stream.Empty
     else cons(head, tail.init)
 
-  /** Returns the rightmost <code>n</code> elements from this iterable.
+  /** Returns the rightmost `n` elements from this iterable.
    *  @param n the number of elements to take
    */
   override def takeRight(n: Int): Stream[A] = {
@@ -432,7 +432,7 @@ self =>
   // there's nothing we can do about dropRight, so we just keep the definition in LinearSeq
 
   /** Returns the longest prefix of this stream whose elements satisfy
-   *  the predicate <code>p</code>.
+   *  the predicate `p`.
    *
    *  @param p the test predicate.
    */
@@ -441,7 +441,7 @@ self =>
     else Stream.Empty
 
   /** Returns the longest suffix of this iterable whose first element
-   *  does not satisfy the predicate <code>p</code>.
+   *  does not satisfy the predicate `p`.
    *
    *  @param p the test predicate.
    */
@@ -458,8 +458,8 @@ self =>
     if (isEmpty) this
     else cons(head, tail.filter(head !=).distinct)
 
-  /** Returns a new sequence of given length containing the elements of this sequence followed by zero
-   *  or more occurrences of given elements.
+  /** Returns a new sequence of given length containing the elements of this
+   *  sequence followed by zero or more occurrences of given elements.
    */
   override def padTo[B >: A, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Stream[A], B, That]): That = {
     def loop(len: Int, these: Stream[A]): Stream[B] =
@@ -534,8 +534,7 @@ final class StreamIterator[+A](self: Stream[A]) extends Iterator[A] {
 }
 
 /**
- * The object <code>Stream</code> provides helper functions
- * to manipulate streams.
+ * The object `Stream` provides helper functions to manipulate streams.
  *
  * @author Martin Odersky, Matthias Zenger
  * @version 1.1 08/08/03
@@ -544,7 +543,7 @@ final class StreamIterator[+A](self: Stream[A]) extends Iterator[A] {
 object Stream extends SeqFactory[Stream] {
 
   /** The factory for streams.
-   *  @note Methods such as map/flatMap will not invoke the Builder factory,
+   *  @note Methods such as map/flatMap will not invoke the `Builder` factory,
    *        but will return a new stream directly, to preserve laziness.
    *        The new stream is then cast to the factory's result type.
    *        This means that every CanBuildFrom that takes a
@@ -650,28 +649,27 @@ object Stream extends SeqFactory[Stream] {
     iterate(start)(f) take len
 
   /**
-   * Create an infinite stream starting at <code>start</code>
-   * and incrementing by step <code>step</code>
+   * Create an infinite stream starting at `start` and incrementing by
+   * step `step`.
    *
    * @param start the start value of the stream
    * @param step the increment value of the stream
-   * @return the stream starting at value <code>start</code>.
+   * @return the stream starting at value `start`.
    */
   def from(start: Int, step: Int): Stream[Int] =
     cons(start, from(start+step, step))
 
   /**
-   * Create an infinite stream starting at <code>start</code>
-   * and incrementing by 1.
+   * Create an infinite stream starting at `start` and incrementing by `1`.
    *
    * @param start the start value of the stream
-   * @return the stream starting at value <code>start</code>.
+   * @return the stream starting at value `start`.
    */
   def from(start: Int): Stream[Int] = from(start, 1)
 
   /**
-   * Create an infinite stream containing the given element expression (which is computed for each
-   * occurrence)
+   * Create an infinite stream containing the given element expression (which
+   * is computed for each occurrence).
    *
    * @param elem the element composing the resulting stream
    * @return the stream containing an infinite number of elem
@@ -720,15 +718,14 @@ object Stream extends SeqFactory[Stream] {
   def concat[A](xs: Iterator[Stream[A]]): Stream[A] = xs.toStream.flatten //(conforms[Stream[A], scala.collection.Traversable[A]])
 
   /**
-   * Create a stream with element values
-   * <code>v<sub>n+1</sub> = step(v<sub>n</sub>)</code>
-   * where <code>v<sub>0</sub> = start</code>
-   * and elements are in the range between <code>start</code> (inclusive)
-   * and <code>end</code> (exclusive)
+   * Create a stream with element values `v,,n+1,, = step(v,,n,,)` where
+   * `v,,0,, = start` and elements are in the range between `start` (inclusive)
+   * and `end` (exclusive).
+   *
    * @param start the start value of the stream
    * @param end the end value of the stream
    * @param step the increment function of the stream, must be monotonically increasing or decreasing
-   * @return the stream starting at value <code>start</code>.
+   * @return the stream starting at value `start`.
    */
   @deprecated("use `iterate` instead.", "2.8.0")
   def range(start: Int, end: Int, step: Int => Int): Stream[Int] =
diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala
index d31627f55a..b8d817f310 100644
--- a/src/library/scala/collection/mutable/ArrayStack.scala
+++ b/src/library/scala/collection/mutable/ArrayStack.scala
@@ -6,15 +6,11 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.collection
 package mutable
 
 import generic._
 
-
-
 /** Factory object for the `ArrayStack` class.
  *
  *  $factoryInfo
@@ -88,8 +84,7 @@ extends Seq[T]
 
   override def companion = ArrayStack
 
-  /** Replace element at index <code>n</code> with the new element
-   *  <code>newelem</code>.
+  /** Replace element at index `n` with the new element `newelem`.
    *
    *  This is a constant time operation.
    *
diff --git a/src/library/scala/collection/mutable/BufferProxy.scala b/src/library/scala/collection/mutable/BufferProxy.scala
index a06b930033..f7831a7d3f 100644
--- a/src/library/scala/collection/mutable/BufferProxy.scala
+++ b/src/library/scala/collection/mutable/BufferProxy.scala
@@ -56,9 +56,8 @@ trait BufferProxy[A] extends Buffer[A] with Proxy {
 
   override def readOnly = self.readOnly
 
-  /** Appends a number of elements provided by a traversable object
-   *  via its <code>foreach</code> method. The identity of the
-   *  buffer is returned.
+  /** Appends a number of elements provided by a traversable object via its
+   *  `foreach` method. The identity of the buffer is returned.
    *
    *  @param iter  the traversable object.
    *  @return      the updated buffer.
diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala
index 69b15d7a6f..aec7b7bce9 100644
--- a/src/library/scala/collection/mutable/ListBuffer.scala
+++ b/src/library/scala/collection/mutable/ListBuffer.scala
@@ -363,7 +363,7 @@ final class ListBuffer[A]
 
   /** Returns a clone of this buffer.
    *
-   *  @return a <code>ListBuffer</code> with the same elements.
+   *  @return a `ListBuffer` with the same elements.
    */
   override def clone(): ListBuffer[A] = (new ListBuffer[A]) ++= this
 
diff --git a/src/library/scala/collection/mutable/StackProxy.scala b/src/library/scala/collection/mutable/StackProxy.scala
index 5dd5592096..d5439a1531 100644
--- a/src/library/scala/collection/mutable/StackProxy.scala
+++ b/src/library/scala/collection/mutable/StackProxy.scala
@@ -1,17 +1,14 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
 **    / __/ __// _ | / /  / _ |    (c) 2003-2011, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.collection
 package mutable
 
-
 /** A stack implements a data structure which allows to store and retrieve
  *  objects in a last-in-first-out (LIFO) fashion.
  *
@@ -25,9 +22,9 @@ trait StackProxy[A] extends Stack[A] with Proxy {
 
   def self: Stack[A]
 
-  /** Access element number <code>n</code>.
+  /** Access element number `n`.
    *
-   *  @return  the element at index <code>n</code>.
+   *  @return  the element at index `n`.
    */
   override def apply(n: Int): A = self.apply(n)
 
@@ -52,9 +49,9 @@ trait StackProxy[A] extends Stack[A] with Proxy {
 
   override def pushAll(xs: TraversableOnce[A]): this.type = { self pushAll xs; this }
 
-  /** Pushes all elements provided by an <code>Iterable</code> object
-   *  on top of the stack. The elements are pushed in the order they
-   *  are given out by the iterator.
+  /** Pushes all elements provided by an `Iterable` object on top of the
+   *  stack. The elements are pushed in the order they are given out by
+   *  the iterator.
    *
    *  @param  iter        an iterable object
    */
diff --git a/src/library/scala/collection/mutable/SynchronizedBuffer.scala b/src/library/scala/collection/mutable/SynchronizedBuffer.scala
index 5b76d94517..d55ce8d684 100644
--- a/src/library/scala/collection/mutable/SynchronizedBuffer.scala
+++ b/src/library/scala/collection/mutable/SynchronizedBuffer.scala
@@ -85,7 +85,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
   }
 
   /** Appends a number of elements provided by a traversable object
-   *  via its <code>foreach</code> method.
+   *  via its `foreach` method.
    *
    *  @param xs the traversable object.
    */
@@ -103,8 +103,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
   }
 
   /** Prepends a number of elements provided by a traversable object
-   *  via its <code>foreach</code> method. The identity of the
-   *  buffer is returned.
+   *  via its `foreach` method. The identity of the buffer is returned.
    *
    *  @param xs the traversable object.
    */
@@ -117,8 +116,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
   override def prepend(elems: A*): Unit = prependAll(elems)
 
   /** Prepends a number of elements provided by a traversable object
-   *  via its <code>foreach</code> method. The identity of the
-   *  buffer is returned.
+   *  via its `foreach` method. The identity of the buffer is returned.
    *
    *  @param xs the traversable object.
    */
@@ -126,9 +124,9 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
     super.prependAll(xs)
   }
 
-  /** Inserts new elements at the index <code>n</code>. Opposed to method
-   *  <code>update</code>, this method will not replace an element with a
-   *  one. Instead, it will insert the new elements at index <code>n</code>.
+  /** Inserts new elements at the index `n`. Opposed to method `update`,
+   *  this method will not replace an element with a one.
+   *  Instead, it will insert the new elements at index `n`.
    *
    *  @param n      the index where a new element will be inserted.
    *  @param elems  the new elements to insert.
@@ -137,9 +135,9 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
     super.insertAll(n, elems)
   }
 
-  /** Inserts new elements at the index <code>n</code>. Opposed to method
-   *  <code>update</code>, this method will not replace an element with a
-   *  one. Instead, it will insert a new element at index <code>n</code>.
+  /** Inserts new elements at the index `n`. Opposed to method `update`,
+   *  this method will not replace an element with a one.
+   *  Instead, it will insert a new element at index `n`.
    *
    *  @param n     the index where a new element will be inserted.
    *  @param xs    the traversable object providing all elements to insert.
@@ -148,8 +146,7 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
      super.insertAll(n, xs)
   }
 
-  /** Replace element at index <code>n</code> with the new element
-   *  <code>newelem</code>.
+  /** Replace element at index `n` with the new element `newelem`.
    *
    *  @param n       the index of the element to replace.
    *  @param newelem the new element.
@@ -178,13 +175,13 @@ trait SynchronizedBuffer[A] extends Buffer[A] {
 
   /** Return a clone of this buffer.
    *
-   *  @return an <code>ArrayBuffer</code> with the same elements.
+   *  @return an `ArrayBuffer` with the same elements.
    */
   override def clone(): Self = synchronized {
     super.clone()
   }
 
-  /** The hashCode method always yields an error, since it is not
+  /** The `hashCode` method always yields an error, since it is not
    *  safe to use buffers as keys in hash tables.
    *
    *  @return never.
diff --git a/src/library/scala/collection/script/Message.scala b/src/library/scala/collection/script/Message.scala
index 877d005036..7466f2ac3e 100644
--- a/src/library/scala/collection/script/Message.scala
+++ b/src/library/scala/collection/script/Message.scala
@@ -6,18 +6,15 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.collection
 package script
 
 import mutable.ArrayBuffer
 
-/** Class <code>Message</code> represents messages that are issued by observable
- *  collection classes whenever a data structure is changed. Class <code>Message</code>
- *  has several subclasses for the various kinds of events: <code>Update</code>
- *  <code>Remove</code>, <code>Include</code>, <code>Reset</code>, and
- *  <code>Script</code>.
+/** Class `Message` represents messages that are issued by observable
+ *  collection classes whenever a data structure is changed. Class `Message`
+ *  has several subclasses for the various kinds of events: `Update`
+ *  `Remove`, `Include`, `Reset`, and `Script`.
  *
  *  @author  Matthias Zenger
  *  @version 1.0, 08/07/2003
@@ -78,7 +75,7 @@ class Script[A] extends ArrayBuffer[Message[A]] with Message[A] {
       if (i > 1)
         res = res + ", "
       res = res + "[" + i + "] " + it.next
-      i = i + 1
+      i += 1
     }
     res + ")"
   }
diff --git a/src/library/scala/concurrent/FutureTaskRunner.scala b/src/library/scala/concurrent/FutureTaskRunner.scala
index 206155ce2a..c5fcde2d19 100644
--- a/src/library/scala/concurrent/FutureTaskRunner.scala
+++ b/src/library/scala/concurrent/FutureTaskRunner.scala
@@ -1,6 +1,14 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2009-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
 package scala.concurrent
 
-/** The <code>FutureTaskRunner</code> trait is a base trait of task runners
+/** The `FutureTaskRunner</code> trait is a base trait of task runners
  *  that provide some sort of future abstraction.
  *
  *  @author Philipp Haller
diff --git a/src/library/scala/concurrent/MailBox.scala b/src/library/scala/concurrent/MailBox.scala
index b00ab79919..6f9e39d8de 100644
--- a/src/library/scala/concurrent/MailBox.scala
+++ b/src/library/scala/concurrent/MailBox.scala
@@ -6,8 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.concurrent
 
 /** This class ...
@@ -83,7 +81,7 @@ class MailBox extends AnyRef with ListQueueCreator {
 
   /**
   * Block until there is a message in the mailbox for which the processor
-  * <code>f</code> is defined.
+  * `f` is defined.
   */
   def receive[A](f: PartialFunction[Message, A]): A = {
     val r = new Receiver(f)
@@ -93,7 +91,7 @@ class MailBox extends AnyRef with ListQueueCreator {
 
   /**
   * Block until there is a message in the mailbox for which the processor
-  * <code>f</code> is defined or the timeout is over.
+  * `f` is defined or the timeout is over.
   */
   def receiveWithin[A](msec: Long)(f: PartialFunction[Message, A]): A = {
     val r = new Receiver(f)
diff --git a/src/library/scala/concurrent/SyncChannel.scala b/src/library/scala/concurrent/SyncChannel.scala
index 1c398f94bb..9f8f0d313b 100644
--- a/src/library/scala/concurrent/SyncChannel.scala
+++ b/src/library/scala/concurrent/SyncChannel.scala
@@ -6,14 +6,11 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.concurrent
 
-/** A <code>SyncChannel</code> allows one to exchange data
- *  synchronously between a reader and a writer thread.
- *  The writer thread is blocked until the data to be written
- *  has been read by a corresponding reader thread.
+/** A `SyncChannel` allows one to exchange data synchronously between
+ *  a reader and a writer thread. The writer thread is blocked until the
+ *  data to be written has been read by a corresponding reader thread.
  *
  *  @author  Philipp Haller
  *  @version 2.0, 04/17/2008
diff --git a/src/library/scala/concurrent/TIMEOUT.scala b/src/library/scala/concurrent/TIMEOUT.scala
index 54d7db853c..d0328928fa 100644
--- a/src/library/scala/concurrent/TIMEOUT.scala
+++ b/src/library/scala/concurrent/TIMEOUT.scala
@@ -6,13 +6,11 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.concurrent
 
 /**
  * The message sent to a message box when the period specified in
- * <code>receiveWithin</code> expires.
+ * `receiveWithin` expires.
  *
  * @author  Martin Odersky
  * @version 1.0, 10/03/2003
diff --git a/src/library/scala/concurrent/TaskRunner.scala b/src/library/scala/concurrent/TaskRunner.scala
index 7337c7371f..64e62adfd3 100644
--- a/src/library/scala/concurrent/TaskRunner.scala
+++ b/src/library/scala/concurrent/TaskRunner.scala
@@ -6,11 +6,9 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.concurrent
 
-/** The <code>TaskRunner</code> trait...
+/** The `TaskRunner` trait...
  *
  *  @author Philipp Haller
  */
diff --git a/src/library/scala/concurrent/TaskRunners.scala b/src/library/scala/concurrent/TaskRunners.scala
index 9eb036c110..588073dc5e 100644
--- a/src/library/scala/concurrent/TaskRunners.scala
+++ b/src/library/scala/concurrent/TaskRunners.scala
@@ -6,13 +6,11 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.concurrent
 
 import java.util.concurrent.{ThreadPoolExecutor, LinkedBlockingQueue, TimeUnit}
 
-/** The <code>TaskRunners</code> object...
+/** The `TaskRunners` object...
  *
  *  @author Philipp Haller
  */
diff --git a/src/library/scala/concurrent/ThreadPoolRunner.scala b/src/library/scala/concurrent/ThreadPoolRunner.scala
index 5747344a29..27d8f2cc32 100644
--- a/src/library/scala/concurrent/ThreadPoolRunner.scala
+++ b/src/library/scala/concurrent/ThreadPoolRunner.scala
@@ -6,14 +6,11 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.concurrent
 
 import java.util.concurrent.{ExecutorService, Callable, TimeUnit}
 
-/** The <code>ThreadPoolRunner</code> trait uses
- *  a <code>java.util.concurrent.ExecutorService</code>
+/** The `ThreadPoolRunner` trait uses a `java.util.concurrent.ExecutorService`
  *  to run submitted tasks.
  *
  *  @author Philipp Haller
diff --git a/src/library/scala/concurrent/ThreadRunner.scala b/src/library/scala/concurrent/ThreadRunner.scala
index ee6e2b939b..28fcf57df8 100644
--- a/src/library/scala/concurrent/ThreadRunner.scala
+++ b/src/library/scala/concurrent/ThreadRunner.scala
@@ -6,13 +6,11 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.concurrent
 
 import java.lang.Thread
 
-/** The <code>ThreadRunner</code> trait...
+/** The `ThreadRunner` trait...
  *
  *  @author Philipp Haller
  */
diff --git a/src/library/scala/concurrent/pilib.scala b/src/library/scala/concurrent/pilib.scala
index c2968b990d..246fe6d786 100644
--- a/src/library/scala/concurrent/pilib.scala
+++ b/src/library/scala/concurrent/pilib.scala
@@ -36,7 +36,7 @@ object pilib {
 
   /**
    * Run several processes in parallel using the following syntax:
-   * <code>spawn &lt; p<sub>1</sub> | ... | p<sub>n</sub> &gt;</code>
+   * `spawn < p,,1,, | ... | p,,n,, >`.
    */
   abstract class Spawn {
     def <(p: => Unit): Spawn
diff --git a/src/library/scala/io/Source.scala b/src/library/scala/io/Source.scala
index 103be17228..09887efdae 100644
--- a/src/library/scala/io/Source.scala
+++ b/src/library/scala/io/Source.scala
@@ -6,8 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.io
 
 import java.io.{ FileInputStream, InputStream, PrintStream, File => JFile }
@@ -22,7 +20,7 @@ import java.net.{ URI, URL }
 object Source {
   val DefaultBufSize = 2048
 
-  /** Creates a <code>Source</code> from System.in.
+  /** Creates a `Source` from System.in.
    */
   def stdin = fromInputStream(System.in)
 
@@ -59,7 +57,7 @@ object Source {
   def fromFile(name: String, enc: String): BufferedSource =
     fromFile(name)(Codec(enc))
 
-  /** creates <code>Source</code> from file with given file: URI
+  /** creates `ource` from file with given file `URI`.
    */
   def fromFile(uri: URI)(implicit codec: Codec): BufferedSource =
     fromFile(new JFile(uri))(codec)
@@ -83,9 +81,9 @@ object Source {
   def fromFile(file: JFile, enc: String, bufferSize: Int): BufferedSource =
     fromFile(file, bufferSize)(Codec(enc))
 
-  /** Creates Source from <code>file</code>, using given character encoding,
-   *  setting its description to filename. Input is buffered in a buffer of
-   *  size <code>bufferSize</code>.
+  /** Creates Source from `file`, using given character encoding, setting
+   *  its description to filename. Input is buffered in a buffer of size
+   *  `bufferSize`.
    */
   def fromFile(file: JFile, bufferSize: Int)(implicit codec: Codec): BufferedSource = {
     val inputStream = new FileInputStream(file)
@@ -98,12 +96,12 @@ object Source {
     )(codec) withDescription ("file:" + file.getAbsolutePath)
   }
 
-  /** Create a <code>Source</code> from array of bytes, decoding
+  /** Create a `Source` from array of bytes, decoding
    *  the bytes according to codec.
    *
    *  @param bytes ...
    *  @param enc   ...
-   *  @return      the created <code>Source</code> instance.
+   *  @return      the created `Source` instance.
    */
   def fromBytes(bytes: Array[Byte])(implicit codec: Codec): Source =
     fromString(new String(bytes, codec.name))
@@ -111,13 +109,13 @@ object Source {
   def fromBytes(bytes: Array[Byte], enc: String): Source =
     fromBytes(bytes)(Codec(enc))
 
-  /** Create a <code>Source</code> from array of bytes, assuming
+  /** Create a `Source` from array of bytes, assuming
    *  one byte per character (ISO-8859-1 encoding.)
    */
   def fromRawBytes(bytes: Array[Byte]): Source =
     fromString(new String(bytes, Codec.ISO8859.name))
 
-  /** creates <code>Source</code> from file with given file: URI
+  /** creates `Source` from file with given file: URI
    */
   def fromURI(uri: URI)(implicit codec: Codec): BufferedSource =
     fromFile(new JFile(uri))(codec)
@@ -171,9 +169,9 @@ object Source {
     createBufferedSource(is, reset = () => fromInputStream(is)(codec), close = () => is.close())(codec)
 }
 
-/** The class <code>Source</code> implements an iterable representation
- *  of source data.  Calling method <code>reset</code> returns an identical,
- *  resetted source, where possible.
+/** The class `Source` implements an iterable representation of source data.
+ *  Calling method `reset` returns an identical, resetted source, where
+ *  possible.
  *
  *  @author  Burak Emir
  *  @version 1.0
@@ -233,7 +231,7 @@ abstract class Source extends Iterator[Char] {
    */
   def getLines(): Iterator[String] = new LineIterator()
 
-  /** Returns <code>true</code> if this source has more characters.
+  /** Returns `'''true'''` if this source has more characters.
    */
   def hasNext = iter.hasNext
 
@@ -284,11 +282,11 @@ abstract class Source extends Iterator[Char] {
   def ch = positioner.ch
   def pos = positioner.pos
 
-  /** Reports an error message to the output stream <code>out</code>.
+  /** Reports an error message to the output stream `out`.
    *
    *  @param pos the source position (line/column)
    *  @param msg the error message to report
-   *  @param out PrintStream to use (optional: defaults to <code>Console.err</code>)
+   *  @param out PrintStream to use (optional: defaults to `Console.err`)
    */
   def reportError(
     pos: Int,
@@ -315,7 +313,7 @@ abstract class Source extends Iterator[Char] {
   /**
    *  @param pos the source position (line/column)
    *  @param msg the warning message to report
-   *  @param out PrintStream to use (optional: defaults to <code>Console.out</code>)
+   *  @param out PrintStream to use (optional: defaults to `Console.out`)
    */
   def reportWarning(
     pos: Int,
diff --git a/src/library/scala/math/BigInt.scala b/src/library/scala/math/BigInt.scala
index 687b6c9713..361e02cb16 100644
--- a/src/library/scala/math/BigInt.scala
+++ b/src/library/scala/math/BigInt.scala
@@ -6,8 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.math
 
 import java.math.BigInteger
@@ -29,11 +27,11 @@ object BigInt {
   @deprecated("Use Long.MaxValue", "2.9.0")
   val MaxLong = BigInt(Long.MaxValue)
 
-  /** Constructs a <code>BigInt</code> whose value is equal to that of the
+  /** Constructs a `BigInt` whose value is equal to that of the
    *  specified integer value.
    *
    *  @param i the specified integer value
-   *  @return  the constructed <code>BigInt</code>
+   *  @return  the constructed `BigInt`
    */
   def apply(i: Int): BigInt =
     if (minCached <= i && i <= maxCached) {
@@ -43,11 +41,11 @@ object BigInt {
       n
     } else new BigInt(BigInteger.valueOf(i))
 
-  /** Constructs a <code>BigInt</code> whose value is equal to that of the
+  /** Constructs a `BigInt` whose value is equal to that of the
    *  specified long value.
    *
    *  @param l the specified long value
-   *  @return  the constructed <code>BigInt</code>
+   *  @return  the constructed `BigInt`
    */
   def apply(l: Long): BigInt =
     if (minCached <= l && l <= maxCached) apply(l.toInt)
@@ -85,8 +83,8 @@ object BigInt {
   def apply(x: String): BigInt =
     new BigInt(new BigInteger(x))
 
-  /** Translates the string representation of a BigInt in the
-   *  specified <code>radix</code> into a BigInt.
+  /** Translates the string representation of a `BigInt` in the
+   *  specified `radix` into a BigInt.
    *
    *  @param x     ...
    *  @param radix ...
@@ -100,7 +98,7 @@ object BigInt {
   def probablePrime(bitLength: Int, rnd: scala.util.Random): BigInt =
     new BigInt(BigInteger.probablePrime(bitLength, rnd.self))
 
-  /** Implicit conversion from <code>int</code> to <code>BigInt</code>.
+  /** Implicit conversion from `Int` to `BigInt`.
    */
   implicit def int2bigInt(i: Int): BigInt = apply(i)
 
@@ -340,21 +338,21 @@ class BigInt(val bigInteger: BigInteger) extends ScalaNumber with ScalaNumericCo
    */
   def longValue   = this.bigInteger.longValue
 
-  /** Converts this BigInt to a <tt>float</tt>.
-   *  if this BigInt has too great a magnitude to represent as a float,
-   *  it will be converted to <code>Float.NEGATIVE_INFINITY</code> or
-   *  <code>Float.POSITIVE_INFINITY</code> as appropriate.
+  /** Converts this `BigInt` to a `float`.
+   *  If this `BigInt` has too great a magnitude to represent as a float,
+   *  it will be converted to `Float.NEGATIVE_INFINITY` or
+   *  `Float.POSITIVE_INFINITY` as appropriate.
    */
   def floatValue  = this.bigInteger.floatValue
 
-  /** Converts this BigInt to a <tt>double</tt>.
-   *  if this BigInt has too great a magnitude to represent as a double,
-   *  it will be converted to <code>Double.NEGATIVE_INFINITY</code> or
-   *  <code>Double.POSITIVE_INFINITY</code> as appropriate.
+  /** Converts this `BigInt` to a `double`.
+   *  if this `BigInt` has too great a magnitude to represent as a double,
+   *  it will be converted to `Double.NEGATIVE_INFINITY` or
+   *  `Double.POSITIVE_INFINITY` as appropriate.
    */
   def doubleValue = this.bigInteger.doubleValue
 
-  /** Create a NumericRange[BigInt] in range <code>[start;end)</code>
+  /** Create a `NumericRange[BigInt]` in range `[start;end)`
    *  with the specified step, where start is the target BigInt.
    *
    *  @param end    the end value of the range (exclusive)
diff --git a/src/library/scala/math/PartialOrdering.scala b/src/library/scala/math/PartialOrdering.scala
index cd3b132c8b..97abf8c2ad 100644
--- a/src/library/scala/math/PartialOrdering.scala
+++ b/src/library/scala/math/PartialOrdering.scala
@@ -6,34 +6,24 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.math
 
-/** <p>
- *    A trait for representing partial orderings.  It is important to
- *    distinguish between a type that has a partial order and a representation
- *    of partial ordering on some type.  This trait is for representing the
- *    latter.
- *  </p>
- *  <p>
- *    A <a href="http://en.wikipedia.org/wiki/Partial_order">partial ordering</a>
- *    is a binary relation on a type <code>T</code> that is also an equivalence
- *    relation on values of type <code>T</code>.  This relation is exposed as
- *    the <code>lteq</code> method of the <code>PartialOrdering</code> trait.
- *    This relation must be:
- *  </p>
- *  <ul>
- *    <li>reflexive: <code>lteq(x, x) == true</code>, for any <code>x</code> of
- *      type <code>T</code>.</li>
- *    <li>anti-symmetric: <code>lteq(x, y) == true</code> and
- *      <code>lteq(y, x) == true</code> then <code>equiv(x, y)</code>, for any
- *      <code>x</code> and <code>y</code> of type <code>T</code>.</li>
- *    <li>transitive: if <code>lteq(x, y) == true</code> and
- *      <code>lteq(y, z) == true</code> then <code>lteq(x, z) == true</code>,
- *      for any <code>x</code>, <code>y</code>, and <code>z</code> of type
- *      <code>T</code>.</li>
- * </ul>
+/** A trait for representing partial orderings.  It is important to
+ *  distinguish between a type that has a partial order and a representation
+ *  of partial ordering on some type.  This trait is for representing the
+ *  latter.
+ *
+ *  A [[http://en.wikipedia.org/wiki/Partial_order partial ordering]] is a
+ *  binary relation on a type `T` that is also an equivalence relation on
+ *  values of type `T`.  This relation is exposed as the `lteq` method of
+ *  the `PartialOrdering` trait. This relation must be:
+ *
+ *  - reflexive: `lteq(x, x) == '''true'''`, for any `x` of type `T`.
+ *  - anti-symmetric: `lteq(x, y) == '''true'''` and `lteq(y, x) == true`
+ *    then `equiv(x, y)`, for any `x` and `y` of type `T`.
+ *  - transitive: if `lteq(x, y) == '''true'''` and
+ *    `lteq(y, z) == '''true'''` then `lteq(x, z) == '''true'''`,
+ *    for any `x`, `y`, and `z` of type `T`.
  *
  *  @author  Geoffrey Washburn
  *  @version 1.0, 2008-04-0-3
@@ -43,37 +33,34 @@ package scala.math
 trait PartialOrdering[T] extends Equiv[T] {
   outer =>
 
-  /** Result of comparing <code>x</code> with operand <code>y</code>.
-   *  Returns <code>None</code> if operands are not comparable.
-   *  If operands are comparable, returns <code>Some(r)</code> where
-   *  <code>r &lt; 0</code>    iff    <code>x &lt; y</code>
-   *  <code>r == 0</code>   iff    <code>x == y</code>
-   *  <code>r &gt; 0</code>    iff    <code>x &gt; y</code>
+  /** Result of comparing `x` with operand `y`.
+   *  Returns `None` if operands are not comparable.
+   *  If operands are comparable, returns `Some(r)` where
+   *  - `r < 0`    iff    `x < y`
+   *  - `r == 0`   iff    `x == y`
+   *  - `r > 0`    iff    `x > y`
    */
   def tryCompare(x: T, y: T): Option[Int]
 
-  /** Returns <code>true</code> iff <code>x</code> comes before
-   *  <code>y</code> in the ordering.
+  /** Returns `'''true'''` iff `x` comes before `y` in the ordering.
    */
   def lteq(x: T, y: T): Boolean
 
-  /** Returns <code>true</code> iff <code>y</code> comes before
-   *  <code>x</code> in the ordering.
+  /** Returns `'''true'''` iff `y` comes before `x` in the ordering.
    */
   def gteq(x: T, y: T): Boolean = lteq(y, x)
 
-  /** Returns <code>true</code> iff <code>x</code> comes before
-   *  <code>y</code> in the ordering and is not the same as <code>y</code>.
+  /** Returns `'''true'''` iff `x` comes before `y` in the ordering
+   *  and is not the same as `y`.
    */
   def lt(x: T, y: T): Boolean = lteq(x, y) && !equiv(x, y)
 
-  /** Returns <code>true</code> iff <code>y</code> comes before
-   *  <code>x</code> in the ordering and is not the same as <code>x</code>.
+  /** Returns `'''true'''` iff `y` comes before `x` in the ordering
+   *  and is not the same as `x`.
    */
   def gt(x: T, y: T): Boolean = gteq(x, y) && !equiv(x, y)
 
-  /** Returns <code>true</code> iff <code>x</code> is equivalent to
-   *  <code>y</code> in the ordering.
+  /** Returns `'''true'''` iff `x` is equivalent to `y` in the ordering.
    */
   def equiv(x: T, y: T): Boolean = lteq(x,y) && lteq(y,x)
 
diff --git a/src/library/scala/math/PartiallyOrdered.scala b/src/library/scala/math/PartiallyOrdered.scala
index 6c447d81c6..2c636d8898 100644
--- a/src/library/scala/math/PartiallyOrdered.scala
+++ b/src/library/scala/math/PartiallyOrdered.scala
@@ -17,12 +17,12 @@ package scala.math
  */
 trait PartiallyOrdered[+A] {
 
-  /** Result of comparing <code>this</code> with operand <code>that</code>.
-   *  Returns <code>None</code> if operands are not comparable.
-   *  If operands are comparable, returns <code>Some(x)</code> where
-   *  <code>x &lt; 0</code>    iff    <code>this &lt; that</code>
-   *  <code>x == 0</code>   iff    <code>this == that</code>
-   *  <code>x &gt; 0</code>    iff    <code>this &gt; that</code>
+  /** Result of comparing `'''this'''` with operand `that`.
+   *  Returns `None` if operands are not comparable.
+   *  If operands are comparable, returns `Some(x)` where
+   *  - `x < 0`    iff   `'''this''' &lt; that`
+   *  - `x == 0`   iff   `'''this''' == that`
+   *  - `x > 0`    iff   `'''this''' &gt; that`
    */
   def tryCompareTo [B >: A <% PartiallyOrdered[B]](that: B): Option[Int]
 
diff --git a/src/library/scala/math/package.scala b/src/library/scala/math/package.scala
index 2aadfb8e1e..255955be67 100644
--- a/src/library/scala/math/package.scala
+++ b/src/library/scala/math/package.scala
@@ -8,9 +8,9 @@
 
 package scala
 
-/** The package object <code>scala.math</code> contains methods for performing basic numeric
- *  operations such as the elementary exponential, logarithm, square root, and
- *  trigonometric functions.
+/** The package object `scala.math` contains methods for performing basic
+ *  numeric operations such as the elementary exponential, logarithm,
+ *  square root, and trigonometric functions.
  */
 
 package object math extends MathCommon {
@@ -27,4 +27,4 @@ package object math extends MathCommon {
   def hypot(x: Double, y: Double): Double = java.lang.Math.hypot(x, y)
   def expm1(x: Double): Double = java.lang.Math.expm1(x)
   def log1p(x: Double): Double = java.lang.Math.log1p(x)
-}
\ No newline at end of file
+}
diff --git a/src/library/scala/ref/Reference.scala b/src/library/scala/ref/Reference.scala
index 0906cf743e..32b6caa43a 100644
--- a/src/library/scala/ref/Reference.scala
+++ b/src/library/scala/ref/Reference.scala
@@ -6,17 +6,16 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.ref
 
 /**
- * @see <code>java.lang.ref.Reference</code>
+ * @see `java.lang.ref.Reference`
  * @author Sean McDirmid
  */
 trait Reference[+T <: AnyRef] extends Function0[T] {
   /** return the underlying value */
   def apply(): T
-  /** return <code>Some</code> underlying if it hasn't been collected, otherwise <code>None</code> */
+  /** return `Some` underlying if it hasn't been collected, otherwise `None` */
   def get: Option[T]
   override def toString = get.map(_.toString).getOrElse("<deleted>")
   def clear(): Unit
diff --git a/src/library/scala/reflect/BeanProperty.scala b/src/library/scala/reflect/BeanProperty.scala
index 1c7b84a7c8..b52774cdff 100644
--- a/src/library/scala/reflect/BeanProperty.scala
+++ b/src/library/scala/reflect/BeanProperty.scala
@@ -6,8 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.reflect
 
 import annotation.target._
@@ -23,9 +21,8 @@ import annotation.target._
  *    def setStatus(s: String) { this.status = s }
  *    def getStatus: String = this.status
  *  }}}
- *  For fields of type `Boolean`, if you need a getter
- *  named <code>isStatus</code>, use the
- *  `scala.reflect.BooleanBeanProperty` annotation instead.
+ *  For fields of type `Boolean`, if you need a getter named `isStatus`,
+ *  use the `scala.reflect.BooleanBeanProperty` annotation instead.
  */
 @field
 class BeanProperty extends annotation.StaticAnnotation
diff --git a/src/library/scala/reflect/NameTransformer.scala b/src/library/scala/reflect/NameTransformer.scala
index 7bc5a61f6c..6c12c8db33 100755
--- a/src/library/scala/reflect/NameTransformer.scala
+++ b/src/library/scala/reflect/NameTransformer.scala
@@ -130,10 +130,10 @@ object NameTransformer {
               unicode = true
             } catch {
               case _:NumberFormatException =>
-                /* <code>hex</code> did not decode to a hexadecimal number, so
+                /* `hex` did not decode to a hexadecimal number, so
                  * do nothing. */
             }
-                       }
+          }
         }
       }
       /* If we didn't see an opcode or encoded Unicode glyph, and the
diff --git a/src/library/scala/reflect/Type.scala b/src/library/scala/reflect/Type.scala
index 5aa92b3828..ddf44d1048 100644
--- a/src/library/scala/reflect/Type.scala
+++ b/src/library/scala/reflect/Type.scala
@@ -32,23 +32,25 @@ case class SingleType(pre: Type, sym: Symbol) extends Type
   * clazz.this */
 case class ThisType(clazz: Symbol) extends Type
 
-/** This type is required by the compiler and <b>should not be used in client code</b>.
+/** This type is required by the compiler and '''should not be used in client code'''.
   * clazz.super[superClazz]
-  * <code>tpe[args1, ..., argsn]</code> */
+  * `tpe[args,,1,,, ..., args,,n,,]`
+  */
 case class AppliedType(tpe: Type, args: List[Type]) extends Type
 
-/** This type is required by the compiler and <b>should not be used in client code</b>.
+/** This type is required by the compiler and '''should not be used in client code'''.
   * [a &lt;: lo &gt;: hi] */
 case class TypeBounds(lo: Type, hi: Type) extends Type
 
-/** This type is required by the compiler and <b>should not be used in client code</b>.
-  * <code>(formals1 ... formalsn) restpe</code> */
+/** This type is required by the compiler and '''should not be used in client code'''.
+  * `(formals,,1,, ... formals,,n,,) restpe`
+  */
 case class MethodType(formals: List[Symbol], restpe: Type) extends Type
 
-/** This type is required by the compiler and <b>should not be used in client code</b>. */
+/** This type is required by the compiler and '''should not be used in client code'''. */
 case class NullaryMethodType(resultType: Type) extends Type
 
-/** This type is required by the compiler and <b>should not be used in client code</b>. */
+/** This type is required by the compiler and '''should not be used in client code'''. */
 case class PolyType(typeParams: List[Symbol], typeBounds: List[(Type, Type)], resultType: Type) extends Type
 
 /* Standard pattern match:
diff --git a/src/library/scala/reflect/generic/PickleBuffer.scala b/src/library/scala/reflect/generic/PickleBuffer.scala
index f52a248f3c..a42e673361 100755
--- a/src/library/scala/reflect/generic/PickleBuffer.scala
+++ b/src/library/scala/reflect/generic/PickleBuffer.scala
@@ -61,7 +61,7 @@ package generic
     writeByte((x & 0x7f).toInt)
   }
 
-  /** Write a natural number <code>x</code> at position <code>pos</code>.
+  /** Write a natural number `x` at position `pos`.
    *  If number is more than one byte, shift rest of array to make space.
    *
    *  @param pos ...
@@ -150,9 +150,8 @@ package generic
     result.toIndexedSeq
   }
 
-  /** Perform operation <code>op</code> until the condition
-   *  <code>readIndex == end</code> is satisfied.
-   *  Concatenate results into a list.
+  /** Perform operation `op` until the condition `readIndex == end` is
+   *  satisfied. Concatenate results into a list.
    *
    *  @param end ...
    *  @param op  ...
@@ -161,8 +160,8 @@ package generic
   def until[T](end: Int, op: () => T): List[T] =
     if (readIndex == end) List() else op() :: until(end, op);
 
-  /** Perform operation <code>op</code> the number of
-   *  times specified.  Concatenate the results into a list.
+  /** Perform operation `op` the number of times specified.
+   *  Concatenate the results into a list.
    */
   def times[T](n: Int, op: ()=>T): List[T] =
     if (n == 0) List() else op() :: times(n-1, op)
diff --git a/src/library/scala/reflect/generic/Trees.scala b/src/library/scala/reflect/generic/Trees.scala
index 30dc68981f..5940ebf23e 100755
--- a/src/library/scala/reflect/generic/Trees.scala
+++ b/src/library/scala/reflect/generic/Trees.scala
@@ -1,3 +1,11 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2011, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
 package scala.reflect
 package generic
 
@@ -571,19 +579,19 @@ import Flags._
   }
 
   /** A synthetic term holding an arbitrary type.  Not to be confused with
-    * with TypTree, the trait for trees that are only used for type trees.
-    * TypeTree's are inserted in several places, but most notably in
-    * <code>RefCheck</code>, where the arbitrary type trees are all replaced by
+    * `TypTree`, the trait for trees that are only used for type trees.
+    * `TypeTree`'s are inserted in several places, but most notably in
+    * `RefCheck`, where the arbitrary type trees are all replaced by
     * TypeTree's. */
   abstract class AbsTypeTree extends TypTree {
     override def symbol = if (tpe == null) null else tpe.typeSymbol
     override def isEmpty = (tpe eq null) || tpe == NoType
   }
 
-  /** A tree that has an annotation attached to it. Only used for annotated types and
-   *  annotation ascriptions, annotations on definitions are stored in the Modifiers.
-   *  Eliminated by typechecker (typedAnnotated), the annotations are then stored in
-   *  an AnnotatedType.
+  /** A tree that has an annotation attached to it. Only used for annotated
+   *  types and annotation ascriptions, annotations on definitions are stored
+   *  in the Modifiers. Eliminated by typechecker (`typedAnnotated`), the
+   *  annotations are then stored in an `AnnotatedType`.
    */
   case class Annotated(annot: Tree, arg: Tree) extends Tree
 
diff --git a/src/library/scala/reflect/generic/UnPickler.scala b/src/library/scala/reflect/generic/UnPickler.scala
index f921846d86..e390dbb54b 100755
--- a/src/library/scala/reflect/generic/UnPickler.scala
+++ b/src/library/scala/reflect/generic/UnPickler.scala
@@ -147,9 +147,9 @@ abstract class UnPickler {
       result
     }
 
-    /** If entry at <code>i</code> is undefined, define it by performing
-     *  operation <code>op</code> with <code>readIndex at start of i'th
-     *  entry. Restore <code>readIndex</code> afterwards.
+    /** If entry at `i` is undefined, define it by performing operation `op`
+     *  with `readIndex` at start of `i`'th entry. Restore `readIndex`
+     *  afterwards.
      */
     protected def at[T <: AnyRef](i: Int, op: () => T): T = {
       var r = entries(i)
diff --git a/src/library/scala/runtime/Nothing$.scala b/src/library/scala/runtime/Nothing$.scala
index c52783b7cd..7d03280644 100644
--- a/src/library/scala/runtime/Nothing$.scala
+++ b/src/library/scala/runtime/Nothing$.scala
@@ -1,20 +1,16 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
 **    / __/ __// _ | / /  / _ |    (c) 2003-2011, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.runtime
 
-
 /**
  * Dummy class which exist only to satisfy the JVM. It corresponds
- * to <code>scala.Nothing</code>. If such type appears in method
+ * to `scala.Nothing`. If such type appears in method
  * signatures, it is erased to this one.
  */
-
 sealed abstract class Nothing$ extends Throwable
diff --git a/src/library/scala/runtime/Null$.scala b/src/library/scala/runtime/Null$.scala
index 3ba1bb3eb9..964bafa056 100644
--- a/src/library/scala/runtime/Null$.scala
+++ b/src/library/scala/runtime/Null$.scala
@@ -1,20 +1,16 @@
 /*                     __                                               *\
 **     ________ ___   / /  ___     Scala API                            **
 **    / __/ __// _ | / /  / _ |    (c) 2003-2011, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |                                         **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
 ** /____/\___/_/ |_/____/_/ | |                                         **
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.runtime
 
-
 /**
- * Dummy class which exist only to satisfy the JVM. It corresponds
- * to <code>scala.Null</code>. If such type appears in method
- * signatures, it is erased to this one.
+ * Dummy class which exist only to satisfy the JVM. It corresponds to
+ * `scala.Null`. If such type appears in method signatures, it is erased
+ * to this one.
  */
-
 sealed abstract class Null$
diff --git a/src/library/scala/runtime/RichFloat.scala b/src/library/scala/runtime/RichFloat.scala
index 3c385e350b..c6478ec0c9 100644
--- a/src/library/scala/runtime/RichFloat.scala
+++ b/src/library/scala/runtime/RichFloat.scala
@@ -19,7 +19,7 @@ final class RichFloat(val self: Float) extends FractionalProxy[Float] {
    *  angle measured in radians.
    *
    *  @param  x an angle, in degrees
-   *  @return the measurement of the angle <code>x</code> in radians.
+   *  @return the measurement of the angle `x` in radians.
    */
   def toRadians: Float = math.toRadians(self).toFloat
 
@@ -27,7 +27,7 @@ final class RichFloat(val self: Float) extends FractionalProxy[Float] {
    *  angle measured in degrees.
    *
    *  @param  x angle, in radians
-   *  @return the measurement of the angle <code>x</code> in degrees.
+   *  @return the measurement of the angle `x` in degrees.
    */
   def toDegrees: Float = math.toDegrees(self).toFloat
 
diff --git a/src/library/scala/runtime/StringAdd.scala b/src/library/scala/runtime/StringAdd.scala
index 824c4f53b5..ae1975cb4c 100644
--- a/src/library/scala/runtime/StringAdd.scala
+++ b/src/library/scala/runtime/StringAdd.scala
@@ -6,17 +6,14 @@
 **                                                                      **
 \*                                                                      */
 
-
-
 package scala.runtime
 
-
 final class StringAdd(self: Any) {
 
   def +(other: String) = String.valueOf(self) + other
 
-  /** Returns string formatted according to given <code>format</code> string.
-   *  Format strings are as for <code>String.format</code>
+  /** Returns string formatted according to given `format` string.
+   *  Format strings are as for `String.format`
    *  (@see java.lang.String.format).
    */
   def formatted(fmtstr: String): String = fmtstr format self
diff --git a/src/library/scala/text/Document.scala b/src/library/scala/text/Document.scala
index 9d2b9a1f15..c0a54799a3 100644
--- a/src/library/scala/text/Document.scala
+++ b/src/library/scala/text/Document.scala
@@ -6,11 +6,8 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.text
 
-
 import java.io.Writer
 
 case object DocNil extends Document
@@ -34,8 +31,8 @@ abstract class Document {
   def :/:(hd: String): Document = hd :: DocBreak :: this
 
   /**
-   * Format this document on <code>writer</code> and try to set line
-   * breaks so that the result fits in <code>width</code> columns.
+   * Format this document on `writer` and try to set line
+   * breaks so that the result fits in `width` columns.
    *
    * @param width  ...
    * @param writer ...
diff --git a/src/library/scala/util/parsing/input/StreamReader.scala b/src/library/scala/util/parsing/input/StreamReader.scala
index 1905b3dcdf..8244177359 100644
--- a/src/library/scala/util/parsing/input/StreamReader.scala
+++ b/src/library/scala/util/parsing/input/StreamReader.scala
@@ -6,15 +6,14 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.util.parsing.input
 
 import java.io.BufferedReader
 import scala.collection.immutable.PagedSeq
 
-/** An object to create a StreamReader from a <code>java.io.Reader</code>.
+/** An object to create a `StreamReader` from a `java.io.Reader`.
  *
- * @param in the <code>java.io.Reader</code> that provides the underlying
+ * @param in the `java.io.Reader` that provides the underlying
  *           stream of characters for this Reader.
  *
  * @author Miles Sabin
@@ -38,7 +37,7 @@ object StreamReader {
  *  when a StreamReader are used for input.
  *
  *  If you need to match regexes spanning several lines you should consider
- *  class <code>PagedSeqReader</code> instead.
+ *  class `PagedSeqReader` instead.
  *
  *  @author Miles Sabin
  *  @author Martin Odersky
diff --git a/src/library/scala/xml/Atom.scala b/src/library/scala/xml/Atom.scala
index 61329af721..8fb81eaa07 100644
--- a/src/library/scala/xml/Atom.scala
+++ b/src/library/scala/xml/Atom.scala
@@ -6,14 +6,13 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.xml
 
-/** The class <code>Atom</code> provides an XML node for text (PCDATA).
+/** The class `Atom` provides an XML node for text (`PCDATA`).
  *  It is used in both non-bound and bound XML representations.
  *
  *  @author Burak Emir
- *  @param text the text contained in this node, may not be <code>null</code>.
+ *  @param text the text contained in this node, may not be `'''null'''`.
  */
 class Atom[+A](val data: A) extends SpecialNode with Serializable
 {
diff --git a/src/library/scala/xml/Comment.scala b/src/library/scala/xml/Comment.scala
index dc649eb308..ecaec4ba6b 100644
--- a/src/library/scala/xml/Comment.scala
+++ b/src/library/scala/xml/Comment.scala
@@ -6,12 +6,9 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.xml
 
-
-/** The class <code>Comment</code> implements an XML node for comments.
+/** The class `Comment` implements an XML node for comments.
  *
  * @author Burak Emir
  * @param text the text contained in this node, may not contain "--"
diff --git a/src/library/scala/xml/Document.scala b/src/library/scala/xml/Document.scala
index df8a926028..4d8208d691 100644
--- a/src/library/scala/xml/Document.scala
+++ b/src/library/scala/xml/Document.scala
@@ -6,14 +6,12 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.xml
 
 /** A document information item (according to InfoSet spec). The comments
  *  are copied from the Infoset spec, only augmented with some information
  *  on the Scala types for definitions that might have no value.
- *  also plays the role of an <code>XMLEvent</code> for pull parsing
+ *  Also plays the role of an `XMLEvent` for pull parsing.
  *
  *  @author  Burak Emir
  *  @version 1.0, 26/04/2005
@@ -62,14 +60,14 @@ class Document extends NodeSeq with pull.XMLEvent with Serializable {
   /** An indication of the standalone status of the document, either
    *  true or false. This property is derived from the optional standalone
    *  document declaration in the XML declaration at the beginning of the
-   *  document entity, and has no value (<code>None</code>) if there is no
+   *  document entity, and has no value (`None`) if there is no
    *  standalone document declaration.
    */
   var standAlone: Option[Boolean] = _
 
   /** A string representing the XML version of the document. This
    *  property is derived from the XML declaration optionally present at
-   *  the beginning of the document entity, and has no value (<code>None</code>)
+   *  the beginning of the document entity, and has no value (`None`)
    *  if there is no XML declaration.
    */
   var version: Option[String] = _
diff --git a/src/library/scala/xml/Elem.scala b/src/library/scala/xml/Elem.scala
index 4ea7e90de2..a522cdab20 100644
--- a/src/library/scala/xml/Elem.scala
+++ b/src/library/scala/xml/Elem.scala
@@ -6,16 +6,16 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.xml
 
-/** This singleton object contains the apply and unapplySeq methods for convenient construction and
- *  deconstruction. It is possible to deconstruct any Node instance (that is not a SpecialNode or
- *  a Group) using the syntax
- * <code> case Elem(prefix, label, attribs, scope, child @ _*) => ... </code>
+/** This singleton object contains the apply and unapplySeq methods for
+ *  convenient construction and deconstruction. It is possible to deconstruct
+ *  any `Node` instance (that is not a `SpecialNode` or a `Group`) using the
+ *  syntax `case Elem(prefix, label, attribs, scope, child @ _*) => ...`
  *
- * Copyright 2008 Google Inc. All Rights Reserved.
- * @author Burak Emir <bqe@google.com>
+ *  Copyright 2008 Google Inc. All Rights Reserved.
+ *
+ *  @author Burak Emir <bqe@google.com>
  */
 object Elem {
   def apply(prefix: String,label: String, attributes: MetaData, scope: NamespaceBinding, child: Node*) =
@@ -27,7 +27,7 @@ object Elem {
   }
 }
 
-/** The case class <code>Elem</code> extends the <code>Node</code> class,
+/** The case class `Elem` extends the `Node` class,
  *  providing an immutable data object representing an XML element.
  *
  *  @param prefix namespace prefix (may be null, but not the empty string)
@@ -83,8 +83,7 @@ extends Node with Serializable
     child: Seq[Node] = this.child.toSeq
   ): Elem = Elem(prefix, label, attributes, scope, child: _*)
 
-  /** Returns concatenation of <code>text(n)</code> for each child
-   *  <code>n</code>.
+  /** Returns concatenation of `text(n)` for each child `n`.
    */
   override def text = child map (_.text) mkString
 }
diff --git a/src/library/scala/xml/EntityRef.scala b/src/library/scala/xml/EntityRef.scala
index d3f0a3f986..60feeb845d 100644
--- a/src/library/scala/xml/EntityRef.scala
+++ b/src/library/scala/xml/EntityRef.scala
@@ -6,14 +6,9 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.xml
 
-
-
-/** The class <code>EntityRef</code> implements an XML node for entity
- *  references.
+/** The class `EntityRef` implements an XML node for entity references.
  *
  * @author  Burak Emir
  * @version 1.0
@@ -33,10 +28,10 @@ case class EntityRef(entityName: String) extends SpecialNode {
     case _      => Utility.sbToString(buildString)
   }
 
-  /** Appends "&amp; entityName;" to this string buffer.
+  /** Appends `"&amp; entityName;"` to this string buffer.
    *
    *  @param  sb the string buffer.
-   *  @return the modified string buffer <code>sb</code>.
+   *  @return the modified string buffer `sb`.
    */
   override def buildString(sb: StringBuilder) =
     sb.append("&").append(entityName).append(";")
diff --git a/src/library/scala/xml/MetaData.scala b/src/library/scala/xml/MetaData.scala
index e3e025cf59..cbfb076004 100644
--- a/src/library/scala/xml/MetaData.scala
+++ b/src/library/scala/xml/MetaData.scala
@@ -6,7 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.xml
 
 import Utility.sbToString
@@ -20,10 +19,12 @@ import scala.collection.Iterator
 object MetaData {
 
   /**
-   * appends all attributes from new_tail to attribs, without attempting to detect
-   * or remove duplicates. The method guarantees that all attributes from attribs come before
-   * the attributes in new_tail, but does not guarantee to preserve the relative order of attribs.
-   * Duplicates can be removed with normalize.
+   * appends all attributes from new_tail to attribs, without attempting to
+   * detect or remove duplicates. The method guarantees that all attributes
+   * from attribs come before the attributes in new_tail, but does not
+   * guarantee to preserve the relative order of attribs.
+   *
+   * Duplicates can be removed with `normalize`.
    */
   @tailrec
   def concatenate(attribs: MetaData, new_tail: MetaData): MetaData =
@@ -60,16 +61,17 @@ object MetaData {
 
 }
 
-/** <p>
- *    This class represents an attribute and at the same time a linked list of attributes.
- *    Every instance of this class is either an instance of UnprefixedAttribute <code>key,value</code>
- *    or an instance of PrefixedAttribute <code>namespace_prefix,key,value</code> or Null, the empty
- *    attribute list. Namespace URIs are obtained by using the namespace scope of the element owning
- *    this attribute (see <code>getNamespace</code>)
- * </p>
+/** This class represents an attribute and at the same time a linked list of
+ *  attributes. Every instance of this class is either
+ *  - an instance of `UnprefixedAttribute key,value` or
+ *  - an instance of `PrefixedAttribute namespace_prefix,key,value` or
+ *  - `Null, the empty attribute list.
  *
- * Copyright 2008 Google Inc. All Rights Reserved.
- * @author Burak Emir <bqe@google.com>
+ *  Namespace URIs are obtained by using the namespace scope of the element
+ *  owning this attribute (see `getNamespace`).
+ *
+ *  Copyright 2008 Google Inc. All Rights Reserved.
+ *  @author Burak Emir <bqe@google.com>
  */
 abstract class MetaData extends Iterable[MetaData] with Equality with Serializable {
   /** Updates this MetaData with the MetaData given as argument. All attributes that occur in updates
@@ -91,7 +93,7 @@ abstract class MetaData extends Iterable[MetaData] with Equality with Serializab
    */
   def apply(key: String): Seq[Node]
 
-  /** convenience method, same as <code>apply(namespace, owner.scope, key)</code>.
+  /** convenience method, same as `apply(namespace, owner.scope, key)`.
    *
    *  @param namespace_uri namespace uri of key
    *  @param owner the element owning this attribute list
@@ -207,7 +209,7 @@ abstract class MetaData extends Iterable[MetaData] with Equality with Serializab
 
   /**
    *  @param scope ...
-   *  @return      <code>true</code> iff ...
+   *  @return      `'''true'''` iff ...
    */
   def wellformed(scope: NamespaceBinding): Boolean
 
diff --git a/src/library/scala/xml/NamespaceBinding.scala b/src/library/scala/xml/NamespaceBinding.scala
index 7ad2b42989..f284a6e407 100644
--- a/src/library/scala/xml/NamespaceBinding.scala
+++ b/src/library/scala/xml/NamespaceBinding.scala
@@ -6,14 +6,11 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.xml
 
 import Utility.sbToString
 
-
-/** The class <code>NamespaceBinding</code> represents namespace bindings
+/** The class `NamespaceBinding` represents namespace bindings
  *  and scopes. The binding for the default namespace is treated as a null
  *  prefix. the absent namespace is represented with the null uri. Neither
  *  prefix nor uri may be empty, which is not checked.
diff --git a/src/library/scala/xml/Node.scala b/src/library/scala/xml/Node.scala
index bf4d81eb27..f219b73d81 100644
--- a/src/library/scala/xml/Node.scala
+++ b/src/library/scala/xml/Node.scala
@@ -6,7 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.xml
 
 /**
@@ -61,8 +60,8 @@ abstract class Node extends NodeSeq {
   def namespace = getNamespace(this.prefix)
 
   /**
-   * Convenience method, same as <code>scope.getURI(pre)</code> but additionally
-   * checks if scope is <code>null</code>.
+   * Convenience method, same as `scope.getURI(pre)` but additionally
+   * checks if scope is `'''null'''`.
    *
    * @param pre the prefix whose namespace name we would like to obtain
    * @return    the namespace if <code>scope != null</code> and prefix was
@@ -72,7 +71,7 @@ abstract class Node extends NodeSeq {
 
   /**
    * Convenience method, looks up an unprefixed attribute in attributes of this node.
-   * Same as <code>attributes.getValue(key)</code>
+   * Same as `attributes.getValue(key)`
    *
    * @param  key of queried attribute.
    * @return value of <code>UnprefixedAttribute</code> with given key
@@ -82,20 +81,20 @@ abstract class Node extends NodeSeq {
 
   /**
    * Convenience method, looks up a prefixed attribute in attributes of this node.
-   * Same as <code>attributes.getValue(uri, this, key)</code>
+   * Same as `attributes.getValue(uri, this, key)`-
    *
    * @param  uri namespace of queried attribute (may not be null).
    * @param  key of queried attribute.
-   * @return value of <code>PrefixedAttribute</code> with given namespace
-   *         and given key, otherwise <code>null</code>.
+   * @return value of `PrefixedAttribute` with given namespace
+   *         and given key, otherwise `'''null'''`.
    */
   final def attribute(uri: String, key: String): Option[Seq[Node]] =
     attributes.get(uri, this, key)
 
   /**
    * Returns attribute meaning all attributes of this node, prefixed and
-   * unprefixed, in no particular order. In class <code>Node</code>, this
-   * defaults to <code>Null</code> (the empty attribute list).
+   * unprefixed, in no particular order. In class `Node`, this
+   * defaults to `Null` (the empty attribute list).
    *
    * @return all attributes of this node
    */
@@ -160,28 +159,28 @@ abstract class Node extends NodeSeq {
     Utility.toXML(this, stripComments = stripComments).toString
 
   /**
-   * Same as <code>toString(false)</code>.
+   * Same as `toString('''false''')`.
    *
    * @see <code><a href="#toString">toString(Boolean)</a></code>
    */
   override def toString(): String = buildString(false)
 
   /**
-   * Appends qualified name of this node to <code>StringBuilder</code>.
+   * Appends qualified name of this node to `StringBuilder`.
    *
    * @param sb ...
    * @return   ...
    */
   def nameToString(sb: StringBuilder): StringBuilder = {
     if (null != prefix) {
-      sb.append(prefix)
-      sb.append(':')
+      sb append prefix
+      sb append ':'
     }
-    sb.append(label)
+    sb append label
   }
 
   /**
-   * Returns a type symbol (e.g. DTD, XSD), default <code>null</code>.
+   * Returns a type symbol (e.g. DTD, XSD), default `'''null'''`.
    */
   def xmlType(): TypeSymbol = null
 
diff --git a/src/library/scala/xml/Utility.scala b/src/library/scala/xml/Utility.scala
index 3969bb9338..a96533e793 100644
--- a/src/library/scala/xml/Utility.scala
+++ b/src/library/scala/xml/Utility.scala
@@ -98,7 +98,7 @@ object Utility extends AnyRef with parsing.TokenTests {
   import Escapes.{ escMap, unescMap }
 
   /**
-   * Appends escaped string to <code>s</code>.
+   * Appends escaped string to `s`.
    *
    * @param text ...
    * @param s    ...
@@ -134,8 +134,7 @@ object Utility extends AnyRef with parsing.TokenTests {
    *
    * @param ref ...
    * @param s   ...
-   * @return    <code>null</code> if <code>ref</code> was not a predefined
-   *            entity.
+   * @return    `'''null'''` if `ref` was not a predefined entity.
    */
   final def unescape(ref: String, s: StringBuilder): StringBuilder =
     (unescMap get ref) map (s append _) orNull
@@ -271,7 +270,7 @@ object Utility extends AnyRef with parsing.TokenTests {
   def appendQuoted(s: String): String = sbToString(appendQuoted(s, _))
 
   /**
-   * Appends &quot;s&quot; if string <code>s</code> does not contain &quot;,
+   * Appends &quot;s&quot; if string `s` does not contain &quot;,
    * &apos;s&apos; otherwise.
    *
    * @param s  ...
diff --git a/src/library/scala/xml/XML.scala b/src/library/scala/xml/XML.scala
index 04dedfdf45..678028dd28 100644
--- a/src/library/scala/xml/XML.scala
+++ b/src/library/scala/xml/XML.scala
@@ -6,8 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.xml
 
 import parsing.NoBindingFactoryAdapter
@@ -30,9 +28,9 @@ object Source
 }
 import Source._
 
-/** The object <code>XML</code> provides constants, and functions to load
+/** The object `XML` provides constants, and functions to load
  *  and save XML elements. Use this when data binding is not desired, i.e.
- *  when XML is handled using <code>Symbol</code> nodes.
+ *  when XML is handled using `Symbol` nodes.
  *
  *  @author  Burak Emir
  *  @version 1.0, 25/04/2005
@@ -89,7 +87,7 @@ object XML extends XMLLoader[Elem]
    *
    *  @param w        the writer
    *  @param node     the xml node we want to write
-   *  @param enc      the string to be used in <code>xmlDecl</code>
+   *  @param enc      the string to be used in `xmlDecl`
    *  @param xmlDecl  if true, write xml declaration
    *  @param doctype  if not null, write doctype declaration
    */
diff --git a/src/library/scala/xml/include/XIncludeException.scala b/src/library/scala/xml/include/XIncludeException.scala
index a8ef3954c5..033cf4db61 100644
--- a/src/library/scala/xml/include/XIncludeException.scala
+++ b/src/library/scala/xml/include/XIncludeException.scala
@@ -6,39 +6,33 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.xml
 package include
 
 /**
- * <p>
- * <code>XIncludeException</code> is the generic superclass
- * for all checked exceptions that may be thrown as a result
- * of a violation of XInclude's rules.
- * </p>
- * <p>
- * Constructs an <code>XIncludeException</code> with the specified detail
- * message. The error message string <code>message</code> can later be
- * retrieved by the <code>{@link java.lang.Throwable#getMessage}</code>
- * method of class <code>java.lang.Throwable</code>.
- * </p>
+ * `XIncludeException` is the generic superclass for all checked exceptions
+ * that may be thrown as a result of a violation of XInclude's rules.
+ *
+ * Constructs an `XIncludeException` with the specified detail message.
+ * The error message string `message` can later be retrieved by the
+ * `{@link java.lang.Throwable#getMessage}`
+ * method of class `java.lang.Throwable`.
  *
  * @param   message   the detail message.
  */
 class XIncludeException(message: String) extends Exception(message) {
 
   /**
-   * uses <code>null</code> as its error detail message.
+   * uses `'''null'''` as its error detail message.
    */
   def this() = this(null)
 
   private var rootCause: Throwable = null
 
   /**
-   * When an <code>IOException</code>, <code>MalformedURLException</code>
-   * or other generic exception is thrown while processing an XML document
-   * for XIncludes, it is customarily replaced
-   * by some form of <code>XIncludeException</code>.
+   * When an `IOException`, `MalformedURLException` or other generic
+   * exception is thrown while processing an XML document for XIncludes,
+   * it is customarily replaced by some form of `XIncludeException`.
    * This method allows you to store the original exception.
    *
    * @param   nestedException   the underlying exception which
@@ -49,15 +43,14 @@ class XIncludeException(message: String) extends Exception(message) {
   }
 
   /**
-   * When an <code>IOException</code>, <code>MalformedURLException</code>
-   * or other generic exception is thrown while processing an XML document
-   * for XIncludes, it is customarily replaced
-   * by some form of <code>XIncludeException</code>.
+   * When an `IOException`, `MalformedURLException` or other generic
+   * exception is thrown while processing an XML document for XIncludes,
+   * it is customarily replaced by some form of `XIncludeException`.
    * This method allows you to retrieve the original exception.
-   * It returns null if no such exception caused this <code>XIncludeException</code>.
+   * It returns null if no such exception caused this `XIncludeException`.
    *
    * @return Throwable   the underlying exception which caused the
-   *                     <code>XIncludeException</code> to be thrown
+   *                     `XIncludeException` to be thrown
    */
   def getRootCause(): Throwable = this.rootCause
 
diff --git a/src/library/scala/xml/include/sax/XIncludeFilter.scala b/src/library/scala/xml/include/sax/XIncludeFilter.scala
index adcaf1738b..4bd0336a26 100644
--- a/src/library/scala/xml/include/sax/XIncludeFilter.scala
+++ b/src/library/scala/xml/include/sax/XIncludeFilter.scala
@@ -6,7 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.xml
 package include.sax
 
@@ -19,57 +18,40 @@ import java.io.{ InputStream, BufferedInputStream, InputStreamReader, IOExceptio
 import java.util.Stack
 import java.net.{ URL, MalformedURLException }
 
-/**
- * <p>
- *  This is a SAX filter which resolves all XInclude include elements
- *  before passing them on to the client application. Currently this
- *  class has the following known deviation from the XInclude specification:
- * </p>
- *  <ol>
- *   <li>XPointer is not supported.</li>
- *  </ol>
+/** This is a SAX filter which resolves all XInclude include elements before
+ *  passing them on to the client application. Currently this class has the
+ *  following known deviation from the XInclude specification:
+ *
+ *  1. XPointer is not supported.
  *
- *  <p>
- *    Furthermore, I would definitely use a new instance of this class
- *    for each document you want to process. I doubt it can be used
- *    successfully on multiple documents. Furthermore, I can virtually
- *    guarantee that this class is not thread safe. You have been
- *    warned.
- *  </p>
+ *  Furthermore, I would definitely use a new instance of this class for each
+ *  document you want to process. I doubt it can be used successfully on
+ *  multiple documents. Furthermore, I can virtually guarantee that this
+ *  class is not thread safe. You have been warned.
  *
- *  <p>
- *    Since this class is not designed to be subclassed, and since
- *    I have not yet considered how that might affect the methods
- *    herein or what other protected methods might be needed to support
- *    subclasses, I have declared this class final. I may remove this
- *    restriction later, though the use-case for subclassing is weak.
- *    This class is designed to have its functionality extended via a
- *    a horizontal chain of filters, not a
- *    vertical hierarchy of sub and superclasses.
- *  </p>
+ *  Since this class is not designed to be subclassed, and since I have not
+ *  yet considered how that might affect the methods herein or what other
+ *  protected methods might be needed to support subclasses, I have declared
+ *  this class final. I may remove this restriction later, though the use-case
+ *  for subclassing is weak. This class is designed to have its functionality
+ *  extended via a horizontal chain of filters, not a vertical hierarchy of
+ *  sub and superclasses.
  *
- *  <p>
- *    To use this class:
- *  </p>
- *  <ol>
- *   <li>Construct an <code>XIncludeFilter</code> object with a known base URL</li>
- *   <li>Pass the <code>XMLReader</code> object from which the raw document will
- *       be read to the <code>setParent()</code> method of this object. </li>
- *   <li>Pass your own <code>ContentHandler</code> object to the
- *       <code>setContentHandler()</code> method of this object. This is the
- *       object which will receive events from the parsed and included
- *       document.
- *   </li>
- *   <li>Optional: if you wish to receive comments, set your own
- *       <code>LexicalHandler</code> object as the value of this object's
- *       http://xml.org/sax/properties/lexical-handler property.
- *       Also make sure your <code>LexicalHandler</code> asks this object
- *       for the status of each comment using <code>insideIncludeElement</code>
- *       before doing anything with the comment.
- *   </li>
- *   <li>Pass the URL of the document to read to this object's
- *       <code>parse()</code> method</li>
- *  </ol>
+ *  To use this class:
+ *
+ *  - Construct an `XIncludeFilter` object with a known base URL
+ *  - Pass the `XMLReader` object from which the raw document will be read to
+ *    the `setParent()` method of this object.
+ *  - Pass your own `ContentHandler` object to the `setContentHandler()`
+ *    method of this object. This is the object which will receive events
+ *    from the parsed and included document.
+ *  - Optional: if you wish to receive comments, set your own `LexicalHandler`
+ *    object as the value of this object's
+ *    `http://xml.org/sax/properties/lexical-handler` property.
+ *    Also make sure your `LexicalHandler` asks this object for the status of
+ *    each comment using `insideIncludeElement` before doing anything with the
+ *    comment.
+ *  - Pass the URL of the document to read to this object's `parse()` method
  *
  *  e.g.
  *  {{{
@@ -79,6 +61,7 @@ import java.net.{ URL, MalformedURLException }
  *  includer parse args(i)
  *  }}}
  *  translated from Elliotte Rusty Harold's Java source.
+ *
  * @author Burak Emir
  */
 class XIncludeFilter extends XMLFilterImpl {
@@ -119,15 +102,12 @@ class XIncludeFilter extends XMLFilterImpl {
   // necessary to throw away contents of non-empty XInclude elements
   private var level = 0
 
-  /**
-    * <p>
-    * This utility method returns true if and only if this reader is
-    * currently inside a non-empty include element. (This is <strong>
-    * not</strong> the same as being inside the node set which replaces
-    * the include element.) This is primarily needed for comments
-    * inside include elements. It must be checked by the actual
-    * LexicalHandler to see whether a comment is passed or not.
-    * </p>
+  /** This utility method returns true if and only if this reader is
+    * currently inside a non-empty include element. (This is '''not''' the
+    * same as being inside the node set which replaces the include element.)
+    * This is primarily needed for comments inside include elements.
+    * It must be checked by the actual `LexicalHandler` to see whether
+    * a comment is passed or not.
     *
     * @return boolean
     */
diff --git a/src/swing/scala/swing/FileChooser.scala b/src/swing/scala/swing/FileChooser.scala
index 0459af3ddb..fef99c5d82 100644
--- a/src/swing/scala/swing/FileChooser.scala
+++ b/src/swing/scala/swing/FileChooser.scala
@@ -6,8 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.swing
 
 import java.io.File
@@ -16,9 +14,9 @@ import javax.swing.filechooser._
 
 object FileChooser {
   /**
-   * The result of a file dialog. The precise meaning of the <code>Approve</code>
-   * result depends on the specific dialog type. Could be "save" or "open" for
-   * example.
+   * The result of a file dialog. The precise meaning of the `Approve`
+   * result depends on the specific dialog type. Could be `"save"` or
+   * `"open"` for instance.
    */
   object Result extends Enumeration {
     val Cancel = Value(JFileChooser.CANCEL_OPTION)
@@ -39,7 +37,7 @@ object FileChooser {
 /**
  * Used to open file dialogs.
  *
- * @see javax.swing.JFileChooser
+ * @see [[javax.swing.JFileChooser]]
  */
 class FileChooser(dir: File) {
   import FileChooser._
@@ -66,7 +64,7 @@ class FileChooser(dir: File) {
   def fileSelectionMode: SelectionMode.Value = SelectionMode(peer.getFileSelectionMode)
   def fileSelectionMode_=(s: SelectionMode.Value) { peer.setFileSelectionMode(s.id) }
   def fileFilter: FileFilter = peer.getFileFilter
-  def fileFilter_=(f: FileFilter) { peer.setFileFilter(f) }
+  def fileFilter_=(f: FileFilter) { peer setFileFilter f }
 
   def selectedFile: File = peer.getSelectedFile
   def selectedFile_=(file: File) { peer.setSelectedFile(file) }
diff --git a/src/swing/scala/swing/LayoutContainer.scala b/src/swing/scala/swing/LayoutContainer.scala
index 0865abf595..da1c766437 100644
--- a/src/swing/scala/swing/LayoutContainer.scala
+++ b/src/swing/scala/swing/LayoutContainer.scala
@@ -6,22 +6,19 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.swing
 
 import javax.swing.JComponent
 import scala.collection.mutable
 
-/** <p>
- *    A container that associates layout constraints of member type
- *    <code>Constraints</code> with its children. See <code>GridBagPanel</code>
- *    for an example container with custom constraints.
- *  </p>
+/** A container that associates layout constraints of member type
+ *  `Constraints` with its children.
+ *
+ *  See `GridBagPanel` for an example container with custom constraints.
  *
  *  @note [Java Swing] In scala.swing, panels and layout managers are
- *  combined into subclasses of this base class. This approach allows for typed
- *  component constraints.
+ *  combined into subclasses of this base class. This approach allows for
+ *  typed component constraints.
  */
 trait LayoutContainer extends Container.Wrapper {
   /**
diff --git a/src/swing/scala/swing/SimpleGUIApplication.scala b/src/swing/scala/swing/SimpleGUIApplication.scala
index 74d5d5ee04..f12e43ff5f 100644
--- a/src/swing/scala/swing/SimpleGUIApplication.scala
+++ b/src/swing/scala/swing/SimpleGUIApplication.scala
@@ -6,20 +6,19 @@
 **                          |/                                          **
 \*                                                                      */
 
-
-
 package scala.swing
 
 import javax.swing._
 
 /**
- * Extend this class for most simple UI applications. Clients need to implement the
- * <code>top</code> method. Framework initialization is done by this class.
+ * Extend this class for most simple UI applications. Clients need to
+ * implement the `top` method. Framework initialization is done by this class.
  *
- * In order to conform to Swing's threading policy, never implement top or any additional
- * member that created Swing components as a value unless component creation happens on
- * the EDT (see Swing.onEDT and Swing.onEDTWait). Lazy values are okay for the same reason
- * if they are initialized on the EDT always.
+ * In order to conform to Swing's threading policy, never implement top or any
+ * additional member that created Swing components as a value unless component
+ * creation happens on the EDT (see `Swing.onEDT` and `Swing.onEDTWait`).
+ * Lazy values are okay for the same reason if they are initialized on the EDT
+ * always.
  */
 @deprecated("Use SimpleSwingApplication instead", "2.8.0") abstract class SimpleGUIApplication extends GUIApplication {
 
diff --git a/src/swing/scala/swing/UIElement.scala b/src/swing/scala/swing/UIElement.scala
index 048568dda2..9e505ea9a6 100644
--- a/src/swing/scala/swing/UIElement.scala
+++ b/src/swing/scala/swing/UIElement.scala
@@ -44,8 +44,8 @@ object UIElement {
    * Returns a wrapper for a given Java Swing peer. If there is a
    * compatible wrapper in use, this method will return it.
    *
-   * `wrap` methods in companion objects of subclasses of UIElement have the
-   * same behavior, except that they return more specific wrappers.
+   * `wrap` methods in companion objects of subclasses of `UIElement` have
+   * the  same behavior, except that they return more specific wrappers.
    */
   def wrap(c: java.awt.Component): UIElement = {
     val w = cachedWrapper[UIElement](c)
@@ -57,7 +57,7 @@ object UIElement {
 /**
  * The base trait of all user interface elements. Subclasses belong to one
  * of two groups: top-level elements such as windows and dialogs, or
- * <code>Component</code>s.
+ * `Component`s.
  *
  * @note [Java Swing] This trait does not have an exact counterpart in
  * Java Swing. The peer is of type java.awt.Component since this is the
@@ -78,19 +78,19 @@ trait UIElement extends Proxy with LazyPublisher {
   UIElement.cache(this)
 
   def foreground: Color = peer.getForeground
-  def foreground_=(c: Color) = peer.setForeground(c)
+  def foreground_=(c: Color) = peer setForeground c
   def background: Color = peer.getBackground
-  def background_=(c: Color) = peer.setBackground(c)
+  def background_=(c: Color) = peer setBackground c
 
   def minimumSize = peer.getMinimumSize
-  def minimumSize_=(x: Dimension) = peer.setMinimumSize(x)
+  def minimumSize_=(x: Dimension) = peer setMinimumSize x
   def maximumSize = peer.getMaximumSize
-  def maximumSize_=(x: Dimension) = peer.setMaximumSize(x)
+  def maximumSize_=(x: Dimension) = peer setMaximumSize x
   def preferredSize = peer.getPreferredSize
-  def preferredSize_=(x: Dimension) = peer.setPreferredSize(x)
+  def preferredSize_=(x: Dimension) = peer setPreferredSize x
 
   def font: Font = peer.getFont
-  def font_=(f: Font) = peer.setFont(f)
+  def font_=(f: Font) = peer setFont f
 
   def locationOnScreen = peer.getLocationOnScreen
   def location = peer.getLocation
diff --git a/src/swing/scala/swing/event/AdjustingEvent.scala b/src/swing/scala/swing/event/AdjustingEvent.scala
index b9469bc588..26815595eb 100644
--- a/src/swing/scala/swing/event/AdjustingEvent.scala
+++ b/src/swing/scala/swing/event/AdjustingEvent.scala
@@ -11,13 +11,12 @@
 package scala.swing
 package event
 
-/** <p>
- *    An event that indicates some editing operation that can be still in
- *    progress.<br/>
- *    Example: dragging a slider creates a number of <code>AdjustmentEvents</code>
- *    with <code>adjusting == true</code> until the user finally releases the
- *    mouse button.
- *  </p>
+/** An event that indicates some editing operation that can be still
+ *  in progress.
+ *
+ *  Example: dragging a slider creates a number of `AdjustmentEvents`
+ *  with `adjusting == '''true'''` until the user finally releases the
+ *  mouse button.
  */
 trait AdjustingEvent extends ComponentEvent {
   def adjusting: Boolean