--- old/src/java.base/share/classes/java/util/Locale.java	2015-09-24 14:38:11.117755626 +0300
+++ new/src/java.base/share/classes/java/util/Locale.java	2015-09-24 14:38:10.713755635 +0300
@@ -825,7 +825,7 @@
      * setDefault(Locale.Category, Locale) method.
      *
      * @param category - the specified category to get the default locale
-     * @throws NullPointerException - if category is null
+     * @throws NullPointerException if category is null
      * @return the default locale for the specified Category for this instance
      *     of the Java Virtual Machine
      * @see #setDefault(Locale.Category, Locale)
@@ -954,9 +954,9 @@
      *
      * @param category - the specified category to set the default locale
      * @param newLocale - the new default locale
-     * @throws SecurityException - if a security manager exists and its
+     * @throws SecurityException if a security manager exists and its
      *     checkPermission method doesn't allow the operation.
-     * @throws NullPointerException - if category and/or newLocale is null
+     * @throws NullPointerException if category and/or newLocale is null
      * @see SecurityManager#checkPermission(java.security.Permission)
      * @see PropertyPermission
      * @see #getDefault(Locale.Category)
--- old/src/java.base/share/classes/sun/reflect/generics/factory/CoreReflectionFactory.java	2015-09-24 14:38:12.297755601 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/factory/CoreReflectionFactory.java	2015-09-24 14:38:11.805755611 +0300
@@ -70,20 +70,20 @@
 
     /**
      * Factory for this class. Returns an instance of
-     * <tt>CoreReflectionFactory</tt> for the declaration and scope
+     * {@code CoreReflectionFactory} for the declaration and scope
      * provided.
      * This factory will produce reflective objects of the appropriate
      * kind. Classes produced will be those that would be loaded by the
-     * defining class loader of the declaration <tt>d</tt> (if <tt>d</tt>
+     * defining class loader of the declaration {@code d} (if {@code d}
      * is a type declaration, or by the defining loader of the declaring
-     * class of <tt>d</tt> otherwise.
+     * class of {@code d} otherwise.
      * <p> Type variables will be created or lookup as necessary in the
-     * scope <tt> s</tt>.
+     * scope {@code s}.
      * @param d - the generic declaration (class, interface, method or
      * constructor) that this factory services
      * @param s  the scope in which the factory will allocate and search for
      * type variables
-     * @return an instance of <tt>CoreReflectionFactory</tt>
+     * @return an instance of {@code CoreReflectionFactory}
      */
     public static CoreReflectionFactory make(GenericDeclaration d, Scope s) {
         return new CoreReflectionFactory(d, s);
--- old/src/java.base/share/classes/sun/reflect/generics/factory/GenericsFactory.java	2015-09-24 14:38:13.341755578 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/factory/GenericsFactory.java	2015-09-24 14:38:12.921755587 +0300
@@ -47,32 +47,32 @@
  */
 public interface GenericsFactory {
     /**
-     * Returns a new type variable declaration. Note that <tt>name</tt>
-     * may be empty (but not <tt>null</tt>). If <tt>bounds</tt> is
-     * empty, a bound of <tt>java.lang.Object</tt> is used.
+     * Returns a new type variable declaration. Note that {@code name}
+     * may be empty (but not {@code null}). If {@code bounds} is
+     * empty, a bound of {@code java.lang.Object} is used.
      * @param name The name of the type variable
      * @param bounds An array of abstract syntax trees representing
      * the upper bound(s) on the type variable being declared
      * @return a new type variable declaration
-     * @throws NullPointerException - if any of the actual parameters
-     * or any of the elements of <tt>bounds</tt> are <tt>null</tt>.
+     * @throws NullPointerException if any of the actual parameters
+     * or any of the elements of {@code bounds} are {@code null}.
      */
     TypeVariable<?> makeTypeVariable(String name,
                                      FieldTypeSignature[] bounds);
     /**
-     * Returns an instance of the <tt>ParameterizedType</tt> interface
+     * Returns an instance of the {@code ParameterizedType} interface
      * that corresponds to a generic type instantiation of the
-     * generic declaration <tt>declaration</tt> with actual type arguments
-     * <tt>typeArgs</tt>.
-     * If <tt>owner</tt> is <tt>null</tt>, the declaring class of
-     * <tt>declaration</tt> is used as the owner of this parameterized
+     * generic declaration {@code declaration} with actual type arguments
+     * {@code typeArgs}.
+     * If {@code owner} is {@code null}, the declaring class of
+     * {@code declaration} is used as the owner of this parameterized
      * type.
      * <p> This method throws a MalformedParameterizedTypeException
      * under the following circumstances:
      * If the type declaration does not represent a generic declaration
-     * (i.e., it is not an instance of <tt>GenericDeclaration</tt>).
+     * (i.e., it is not an instance of {@code GenericDeclaration}).
      * If the number of actual type arguments (i.e., the size of the
-     * array <tt>typeArgs</tt>) does not correspond to the number of
+     * array {@code typeArgs}) does not correspond to the number of
      * formal type arguments.
      * If any of the actual type arguments is not an instance of the
      * bounds on the corresponding formal.
@@ -81,39 +81,39 @@
      * @param typeArgs - the list of actual type arguments
      * @return - a parameterized type representing the instantiation
      * of the declaration with the actual type arguments
-     * @throws MalformedParameterizedTypeException - if the instantiation
+     * @throws MalformedParameterizedTypeException if the instantiation
      * is invalid
-     * @throws NullPointerException - if any of <tt>declaration</tt>
-     * , <tt>typeArgs</tt>
-     * or any of the elements of <tt>typeArgs</tt> are <tt>null</tt>
+     * @throws NullPointerException if any of {@code declaration},
+     * {@code typeArgs}
+     * or any of the elements of {@code typeArgs} are {@code null}
      */
     ParameterizedType makeParameterizedType(Type declaration,
                                             Type[] typeArgs,
                                             Type owner);
 
     /**
-     * Returns the type variable with name <tt>name</tt>, if such
+     * Returns the type variable with name {@code name}, if such
      * a type variable is declared in the
      * scope used to create this factory.
-     * Returns <tt>null</tt> otherwise.
+     * Returns {@code null} otherwise.
      * @param name - the name of the type variable to search for
-     * @return - the type variable with name <tt>name</tt>, or <tt>null</tt>
-     * @throws  NullPointerException - if any of actual parameters are
-     * <tt>null</tt>
+     * @return - the type variable with name {@code name}, or {@code null}
+     * @throws  NullPointerException if any of actual parameters are
+     * {@code null}
      */
     TypeVariable<?> findTypeVariable(String name);
 
     /**
      * Returns a new wildcard type variable. If
-     * <tt>ubs</tt> is empty, a bound of <tt>java.lang.Object</tt> is used.
+     * {@code ubs} is empty, a bound of {@code java.lang.Object} is used.
      * @param ubs An array of abstract syntax trees representing
      * the upper bound(s) on the type variable being declared
      * @param lbs An array of abstract syntax trees representing
      * the lower bound(s) on the type variable being declared
      * @return a new wildcard type variable
-     * @throws NullPointerException - if any of the actual parameters
-     * or any of the elements of <tt>ubs</tt> or <tt>lbs</tt>are
-     * <tt>null</tt>
+     * @throws NullPointerException if any of the actual parameters
+     * or any of the elements of {@code ubs} or {@code lbs} are
+     * {@code null}
      */
     WildcardType makeWildcard(FieldTypeSignature[] ubs,
                               FieldTypeSignature[] lbs);
@@ -127,64 +127,64 @@
      * a MalformedParameterizedTypeException is thrown.
      * @param componentType - the component type of the array
      * @return a (possibly generic) array type.
-     * @throws MalformedParameterizedTypeException if <tt>componentType</tt>
+     * @throws MalformedParameterizedTypeException if {@code componentType}
      * is a parameterized type with non-wildcard type arguments
-     * @throws NullPointerException - if any of the actual parameters
-     * are <tt>null</tt>
+     * @throws NullPointerException if any of the actual parameters
+     * are {@code null}
      */
     Type makeArrayType(Type componentType);
 
     /**
-     * Returns the reflective representation of type <tt>byte</tt>.
-     * @return the reflective representation of type <tt>byte</tt>.
+     * Returns the reflective representation of type {@code byte}.
+     * @return the reflective representation of type {@code byte}.
      */
     Type makeByte();
 
     /**
-     * Returns the reflective representation of type <tt>boolean</tt>.
-     * @return the reflective representation of type <tt>boolean</tt>.
+     * Returns the reflective representation of type {@code boolean}.
+     * @return the reflective representation of type {@code boolean}.
      */
     Type makeBool();
 
     /**
-     * Returns the reflective representation of type <tt>short</tt>.
-     * @return the reflective representation of type <tt>short</tt>.
+     * Returns the reflective representation of type {@code short}.
+     * @return the reflective representation of type {@code short}.
      */
     Type makeShort();
 
     /**
-     * Returns the reflective representation of type <tt>char</tt>.
-     * @return the reflective representation of type <tt>char</tt>.
+     * Returns the reflective representation of type {@code char}.
+     * @return the reflective representation of type {@code char}.
      */
     Type makeChar();
 
     /**
-     * Returns the reflective representation of type <tt>int</tt>.
-     * @return the reflective representation of type <tt>int</tt>.
+     * Returns the reflective representation of type {@code int}.
+     * @return the reflective representation of type {@code int}.
      */
     Type makeInt();
 
     /**
-     * Returns the reflective representation of type <tt>long</tt>.
-     * @return the reflective representation of type <tt>long</tt>.
+     * Returns the reflective representation of type {@code long}.
+     * @return the reflective representation of type {@code long}.
      */
     Type makeLong();
 
     /**
-     * Returns the reflective representation of type <tt>float</tt>.
-     * @return the reflective representation of type <tt>float</tt>.
+     * Returns the reflective representation of type {@code float}.
+     * @return the reflective representation of type {@code float}.
      */
     Type makeFloat();
 
     /**
-     * Returns the reflective representation of type <tt>double</tt>.
-     * @return the reflective representation of type <tt>double</tt>.
+     * Returns the reflective representation of type {@code double}.
+     * @return the reflective representation of type {@code double}.
      */
     Type makeDouble();
 
     /**
-     * Returns the reflective representation of <tt>void</tt>.
-     * @return the reflective representation of <tt>void</tt>.
+     * Returns the reflective representation of {@code void}.
+     * @return the reflective representation of {@code void}.
      */
     Type makeVoid();
 }
--- old/src/java.base/share/classes/sun/reflect/generics/parser/SignatureParser.java	2015-09-24 14:38:14.169755560 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/parser/SignatureParser.java	2015-09-24 14:38:13.833755567 +0300
@@ -135,7 +135,7 @@
 
     /**
      * Static factory method. Produces a parser instance.
-     * @return an instance of <tt>SignatureParser</tt>
+     * @return an instance of {@code SignatureParser}
      */
     public static SignatureParser make() {
         return new SignatureParser();
--- old/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/GenericArrayTypeImpl.java	2015-09-24 14:38:15.281755536 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/GenericArrayTypeImpl.java	2015-09-24 14:38:14.805755546 +0300
@@ -53,10 +53,10 @@
 
 
     /**
-     * Returns a <tt>Type</tt> object representing the component type
+     * Returns a {@code Type} object representing the component type
      * of this array.
      *
-     * @return a <tt>Type</tt> object representing the component type
+     * @return a {@code Type} object representing the component type
      *     of this array
      * @since 1.5
      */
--- old/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/TypeVariableImpl.java	2015-09-24 14:38:16.333755513 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/TypeVariableImpl.java	2015-09-24 14:38:15.921755522 +0300
@@ -46,7 +46,7 @@
 import sun.reflect.misc.ReflectUtil;
 
 /**
- * Implementation of <tt>java.lang.reflect.TypeVariable</tt> interface
+ * Implementation of {@code java.lang.reflect.TypeVariable} interface
  * for core reflection.
  */
 public class TypeVariableImpl<D extends GenericDeclaration>
@@ -99,9 +99,9 @@
 
 
     /**
-     * Returns an array of <tt>Type</tt> objects representing the
+     * Returns an array of {@code Type} objects representing the
      * upper bound(s) of this type variable.  Note that if no upper bound is
-     * explicitly declared, the upper bound is <tt>Object</tt>.
+     * explicitly declared, the upper bound is {@code Object}.
      *
      * <p>For each upper bound B:
      * <ul>
@@ -111,9 +111,9 @@
      *  <li>Otherwise, B is resolved.
      * </ul>
      *
-     * @throws <tt>TypeNotPresentException</tt> if any of the
+     * @throws {@code TypeNotPresentException} if any of the
      *     bounds refers to a non-existent type declaration
-     * @throws <tt>MalformedParameterizedTypeException</tt> if any of the
+     * @throws {@code MalformedParameterizedTypeException} if any of the
      *     bounds refer to a parameterized type that cannot be instantiated
      *     for any reason
      * @return an array of Types representing the upper bound(s) of this
@@ -129,7 +129,7 @@
     }
 
     /**
-     * Returns the <tt>GenericDeclaration</tt> object representing the
+     * Returns the {@code GenericDeclaration} object representing the
      * generic declaration that declared this type variable.
      *
      * @return the generic declaration that declared this type variable.
--- old/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/WildcardTypeImpl.java	2015-09-24 14:38:17.281755493 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/reflectiveObjects/WildcardTypeImpl.java	2015-09-24 14:38:16.921755500 +0300
@@ -78,9 +78,9 @@
     }
 
     /**
-     * Returns an array of <tt>Type</tt> objects representing the upper
+     * Returns an array of {@code Type} objects representing the upper
      * bound(s) of this type variable.  Note that if no upper bound is
-     * explicitly declared, the upper bound is <tt>Object</tt>.
+     * explicitly declared, the upper bound is {@code Object}.
      *
      * <p>For each upper bound B :
      * <ul>
@@ -92,9 +92,9 @@
      *
      * @return an array of Types representing the upper bound(s) of this
      *     type variable
-     * @throws <tt>TypeNotPresentException</tt> if any of the
+     * @throws {@code TypeNotPresentException} if any of the
      *     bounds refers to a non-existent type declaration
-     * @throws <tt>MalformedParameterizedTypeException</tt> if any of the
+     * @throws {@code MalformedParameterizedTypeException} if any of the
      *     bounds refer to a parameterized type that cannot be instantiated
      *     for any reason
      */
@@ -108,9 +108,9 @@
     }
 
     /**
-     * Returns an array of <tt>Type</tt> objects representing the
+     * Returns an array of {@code Type} objects representing the
      * lower bound(s) of this type variable.  Note that if no lower bound is
-     * explicitly declared, the lower bound is the type of <tt>null</tt>.
+     * explicitly declared, the lower bound is the type of {@code null}.
      * In this case, a zero length array is returned.
      *
      * <p>For each lower bound B :
@@ -123,9 +123,9 @@
      *
      * @return an array of Types representing the lower bound(s) of this
      *     type variable
-     * @throws <tt>TypeNotPresentException</tt> if any of the
+     * @throws {@code TypeNotPresentException} if any of the
      *     bounds refers to a non-existent type declaration
-     * @throws <tt>MalformedParameterizedTypeException</tt> if any of the
+     * @throws {@code MalformedParameterizedTypeException} if any of the
      *     bounds refer to a parameterized type that cannot be instantiated
      *     for any reason
      */
--- old/src/java.base/share/classes/sun/reflect/generics/repository/AbstractRepository.java	2015-09-24 14:38:18.197755473 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/repository/AbstractRepository.java	2015-09-24 14:38:17.777755482 +0300
@@ -48,15 +48,15 @@
     private GenericsFactory getFactory() { return factory;}
 
     /**
-     * Accessor for <tt>tree</tt>.
+     * Accessor for {@code tree}.
      * @return the cached AST this repository holds
      */
     protected T getTree(){ return tree;}
 
     /**
-     * Returns a <tt>Reifier</tt> used to convert parts of the
+     * Returns a {@code Reifier} used to convert parts of the
      * AST into reflective objects.
-     * @return a <tt>Reifier</tt> used to convert parts of the
+     * @return a {@code Reifier} used to convert parts of the
      * AST into reflective objects
      */
     protected Reifier getReifier(){return Reifier.make(getFactory());}
--- old/src/java.base/share/classes/sun/reflect/generics/repository/ClassRepository.java	2015-09-24 14:38:19.241755450 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/repository/ClassRepository.java	2015-09-24 14:38:18.801755460 +0300
@@ -63,8 +63,8 @@
      * that this repository is servicing
      * @param f - a factory that will provide instances of reflective
      * objects when this repository converts its AST
-     * @return a <tt>ClassRepository</tt> that manages the generic type
-     * information represented in the signature <tt>rawSig</tt>
+     * @return a {@code ClassRepository} that manages the generic type
+     * information represented in the signature {@code rawSig}
      */
     public static ClassRepository make(String rawSig, GenericsFactory f) {
         return new ClassRepository(rawSig, f);
--- old/src/java.base/share/classes/sun/reflect/generics/repository/ConstructorRepository.java	2015-09-24 14:38:20.269755428 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/repository/ConstructorRepository.java	2015-09-24 14:38:19.865755437 +0300
@@ -64,8 +64,8 @@
      * that this repository is servicing
      * @param f - a factory that will provide instances of reflective
      * objects when this repository converts its AST
-     * @return a <tt>ConstructorRepository</tt> that manages the generic type
-     * information represented in the signature <tt>rawSig</tt>
+     * @return a {@code ConstructorRepository} that manages the generic type
+     * information represented in the signature {@code rawSig}
      */
     public static ConstructorRepository make(String rawSig, GenericsFactory f) {
         return new ConstructorRepository(rawSig, f);
--- old/src/java.base/share/classes/sun/reflect/generics/repository/FieldRepository.java	2015-09-24 14:38:21.237755407 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/repository/FieldRepository.java	2015-09-24 14:38:20.913755414 +0300
@@ -59,8 +59,8 @@
      * that this repository is servicing
      * @param f - a factory that will provide instances of reflective
      * objects when this repository converts its AST
-     * @return a <tt>FieldRepository</tt> that manages the generic type
-     * information represented in the signature <tt>rawSig</tt>
+     * @return a {@code FieldRepository} that manages the generic type
+     * information represented in the signature {@code rawSig}
      */
     public static FieldRepository make(String rawSig, GenericsFactory f) {
         return new FieldRepository(rawSig, f);
--- old/src/java.base/share/classes/sun/reflect/generics/repository/MethodRepository.java	2015-09-24 14:38:22.121755388 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/repository/MethodRepository.java	2015-09-24 14:38:21.721755397 +0300
@@ -53,8 +53,8 @@
      * that this repository is servicing
      * @param f - a factory that will provide instances of reflective
      * objects when this repository converts its AST
-     * @return a <tt>MethodRepository</tt> that manages the generic type
-     * information represented in the signature <tt>rawSig</tt>
+     * @return a {@code MethodRepository} that manages the generic type
+     * information represented in the signature {@code rawSig}
      */
     public static MethodRepository make(String rawSig, GenericsFactory f) {
         return new MethodRepository(rawSig, f);
--- old/src/java.base/share/classes/sun/reflect/generics/scope/AbstractScope.java	2015-09-24 14:38:23.189755365 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/scope/AbstractScope.java	2015-09-24 14:38:22.725755375 +0300
@@ -32,10 +32,10 @@
 /**
  * Abstract superclass for lazy scope objects, used when building
  * factories for generic information repositories.
- * The type parameter <tt>D</tt> represents the type of reflective
+ * The type parameter {@code D} represents the type of reflective
  * object whose scope this class is representing.
  * <p> To subclass this, all one needs to do is implement
- * <tt>computeEnclosingScope</tt> and the subclass' constructor.
+ * {@code computeEnclosingScope} and the subclass' constructor.
  */
 public abstract class AbstractScope<D extends GenericDeclaration>
     implements Scope {
@@ -54,9 +54,9 @@
     protected AbstractScope(D decl){ recvr = decl;}
 
     /**
-     * Accessor for the receiver - the object whose scope this <tt>Scope</tt>
+     * Accessor for the receiver - the object whose scope this {@code Scope}
      * object represents.
-     * @return The object whose scope this <tt>Scope</tt> object represents
+     * @return The object whose scope this {@code Scope} object represents
      */
     protected D getRecvr() {return recvr;}
 
--- old/src/java.base/share/classes/sun/reflect/generics/scope/ClassScope.java	2015-09-24 14:38:24.173755343 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/scope/ClassScope.java	2015-09-24 14:38:23.785755352 +0300
@@ -73,7 +73,7 @@
     }
 
     /**
-     * Factory method. Takes a <tt>Class</tt> object and creates a
+     * Factory method. Takes a {@code Class} object and creates a
      * scope for it.
      * @param c - a Class whose scope we want to obtain
      * @return The type-variable scope for the class c
--- old/src/java.base/share/classes/sun/reflect/generics/scope/DummyScope.java	2015-09-24 14:38:25.173755322 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/scope/DummyScope.java	2015-09-24 14:38:24.817755329 +0300
@@ -29,9 +29,9 @@
 
 /**
  * This class is used to provide enclosing scopes for top level classes.
- * We cannot use <tt>null</tt> to represent such a scope, since the
+ * We cannot use {@code null} to represent such a scope, since the
  * enclosing scope is computed lazily, and so the field storing it is
- * null until it has been computed. Therefore, <tt>null</tt> is reserved
+ * null until it has been computed. Therefore, {@code null} is reserved
  * to represent an as-yet-uncomputed scope, and cannot be used for any
  * other kind of scope.
  */
@@ -53,7 +53,7 @@
 
     /**
      * Lookup a type variable in the scope, using its name. Always returns
-     * <tt>null</tt>.
+     * {@code null}.
      * @param name - the name of the type variable being looked up
      * @return  null
      */
--- old/src/java.base/share/classes/sun/reflect/generics/scope/MethodScope.java	2015-09-24 14:38:26.049755303 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/scope/MethodScope.java	2015-09-24 14:38:25.657755311 +0300
@@ -56,7 +56,7 @@
     }
 
     /**
-     * Factory method. Takes a <tt>Method</tt> object and creates a
+     * Factory method. Takes a {@code Method} object and creates a
      * scope for it.
      * @param m - A Method whose scope we want to obtain
      * @return The type-variable scope for the method m
--- old/src/java.base/share/classes/sun/reflect/generics/tree/TypeTree.java	2015-09-24 14:38:27.141755279 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/tree/TypeTree.java	2015-09-24 14:38:26.713755288 +0300
@@ -33,7 +33,7 @@
 public interface TypeTree extends Tree {
     /**
      * Accept method for the visitor pattern.
-     * @param v - a <tt>TypeTreeVisitor</tt> that will process this
+     * @param v a {@code TypeTreeVisitor} that will process this
      * tree
      */
     void accept(TypeTreeVisitor<?> v);
--- old/src/java.base/share/classes/sun/reflect/generics/visitor/Reifier.java	2015-09-24 14:38:28.197755256 +0300
+++ new/src/java.base/share/classes/sun/reflect/generics/visitor/Reifier.java	2015-09-24 14:38:27.777755265 +0300
@@ -50,7 +50,7 @@
     /**
      * Factory method. The resulting visitor will convert an AST
      * representing generic signatures into corresponding reflective
-     * objects, using the provided factory, <tt>f</tt>.
+     * objects, using the provided factory, {@code f}.
      * @param f - a factory that can be used to manufacture reflective
      * objects returned by this visitor
      * @return A visitor that can be used to reify ASTs representing
--- old/src/java.scripting/share/classes/javax/script/Bindings.java	2015-09-24 14:38:29.161755235 +0300
+++ new/src/java.scripting/share/classes/javax/script/Bindings.java	2015-09-24 14:38:28.781755244 +0300
@@ -28,7 +28,7 @@
 
 /**
  * A mapping of key/value pairs, all of whose keys are
- * <code>Strings</code>.
+ * {@code Strings}.
  *
  * @author Mike Grogan
  * @since 1.6
@@ -49,8 +49,8 @@
     public Object put(String name, Object value);
 
     /**
-     * Adds all the mappings in a given <code>Map</code> to this <code>Bindings</code>.
-     * @param toMerge The <code>Map</code> to merge with this one.
+     * Adds all the mappings in a given {@code Map} to this {@code Bindings}.
+     * @param toMerge The {@code Map} to merge with this one.
      *
      * @throws NullPointerException
      *         if toMerge map is null or if some key in the map is null.
@@ -60,14 +60,14 @@
     public void putAll(Map<? extends String, ? extends Object> toMerge);
 
     /**
-     * Returns <tt>true</tt> if this map contains a mapping for the specified
-     * key.  More formally, returns <tt>true</tt> if and only if
-     * this map contains a mapping for a key <tt>k</tt> such that
-     * <tt>(key==null ? k==null : key.equals(k))</tt>.  (There can be
+     * Returns {@code true} if this map contains a mapping for the specified
+     * key.  More formally, returns {@code true} if and only if
+     * this map contains a mapping for a key {@code k} such that
+     * {@code (key==null ? k==null : key.equals(k))}.  (There can be
      * at most one such mapping.)
      *
      * @param key key whose presence in this map is to be tested.
-     * @return <tt>true</tt> if this map contains a mapping for the specified
+     * @return {@code true} if this map contains a mapping for the specified
      *         key.
      *
      * @throws NullPointerException if key is null
@@ -78,20 +78,21 @@
 
     /**
      * Returns the value to which this map maps the specified key.  Returns
-     * <tt>null</tt> if the map contains no mapping for this key.  A return
-     * value of <tt>null</tt> does not <i>necessarily</i> indicate that the
+     * {@code null} if the map contains no mapping for this key.  A return
+     * value of {@code null} does not <i>necessarily</i> indicate that the
      * map contains no mapping for the key; it's also possible that the map
-     * explicitly maps the key to <tt>null</tt>.  The <tt>containsKey</tt>
+     * explicitly maps the key to {@code null}.  The {@code containsKey}
      * operation may be used to distinguish these two cases.
      *
      * <p>More formally, if this map contains a mapping from a key
-     * <tt>k</tt> to a value <tt>v</tt> such that <tt>(key==null ? k==null :
-     * key.equals(k))</tt>, then this method returns <tt>v</tt>; otherwise
-     * it returns <tt>null</tt>.  (There can be at most one such mapping.)
+     * {@code k} to a value {@code v} such that
+     * {@code (key==null ? k==null : key.equals(k))},
+     * then this method returns {@code v}; otherwise
+     * it returns {@code null}.  (There can be at most one such mapping.)
      *
      * @param key key whose associated value is to be returned.
      * @return the value to which this map maps the specified key, or
-     *         <tt>null</tt> if the map contains no mapping for this key.
+     *         {@code null} if the map contains no mapping for this key.
      *
      * @throws NullPointerException if key is null
      * @throws ClassCastException if key is not String
@@ -102,19 +103,19 @@
     /**
      * Removes the mapping for this key from this map if it is present
      * (optional operation).   More formally, if this map contains a mapping
-     * from key <tt>k</tt> to value <tt>v</tt> such that
-     * <code>(key==null ?  k==null : key.equals(k))</code>, that mapping
+     * from key {@code k} to value {@code v} such that
+     * {@code (key==null ?  k==null : key.equals(k))}, that mapping
      * is removed.  (The map can contain at most one such mapping.)
      *
      * <p>Returns the value to which the map previously associated the key, or
-     * <tt>null</tt> if the map contained no mapping for this key.  (A
-     * <tt>null</tt> return can also indicate that the map previously
-     * associated <tt>null</tt> with the specified key if the implementation
-     * supports <tt>null</tt> values.)  The map will not contain a mapping for
+     * {@code null} if the map contained no mapping for this key.  (A
+     * {@code null} return can also indicate that the map previously
+     * associated {@code null} with the specified key if the implementation
+     * supports {@code null} values.)  The map will not contain a mapping for
      * the specified  key once the call returns.
      *
      * @param key key whose mapping is to be removed from the map.
-     * @return previous value associated with specified key, or <tt>null</tt>
+     * @return previous value associated with specified key, or {@code null}
      *         if there was no mapping for key.
      *
      * @throws NullPointerException if key is null
--- old/src/java.scripting/share/classes/javax/script/SimpleBindings.java	2015-09-24 14:38:29.965755218 +0300
+++ new/src/java.scripting/share/classes/javax/script/SimpleBindings.java	2015-09-24 14:38:29.577755226 +0300
@@ -32,7 +32,7 @@
 
 /**
  * A simple implementation of Bindings backed by
- * a <code>HashMap</code> or some other specified <code>Map</code>.
+ * a {@code HashMap} or some other specified {@code Map}.
  *
  * @author Mike Grogan
  * @since 1.6
@@ -40,13 +40,13 @@
 public class SimpleBindings implements Bindings {
 
     /**
-     * The <code>Map</code> field stores the attributes.
+     * The {@code Map} field stores the attributes.
      */
     private Map<String,Object> map;
 
     /**
-     * Constructor uses an existing <code>Map</code> to store the values.
-     * @param m The <code>Map</code> backing this <code>SimpleBindings</code>.
+     * Constructor uses an existing {@code Map} to store the values.
+     * @param m The {@code Map} backing this {@code SimpleBindings}.
      * @throws NullPointerException if m is null
      */
     public SimpleBindings(Map<String,Object> m) {
@@ -57,14 +57,14 @@
     }
 
     /**
-     * Default constructor uses a <code>HashMap</code>.
+     * Default constructor uses a {@code HashMap}.
      */
     public SimpleBindings() {
         this(new HashMap<String,Object>());
     }
 
     /**
-     * Sets the specified key/value in the underlying <code>map</code> field.
+     * Sets the specified key/value in the underlying {@code map} field.
      *
      * @param name Name of value
      * @param value Value to set.
@@ -81,9 +81,9 @@
     }
 
     /**
-     * <code>putAll</code> is implemented using <code>Map.putAll</code>.
+     * {@code putAll} is implemented using {@code Map.putAll}.
      *
-     * @param toMerge The <code>Map</code> of values to add.
+     * @param toMerge The {@code Map} of values to add.
      *
      * @throws NullPointerException
      *         if toMerge map is null or if some key in the map is null.
@@ -107,14 +107,14 @@
     }
 
     /**
-     * Returns <tt>true</tt> if this map contains a mapping for the specified
-     * key.  More formally, returns <tt>true</tt> if and only if
-     * this map contains a mapping for a key <tt>k</tt> such that
-     * <tt>(key==null ? k==null : key.equals(k))</tt>.  (There can be
+     * Returns {@code true} if this map contains a mapping for the specified
+     * key.  More formally, returns {@code true} if and only if
+     * this map contains a mapping for a key {@code k} such that
+     * {@code (key==null ? k==null : key.equals(k))}.  (There can be
      * at most one such mapping.)
      *
      * @param key key whose presence in this map is to be tested.
-     * @return <tt>true</tt> if this map contains a mapping for the specified
+     * @return {@code true} if this map contains a mapping for the specified
      *         key.
      *
      * @throws NullPointerException if key is null
@@ -138,20 +138,21 @@
 
     /**
      * Returns the value to which this map maps the specified key.  Returns
-     * <tt>null</tt> if the map contains no mapping for this key.  A return
-     * value of <tt>null</tt> does not <i>necessarily</i> indicate that the
+     * {@code null} if the map contains no mapping for this key.  A return
+     * value of {@code null} does not <i>necessarily</i> indicate that the
      * map contains no mapping for the key; it's also possible that the map
-     * explicitly maps the key to <tt>null</tt>.  The <tt>containsKey</tt>
+     * explicitly maps the key to {@code null}.  The {@code containsKey}
      * operation may be used to distinguish these two cases.
      *
      * <p>More formally, if this map contains a mapping from a key
-     * <tt>k</tt> to a value <tt>v</tt> such that <tt>(key==null ? k==null :
-     * key.equals(k))</tt>, then this method returns <tt>v</tt>; otherwise
-     * it returns <tt>null</tt>.  (There can be at most one such mapping.)
+     * {@code k} to a value {@code v} such that
+     * {@code (key==null ? k==null : key.equals(k))},
+     * then this method returns {@code v}; otherwise
+     * it returns {@code null}.  (There can be at most one such mapping.)
      *
      * @param key key whose associated value is to be returned.
      * @return the value to which this map maps the specified key, or
-     *         <tt>null</tt> if the map contains no mapping for this key.
+     *         {@code null} if the map contains no mapping for this key.
      *
      * @throws NullPointerException if key is null
      * @throws ClassCastException if key is not String
@@ -175,19 +176,19 @@
     /**
      * Removes the mapping for this key from this map if it is present
      * (optional operation).   More formally, if this map contains a mapping
-     * from key <tt>k</tt> to value <tt>v</tt> such that
-     * <code>(key==null ?  k==null : key.equals(k))</code>, that mapping
+     * from key {@code k} to value {@code v} such that
+     * {@code (key==null ?  k==null : key.equals(k))}, that mapping
      * is removed.  (The map can contain at most one such mapping.)
      *
      * <p>Returns the value to which the map previously associated the key, or
-     * <tt>null</tt> if the map contained no mapping for this key.  (A
-     * <tt>null</tt> return can also indicate that the map previously
-     * associated <tt>null</tt> with the specified key if the implementation
-     * supports <tt>null</tt> values.)  The map will not contain a mapping for
+     * {@code null} if the map contained no mapping for this key.  (A
+     * {@code null} return can also indicate that the map previously
+     * associated {@code null} with the specified key if the implementation
+     * supports {@code null} values.)  The map will not contain a mapping for
      * the specified  key once the call returns.
      *
      * @param key key whose mapping is to be removed from the map.
-     * @return previous value associated with specified key, or <tt>null</tt>
+     * @return previous value associated with specified key, or {@code null}
      *         if there was no mapping for key.
      *
      * @throws NullPointerException if key is null
--- old/src/jdk.jconsole/share/classes/com/sun/tools/jconsole/JConsolePlugin.java	2015-09-24 14:38:30.925755197 +0300
+++ new/src/jdk.jconsole/share/classes/com/sun/tools/jconsole/JConsolePlugin.java	2015-09-24 14:38:30.565755205 +0300
@@ -54,7 +54,7 @@
  * <blockquote><pre>
  * jconsole -pluginpath &lt;plugin-path&gt; </pre></blockquote>
  *
- * <p> where <tt>&lt;plugin-path&gt;</tt> specifies the paths of JConsole
+ * <p> where {@code <plugin-path>} specifies the paths of JConsole
  * plugins to look up which can be a directory or a jar file. Multiple
  * paths are separated by the path separator character of the platform.
  *
@@ -106,7 +106,7 @@
 
     /**
      * Returns the {@link JConsoleContext JConsoleContext} object representing
-     * the connection to an application.  This method may return <tt>null</tt>
+     * the connection to an application.  This method may return {@code null}
      * if it is called before the {@link #setContext context} is initialized.
      *
      * @return the {@link JConsoleContext JConsoleContext} object representing
@@ -146,24 +146,24 @@
      * method to schedule the returned {@code SwingWorker} for execution
      * if:
      * <ul>
-     *   <li> the <tt>SwingWorker</tt> object has not been executed
+     *   <li> the {@code SwingWorker} object has not been executed
      *        (i.e. the {@link SwingWorker#getState} method
      *        returns {@link javax.swing.SwingWorker.StateValue#PENDING PENDING}
      *        state); and</li>
-     *   <li> the <tt>SwingWorker</tt> object returned in the previous
-     *        update has completed the task if it was not <tt>null</tt>
+     *   <li> the {@code SwingWorker} object returned in the previous
+     *        update has completed the task if it was not {@code null}
      *        (i.e. the {@link SwingWorker#isDone SwingWorker.isDone} method
-     *        returns <tt>true</tt>).</li>
+     *        returns {@code true}).</li>
      * </ul>
      * <br>
-     * Otherwise, <tt>SwingWorker</tt> object will not be scheduled to work.
+     * Otherwise, {@code SwingWorker} object will not be scheduled to work.
      *
      * <p>
      * A plugin can schedule its own GUI update and this method
-     * will return <tt>null</tt>.
+     * will return {@code null}.
      *
-     * @return a <tt>SwingWorker</tt> to perform the GUI update; or
-     *         <tt>null</tt>.
+     * @return a {@code SwingWorker} to perform the GUI update; or
+     *         {@code null}.
      */
     public abstract SwingWorker<?,?> newSwingWorker();
 
--- old/src/jdk.jconsole/share/classes/sun/tools/jconsole/ProxyClient.java	2015-09-24 14:38:31.905755176 +0300
+++ new/src/jdk.jconsole/share/classes/sun/tools/jconsole/ProxyClient.java	2015-09-24 14:38:31.505755185 +0300
@@ -581,7 +581,7 @@
 
     /**
      * Returns a map of MBeans with ObjectName as the key and MBeanInfo value
-     * of a given domain.  If domain is <tt>null</tt>, all MBeans
+     * of a given domain.  If domain is {@code null}, all MBeans
      * are returned.  If no MBean found, an empty map is returned.
      *
      */
--- old/src/jdk.rmic/share/classes/sun/tools/java/ClassDefinition.java	2015-09-24 14:38:32.949755153 +0300
+++ new/src/jdk.rmic/share/classes/sun/tools/java/ClassDefinition.java	2015-09-24 14:38:32.489755163 +0300
@@ -259,7 +259,7 @@
      * Tell if the class is inner.
      * This predicate also returns true for top-level nested types.
      * To test for a true inner class as seen by the programmer,
-     * use <tt>!isTopLevel()</tt>.
+     * use {@code !isTopLevel()}.
      */
     public final boolean isInnerClass() {
         return outerClass != null;
@@ -911,7 +911,7 @@
     }
 
     /**
-     * Note that this class is being used somehow by <tt>ref</tt>.
+     * Note that this class is being used somehow by {@code ref}.
      * Report deprecation errors, etc.
      */
     public void noteUsedBy(ClassDefinition ref, long where, Environment env) {
--- old/src/jdk.rmic/share/classes/sun/tools/java/Identifier.java	2015-09-24 14:38:33.797755135 +0300
+++ new/src/jdk.rmic/share/classes/sun/tools/java/Identifier.java	2015-09-24 14:38:33.461755142 +0300
@@ -200,7 +200,7 @@
     /** A space character, which precedes the first inner class
      *  name in a qualified name, and thus marks the qualification
      *  as involving inner classes, instead of merely packages.<p>
-     *  Ex:  <tt>java.util.Vector. Enumerator</tt>.
+     *  Ex:  {@code java.util.Vector. Enumerator}.
      */
     public static final char INNERCLASS_PREFIX = ' ';
 
@@ -229,7 +229,7 @@
      * and with any nesting flattened into a new qualfication structure.
      * If the original identifier is inner,
      * the result will be qualified, and can be further
-     * decomposed by means of <tt>getQualifier</tt> and <tt>getName</tt>.
+     * decomposed by means of {@code getQualifier} and {@code getName}.
      * <p>
      * For example:
      * <pre>
--- old/src/jdk.rmic/share/classes/sun/tools/javac/SourceMember.java	2015-09-24 14:38:34.885755111 +0300
+++ new/src/jdk.rmic/share/classes/sun/tools/javac/SourceMember.java	2015-09-24 14:38:34.381755122 +0300
@@ -394,7 +394,7 @@
      * <p>
      * This is the method which requests checking.
      * The real work is done by
-     * <tt>Vset check(Environment, Context, Vset)</tt>.
+     * {@code Vset check(Environment, Context, Vset)}.
      */
     public void check(Environment env) throws ClassNotFound {
         if (tracing) env.dtEnter("SourceMember.check: " +
--- old/src/jdk.rmic/share/classes/sun/tools/tree/Expression.java	2015-09-24 14:38:35.845755091 +0300
+++ new/src/jdk.rmic/share/classes/sun/tools/tree/Expression.java	2015-09-24 14:38:35.437755099 +0300
@@ -210,8 +210,8 @@
     }
 
     /**
-     * Return a <code>FieldUpdater</code> object to be used in updating the
-     * value of the location denoted by <code>this</code>, which must be an
+     * Return a {@code FieldUpdater} object to be used in updating the
+     * value of the location denoted by {@code this}, which must be an
      * expression suitable for the left-hand side of an assignment.
      * This is used for implementing assignments to private fields for which
      * an access method is required.  Returns null if no access method is
@@ -228,8 +228,8 @@
     }
 
     /**
-     * Return a <code>FieldUpdater</code> object to be used in updating the value of the
-     * location denoted by <code>this</code>, which must be an expression suitable for the
+     * Return a {@code FieldUpdater} object to be used in updating the value of the
+     * location denoted by {@code this}, which must be an expression suitable for the
      * left-hand side of an assignment.  This is used for implementing the assignment
      * operators and the increment/decrement operators on private fields that require an
      * access method, e.g., uplevel from an inner class.  Returns null if no access method
@@ -260,9 +260,9 @@
      * <li> a type name followed by fields or types
      * <li> a package name followed a type and then fields or types
      * </nl>
-     * If a type name is found, it rewrites itself as a <tt>TypeExpression</tt>.
+     * If a type name is found, it rewrites itself as a {@code TypeExpression}.
      * If a node decides it can only be a package prefix, it sets its
-     * type to <tt>Type.tPackage</tt>.  The caller must detect this
+     * type to {@code Type.tPackage}.  The caller must detect this
      * and act appropriately to verify the full package name.
      * @arg loc the expression containing the ambiguous expression
      */