7132338: Use @code friendly idiom for '\' in javadoc

Reviewed-by: alanb

src/share/classes/java/io/LineNumberInputStream.java

 /*
- * Copyright (c) 1995, 2004, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1995, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -30,13 +30,13 @@ package java.io;
  * functionality of keeping track of the current line number.
  * <p>
  * A line is a sequence of bytes ending with a carriage return
- * character (<code>'&#92;r'</code>), a newline character
- * (<code>'&#92;n'</code>), or a carriage return character followed
+ * character ({@code '\u005Cr'}), a newline character
+ * ({@code '\u005Cn'}), or a carriage return character followed
  * immediately by a linefeed character. In all three cases, the line
  * terminating character(s) are returned as a single newline character.
  * <p>
- * The line number begins at <code>0</code>, and is incremented by
- * <code>1</code> when a <code>read</code> returns a newline character.
+ * The line number begins at {@code 0}, and is incremented by
+ * {@code 1} when a {@code read} returns a newline character.
  *
  * @author     Arthur van Hoff
  * @see        java.io.LineNumberReader
@@ -66,22 +66,22 @@ class LineNumberInputStream extends FilterInputStream {
 
     /**
      * Reads the next byte of data from this input stream. The value
-     * byte is returned as an <code>int</code> in the range
-     * <code>0</code> to <code>255</code>. If no byte is available
+     * byte is returned as an {@code int} in the range
+     * {@code 0} to {@code 255}. If no byte is available
      * because the end of the stream has been reached, the value
-     * <code>-1</code> is returned. This method blocks until input data
+     * {@code -1} is returned. This method blocks until input data
      * is available, the end of the stream is detected, or an exception
      * is thrown.
      * <p>
-     * The <code>read</code> method of
-     * <code>LineNumberInputStream</code> calls the <code>read</code>
+     * The {@code read} method of
+     * {@code LineNumberInputStream} calls the {@code read}
      * method of the underlying input stream. It checks for carriage
      * returns and newline characters in the input, and modifies the
      * current line number as appropriate. A carriage-return character or
      * a carriage return followed by a newline character are both
      * converted into a single newline character.
      *
-     * @return     the next byte of data, or <code>-1</code> if the end of this
+     * @return     the next byte of data, or {@code -1} if the end of this
      *             stream is reached.
      * @exception  IOException  if an I/O error occurs.
      * @see        java.io.FilterInputStream#in
@@ -111,18 +111,18 @@ class LineNumberInputStream extends FilterInputStream {
     }
 
     /**
-     * Reads up to <code>len</code> bytes of data from this input stream
+     * Reads up to {@code len} bytes of data from this input stream
      * into an array of bytes. This method blocks until some input is available.
      * <p>
-     * The <code>read</code> method of
-     * <code>LineNumberInputStream</code> repeatedly calls the
-     * <code>read</code> method of zero arguments to fill in the byte array.
+     * The {@code read} method of
+     * {@code LineNumberInputStream} repeatedly calls the
+     * {@code read} method of zero arguments to fill in the byte array.
      *
      * @param      b     the buffer into which the data is read.
      * @param      off   the start offset of the data.
      * @param      len   the maximum number of bytes read.
      * @return     the total number of bytes read into the buffer, or
-     *             <code>-1</code> if there is no more data because the end of
+     *             {@code -1} if there is no more data because the end of
      *             this stream has been reached.
      * @exception  IOException  if an I/O error occurs.
      * @see        java.io.LineNumberInputStream#read()
@@ -160,15 +160,15 @@ class LineNumberInputStream extends FilterInputStream {
     }
 
     /**
-     * Skips over and discards <code>n</code> bytes of data from this
-     * input stream. The <code>skip</code> method may, for a variety of
+     * Skips over and discards {@code n} bytes of data from this
+     * input stream. The {@code skip} method may, for a variety of
      * reasons, end up skipping over some smaller number of bytes,
-     * possibly <code>0</code>. The actual number of bytes skipped is
-     * returned.  If <code>n</code> is negative, no bytes are skipped.
+     * possibly {@code 0}. The actual number of bytes skipped is
+     * returned.  If {@code n} is negative, no bytes are skipped.
      * <p>
-     * The <code>skip</code> method of <code>LineNumberInputStream</code> creates
+     * The {@code skip} method of {@code LineNumberInputStream} creates
      * a byte array and then repeatedly reads into it until
-     * <code>n</code> bytes have been read or the end of the stream has
+     * {@code n} bytes have been read or the end of the stream has
      * been reached.
      *
      * @param      n   the number of bytes to be skipped.
@@ -225,12 +225,12 @@ class LineNumberInputStream extends FilterInputStream {
      * <p>
      * Note that if the underlying input stream is able to supply
      * <i>k</i> input characters without blocking, the
-     * <code>LineNumberInputStream</code> can guarantee only to provide
+     * {@code LineNumberInputStream} can guarantee only to provide
      * <i>k</i>/2 characters without blocking, because the
      * <i>k</i> characters from the underlying input stream might
-     * consist of <i>k</i>/2 pairs of <code>'&#92;r'</code> and
-     * <code>'&#92;n'</code>, which are converted to just
-     * <i>k</i>/2 <code>'&#92;n'</code> characters.
+     * consist of <i>k</i>/2 pairs of {@code '\u005Cr'} and
+     * {@code '\u005Cn'}, which are converted to just
+     * <i>k</i>/2 {@code '\u005Cn'} characters.
      *
      * @return     the number of bytes that can be read from this input stream
      *             without blocking.
@@ -243,12 +243,12 @@ class LineNumberInputStream extends FilterInputStream {
 
     /**
      * Marks the current position in this input stream. A subsequent
-     * call to the <code>reset</code> method repositions this stream at
+     * call to the {@code reset} method repositions this stream at
      * the last marked position so that subsequent reads re-read the same bytes.
      * <p>
-     * The <code>mark</code> method of
-     * <code>LineNumberInputStream</code> remembers the current line
-     * number in a private variable, and then calls the <code>mark</code>
+     * The {@code mark} method of
+     * {@code LineNumberInputStream} remembers the current line
+     * number in a private variable, and then calls the {@code mark}
      * method of the underlying input stream.
      *
      * @param   readlimit   the maximum limit of bytes that can be read before
@@ -264,12 +264,12 @@ class LineNumberInputStream extends FilterInputStream {
 
     /**
      * Repositions this stream to the position at the time the
-     * <code>mark</code> method was last called on this input stream.
+     * {@code mark} method was last called on this input stream.
      * <p>
-     * The <code>reset</code> method of
-     * <code>LineNumberInputStream</code> resets the line number to be
-     * the line number at the time the <code>mark</code> method was
-     * called, and then calls the <code>reset</code> method of the
+     * The {@code reset} method of
+     * {@code LineNumberInputStream} resets the line number to be
+     * the line number at the time the {@code mark} method was
+     * called, and then calls the {@code reset} method of the
      * underlying input stream.
      * <p>
      * Stream marks are intended to be used in

src/share/classes/java/io/StreamTokenizer.java

 /*
- * Copyright (c) 1995, 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1995, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -28,7 +28,7 @@ package java.io;
 import java.util.Arrays;
 
 /**
- * The <code>StreamTokenizer</code> class takes an input stream and
+ * The {@code StreamTokenizer} class takes an input stream and
  * parses it into "tokens", allowing the tokens to be
  * read one at a time. The parsing process is controlled by a table
  * and a number of flags that can be set to various states. The
@@ -36,7 +36,7 @@ import java.util.Arrays;
  * strings, and various comment styles.
  * <p>
  * Each byte read from the input stream is regarded as a character
- * in the range <code>'&#92;u0000'</code> through <code>'&#92;u00FF'</code>.
+ * in the range {@code '\u005Cu0000'} through {@code '\u005Cu00FF'}.
  * The character value is used to look up five possible attributes of
  * the character: <i>white space</i>, <i>alphabetic</i>,
  * <i>numeric</i>, <i>string quote</i>, and <i>comment character</i>.
@@ -53,8 +53,8 @@ import java.util.Arrays;
  * <p>
  * A typical application first constructs an instance of this class,
  * sets up the syntax tables, and then repeatedly loops calling the
- * <code>nextToken</code> method in each iteration of the loop until
- * it returns the value <code>TT_EOF</code>.
+ * {@code nextToken} method in each iteration of the loop until
+ * it returns the value {@code TT_EOF}.
  *
  * @author  James Gosling
  * @see     java.io.StreamTokenizer#nextToken()
@@ -99,19 +99,19 @@ public class StreamTokenizer {
     private static final byte CT_COMMENT = 16;
 
     /**
-     * After a call to the <code>nextToken</code> method, this field
+     * After a call to the {@code nextToken} method, this field
      * contains the type of the token just read. For a single character
      * token, its value is the single character, converted to an integer.
      * For a quoted string token, its value is the quote character.
      * Otherwise, its value is one of the following:
      * <ul>
-     * <li><code>TT_WORD</code> indicates that the token is a word.
-     * <li><code>TT_NUMBER</code> indicates that the token is a number.
-     * <li><code>TT_EOL</code> indicates that the end of line has been read.
+     * <li>{@code TT_WORD} indicates that the token is a word.
+     * <li>{@code TT_NUMBER} indicates that the token is a number.
+     * <li>{@code TT_EOL} indicates that the end of line has been read.
      *     The field can only have this value if the
-     *     <code>eolIsSignificant</code> method has been called with the
-     *     argument <code>true</code>.
-     * <li><code>TT_EOF</code> indicates that the end of the input stream
+     *     {@code eolIsSignificant} method has been called with the
+     *     argument {@code true}.
+     * <li>{@code TT_EOF} indicates that the end of the input stream
      *     has been reached.
      * </ul>
      * <p>
@@ -160,8 +160,8 @@ public class StreamTokenizer {
      * the string.
      * <p>
      * The current token is a word when the value of the
-     * <code>ttype</code> field is <code>TT_WORD</code>. The current token is
-     * a quoted string token when the value of the <code>ttype</code> field is
+     * {@code ttype} field is {@code TT_WORD}. The current token is
+     * a quoted string token when the value of the {@code ttype} field is
      * a quote character.
      * <p>
      * The initial value of this field is null.
@@ -175,7 +175,7 @@ public class StreamTokenizer {
     /**
      * If the current token is a number, this field contains the value
      * of that number. The current token is a number when the value of
-     * the <code>ttype</code> field is <code>TT_NUMBER</code>.
+     * the {@code ttype} field is {@code TT_NUMBER}.
      * <p>
      * The initial value of this field is 0.0.
      *
@@ -201,14 +201,14 @@ public class StreamTokenizer {
      * stream. The stream tokenizer is initialized to the following
      * default state:
      * <ul>
-     * <li>All byte values <code>'A'</code> through <code>'Z'</code>,
-     *     <code>'a'</code> through <code>'z'</code>, and
-     *     <code>'&#92;u00A0'</code> through <code>'&#92;u00FF'</code> are
+     * <li>All byte values {@code 'A'} through {@code 'Z'},
+     *     {@code 'a'} through {@code 'z'}, and
+     *     {@code '\u005Cu00A0'} through {@code '\u005Cu00FF'} are
      *     considered to be alphabetic.
-     * <li>All byte values <code>'&#92;u0000'</code> through
-     *     <code>'&#92;u0020'</code> are considered to be white space.
-     * <li><code>'/'</code> is a comment character.
-     * <li>Single quote <code>'&#92;''</code> and double quote <code>'"'</code>
+     * <li>All byte values {@code '\u005Cu0000'} through
+     *     {@code '\u005Cu0020'} are considered to be white space.
+     * <li>{@code '/'} is a comment character.
+     * <li>Single quote {@code '\u005C''} and double quote {@code '"'}
      *     are string quote characters.
      * <li>Numbers are parsed.
      * <li>Ends of lines are treated as white space, not as separate tokens.
@@ -252,7 +252,7 @@ public class StreamTokenizer {
 
     /**
      * Resets this tokenizer's syntax table so that all characters are
-     * "ordinary." See the <code>ordinaryChar</code> method
+     * "ordinary." See the {@code ordinaryChar} method
      * for more information on a character being ordinary.
      *
      * @see     java.io.StreamTokenizer#ordinaryChar(int)
@@ -305,7 +305,7 @@ public class StreamTokenizer {
      * Specifies that all characters <i>c</i> in the range
      * <code>low&nbsp;&lt;=&nbsp;<i>c</i>&nbsp;&lt;=&nbsp;high</code>
      * are "ordinary" in this tokenizer. See the
-     * <code>ordinaryChar</code> method for more information on a
+     * {@code ordinaryChar} method for more information on a
      * character being ordinary.
      *
      * @param   low   the low end of the range.
@@ -327,12 +327,12 @@ public class StreamTokenizer {
      * character has as a comment character, word component, string
      * delimiter, white space, or number character. When such a character
      * is encountered by the parser, the parser treats it as a
-     * single-character token and sets <code>ttype</code> field to the
+     * single-character token and sets {@code ttype} field to the
      * character value.
      *
      * <p>Making a line terminator character "ordinary" may interfere
-     * with the ability of a <code>StreamTokenizer</code> to count
-     * lines. The <code>lineno</code> method may no longer reflect
+     * with the ability of a {@code StreamTokenizer} to count
+     * lines. The {@code lineno} method may no longer reflect
      * the presence of such terminator characters in its line count.
      *
      * @param   ch   the character.
@@ -361,9 +361,9 @@ public class StreamTokenizer {
      * Specifies that matching pairs of this character delimit string
      * constants in this tokenizer.
      * <p>
-     * When the <code>nextToken</code> method encounters a string
-     * constant, the <code>ttype</code> field is set to the string
-     * delimiter and the <code>sval</code> field is set to the body of
+     * When the {@code nextToken} method encounters a string
+     * constant, the {@code ttype} field is set to the string
+     * delimiter and the {@code sval} field is set to the body of
      * the string.
      * <p>
      * If a string quote character is encountered, then a string is
@@ -371,7 +371,7 @@ public class StreamTokenizer {
      * the string quote character, up to (but not including) the next
      * occurrence of that same string quote character, or a line
      * terminator, or end of file. The usual escape sequences such as
-     * <code>"&#92;n"</code> and <code>"&#92;t"</code> are recognized and
+     * {@code "\u005Cn"} and {@code "\u005Ct"} are recognized and
      * converted to single characters as the string is parsed.
      *
      * <p>Any other attribute settings for the specified character are cleared.
@@ -398,9 +398,9 @@ public class StreamTokenizer {
      * <p>
      * When the parser encounters a word token that has the format of a
      * double precision floating-point number, it treats the token as a
-     * number rather than a word, by setting the <code>ttype</code>
-     * field to the value <code>TT_NUMBER</code> and putting the numeric
-     * value of the token into the <code>nval</code> field.
+     * number rather than a word, by setting the {@code ttype}
+     * field to the value {@code TT_NUMBER} and putting the numeric
+     * value of the token into the {@code nval} field.
      *
      * @see     java.io.StreamTokenizer#nval
      * @see     java.io.StreamTokenizer#TT_NUMBER
@@ -416,21 +416,21 @@ public class StreamTokenizer {
     /**
      * Determines whether or not ends of line are treated as tokens.
      * If the flag argument is true, this tokenizer treats end of lines
-     * as tokens; the <code>nextToken</code> method returns
-     * <code>TT_EOL</code> and also sets the <code>ttype</code> field to
+     * as tokens; the {@code nextToken} method returns
+     * {@code TT_EOL} and also sets the {@code ttype} field to
      * this value when an end of line is read.
      * <p>
      * A line is a sequence of characters ending with either a
-     * carriage-return character (<code>'&#92;r'</code>) or a newline
-     * character (<code>'&#92;n'</code>). In addition, a carriage-return
+     * carriage-return character ({@code '\u005Cr'}) or a newline
+     * character ({@code '\u005Cn'}). In addition, a carriage-return
      * character followed immediately by a newline character is treated
      * as a single end-of-line token.
      * <p>
-     * If the <code>flag</code> is false, end-of-line characters are
+     * If the {@code flag} is false, end-of-line characters are
      * treated as white space and serve only to separate tokens.
      *
-     * @param   flag   <code>true</code> indicates that end-of-line characters
-     *                 are separate tokens; <code>false</code> indicates that
+     * @param   flag   {@code true} indicates that end-of-line characters
+     *                 are separate tokens; {@code false} indicates that
      *                 end-of-line characters are white space.
      * @see     java.io.StreamTokenizer#nextToken()
      * @see     java.io.StreamTokenizer#ttype
@@ -442,14 +442,14 @@ public class StreamTokenizer {
 
     /**
      * Determines whether or not the tokenizer recognizes C-style comments.
-     * If the flag argument is <code>true</code>, this stream tokenizer
+     * If the flag argument is {@code true}, this stream tokenizer
      * recognizes C-style comments. All text between successive
-     * occurrences of <code>/*</code> and <code>*&#47;</code> are discarded.
+     * occurrences of {@code /*} and <code>*&#47;</code> are discarded.
      * <p>
-     * If the flag argument is <code>false</code>, then C-style comments
+     * If the flag argument is {@code false}, then C-style comments
      * are not treated specially.
      *
-     * @param   flag   <code>true</code> indicates to recognize and ignore
+     * @param   flag   {@code true} indicates to recognize and ignore
      *                 C-style comments.
      */
     public void slashStarComments(boolean flag) {
@@ -458,15 +458,15 @@ public class StreamTokenizer {
 
     /**
      * Determines whether or not the tokenizer recognizes C++-style comments.
-     * If the flag argument is <code>true</code>, this stream tokenizer
+     * If the flag argument is {@code true}, this stream tokenizer
      * recognizes C++-style comments. Any occurrence of two consecutive
-     * slash characters (<code>'/'</code>) is treated as the beginning of
+     * slash characters ({@code '/'}) is treated as the beginning of
      * a comment that extends to the end of the line.
      * <p>
-     * If the flag argument is <code>false</code>, then C++-style
+     * If the flag argument is {@code false}, then C++-style
      * comments are not treated specially.
      *
-     * @param   flag   <code>true</code> indicates to recognize and ignore
+     * @param   flag   {@code true} indicates to recognize and ignore
      *                 C++-style comments.
      */
     public void slashSlashComments(boolean flag) {
@@ -475,16 +475,16 @@ public class StreamTokenizer {
 
     /**
      * Determines whether or not word token are automatically lowercased.
-     * If the flag argument is <code>true</code>, then the value in the
-     * <code>sval</code> field is lowercased whenever a word token is
-     * returned (the <code>ttype</code> field has the
-     * value <code>TT_WORD</code> by the <code>nextToken</code> method
+     * If the flag argument is {@code true}, then the value in the
+     * {@code sval} field is lowercased whenever a word token is
+     * returned (the {@code ttype} field has the
+     * value {@code TT_WORD} by the {@code nextToken} method
      * of this tokenizer.
      * <p>
-     * If the flag argument is <code>false</code>, then the
-     * <code>sval</code> field is not modified.
+     * If the flag argument is {@code false}, then the
+     * {@code sval} field is not modified.
      *
-     * @param   fl   <code>true</code> indicates that all word tokens should
+     * @param   fl   {@code true} indicates that all word tokens should
      *               be lowercased.
      * @see     java.io.StreamTokenizer#nextToken()
      * @see     java.io.StreamTokenizer#ttype
@@ -506,9 +506,9 @@ public class StreamTokenizer {
 
     /**
      * Parses the next token from the input stream of this tokenizer.
-     * The type of the next token is returned in the <code>ttype</code>
+     * The type of the next token is returned in the {@code ttype}
      * field. Additional information about the token may be in the
-     * <code>nval</code> field or the <code>sval</code> field of this
+     * {@code nval} field or the {@code sval} field of this
      * tokenizer.
      * <p>
      * Typical clients of this
@@ -516,7 +516,7 @@ public class StreamTokenizer {
      * calling nextToken to parse successive tokens until TT_EOF
      * is returned.
      *
-     * @return     the value of the <code>ttype</code> field.
+     * @return     the value of the {@code ttype} field.
      * @exception  IOException  if an I/O error occurs.
      * @see        java.io.StreamTokenizer#nval
      * @see        java.io.StreamTokenizer#sval
@@ -752,10 +752,10 @@ public class StreamTokenizer {
     }
 
     /**
-     * Causes the next call to the <code>nextToken</code> method of this
-     * tokenizer to return the current value in the <code>ttype</code>
-     * field, and not to modify the value in the <code>nval</code> or
-     * <code>sval</code> field.
+     * Causes the next call to the {@code nextToken} method of this
+     * tokenizer to return the current value in the {@code ttype}
+     * field, and not to modify the value in the {@code nval} or
+     * {@code sval} field.
      *
      * @see     java.io.StreamTokenizer#nextToken()
      * @see     java.io.StreamTokenizer#nval

src/share/classes/java/lang/Byte.java

@@ -110,8 +110,8 @@ public final class Byte extends Number implements Comparable<Byte> {
      * determined by whether {@link java.lang.Character#digit(char,
      * int)} returns a nonnegative value) except that the first
      * character may be an ASCII minus sign {@code '-'}
-     * (<code>'&#92;u002D'</code>) to indicate a negative value or an
-     * ASCII plus sign {@code '+'} (<code>'&#92;u002B'</code>) to
+     * ({@code '\u005Cu002D'}) to indicate a negative value or an
+     * ASCII plus sign {@code '+'} ({@code '\u005Cu002B'}) to
      * indicate a positive value.  The resulting {@code byte} value is
      * returned.
      *
@@ -127,8 +127,8 @@ public final class Byte extends Number implements Comparable<Byte> {
      *
      * <li> Any character of the string is not a digit of the
      * specified radix, except that the first character may be a minus
-     * sign {@code '-'} (<code>'&#92;u002D'</code>) or plus sign
-     * {@code '+'} (<code>'&#92;u002B'</code>) provided that the
+     * sign {@code '-'} ({@code '\u005Cu002D'}) or plus sign
+     * {@code '+'} ({@code '\u005Cu002B'}) provided that the
      * string is longer than length 1.
      *
      * <li> The value represented by the string is not a value of type
@@ -157,9 +157,9 @@ public final class Byte extends Number implements Comparable<Byte> {
      * Parses the string argument as a signed decimal {@code
      * byte}. The characters in the string must all be decimal digits,
      * except that the first character may be an ASCII minus sign
-     * {@code '-'} (<code>'&#92;u002D'</code>) to indicate a negative
+     * {@code '-'} ({@code '\u005Cu002D'}) to indicate a negative
      * value or an ASCII plus sign {@code '+'}
-     * (<code>'&#92;u002B'</code>) to indicate a positive value. The
+     * ({@code '\u005Cu002B'}) to indicate a positive value. The
      * resulting {@code byte} value is returned, exactly as if the
      * argument and the radix 10 were given as arguments to the {@link
      * #parseByte(java.lang.String, int)} method.

src/share/classes/java/lang/Double.java

 /*
- * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -140,7 +140,7 @@ public final class Double extends Number implements Comparable<Double> {
      * <li>Otherwise, the result is a string that represents the sign and
      * magnitude (absolute value) of the argument. If the sign is negative,
      * the first character of the result is '{@code -}'
-     * (<code>'&#92;u002D'</code>); if the sign is positive, no sign character
+     * ({@code '\u005Cu002D'}); if the sign is positive, no sign character
      * appears in the result. As for the magnitude <i>m</i>:
      * <ul>
      * <li>If <i>m</i> is infinity, it is represented by the characters
@@ -156,7 +156,7 @@ public final class Double extends Number implements Comparable<Double> {
      * <li>If <i>m</i> is greater than or equal to 10<sup>-3</sup> but less
      * than 10<sup>7</sup>, then it is represented as the integer part of
      * <i>m</i>, in decimal form with no leading zeroes, followed by
-     * '{@code .}' (<code>'&#92;u002E'</code>), followed by one or
+     * '{@code .}' ({@code '\u005Cu002E'}), followed by one or
      * more decimal digits representing the fractional part of <i>m</i>.
      *
      * <li>If <i>m</i> is less than 10<sup>-3</sup> or greater than or
@@ -168,9 +168,9 @@ public final class Double extends Number implements Comparable<Double> {
      * 10<sup><i>n</i></sup> so that 1 &le; <i>a</i> {@literal <} 10. The
      * magnitude is then represented as the integer part of <i>a</i>,
      * as a single decimal digit, followed by '{@code .}'
-     * (<code>'&#92;u002E'</code>), followed by decimal digits
+     * ({@code '\u005Cu002E'}), followed by decimal digits
      * representing the fractional part of <i>a</i>, followed by the
-     * letter '{@code E}' (<code>'&#92;u0045'</code>), followed
+     * letter '{@code E}' ({@code '\u005Cu0045'}), followed
      * by a representation of <i>n</i> as a decimal integer, as
      * produced by the method {@link Integer#toString(int)}.
      * </ul>
@@ -208,7 +208,7 @@ public final class Double extends Number implements Comparable<Double> {
      * <li>Otherwise, the result is a string that represents the sign
      * and magnitude of the argument. If the sign is negative, the
      * first character of the result is '{@code -}'
-     * (<code>'&#92;u002D'</code>); if the sign is positive, no sign
+     * ({@code '\u005Cu002D'}); if the sign is positive, no sign
      * character appears in the result. As for the magnitude <i>m</i>:
      *
      * <ul>

src/share/classes/java/lang/Float.java

 /*
- * Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -138,7 +138,7 @@ public final class Float extends Number implements Comparable<Float> {
      * <li>Otherwise, the result is a string that represents the sign and
      *     magnitude (absolute value) of the argument. If the sign is
      *     negative, the first character of the result is
-     *     '{@code -}' (<code>'&#92;u002D'</code>); if the sign is
+     *     '{@code -}' ({@code '\u005Cu002D'}); if the sign is
      *     positive, no sign character appears in the result. As for
      *     the magnitude <i>m</i>:
      * <ul>
@@ -154,7 +154,7 @@ public final class Float extends Number implements Comparable<Float> {
      *      less than 10<sup>7</sup>, then it is represented as the
      *      integer part of <i>m</i>, in decimal form with no leading
      *      zeroes, followed by '{@code .}'
-     *      (<code>'&#92;u002E'</code>), followed by one or more
+     *      ({@code '\u005Cu002E'}), followed by one or more
      *      decimal digits representing the fractional part of
      *      <i>m</i>.
      * <li> If <i>m</i> is less than 10<sup>-3</sup> or greater than or
@@ -166,10 +166,10 @@ public final class Float extends Number implements Comparable<Float> {
      *      10<sup><i>n</i></sup> so that 1 &le; <i>a</i> {@literal <} 10.
      *      The magnitude is then represented as the integer part of
      *      <i>a</i>, as a single decimal digit, followed by
-     *      '{@code .}' (<code>'&#92;u002E'</code>), followed by
+     *      '{@code .}' ({@code '\u005Cu002E'}), followed by
      *      decimal digits representing the fractional part of
      *      <i>a</i>, followed by the letter '{@code E}'
-     *      (<code>'&#92;u0045'</code>), followed by a representation
+     *      ({@code '\u005Cu0045'}), followed by a representation
      *      of <i>n</i> as a decimal integer, as produced by the
      *      method {@link java.lang.Integer#toString(int)}.
      *
@@ -210,7 +210,7 @@ public final class Float extends Number implements Comparable<Float> {
      * <li>Otherwise, the result is a string that represents the sign and
      * magnitude (absolute value) of the argument. If the sign is negative,
      * the first character of the result is '{@code -}'
-     * (<code>'&#92;u002D'</code>); if the sign is positive, no sign character
+     * ({@code '\u005Cu002D'}); if the sign is positive, no sign character
      * appears in the result. As for the magnitude <i>m</i>:
      *
      * <ul>

src/share/classes/java/lang/Integer.java

@@ -93,13 +93,13 @@ public final class Integer extends Number implements Comparable<Integer> {
      *
      * <p>If the first argument is negative, the first element of the
      * result is the ASCII minus character {@code '-'}
-     * (<code>'&#92;u002D'</code>). If the first argument is not
+     * ({@code '\u005Cu002D'}). If the first argument is not
      * negative, no sign character appears in the result.
      *
      * <p>The remaining characters of the result represent the magnitude
      * of the first argument. If the magnitude is zero, it is
      * represented by a single zero character {@code '0'}
-     * (<code>'&#92;u0030'</code>); otherwise, the first character of
+     * ({@code '\u005Cu0030'}); otherwise, the first character of
      * the representation of the magnitude will not be the zero
      * character.  The following ASCII characters are used as digits:
      *
@@ -107,9 +107,9 @@ public final class Integer extends Number implements Comparable<Integer> {
      *   {@code 0123456789abcdefghijklmnopqrstuvwxyz}
      * </blockquote>
      *
-     * These are <code>'&#92;u0030'</code> through
-     * <code>'&#92;u0039'</code> and <code>'&#92;u0061'</code> through
-     * <code>'&#92;u007A'</code>. If {@code radix} is
+     * These are {@code '\u005Cu0030'} through
+     * {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through
+     * {@code '\u005Cu007A'}. If {@code radix} is
      * <var>N</var>, then the first <var>N</var> of these characters
      * are used as radix-<var>N</var> digits in the order shown. Thus,
      * the digits for hexadecimal (radix 16) are
@@ -170,7 +170,7 @@ public final class Integer extends Number implements Comparable<Integer> {
      * value, no leading sign character is printed.
      *
      * <p>If the magnitude is zero, it is represented by a single zero
-     * character {@code '0'} (<code>'&#92;u0030'</code>); otherwise,
+     * character {@code '0'} ({@code '\u005Cu0030'}); otherwise,
      * the first character of the representation of the magnitude will
      * not be the zero character.
      *
@@ -203,7 +203,7 @@ public final class Integer extends Number implements Comparable<Integer> {
      * Integer.parseUnsignedInt(s, 16)}.
      *
      * <p>If the unsigned magnitude is zero, it is represented by a
-     * single zero character {@code '0'} (<code>'&#92;u0030'</code>);
+     * single zero character {@code '0'} ({@code '\u005Cu0030'});
      * otherwise, the first character of the representation of the
      * unsigned magnitude will not be the zero character. The
      * following characters are used as hexadecimal digits:
@@ -212,9 +212,9 @@ public final class Integer extends Number implements Comparable<Integer> {
      *  {@code 0123456789abcdef}
      * </blockquote>
      *
-     * These are the characters <code>'&#92;u0030'</code> through
-     * <code>'&#92;u0039'</code> and <code>'&#92;u0061'</code> through
-     * <code>'&#92;u0066'</code>. If uppercase letters are
+     * These are the characters {@code '\u005Cu0030'} through
+     * {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through
+     * {@code '\u005Cu0066'}. If uppercase letters are
      * desired, the {@link java.lang.String#toUpperCase()} method may
      * be called on the result:
      *
@@ -248,7 +248,7 @@ public final class Integer extends Number implements Comparable<Integer> {
      * Integer.parseUnsignedInt(s, 8)}.
      *
      * <p>If the unsigned magnitude is zero, it is represented by a
-     * single zero character {@code '0'} (<code>'&#92;u0030'</code>);
+     * single zero character {@code '0'} ({@code '\u005Cu0030'});
      * otherwise, the first character of the representation of the
      * unsigned magnitude will not be the zero character. The
      * following characters are used as octal digits:
@@ -257,8 +257,8 @@ public final class Integer extends Number implements Comparable<Integer> {
      * {@code 01234567}
      * </blockquote>
      *
-     * These are the characters <code>'&#92;u0030'</code> through
-     * <code>'&#92;u0037'</code>.
+     * These are the characters {@code '\u005Cu0030'} through
+     * {@code '\u005Cu0037'}.
      *
      * @param   i   an integer to be converted to a string.
      * @return  the string representation of the unsigned integer value
@@ -286,11 +286,11 @@ public final class Integer extends Number implements Comparable<Integer> {
      * Integer.parseUnsignedInt(s, 2)}.
      *
      * <p>If the unsigned magnitude is zero, it is represented by a
-     * single zero character {@code '0'} (<code>'&#92;u0030'</code>);
+     * single zero character {@code '0'} ({@code '\u005Cu0030'});
      * otherwise, the first character of the representation of the
      * unsigned magnitude will not be the zero character. The
-     * characters {@code '0'} (<code>'&#92;u0030'</code>) and {@code
-     * '1'} (<code>'&#92;u0031'</code>) are used as binary digits.
+     * characters {@code '0'} ({@code '\u005Cu0030'}) and {@code
+     * '1'} ({@code '\u005Cu0031'}) are used as binary digits.
      *
      * @param   i   an integer to be converted to a string.
      * @return  the string representation of the unsigned integer value
@@ -461,9 +461,9 @@ public final class Integer extends Number implements Comparable<Integer> {
      * must all be digits of the specified radix (as determined by
      * whether {@link java.lang.Character#digit(char, int)} returns a
      * nonnegative value), except that the first character may be an
-     * ASCII minus sign {@code '-'} (<code>'&#92;u002D'</code>) to
+     * ASCII minus sign {@code '-'} ({@code '\u005Cu002D'}) to
      * indicate a negative value or an ASCII plus sign {@code '+'}
-     * (<code>'&#92;u002B'</code>) to indicate a positive value. The
+     * ({@code '\u005Cu002B'}) to indicate a positive value. The
      * resulting integer value is returned.
      *
      * <p>An exception of type {@code NumberFormatException} is
@@ -478,8 +478,8 @@ public final class Integer extends Number implements Comparable<Integer> {
      *
      * <li>Any character of the string is not a digit of the specified
      * radix, except that the first character may be a minus sign
-     * {@code '-'} (<code>'&#92;u002D'</code>) or plus sign
-     * {@code '+'} (<code>'&#92;u002B'</code>) provided that the
+     * {@code '-'} ({@code '\u005Cu002D'}) or plus sign
+     * {@code '+'} ({@code '\u005Cu002B'}) provided that the
      * string is longer than length 1.
      *
      * <li>The value represented by the string is not a value of type
@@ -579,8 +579,8 @@ public final class Integer extends Number implements Comparable<Integer> {
      * Parses the string argument as a signed decimal integer. The
      * characters in the string must all be decimal digits, except
      * that the first character may be an ASCII minus sign {@code '-'}
-     * (<code>'&#92;u002D'</code>) to indicate a negative value or an
-     * ASCII plus sign {@code '+'} (<code>'&#92;u002B'</code>) to
+     * ({@code '\u005Cu002D'}) to indicate a negative value or an
+     * ASCII plus sign {@code '+'} ({@code '\u005Cu002B'}) to
      * indicate a positive value. The resulting integer value is
      * returned, exactly as if the argument and the radix 10 were
      * given as arguments to the {@link #parseInt(java.lang.String,
@@ -606,7 +606,7 @@ public final class Integer extends Number implements Comparable<Integer> {
      * specified radix (as determined by whether {@link
      * java.lang.Character#digit(char, int)} returns a nonnegative
      * value), except that the first character may be an ASCII plus
-     * sign {@code '+'} (<code>'&#92;u002B'</code>). The resulting
+     * sign {@code '+'} ({@code '\u005Cu002B'}). The resulting
      * integer value is returned.
      *
      * <p>An exception of type {@code NumberFormatException} is
@@ -621,7 +621,7 @@ public final class Integer extends Number implements Comparable<Integer> {
      *
      * <li>Any character of the string is not a digit of the specified
      * radix, except that the first character may be a plus sign
-     * {@code '+'} (<code>'&#92;u002B'</code>) provided that the
+     * {@code '+'} ({@code '\u005Cu002B'}) provided that the
      * string is longer than length 1.
      *
      * <li>The value represented by the string is larger than the
@@ -676,7 +676,7 @@ public final class Integer extends Number implements Comparable<Integer> {
      * Parses the string argument as an unsigned decimal integer. The
      * characters in the string must all be decimal digits, except
      * that the first character may be an an ASCII plus sign {@code
-     * '+'} (<code>'&#92;u002B'</code>). The resulting integer value
+     * '+'} ({@code '\u005Cu002B'}). The resulting integer value
      * is returned, exactly as if the argument and the radix 10 were
      * given as arguments to the {@link
      * #parseUnsignedInt(java.lang.String, int)} method.

src/share/classes/java/lang/Long.java

@@ -81,13 +81,13 @@ public final class Long extends Number implements Comparable<Long> {
      *
      * <p>If the first argument is negative, the first element of the
      * result is the ASCII minus sign {@code '-'}
-     * (<code>'&#92;u002d'</code>). If the first argument is not
+     * ({@code '\u005Cu002d'}). If the first argument is not
      * negative, no sign character appears in the result.
      *
      * <p>The remaining characters of the result represent the magnitude
      * of the first argument. If the magnitude is zero, it is
      * represented by a single zero character {@code '0'}
-     * (<code>'&#92;u0030'</code>); otherwise, the first character of
+     * ({@code '\u005Cu0030'}); otherwise, the first character of
      * the representation of the magnitude will not be the zero
      * character.  The following ASCII characters are used as digits:
      *
@@ -95,9 +95,9 @@ public final class Long extends Number implements Comparable<Long> {
      *   {@code 0123456789abcdefghijklmnopqrstuvwxyz}
      * </blockquote>
      *
-     * These are <code>'&#92;u0030'</code> through
-     * <code>'&#92;u0039'</code> and <code>'&#92;u0061'</code> through
-     * <code>'&#92;u007a'</code>. If {@code radix} is
+     * These are {@code '\u005Cu0030'} through
+     * {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through
+     * {@code '\u005Cu007a'}. If {@code radix} is
      * <var>N</var>, then the first <var>N</var> of these characters
      * are used as radix-<var>N</var> digits in the order shown. Thus,
      * the digits for hexadecimal (radix 16) are
@@ -154,7 +154,7 @@ public final class Long extends Number implements Comparable<Long> {
      * value, no leading sign character is printed.
      *
      * <p>If the magnitude is zero, it is represented by a single zero
-     * character {@code '0'} (<code>'&#92;u0030'</code>); otherwise,
+     * character {@code '0'} ({@code '\u005Cu0030'}); otherwise,
      * the first character of the representation of the magnitude will
      * not be the zero character.
      *
@@ -239,7 +239,7 @@ public final class Long extends Number implements Comparable<Long> {
      * 16)}.
      *
      * <p>If the unsigned magnitude is zero, it is represented by a
-     * single zero character {@code '0'} (<code>'&#92;u0030'</code>);
+     * single zero character {@code '0'} ({@code '\u005Cu0030'});
      * otherwise, the first character of the representation of the
      * unsigned magnitude will not be the zero character. The
      * following characters are used as hexadecimal digits:
@@ -248,9 +248,9 @@ public final class Long extends Number implements Comparable<Long> {
      *  {@code 0123456789abcdef}
      * </blockquote>
      *
-     * These are the characters <code>'&#92;u0030'</code> through
-     * <code>'&#92;u0039'</code> and  <code>'&#92;u0061'</code> through
-     * <code>'&#92;u0066'</code>.  If uppercase letters are desired,
+     * These are the characters {@code '\u005Cu0030'} through
+     * {@code '\u005Cu0039'} and  {@code '\u005Cu0061'} through
+     * {@code '\u005Cu0066'}.  If uppercase letters are desired,
      * the {@link java.lang.String#toUpperCase()} method may be called
      * on the result:
      *
@@ -286,7 +286,7 @@ public final class Long extends Number implements Comparable<Long> {
      * 8)}.
      *
      * <p>If the unsigned magnitude is zero, it is represented by a
-     * single zero character {@code '0'} (<code>'&#92;u0030'</code>);
+     * single zero character {@code '0'} ({@code '\u005Cu0030'});
      * otherwise, the first character of the representation of the
      * unsigned magnitude will not be the zero character. The
      * following characters are used as octal digits:
@@ -295,8 +295,8 @@ public final class Long extends Number implements Comparable<Long> {
      *  {@code 01234567}
      * </blockquote>
      *
-     * These are the characters <code>'&#92;u0030'</code> through
-     * <code>'&#92;u0037'</code>.
+     * These are the characters {@code '\u005Cu0030'} through
+     * {@code '\u005Cu0037'}.
      *
      * @param   i   a {@code long} to be converted to a string.
      * @return  the string representation of the unsigned {@code long}
@@ -325,11 +325,11 @@ public final class Long extends Number implements Comparable<Long> {
      * 2)}.
      *
      * <p>If the unsigned magnitude is zero, it is represented by a
-     * single zero character {@code '0'} (<code>'&#92;u0030'</code>);
+     * single zero character {@code '0'} ({@code '\u005Cu0030'});
      * otherwise, the first character of the representation of the
      * unsigned magnitude will not be the zero character. The
-     * characters {@code '0'} (<code>'&#92;u0030'</code>) and {@code
-     * '1'} (<code>'&#92;u0031'</code>) are used as binary digits.
+     * characters {@code '0'} ({@code '\u005Cu0030'}) and {@code
+     * '1'} ({@code '\u005Cu0031'}) are used as binary digits.
      *
      * @param   i   a {@code long} to be converted to a string.
      * @return  the string representation of the unsigned {@code long}
@@ -467,14 +467,14 @@ public final class Long extends Number implements Comparable<Long> {
      * string must all be digits of the specified radix (as determined
      * by whether {@link java.lang.Character#digit(char, int)} returns
      * a nonnegative value), except that the first character may be an
-     * ASCII minus sign {@code '-'} (<code>'&#92;u002D'</code>) to
+     * ASCII minus sign {@code '-'} ({@code '\u005Cu002D'}) to
      * indicate a negative value or an ASCII plus sign {@code '+'}
-     * (<code>'&#92;u002B'</code>) to indicate a positive value. The
+     * ({@code '\u005Cu002B'}) to indicate a positive value. The
      * resulting {@code long} value is returned.
      *
      * <p>Note that neither the character {@code L}
-     * (<code>'&#92;u004C'</code>) nor {@code l}
-     * (<code>'&#92;u006C'</code>) is permitted to appear at the end
+     * ({@code '\u005Cu004C'}) nor {@code l}
+     * ({@code '\u005Cu006C'}) is permitted to appear at the end
      * of the string as a type indicator, as would be permitted in
      * Java programming language source code - except that either
      * {@code L} or {@code l} may appear as a digit for a
@@ -493,8 +493,8 @@ public final class Long extends Number implements Comparable<Long> {
      *
      * <li>Any character of the string is not a digit of the specified
      * radix, except that the first character may be a minus sign
-     * {@code '-'} (<code>'&#92;u002d'</code>) or plus sign {@code
-     * '+'} (<code>'&#92;u002B'</code>) provided that the string is
+     * {@code '-'} ({@code '\u005Cu002d'}) or plus sign {@code
+     * '+'} ({@code '\u005Cu002B'}) provided that the string is
      * longer than length 1.
      *
      * <li>The value represented by the string is not a value of type
@@ -584,16 +584,16 @@ public final class Long extends Number implements Comparable<Long> {
      * Parses the string argument as a signed decimal {@code long}.
      * The characters in the string must all be decimal digits, except
      * that the first character may be an ASCII minus sign {@code '-'}
-     * (<code>&#92;u002D'</code>) to indicate a negative value or an
-     * ASCII plus sign {@code '+'} (<code>'&#92;u002B'</code>) to
+     * ({@code \u005Cu002D'}) to indicate a negative value or an
+     * ASCII plus sign {@code '+'} ({@code '\u005Cu002B'}) to
      * indicate a positive value. The resulting {@code long} value is
      * returned, exactly as if the argument and the radix {@code 10}
      * were given as arguments to the {@link
      * #parseLong(java.lang.String, int)} method.
      *
      * <p>Note that neither the character {@code L}
-     * (<code>'&#92;u004C'</code>) nor {@code l}
-     * (<code>'&#92;u006C'</code>) is permitted to appear at the end
+     * ({@code '\u005Cu004C'}) nor {@code l}
+     * ({@code '\u005Cu006C'}) is permitted to appear at the end
      * of the string as a type indicator, as would be permitted in
      * Java programming language source code.
      *
@@ -618,7 +618,7 @@ public final class Long extends Number implements Comparable<Long> {
      * specified radix (as determined by whether {@link
      * java.lang.Character#digit(char, int)} returns a nonnegative
      * value), except that the first character may be an ASCII plus
-     * sign {@code '+'} (<code>'&#92;u002B'</code>). The resulting
+     * sign {@code '+'} ({@code '\u005Cu002B'}). The resulting
      * integer value is returned.
      *
      * <p>An exception of type {@code NumberFormatException} is
@@ -633,7 +633,7 @@ public final class Long extends Number implements Comparable<Long> {
      *
      * <li>Any character of the string is not a digit of the specified
      * radix, except that the first character may be a plus sign
-     * {@code '+'} (<code>'&#92;u002B'</code>) provided that the
+     * {@code '+'} ({@code '\u005Cu002B'}) provided that the
      * string is longer than length 1.
      *
      * <li>The value represented by the string is larger than the
@@ -707,7 +707,7 @@ public final class Long extends Number implements Comparable<Long> {
      * Parses the string argument as an unsigned decimal {@code long}. The
      * characters in the string must all be decimal digits, except
      * that the first character may be an an ASCII plus sign {@code
-     * '+'} (<code>'&#92;u002B'</code>). The resulting integer value
+     * '+'} ({@code '\u005Cu002B'}). The resulting integer value
      * is returned, exactly as if the argument and the radix 10 were
      * given as arguments to the {@link
      * #parseUnsignedLong(java.lang.String, int)} method.
@@ -1148,8 +1148,8 @@ public final class Long extends Number implements Comparable<Long> {
      * </ul>
      *
      * <p>Note that, in every case, neither {@code L}
-     * (<code>'&#92;u004C'</code>) nor {@code l}
-     * (<code>'&#92;u006C'</code>) is permitted to appear at the end
+     * ({@code '\u005Cu004C'}) nor {@code l}
+     * ({@code '\u005Cu006C'}) is permitted to appear at the end
      * of the property value as a type indicator, as would be
      * permitted in Java programming language source code.
      *

src/share/classes/java/lang/Short.java

@@ -80,8 +80,8 @@ public final class Short extends Number implements Comparable<Short> {
      * determined by whether {@link java.lang.Character#digit(char,
      * int)} returns a nonnegative value) except that the first
      * character may be an ASCII minus sign {@code '-'}
-     * (<code>'&#92;u002D'</code>) to indicate a negative value or an
-     * ASCII plus sign {@code '+'} (<code>'&#92;u002B'</code>) to
+     * ({@code '\u005Cu002D'}) to indicate a negative value or an
+     * ASCII plus sign {@code '+'} ({@code '\u005Cu002B'}) to
      * indicate a positive value.  The resulting {@code short} value
      * is returned.
      *
@@ -97,8 +97,8 @@ public final class Short extends Number implements Comparable<Short> {
      *
      * <li> Any character of the string is not a digit of the
      * specified radix, except that the first character may be a minus
-     * sign {@code '-'} (<code>'&#92;u002D'</code>) or plus sign
-     * {@code '+'} (<code>'&#92;u002B'</code>) provided that the
+     * sign {@code '-'} ({@code '\u005Cu002D'}) or plus sign
+     * {@code '+'} ({@code '\u005Cu002B'}) provided that the
      * string is longer than length 1.
      *
      * <li> The value represented by the string is not a value of type
@@ -126,9 +126,9 @@ public final class Short extends Number implements Comparable<Short> {
      * Parses the string argument as a signed decimal {@code
      * short}. The characters in the string must all be decimal
      * digits, except that the first character may be an ASCII minus
-     * sign {@code '-'} (<code>'&#92;u002D'</code>) to indicate a
+     * sign {@code '-'} ({@code '\u005Cu002D'}) to indicate a
      * negative value or an ASCII plus sign {@code '+'}
-     * (<code>'&#92;u002B'</code>) to indicate a positive value.  The
+     * ({@code '\u005Cu002B'}) to indicate a positive value.  The
      * resulting {@code short} value is returned, exactly as if the
      * argument and the radix 10 were given as arguments to the {@link
      * #parseShort(java.lang.String, int)} method.