8199236: Nashorn uses deprecated HTML tags in Javadoc

Reviewed-by: jlaskey, sundar

src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Label.java

@@ -101,7 +101,7 @@ public final class Label implements Serializable {
         }
 
         /**
-         * Retrieve the top <tt>count</tt> types on the stack without modifying it.
+         * Retrieve the top <code>count</code> types on the stack without modifying it.
          *
          * @param count number of types to return
          * @return array of Types

src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/MethodEmitter.java

@@ -2057,7 +2057,7 @@ public class MethodEmitter {
     }
 
     /**
-     * Retrieve the top <tt>count</tt> types on the stack without modifying it.
+     * Retrieve the top <code>count</code> types on the stack without modifying it.
      *
      * @param count number of types to return
      * @return array of Types

src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/ir/Block.java

@@ -257,7 +257,7 @@ public class Block extends Node implements BreakableNode, Terminal, Flags<Block>
     }
 
     /**
-     * Test if this block represents a <tt>catch</tt> block in a <tt>try</tt> statement.
+     * Test if this block represents a <code>catch</code> block in a <code>try</code> statement.
      * This is used by the Splitter as catch blocks are not be subject to splitting.
      *
      * @return true if this block represents a catch block in a try statement.

src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/parser/DateParser.java

@@ -41,7 +41,7 @@ import java.util.Locale;
  * of different formats.
  *
  * <p>This class is neither thread-safe nor reusable. Calling the
- * <tt>parse()</tt> method more than once will yield undefined results.</p>
+ * <code>parse()</code> method more than once will yield undefined results.</p>
  */
 public class DateParser {
 
@@ -118,7 +118,7 @@ public class DateParser {
     }
 
     /**
-     * Construct a new <tt>DateParser</tt> instance for parsing the given string.
+     * Construct a new <code>DateParser</code> instance for parsing the given string.
      * @param string the string to be parsed
      */
     public DateParser(final String string) {
@@ -130,7 +130,7 @@ public class DateParser {
     /**
      * Try parsing the given string as date according to the extended ISO 8601 format
      * specified in ES5 15.9.1.15. Fall back to legacy mode if that fails.
-     * This method returns <tt>true</tt> if the string could be parsed.
+     * This method returns <code>true</code> if the string could be parsed.
      * @return true if the string could be parsed as date
      */
     public boolean parse() {
@@ -143,8 +143,8 @@ public class DateParser {
      *
      * <pre>  [('-'|'+')yy]yyyy[-MM[-dd]][Thh:mm[:ss[.sss]][Z|(+|-)hh:mm]] </pre>
      *
-     * <p>If the string does not contain a time zone offset, the <tt>TIMEZONE</tt> field
-     * is set to <tt>0</tt> (GMT).</p>
+     * <p>If the string does not contain a time zone offset, the <code>TIMEZONE</code> field
+     * is set to <code>0</code> (GMT).</p>
      * @return true if string represents a valid ES5 date string.
      */
     public boolean parseEcmaDate() {
@@ -221,14 +221,14 @@ public class DateParser {
     /**
      * Try parsing the date using a fuzzy algorithm that can handle a variety of formats.
      *
-     * <p>Numbers separated by <tt>':'</tt> are treated as time values, optionally followed by a
-     * millisecond value separated by <tt>'.'</tt>. Other number values are treated as date values.
+     * <p>Numbers separated by <code>':'</code> are treated as time values, optionally followed by a
+     * millisecond value separated by <code>'.'</code>. Other number values are treated as date values.
      * The exact sequence of day, month, and year values to apply is determined heuristically.</p>
      *
      * <p>English month names and selected time zone names as well as AM/PM markers are recognized
-     * and handled properly. Additionally, numeric time zone offsets such as <tt>(+|-)hh:mm</tt> or
-     * <tt>(+|-)hhmm</tt> are recognized. If the string does not contain a time zone offset
-     * the <tt>TIMEZONE</tt>field is left undefined, meaning the local time zone should be applied.</p>
+     * and handled properly. Additionally, numeric time zone offsets such as <code>(+|-)hh:mm</code> or
+     * <code>(+|-)hhmm</code> are recognized. If the string does not contain a time zone offset
+     * the <code>TIMEZONE</code>field is left undefined, meaning the local time zone should be applied.</p>
      *
      * <p>English weekday names are recognized but ignored. All text in parentheses is ignored as well.
      * All other text causes parsing to fail.</p>
@@ -331,10 +331,10 @@ public class DateParser {
     }
 
     /**
-     * Get the parsed date and time fields as an array of <tt>Integers</tt>.
+     * Get the parsed date and time fields as an array of <code>Integers</code>.
      *
      * <p>If parsing was successful, all fields are guaranteed to be set except for the
-     * <tt>TIMEZONE</tt> field which may be <tt>null</tt>, meaning that local time zone
+     * <code>TIMEZONE</code> field which may be <code>null</code>, meaning that local time zone
      * offset should be applied.</p>
      *
      * @return the parsed date fields

src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/parser/Lexer.java

@@ -592,7 +592,7 @@ public class Lexer extends Scanner {
 
     /**
      * Check whether the given token represents the beginning of a literal. If so scan
-     * the literal and return <tt>true</tt>, otherwise return false.
+     * the literal and return <code>true</code>, otherwise return false.
      *
      * @param token the token.
      * @param startTokenType the token type.

src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ConsString.java

@@ -32,7 +32,7 @@ import java.util.Deque;
 
 /**
  * This class represents a string composed of two parts which may themselves be
- * instances of <tt>ConsString</tt> or {@link String}. Copying of characters to
+ * instances of <code>ConsString</code> or {@link String}. Copying of characters to
  * a proper string is delayed until it becomes necessary.
  */
 public final class ConsString implements CharSequence {

src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/linker/NameCodec.java

@@ -60,15 +60,15 @@ package jdk.nashorn.internal.runtime.linker;
  * Dangerous characters are the union of all characters forbidden
  * or otherwise restricted by the JVM specification,
  * plus their mates, if they are brackets
- * (<code><big><b>[</b></big></code> and <code><big><b>]</b></big></code>,
- * <code><big><b>&lt;</b></big></code> and <code><big><b>&gt;</b></big></code>),
- * plus, arbitrarily, the colon character <code><big><b>:</b></big></code>.
+ * (<code><b>[</b></code> and <code><b>]</b></code>,
+ * <code><b>&lt;</b></code> and <code><b>&gt;</b></code>),
+ * plus, arbitrarily, the colon character <code><b>:</b></code>.
  * There is no distinction between type, method, and field names.
  * This makes it easier to convert between mangled names of different
  * types, since they do not need to be decoded (demangled).
  * </p>
  * <p>
- * The escape character is backslash <code><big><b>\</b></big></code>
+ * The escape character is backslash <code><b>\</b></code>
  * (also known as reverse solidus).
  * This character is, until now, unheard of in bytecode names,
  * but traditional in the proposed role.
@@ -92,32 +92,32 @@ package jdk.nashorn.internal.runtime.linker;
  * </p>
  * <p>
  * The dangerous characters are
- * <code><big><b>/</b></big></code> (forward slash, used to delimit package components),
- * <code><big><b>.</b></big></code> (dot, also a package delimiter),
- * <code><big><b>;</b></big></code> (semicolon, used in signatures),
- * <code><big><b>$</b></big></code> (dollar, used in inner classes and synthetic members),
- * <code><big><b>&lt;</b></big></code> (left angle),
- * <code><big><b>&gt;</b></big></code> (right angle),
- * <code><big><b>[</b></big></code> (left square bracket, used in array types),
- * <code><big><b>]</b></big></code> (right square bracket, reserved in this scheme for language use),
- * and <code><big><b>:</b></big></code> (colon, reserved in this scheme for language use).
+ * <code><b>/</b></code> (forward slash, used to delimit package components),
+ * <code><b>.</b></code> (dot, also a package delimiter),
+ * <code><b>;</b></code> (semicolon, used in signatures),
+ * <code><b>$</b></code> (dollar, used in inner classes and synthetic members),
+ * <code><b>&lt;</b></code> (left angle),
+ * <code><b>&gt;</b></code> (right angle),
+ * <code><b>[</b></code> (left square bracket, used in array types),
+ * <code><b>]</b></code> (right square bracket, reserved in this scheme for language use),
+ * and <code><b>:</b></code> (colon, reserved in this scheme for language use).
  * Their replacements are, respectively,
- * <code><big><b>|</b></big></code> (vertical bar),
- * <code><big><b>,</b></big></code> (comma),
- * <code><big><b>?</b></big></code> (question mark),
- * <code><big><b>%</b></big></code> (percent),
- * <code><big><b>^</b></big></code> (caret),
- * <code><big><b>_</b></big></code> (underscore), and
- * <code><big><b>{</b></big></code> (left curly bracket),
- * <code><big><b>}</b></big></code> (right curly bracket),
- * <code><big><b>!</b></big></code> (exclamation mark).
+ * <code><b>|</b></code> (vertical bar),
+ * <code><b>,</b></code> (comma),
+ * <code><b>?</b></code> (question mark),
+ * <code><b>%</b></code> (percent),
+ * <code><b>^</b></code> (caret),
+ * <code><b>_</b></code> (underscore), and
+ * <code><b>{</b></code> (left curly bracket),
+ * <code><b>}</b></code> (right curly bracket),
+ * <code><b>!</b></code> (exclamation mark).
  * In addition, the replacement character for the escape character itself is
- * <code><big><b>-</b></big></code> (hyphen),
+ * <code><b>-</b></code> (hyphen),
  * and the replacement character for the null prefix is
- * <code><big><b>=</b></big></code> (equal sign).
+ * <code><b>=</b></code> (equal sign).
  * </p>
  * <p>
- * An escape character <code><big><b>\</b></big></code>
+ * An escape character <code><b>\</b></code>
  * followed by any of these replacement characters
  * is an escape sequence, and there are no other escape sequences.
  * An equal sign is only part of an escape sequence
@@ -135,16 +135,16 @@ package jdk.nashorn.internal.runtime.linker;
  * string can contain <cite>accidental escapes</cite>, apparent escape
  * sequences which must not be interpreted as manglings.
  * These are disabled by replacing their leading backslash with an
- * escape sequence (<code><big><b>\-</b></big></code>).  To mangle a string, three logical steps
+ * escape sequence (<code><b>\-</b></code>).  To mangle a string, three logical steps
  * are required, though they may be carried out in one pass:
  * </p>
  * <ol>
  *   <li>In each accidental escape, replace the backslash with an escape sequence
- * (<code><big><b>\-</b></big></code>).</li>
+ * (<code><b>\-</b></code>).</li>
  *   <li>Replace each dangerous character with an escape sequence
- * (<code><big><b>\|</b></big></code> for <code><big><b>/</b></big></code>, etc.).</li>
+ * (<code><b>\|</b></code> for <code><b>/</b></code>, etc.).</li>
  *   <li>If the first two steps introduced any change, <em>and</em>
- * if the string does not already begin with a backslash, prepend a null prefix (<code><big><b>\=</b></big></code>).</li>
+ * if the string does not already begin with a backslash, prepend a null prefix (<code><b>\=</b></code>).</li>
  * </ol>
  *
  * To demangle a mangled string that begins with an escape,
@@ -174,9 +174,9 @@ package jdk.nashorn.internal.runtime.linker;
  * is a many-to-one function.
  * A mangled string is defined as <cite>validly mangled</cite> if
  * it is in fact the unique mangling of its spelling string.
- * Three examples of invalidly mangled strings are <code><big><b>\=foo</b></big></code>,
- * <code><big><b>\-bar</b></big></code>, and <code><big><b>baz\!</b></big></code>, which demangle to <code><big><b>foo</b></big></code>, <code><big><b>\bar</b></big></code>, and
- * <code><big><b>baz\!</b></big></code>, but then remangle to <code><big><b>foo</b></big></code>, <code><big><b>\bar</b></big></code>, and <code><big><b>\=baz\-!</b></big></code>.
+ * Three examples of invalidly mangled strings are <code><b>\=foo</b></code>,
+ * <code><b>\-bar</b></code>, and <code><b>baz\!</b></code>, which demangle to <code><b>foo</b></code>, <code><b>\bar</b></code>, and
+ * <code><b>baz\!</b></code>, but then remangle to <code><b>foo</b></code>, <code><b>\bar</b></code>, and <code><b>\=baz\-!</b></code>.
  * If a language back-end or runtime is using mangled names,
  * it should never present an invalidly mangled bytecode
  * name to the JVM.  If the runtime encounters one,
@@ -237,10 +237,10 @@ package jdk.nashorn.internal.runtime.linker;
  * </p>
  * <p>
  * For example, an HTML-like spelling
- * <code><big><b>&lt;pre&gt;</b></big></code> mangles to
- * <code><big><b>\^pre\_</b></big></code> and could
+ * <code><b>&lt;pre&gt;</b></code> mangles to
+ * <code><b>\^pre\_</b></code> and could
  * display more cleanly as
- * <code><big><b>'&lt;pre&gt;'</b></big></code>,
+ * <code><b>'&lt;pre&gt;'</b></code>,
  * with the quotes included.
  * Such string-like conventions are <em>not</em> suitable
  * for mangled bytecode names, in part because
@@ -256,11 +256,11 @@ package jdk.nashorn.internal.runtime.linker;
  * which contain dangerous characters (like dots in field
  * names or brackets in method names) should not be
  * simply quoted.  The bytecode names
- * <code><big><b>\=phase\,1</b></big></code> and
- * <code><big><b>phase.1</b></big></code> are distinct,
+ * <code><b>\=phase\,1</b></code> and
+ * <code><b>phase.1</b></code> are distinct,
  * and in demangled displays they should be presented as
- * <code><big><b>'phase.1'</b></big></code> and something like
- * <code><big><b>'phase'.1</b></big></code>, respectively.
+ * <code><b>'phase.1'</b></code> and something like
+ * <code><b>'phase'.1</b></code>, respectively.
  * </p>
  */
 public final class NameCodec {