doc: add graves

src/libstd/io/stdio.rs

@@ -133,17 +133,17 @@ fn handle_ebadf<T>(r: io::Result<T>, default: T) -> io::Result<T> {
 /// A handle to the standard input stream of a process.
 ///
 /// Each handle is a shared reference to a global buffer of input data to this
-/// process. A handle can be `lock`'d to gain full access to [BufRead] methods
+/// process. A handle can be `lock`'d to gain full access to [`BufRead`] methods
 /// (e.g. `.lines()`). Writes to this handle are otherwise locked with respect
 /// to other writes.
 ///
 /// This handle implements the `Read` trait, but beware that concurrent reads
 /// of `Stdin` must be executed with care.
 ///
-/// Created by the [io::stdin] method.
+/// Created by the [`io::stdin`] method.
 ///
-/// [io::stdin]: fn.stdin.html
+/// [`io::stdin`]: fn.stdin.html
-/// [BufRead]: trait.BufRead.html
+/// [`BufRead`]: trait.BufRead.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Stdin {
     inner: Arc<Mutex<BufReader<Maybe<StdinRaw>>>>,
@@ -151,12 +151,12 @@ pub struct Stdin {
 
 /// A locked reference to the `Stdin` handle.
 ///
-/// This handle implements both the [Read] and [BufRead] traits, and
+/// This handle implements both the [`Read`] and [`BufRead`] traits, and
-/// is constructed via the [Stdin::lock] method.
+/// is constructed via the [`Stdin::lock`] method.
 ///
-/// [Read]: trait.Read.html
+/// [`Read`]: trait.Read.html
-/// [BufRead]: trait.BufRead.html
+/// [`BufRead`]: trait.BufRead.html
-/// [Stdin::lock]: struct.Stdin.html#method.lock
+/// [`Stdin::lock`]: struct.Stdin.html#method.lock
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct StdinLock<'a> {
     inner: MutexGuard<'a, BufReader<Maybe<StdinRaw>>>,
@@ -166,7 +166,7 @@ pub struct StdinLock<'a> {
 ///
 /// Each handle returned is a reference to a shared global buffer whose access
 /// is synchronized via a mutex. If you need more explicit control over
-/// locking, see the [lock() method][lock].
+/// locking, see the [`lock() method`][lock].
 ///
 /// [lock]: struct.Stdin.html#method.lock
 ///
@@ -228,7 +228,7 @@ impl Stdin {
     /// guard.
     ///
     /// The lock is released when the returned lock goes out of scope. The
-    /// returned guard also implements the [Read] and [BufRead] traits for
+    /// returned guard also implements the [`Read`] and [`BufRead`] traits for
     /// accessing the underlying data.
     ///
     /// [Read]: trait.Read.html
@@ -241,9 +241,9 @@ impl Stdin {
     /// Locks this handle and reads a line of input into the specified buffer.
     ///
     /// For detailed semantics of this method, see the documentation on
-    /// [BufRead::read_line].
+    /// [`BufRead::read_line`].
     ///
-    /// [BufRead::read_line]: trait.BufRead.html#method.read_line
+    /// [`BufRead::read_line`]: trait.BufRead.html#method.read_line
     ///
     /// # Examples
     ///
@@ -326,9 +326,9 @@ const OUT_MAX: usize = ::usize::MAX;
 /// output stream. Access is also synchronized via a lock and explicit control
 /// over locking is available via the `lock` method.
 ///
-/// Created by the [io::stdout] method.
+/// Created by the [`io::stdout`] method.
 ///
-/// [io::stdout]: fn.stdout.html
+/// [`io::stdout`]: fn.stdout.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Stdout {
     // FIXME: this should be LineWriter or BufWriter depending on the state of
@@ -339,11 +339,11 @@ pub struct Stdout {
 
 /// A locked reference to the `Stdout` handle.
 ///
-/// This handle implements the [Write] trait, and is constructed via
+/// This handle implements the [`Write`] trait, and is constructed via
-/// the [Stdout::lock] method.
+/// the [`Stdout::lock`] method.
 ///
-/// [Write]: trait.Write.html
+/// [`Write`]: trait.Write.html
-/// [Stdout::lock]: struct.Stdout.html#method.lock
+/// [`Stdout::lock`]: struct.Stdout.html#method.lock
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct StdoutLock<'a> {
     inner: ReentrantMutexGuard<'a, RefCell<LineWriter<Maybe<StdoutRaw>>>>,
@@ -441,9 +441,9 @@ impl<'a> Write for StdoutLock<'a> {
 
 /// A handle to the standard error stream of a process.
 ///
-/// For more information, see the [io::stderr] method.
+/// For more information, see the [`io::stderr`] method.
 ///
-/// [io::stderr]: fn.stderr.html
+/// [`io::stderr`]: fn.stderr.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Stderr {
     inner: Arc<ReentrantMutex<RefCell<Maybe<StderrRaw>>>>,
@@ -452,9 +452,9 @@ pub struct Stderr {
 /// A locked reference to the `Stderr` handle.
 ///
 /// This handle implements the `Write` trait and is constructed via
-/// the [Stderr::lock] method.
+/// the [`Stderr::lock`] method.
 ///
-/// [Stderr::lock]: struct.Stderr.html#method.lock
+/// [`Stderr::lock`]: struct.Stderr.html#method.lock
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct StderrLock<'a> {
     inner: ReentrantMutexGuard<'a, RefCell<Maybe<StderrRaw>>>,