preparation for 3.19 release. fixed bugs in javadoc comments

Readme.html

 
 <h1>Javassist version 3</h1>
 
-<h3>Copyright (C) 1999-2013 by Shigeru Chiba, All rights reserved.</h3>
+<h3>Copyright (C) 1999-2015 by Shigeru Chiba, All rights reserved.</h3>
 
 <p><br></p>
 
 <table>
 <tr>
 <td><li><tt><a href="License.html">License.html</a></tt></td>
-<td>License file
+<td>License file (MPL/LGPL/Apache triple license)
 (Also see the <a href="#copyright">copyright notices</a> below)</td>
 </tr>
 
 
 <h2>Changes</h2>
 
-<p>-version 3.19
+<p>-version 3.19 on January 6, 2015
 <ul>
 <li>JIRA JASSIST-158, 205, 206, 207, 208, 209, 211, 212, 216, 220, 223, 224,
         227, 230, 234, 235, 236, 237, 238, 240.

build.xml

 
 <project name="javassist" default="jar" basedir=".">
 
-  <property name="dist-version" value="javassist-3.18.0-GA"/>
+  <property name="dist-version" value="javassist-3.19.0-GA"/>
 
   <property environment="env"/>
   <property name="target.jar" value="javassist.jar"/>

pom.xml

   	Javassist (JAVA programming ASSISTant) makes Java bytecode manipulation
     simple.  It is a class library for editing bytecodes in Java.
   </description>
-  <version>3.18.0-GA</version>
+  <version>3.19.0-GA</version>
   <name>Javassist</name>
   <url>http://www.javassist.org/</url>
 

src/main/META-INF/MANIFEST.MF

 Specification-Title: Javassist
 Specification-Vendor: Shigeru Chiba, www.javassist.org
-Specification-Version: 3.18.0-GA
+Specification-Version: 3.19.0-GA
 Main-Class: javassist.CtClass

src/main/javassist/ByteArrayClassPath.java

  * into a <code>CtClass</code> object representing the class with a name
  * <code>classname</code>, then do as following:
  *
- * <ul><pre>
+ * <pre>
  * ClassPool cp = ClassPool.getDefault();
  * cp.insertClassPath(new ByteArrayClassPath(classname, b));
  * CtClass cc = cp.get(classname);
- * </pre></ul>
+ * </pre>
  *
  * <p>The <code>ClassPool</code> object <code>cp</code> uses the created
  * <code>ByteArrayClassPath</code> object as the source of the class file.

src/main/javassist/ClassClassPath.java

  * with a user-defined class loader and any class files are not found with
  * the default <code>ClassPool</code>.  For example,
  *
- * <ul><pre>
+ * <pre>
  * ClassPool cp = ClassPool.getDefault();
  * cp.insertClassPath(new ClassClassPath(this.getClass()));
- * </pre></ul>
+ * </pre>
  *
  * This code snippet permanently adds a <code>ClassClassPath</code>
  * to the default <code>ClassPool</code>.  Note that the default

src/main/javassist/ClassMap.java

  * definition or a method body.  Define a subclass of this class
  * if a more complex mapping algorithm is needed.  For example,
  *
- * <ul><pre>class MyClassMap extends ClassMap {
+ * <pre>class MyClassMap extends ClassMap {
  *   public Object get(Object jvmClassName) {
  *     String name = toJavaName((String)jvmClassName);
  *     if (name.startsWith("java."))
  *     else
  *         return super.get(jvmClassName);
  *   }
- * }</pre></ul>
+ * }</pre>
  *
  * <p>This subclass maps <code>java.lang.String</code> to
  * <code>java2.lang.String</code>.  Note that <code>get()</code>

src/main/javassist/ClassPool.java

      * <p>When this method is called for the first time, the default
      * class pool is created with the following code snippet:
      *
-     * <ul><code>ClassPool cp = new ClassPool();
+     * <pre>ClassPool cp = new ClassPool();
      * cp.appendSystemPath();
-     * </code></ul>
+     * </pre>
      *
      * <p>If the default class pool cannot find any class files,
      * try <code>ClassClassPath</code> and <code>LoaderClassPath</code>.
      * This method is useful if you want to generate a new class as a copy
      * of another class (except the class name).  For example,
      *
-     * <ul><pre>
+     * <pre>
      * getAndRename("Point", "Pair")
-     * </pre></ul>
+     * </pre>
      *
      * returns a <code>CtClass</code> object representing <code>Pair</code>
      * class.  The definition of <code>Pair</code> is the same as that of

src/main/javassist/CodeConverter.java

  * <code>CtMethod.instrument()</code> as a parameter.
  *
  * <p>Example:
- * <ul><pre>
+ * <pre>
  * ClassPool cp = ClassPool.getDefault();
  * CtClass point = cp.get("Point");
  * CtClass singleton = cp.get("Singleton");
  * CodeConverter conv = new CodeConverter();
  * conv.replaceNew(point, singleton, "makePoint");
  * client.instrument(conv);
- * </pre></ul>
+ * </pre>
  *
  * <p>This program substitutes "<code>Singleton.makePoint()</code>"
  * for all occurrences of "<code>new Point()</code>"
      * <code>Singleton</code>, respectively)
      * replaces all occurrences of:
      *
-     * <ul><code>new Point(x, y)</code></ul>
+     * <pre>new Point(x, y)</pre>
      *
      * in the method body with:
      *
-     * <ul><code>Singleton.createPoint(x, y)</code></ul>
+     * <pre>Singleton.createPoint(x, y)</pre>
      *
      * <p>This enables to intercept instantiation of <code>Point</code>
      * and change the samentics.  For example, the following
      * <code>createPoint()</code> implements the singleton pattern:
      *
-     * <ul><pre>public static Point createPoint(int x, int y) {
+     * <pre>public static Point createPoint(int x, int y) {
      *     if (aPoint == null)
      *         aPoint = new Point(x, y);
      *     return aPoint;
      * }
-     * </pre></ul>
+     * </pre>
      *
      * <p>The static method call substituted for the original <code>new</code>
      * expression must be
      * <code>Point2</code>, respectively)
      * replaces all occurrences of:
      *
-     * <ul><code>new Point(x, y)</code></ul>
+     * <pre>new Point(x, y)</pre>
      *
      * in the method body with:
      *
-     * <ul><code>new Point2(x, y)</code></ul>
+     * <pre>new Point2(x, y)</pre>
      *
      * <p>Note that <code>Point2</code> must be type-compatible with <code>Point</code>.
      * It must have the same set of methods, fields, and constructors as the
      *
      * <p>For example, the program below
      *
-     * <ul><pre>Point p = new Point();
-     * int newX = p.x + 3;</pre></ul>
+     * <pre>Point p = new Point();
+     * int newX = p.x + 3;</pre>
      *
      * <p>can be translated into:
      *
-     * <ul><pre>Point p = new Point();
-     * int newX = Accessor.readX(p) + 3;</pre></ul>
+     * <pre>Point p = new Point();
+     * int newX = Accessor.readX(p) + 3;</pre>
      *
      * <p>where
      *
-     * <ul><pre>public class Accessor {
+     * <pre>public class Accessor {
      *     public static int readX(Object target) { ... }
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>The type of the parameter of <code>readX()</code> must
      * be <code>java.lang.Object</code> independently of the actual
      *
      * <p>For example, the program below
      *
-     * <ul><pre>Point p = new Point();
-     * p.x = 3;</pre></ul>
+     * <pre>Point p = new Point();
+     * p.x = 3;</pre>
      *
      * <p>can be translated into:
      *
-     * <ul><pre>Point p = new Point();
-     * Accessor.writeX(3);</pre></ul>
+     * <pre>Point p = new Point();
+     * Accessor.writeX(3);</pre>
      *
      * <p>where
      *
-     * <ul><pre>public class Accessor {
+     * <pre>public class Accessor {
      *     public static void writeX(Object target, int value) { ... }
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>The type of the first parameter of <code>writeX()</code> must
      * be <code>java.lang.Object</code> independently of the actual
      * method.  For example, if the originally invoked method is
      * <code>move()</code>:
      *
-     * <ul><pre>class Point {
+     * <pre>class Point {
      *     Point move(int x, int y) { ... }
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>Then the before method must be something like this:
      *
-     * <ul><pre>class Verbose {
+     * <pre>class Verbose {
      *     static void print(Point target, int x, int y) { ... }
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>The <code>CodeConverter</code> would translate bytecode
      * equivalent to:
      *
-     * <ul><pre>Point p2 = p.move(x + y, 0);</pre></ul>
+     * <pre>Point p2 = p.move(x + y, 0);</pre>
      *
      * <p>into the bytecode equivalent to:
      *
-     * <ul><pre>int tmp1 = x + y;
+     * <pre>int tmp1 = x + y;
      * int tmp2 = 0;
      * Verbose.print(p, tmp1, tmp2);
-     * Point p2 = p.move(tmp1, tmp2);</pre></ul>
+     * Point p2 = p.move(tmp1, tmp2);</pre>
      *
      * @param origMethod        the method originally invoked.
      * @param beforeMethod      the method invoked before
      * method.  For example, if the originally invoked method is
      * <code>move()</code>:
      *
-     * <ul><pre>class Point {
+     * <pre>class Point {
      *     Point move(int x, int y) { ... }
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>Then the after method must be something like this:
      *
-     * <ul><pre>class Verbose {
+     * <pre>class Verbose {
      *     static void print(Point target, int x, int y) { ... }
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>The <code>CodeConverter</code> would translate bytecode
      * equivalent to:
      *
-     * <ul><pre>Point p2 = p.move(x + y, 0);</pre></ul>
+     * <pre>Point p2 = p.move(x + y, 0);</pre>
      *
      * <p>into the bytecode equivalent to:
      *
-     * <ul><pre>int tmp1 = x + y;
+     * <pre>
+     * int tmp1 = x + y;
      * int tmp2 = 0;
      * Point p2 = p.move(tmp1, tmp2);
-     * Verbose.print(p, tmp1, tmp2);</pre></ul>
+     * Verbose.print(p, tmp1, tmp2);</pre>
      *
      * @param origMethod        the method originally invoked.
      * @param afterMethod       the method invoked after

src/main/javassist/CtClass.java

     /**
      * The version number of this release.
      */
-    public static final String version = "3.18.0-GA";
+    public static final String version = "3.19.0-GA";
 
     /**
      * Prints the version number and the copyright notice.
      *
      * <p>The following command invokes this method:
      *
-     * <ul><pre>java -jar javassist.jar</pre></ul>
+     * <pre>java -jar javassist.jar</pre>
      */
     public static void main(String[] args) {
         System.out.println("Javassist version " + CtClass.version);
-        System.out.println("Copyright (C) 1999-2013 Shigeru Chiba."
+        System.out.println("Copyright (C) 1999-2015 Shigeru Chiba."
                            + " All Rights Reserved.");
     }
 
      *
      * <p>For example,
      *
-     * <pre>class List<T> {
+     * <pre>class List&lt;T&gt; {
      *     T value;
      *     T get() { return value; }
      *     void set(T v) { value = v; }
      * Any regular Java expression can be used for specifying the initial
      * value.  The followings are examples.
      *
-     * <ul><pre>
+     * <pre>
      * cc.addField(f, "0")               // the initial value is 0.
      * cc.addField(f, "i + 1")           // i + 1.
      * cc.addField(f, "new Point()");    // a Point object.
-     * </pre></ul>
+     * </pre>
      *
      * <p>Here, the type of variable <code>cc</code> is <code>CtClass</code>.
      * The type of <code>f</code> is <code>CtField</code>.
      *
      * <p>For example,
      *
-     * <ul><pre>
+     * <pre>
      * CtClass cc = ...;
      * addField(new CtField(CtClass.intType, "i", cc),
      *          CtField.Initializer.constant(1));
-     * </pre></ul>
+     * </pre>
      *
      * <p>This code adds an <code>int</code> field named "i".  The
      * initial value of this field is 1.
      * <code>javassist.bytecode</code> package.  For example, the following
      * expression returns all the attributes of a class file.
      *
-     * <ul><pre>
+     * <pre>
      * getClassFile().getAttributes()
-     * </pre></ul>
+     * </pre>
      *
      * @param name              attribute name
      * @see javassist.bytecode.AttributeInfo
      * <code>javassist.bytecode</code> package.  For example, the following
      * expression adds an attribute <code>info</code> to a class file.
      *
-     * <ul><pre>
+     * <pre>
      * getClassFile().addAttribute(info)
-     * </pre></ul>
+     * </pre>
      *
      * @param name      attribute name
      * @param data      attribute value

src/main/javassist/CtField.java

      * Compiles the given source code and creates a field.
      * Examples of the source code are:
      *
-     * <ul><pre>
+     * <pre>
      * "public String name;"
-     * "public int k = 3;"</pre></ul>
+     * "public int k = 3;"</pre>
      *
      * <p>Note that the source code ends with <code>';'</code>
      * (semicolon).
          * value of the field.  The constructor of the created object receives
          * the parameter:
          *
-         * <ul><code>Object obj</code> - the object including the field.<br>
-         * </ul>
+         * <p><code>Object obj</code> - the object including the field.
          *
          * <p>If the initialized field is static, then the constructor does
          * not receive any parameters.
          * value of the field.  The constructor of the created object receives
          * the parameters:
          *
-         * <ul><code>Object obj</code> - the object including the field.<br>
+         * <p><code>Object obj</code> - the object including the field.<br>
          *     <code>String[] strs</code> - the character strings specified
          *                              by <code>stringParams</code><br>
-         * </ul>
          *
          * <p>If the initialized field is static, then the constructor
          * receives only <code>strs</code>.
          * value of the field.  The constructor of the created object receives
          * the parameters:
          *
-         * <ul><code>Object obj</code> - the object including the field.<br>
+         * <p><code>Object obj</code> - the object including the field.<br>
          *     <code>Object[] args</code> - the parameters passed to the
          *                      constructor of the object including the
          *                      filed.
-         * </ul>
          *
          * <p>If the initialized field is static, then the constructor does
          * not receive any parameters.
          * value of the field.  The constructor of the created object receives
          * the parameters:
          *
-         * <ul><code>Object obj</code> - the object including the field.<br>
+         * <p><code>Object obj</code> - the object including the field.<br>
          *     <code>String[] strs</code> - the character strings specified
          *                              by <code>stringParams</code><br>
          *     <code>Object[] args</code> - the parameters passed to the
          *                      constructor of the object including the
          *                      filed.
-         * </ul>
          *
          * <p>If the initialized field is static, then the constructor receives
          * only <code>strs</code>.
          * value as the initial value of the field.
          * The called method receives the parameters:
          *
-         * <ul><code>Object obj</code> - the object including the field.<br>
-         * </ul>
+         * <p><code>Object obj</code> - the object including the field.
          *
          * <p>If the initialized field is static, then the method does
          * not receive any parameters.
          * value as the initial value of the field.  The called method
          * receives the parameters:
          *
-         * <ul><code>Object obj</code> - the object including the field.<br>
+         * <p><code>Object obj</code> - the object including the field.<br>
          *     <code>String[] strs</code> - the character strings specified
          *                              by <code>stringParams</code><br>
-         * </ul>
          *
          * <p>If the initialized field is static, then the method
          * receive only <code>strs</code>.
          * value as the initial value of the field.  The called method
          * receives the parameters:
          *
-         * <ul><code>Object obj</code> - the object including the field.<br>
+         * <p><code>Object obj</code> - the object including the field.<br>
          *     <code>Object[] args</code> - the parameters passed to the
          *                      constructor of the object including the
          *                      filed.
-         * </ul>
          *
          * <p>If the initialized field is static, then the method does
          * not receive any parameters.
          * value as the initial value of the field.  The called method
          * receives the parameters:
          *
-         * <ul><code>Object obj</code> - the object including the field.<br>
+         * <p><code>Object obj</code> - the object including the field.<br>
          *     <code>String[] strs</code> - the character strings specified
          *                              by <code>stringParams</code><br>
          *     <code>Object[] args</code> - the parameters passed to the
          *                      constructor of the object including the
          *                      filed.
-         * </ul>
          *
          * <p>If the initialized field is static, then the method
          * receive only <code>strs</code>.

src/main/javassist/CtMethod.java

      * <p>For example, suppose that a method <code>at()</code> is as
      * follows:
      *
-     * <ul><pre>public X at(int i) {
+     * <pre>
+     * public X at(int i) {
      *     return (X)super.elementAt(i);
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>(<code>X</code> is a class name.)  If <code>map</code> substitutes
      * <code>String</code> for <code>X</code>, then the created method is:
      *
-     * <ul><pre>public String at(int i) {
+     * <pre>
+     * public String at(int i) {
      *     return (String)super.elementAt(i);
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>By default, all the occurrences of the names of the class
      * declaring <code>at()</code> and the superclass are replaced

src/main/javassist/CtNewConstructor.java

      * <code>Object</code>.  The signature of the super's constructor
      * must be:
      *
-     * <ul><code>constructor(Object[] params, &lt;type&gt; cvalue)
-     * </code></ul>
+     * <pre>constructor(Object[] params, &lt;type&gt; cvalue)
+     * </pre>
      *
      * <p>Here, <code>cvalue</code> is the constant value specified
      * by <code>cparam</code>.
      * <p>If <code>cparam</code> is <code>null</code>, the signature
      * must be:
      *
-     * <ul><code>constructor(Object[] params)</code></ul>
+     * <pre>constructor(Object[] params)</pre>
      *
      * <p>If <code>body</code> is not null, a copy of that method is
      * embedded in the body of the created constructor.
      * The method specified by <code>body</code> must have the
      * signature shown below:
      *
-     * <ul><code>Object method(Object[] params, &lt;type&gt; cvalue)
-     * </code></ul>
+     * <pre>Object method(Object[] params, &lt;type&gt; cvalue)</pre>
      *
      * <p>If <code>cparam</code> is <code>null</code>, the signature
      * must be:
      *
-     * <ul><code>Object method(Object[] params)</code></ul>
+     * <pre>Object method(Object[] params)</pre>
      *
      * <p>Although the type of the returned value is <code>Object</code>,
      * the value must be always <code>null</code>.
      *
      * <p><i>Example:</i>
      *
-     * <ul><pre>ClassPool pool = ... ;
+     * <pre>
+     * ClassPool pool = ... ;
      * CtClass xclass = pool.makeClass("X");
      * CtMethod method = pool.getMethod("Sample", "m");
      * xclass.setSuperclass(pool.get("Y"));
      * ConstParameter cparam = ConstParameter.string("test");
      * CtConstructor c = CtNewConstructor.make(argTypes, null,
      *                                  PASS_PARAMS, method, cparam, xclass);
-     * xclass.addConstructor(c);</pre></ul>
+     * xclass.addConstructor(c);</pre>
      *
      * <p>where the class <code>Sample</code> is as follows:
      *
-     * <ul><pre>public class Sample {
+     * <pre>
+     * public class Sample {
      *     public Object m(Object[] args, String msg) {
      *         System.out.println(msg);
      *         return null;
      *     }
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>This program produces the following class:
      *
-     * <ul><pre>public class X extends Y {
+     * <pre>
+     * public class X extends Y {
      *     public X(int p0) {
      *         super(p0);
      *         String msg = "test";
      *         Object result = null;
      *         // end
      *     }
-     * }</pre></ul>
+     * }</pre>
      *
      * @param parameters        a list of the parameter types
      * @param exceptions        a list of the exceptions

src/main/javassist/CtNewMethod.java

      * The source code must include not only the method body
      * but the whole declaration, for example,
      *
-     * <ul><pre>"public Object id(Object obj) { return obj; }"</pre></ul>
+     * <pre>"public Object id(Object obj) { return obj; }"</pre>
      *
      * @param src               the source text. 
      * @param declaring    the class to which the created method is added.
      * The source code must include not only the method body
      * but the whole declaration, for example,
      *
-     * <ul><pre>"public Object id(Object obj) { return obj; }"</pre></ul>
+     * <pre>"public Object id(Object obj) { return obj; }"</pre>
      *
      * <p>If the source code includes <code>$proceed()</code>, then
      * it is compiled into a method call on the specified object.
      *
      * <p>The following method is an example of the created method.
      *
-     * <ul><pre>int f(int p, int q) {
+     * <pre>
+     * int f(int p, int q) {
      *     return super.f(p, q);
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>The name of the created method can be changed by
      * <code>setName()</code>.
      *
      * <p>The method specified by <code>body</code> must have this singature:
      *
-     * <ul><code>Object method(Object[] params, &lt;type&gt; cvalue)
-     * </code></ul>
+     * <pre>Object method(Object[] params, &lt;type&gt; cvalue)</pre>
      *
      * <p>The type of the <code>cvalue</code> depends on
      * <code>constParam</code>.
      * If <code>constParam</code> is <code>null</code>, the signature
      * must be:
      *
-     * <ul><code>Object method(Object[] params)</code></ul>
+     * <pre>Object method(Object[] params)</pre>
      *
      * <p>The method body copied from <code>body</code> is wrapped in
      * parameter-conversion code, which converts parameters specified by
      * type to the type specified by <code>returnType</code>.  Thus,
      * the resulting method body is as follows:
      *
-     * <ul><pre>Object[] params = new Object[] { p0, p1, ... };
+     * <pre>
+     * Object[] params = new Object[] { p0, p1, ... };
      * &lt;<i>type</i>&gt; cvalue = &lt;<i>constant-value</i>&gt;;
      *  <i>... copied method body ...</i>
      * Object result = &lt;<i>returned value</i>&gt;
      * return (<i>&lt;returnType&gt;</i>)result;
-     * </pre></ul>
+     * </pre>
      *
      * <p>The variables <code>p0</code>, <code>p2</code>, ... represent
      * formal parameters of the created method.
      *
      * <p><i>Example:</i>
      *
-     * <ul><pre>ClassPool pool = ... ;
+     * <pre>
+     * ClassPool pool = ... ;
      * CtClass vec = pool.makeClass("intVector");
      * vec.setSuperclass(pool.get("java.util.Vector"));
      * CtMethod addMethod = pool.getMethod("Sample", "add0");
      * CtClass[] argTypes = { CtClass.intType };
      * CtMethod m = CtNewMethod.wrapped(CtClass.voidType, "add", argTypes,
      *                                  null, addMethod, null, vec);
-     * vec.addMethod(m);</pre></ul>
+     * vec.addMethod(m);</pre>
      *
      * <p>where the class <code>Sample</code> is as follows:
      *
-     * <ul><pre>public class Sample extends java.util.Vector {
+     * <pre>public class Sample extends java.util.Vector {
      *     public Object add0(Object[] args) {
      *         super.addElement(args[0]);
      *         return null;
      *     }
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>This program produces a class <code>intVector</code>:
      *
-     * <ul><pre>public class intVector extends java.util.Vector {
+     * <pre>public class intVector extends java.util.Vector {
      *     public void add(int p0) {
      *         Object[] args = new Object[] { p0 };
      *         // begin of the copied body
      *         Object result = null;
      *         // end
      *     }
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>Note that the type of the parameter to <code>add()</code> depends
      * only on the value of <code>argTypes</code> passed to

src/main/javassist/Loader.java

  * The startup program of an application using <code>MyTranslator</code>
  * should be something like this:
  *
- * <ul><pre>
+ * <pre>
  * import javassist.*;
  *
  * public class Main {
  *     cl.run("MyApp", args);
  *   }
  * }
- * </pre></ul>
+ * </pre>
  *
  * <p>Class <code>MyApp</code> is the main program of the application.
  *
  * <p>This program should be executed as follows:
  *
- * <ul><pre>
+ * <pre>
  * % java Main <i>arg1</i> <i>arg2</i>...
- * </pre></ul>
+ * </pre>
  *
  * <p>It modifies the class <code>MyApp</code> with a <code>MyTranslator</code>
  * object before the JVM loads it.
  *
  * <p>This program execution is equivalent to:
  *
- * <ul><pre>
+ * <pre>
  * % java MyApp <i>arg1</i> <i>arg2</i>...
- * </pre></ul>
+ * </pre>
  *
  * <p>except that classes are translated by <code>MyTranslator</code>
  * at load time.
  * unnecessary.  For example, if only a class <code>test.Rectangle</code>
  * is modified, the <code>main()</code> method above will be the following:
  *
- * <ul><pre>
+ * <pre>
  * ClassPool cp = ClassPool.getDefault();
  * Loader cl = new Loader(cp);
  * CtClass ct = cp.get("test.Rectangle");
  * ct.setSuperclass(cp.get("test.Point"));
- * cl.run("MyApp", args);</pre></ul>
+ * cl.run("MyApp", args);</pre>
  *
  * <p>This program changes the super class of the <code>test.Rectangle</code>
  * class.
      *
      * @param args              command line parameters.
      * <ul>
-     * <code>args[0]</code> is the class name to be loaded.
-     * <br><code>args[1..n]</code> are parameters passed
-     *                      to the target <code>main()</code>.
+     * {@code args[0]} is the class name to be loaded.
+     * <br>{@code args[1..n]} are parameters passed
+     *                      to the target {@code main()}.
      * </ul>
      *
      * @see javassist.Loader#run(String[])
      *
      * @param args              command line parameters.
      * <ul>
-     * <code>args[0]</code> is the class name to be loaded.
-     * <br><code>args[1..n]</code> are parameters passed
-     *                      to the target <code>main()</code>.
+     * {@code args[0]} is the class name to be loaded.
+     * <br>{@code args[1..n]} are parameters passed
+     *                      to the target {@code main()}.
      * </ul>
      */
     public void run(String[] args) throws Throwable {

src/main/javassist/Translator.java

      * Is invoked by a <code>Loader</code> for notifying that
      * a class is loaded.  The <code>Loader</code> calls
      *
-     * <ul><pre>
-     * pool.get(classname).toBytecode()</pre></ul>
+     * <pre>
+     * pool.get(classname).toBytecode()</pre>
      *
      * to read the class file after <code>onLoad()</code> returns.
      *

src/main/javassist/URLClassPath.java

      * "org.javassist.test.Main", then the given URL is used for loading that class.
      * The <code>URLClassPath</code> obtains a class file from:
      *
-     * <ul><pre>http://www.javassist.org:80/java/classes/org/javassist/test/Main.class
-     * </pre></ul>
+     * <pre>http://www.javassist.org:80/java/classes/org/javassist/test/Main.class
+     * </pre>
      *
      * <p>Here, we assume that <code>host</code> is "www.javassist.org",
      * <code>port</code> is 80, and <code>directory</code> is "/java/classes/".

src/main/javassist/bytecode/AnnotationDefaultAttribute.java

  *
  * <p>For example, if you declare the following annotation type:
  *
- * <ul><pre>
+ * <pre>
  * &#64;interface Author {
  *   String name() default "Shakespeare";
  *   int age() default 99;
  * }
- * </pre></ul>
+ * </pre>
  *
  * <p>The defautl values of <code>name</code> and <code>age</code>
  * are stored as annotation default attributes in <code>Author.class</code>.
  * The following code snippet obtains the default value of <code>name</code>:
  * 
- * <ul><pre>
+ * <pre>
  * ClassPool pool = ...
  * CtClass cc = pool.get("Author");
  * CtMethod cm = cc.getDeclaredMethod("age");
  *         = (AnnotationDefaultAttribute)
  *           minfo.getAttribute(AnnotationDefaultAttribute.tag);
  * MemberValue value = ada.getDefaultValue());    // default value of age
- * </pre></ul>
+ * </pre>
  *
  * <p>If the following statement is executed after the code above,
  * the default value of age is set to 80:
  *
- * <ul><pre>
+ * <pre>
  * ada.setDefaultValue(new IntegerMemberValue(minfo.getConstPool(), 80));
- * </pre></ul>
+ * </pre>
  *
  * @see AnnotationsAttribute
  * @see javassist.bytecode.annotation.MemberValue

src/main/javassist/bytecode/AnnotationsAttribute.java

  *
  * <p>For example,
  *
- * <ul><pre>
+ * <pre>
  * import javassist.bytecode.annotation.Annotation;
  *    :
  * CtMethod m = ... ;
  * Annotation an = attr.getAnnotation("Author");
  * String s = ((StringMemberValue)an.getMemberValue("name")).getValue();
  * System.out.println("@Author(name=" + s + ")");
- * </pre></ul>
+ * </pre>
  *
  * <p>This code snippet retrieves an annotation of the type <code>Author</code>
  * from the <code>MethodInfo</code> object specified by <code>minfo</code>.
  *
  * <p>If the annotation type <code>Author</code> is annotated by a meta annotation:
  *
- * <ul><pre>
+ * <pre>
  * &#64;Retention(RetentionPolicy.RUNTIME)
- * </pre></ul>
+ * </pre>
  *
  * <p>Then <code>Author</code> is visible at runtime.  Therefore, the third
  * statement of the code snippet above must be changed into:
  *
- * <ul><pre>
+ * <pre>
  * AnnotationsAttribute attr = (AnnotationsAttribute)
  *         minfo.getAttribute(AnnotationsAttribute.visibleTag);
- * </pre></ul>
+ * </pre>
  *
  * <p>The attribute tag must be <code>visibleTag</code> instead of
  * <code>invisibleTag</code>.
  * <p>If you want to record a new AnnotationAttribute object, execute the
  * following snippet:
  *
- * <ul><pre>
+ * <pre>
  * ClassFile cf = ... ;
  * ConstPool cp = cf.getConstPool();
  * AnnotationsAttribute attr
  * attr.setAnnotation(a);
  * cf.addAttribute(attr);
  * cf.setVersionToJava5();
- * </pre></ul>
+ * </pre>
  *
  * <p>The last statement is necessary if the class file was produced by
  * <code>javac</code> of JDK 1.4 or earlier.  Otherwise, it is not necessary.
 
     /**
      * Changes the annotations.  A call to this method is equivalent to:
-     * <ul><pre>setAnnotations(new Annotation[] { annotation })</pre></ul>
+     * <pre>setAnnotations(new Annotation[] { annotation })</pre>
      *
      * @param annotation    the data structure representing
      *                      the new annotation.

src/main/javassist/bytecode/Bytecode.java

  * <p>A <code>Bytecode</code> object is an unbounded array
  * containing bytecode.  For example,
  *
- * <ul><pre>ConstPool cp = ...;    // constant pool table
+ * <pre>
+ * ConstPool cp = ...;    // constant pool table
  * Bytecode b = new Bytecode(cp, 1, 0);
  * b.addIconst(3);
  * b.addReturn(CtClass.intType);
- * CodeAttribute ca = b.toCodeAttribute();</ul></pre>
+ * CodeAttribute ca = b.toCodeAttribute();</pre>
  *
  * <p>This program produces a Code attribute including a bytecode
  * sequence:
  *
- * <ul><pre>iconst_3
- * ireturn</pre></ul>
+ * <pre>
+ * iconst_3
+ * ireturn</pre>
  *
  * @see ConstPool
  * @see CodeAttribute

src/main/javassist/bytecode/ClassFile.java

      *
      * <p>The returned value is obtained from <code>inner_class_access_flags</code>
      * of the entry representing this nested class itself
-     * in <code>InnerClasses_attribute</code>>. 
+     * in <code>InnerClasses_attribute</code>. 
      */
     public int getInnerAccessFlags() {
         InnerClassesAttribute ica

src/main/javassist/bytecode/MethodInfo.java

     public static boolean doPreverify = false;
 
     /**
-     * The name of constructors: <code>&lt;init&gt</code>.
+     * The name of constructors: <code>&lt;init&gt;</code>.
      */
     public static final String nameInit = "<init>";
 
     /**
      * The name of class initializer (static initializer):
-     * <code>&lt;clinit&gt</code>.
+     * <code>&lt;clinit&gt;</code>.
      */
     public static final String nameClinit = "<clinit>";
 

src/main/javassist/bytecode/SignatureAttribute.java

 
         /**
          * Constructs a <code>TypeParameter</code> representing a type parametre
-         * like <code>&lt;T extends ... &gt;<code>.
+         * like <code>&lt;T extends ... &gt;</code>.
          *
          * @param name      parameter name.
          * @param superClass    an upper bound class-type (or null).
 
         /**
          * Constructs a <code>TypeParameter</code> representing a type parameter
-         * like <code>&lt;T&gt;<code>.
+         * like <code>&lt;T&gt;</code>.
          *
          * @param name          parameter name.
          */

src/main/javassist/bytecode/StackMapTable.java

          * 
          * @param pos               the position.
          * @param offsetDelta
-         * @param k                 the <cod>k</code> last locals are absent. 
+         * @param k                 the <code>k</code> last locals are absent. 
          */
         public void chopFrame(int pos, int offsetDelta, int k) throws BadBytecode {}
 
          * @param offsetDelta
          * @param tags          <code>locals[i].tag</code>.
          * @param data          <code>locals[i].cpool_index</code>
-         *                      or <cod>locals[i].offset</code>.
+         *                      or <code>locals[i].offset</code>.
          */
         public void appendFrame(int pos, int offsetDelta, int[] tags, int[] data)
             throws BadBytecode {} 
          * @param tag           <code>stack[0].tag</code>.
          * @param data          <code>stack[0].cpool_index</code>
          *                      if the tag is <code>OBJECT</code>,
-         *                      or <cod>stack[0].offset</code>
+         *                      or <code>stack[0].offset</code>
          *                      if the tag is <code>UNINIT</code>.
          *                      Otherwise, this parameter is not used.
          */
          *                      either 1, 2, or 3.
          * @param data          <code>locals[].cpool_index</code>
          *                      if the tag is <code>OBJECT</code>,
-         *                      or <cod>locals[].offset</code>
+         *                      or <code>locals[].offset</code>
          *                      if the tag is <code>UNINIT</code>.
          *                      Otherwise, this parameter is not used.
          */
          * @param localTags     <code>locals[].tag</code>.
          * @param localData     <code>locals[].cpool_index</code>
          *                      if the tag is <code>OBJECT</code>,
-         *                      or <cod>locals[].offset</code>
+         *                      or <code>locals[].offset</code>
          *                      if the tag is <code>UNINIT</code>.
          *                      Otherwise, this parameter is not used.
          * @param stackTags     <code>stack[].tag</code>.
          * @param stackData     <code>stack[].cpool_index</code>
          *                      if the tag is <code>OBJECT</code>,
-         *                      or <cod>stack[].offset</code>
+         *                      or <code>stack[].offset</code>
          *                      if the tag is <code>UNINIT</code>.
          *                      Otherwise, this parameter is not used.
          */

src/main/javassist/bytecode/TypeAnnotationsAttribute.java

  * A class representing
  * {@code RuntimeVisibleTypeAnnotations} attribute and
  * {@code RuntimeInvisibleTypeAnnotations} attribute.
+ *
+ * @since 3.19
  */
 public class TypeAnnotationsAttribute extends AttributeInfo {
     /**

src/main/javassist/bytecode/analysis/Analyzer.java

  * // Method to analyze
  * public Object doSomething(int x) {
  *     Number n;
- *     if (x < 5) {
+ *     if (x &lt; 5) {
  *        n = new Double(0);
  *     } else {
  *        n = new Long(0);

src/main/javassist/bytecode/annotation/AnnotationsWriter.java

  *
  * <p>The following code snippet is an example of use of this class:
  *
- * <ul><pre>
+ * <pre>
  * ConstPool pool = ...;
  * output = new ByteArrayOutputStream();
  * writer = new AnnotationsWriter(output, pool);
  * AnnotationsAttribute anno
  *     = new AnnotationsAttribute(pool, AnnotationsAttribute.visibleTag,
  *                                attribute_info);
- * </pre></ul>
+ * </pre>
  *
  * <p>The code snippet above generates the annotation attribute
  * corresponding to this annotation:
  *
- * <ul><pre>
+ * <pre>
  * &nbsp;@Author(name = "chiba", address = "tokyo")
- * </pre></ul>
+ * </pre>
  *
  * @see javassist.bytecode.AnnotationsAttribute
  * @see javassist.bytecode.ParameterAnnotationsAttribute

src/main/javassist/bytecode/annotation/TypeAnnotationsWriter.java

  * A convenience class for constructing a
  * {@code ..TypeAnnotations_attribute}.
  * See the source code of the {@link javassist.bytecode.TypeAnnotationsAttribute} class.
+ *
+ * @since 3.19
  */
 public class TypeAnnotationsWriter extends AnnotationsWriter {
     /**

src/main/javassist/expr/ExprEditor.java

  *
  * <p>The following code is an example:
  *
- * <ul><pre>
+ * <pre>
  * CtMethod cm = ...;
  * cm.instrument(new ExprEditor() {
  *     public void edit(MethodCall m) throws CannotCompileException {
  *                                + m.getLineNumber());
  *     }
  * });
- * </pre></ul>
+ * </pre>
  *
  * <p>This code inspects all method calls appearing in the method represented
  * by <code>cm</code> and it prints the names and the line numbers of the

src/main/javassist/runtime/Desc.java

      * Specifies how a <code>java.lang.Class</code> object is loaded.
      *
      * <p>If true, it is loaded by:
-     * <ul><pre>Thread.currentThread().getContextClassLoader().loadClass()</pre></ul>
+     * <pre>Thread.currentThread().getContextClassLoader().loadClass()</pre>
      * <p>If false, it is loaded by <code>Class.forName()</code>.
      * The default value is false.
      */

src/main/javassist/tools/Dump.java

  * the class file is broken.
  *
  * <p>For example,
- * <ul><pre>% java javassist.tools.Dump foo.class</pre></ul>
+ * <pre>% java javassist.tools.Dump foo.class</pre>
  *
  * <p>prints the contents of the constant pool and the list of methods
  * and fields.

src/main/javassist/tools/framedump.java

  *  of all methods in a class.
  *
  * <p>For example,
- * <ul><pre>% java javassist.tools.framedump foo.class</pre></ul>
+ * <pre>% java javassist.tools.framedump foo.class</pre>
  */
 public class framedump {
     private framedump() {}

src/main/javassist/tools/reflect/ClassMetaobject.java

  * <p>To obtain a class metaobject, calls <code>_getClass()</code>
  * on a reflective object.  For example,
  *
- * <ul><pre>ClassMetaobject cm = ((Metalevel)reflectiveObject)._getClass();
- * </pre></ul>
+ * <pre>ClassMetaobject cm = ((Metalevel)reflectiveObject)._getClass();
+ * </pre>
  *
  * @see javassist.tools.reflect.Metaobject
  * @see javassist.tools.reflect.Metalevel
      * Specifies how a <code>java.lang.Class</code> object is loaded.
      *
      * <p>If true, it is loaded by:
-     * <ul><pre>Thread.currentThread().getContextClassLoader().loadClass()</pre></ul>
+     * <pre>Thread.currentThread().getContextClassLoader().loadClass()</pre>
      * <p>If false, it is loaded by <code>Class.forName()</code>.
      * The default value is false.
      */
      * original name.
      *
      * <p>This method is useful, in conjuction with
-     * <link>ClassMetaobject#getMethod()</link>, to obtain a quick reference
+     * {@link ClassMetaobject#getMethod()}, to obtain a quick reference
      * to the original method in the reflected class (i.e. not the proxy
      * method), using the original name of the method.
      *

src/main/javassist/tools/reflect/Compiler.java

  * by that class name is not reflective.
  * 
  * <p>For example,
- * <ul><pre>% java Compiler Dog -m MetaDog -c CMetaDog Cat -m MetaCat Cow
- * </pre></ul>
+ * <pre>% java Compiler Dog -m MetaDog -c CMetaDog Cat -m MetaCat Cow
+ * </pre>
  *
  * <p>modifies class files <code>Dog.class</code>, <code>Cat.class</code>,
  * and <code>Cow.class</code>.

src/main/javassist/tools/reflect/Loader.java

  * including a reflective class,
  * you must write a start-up program as follows:
  *
- * <ul><pre>
+ * <pre>
  * public class Main {
  *   public static void main(String[] args) throws Throwable {
  *     javassist.tools.reflect.Loader cl
  *     cl.run("MyApp", args);
  *   }
  * }
- * </pre></ul>
+ * </pre>
  *
  * <p>Then run this program as follows:
  *
- * <ul><pre>% java javassist.tools.reflect.Loader Main arg1, ...</pre></ul>
+ * <pre>% java javassist.tools.reflect.Loader Main arg1, ...</pre>
  *
  * <p>This command runs <code>Main.main()</code> with <code>arg1</code>, ...
  * and <code>Main.main()</code> runs <code>MyApp.main()</code> with
  *
  * <p>Also, you can run <code>MyApp</code> in a slightly different way:
  *
- * <ul><pre>
+ * <pre>
  * public class Main2 {
  *   public static void main(String[] args) throws Throwable {
  *     javassist.tools.reflect.Loader cl = new javassist.tools.reflect.Loader();
  *     cl.run("MyApp", args);
  *   }
  * }
- * </pre></ul>
+ * </pre>
  *
  * <p>This program is run as follows:
  *
- * <ul><pre>% java Main2 arg1, ...</pre></ul>
+ * <pre>% java Main2 arg1, ...</pre>
  *
  * <p>The difference from the former one is that the class <code>Main</code>
  * is loaded by <code>javassist.tools.reflect.Loader</code> whereas the class
  *
  * <p>The class <code>Main2</code> is equivalent to this class:
  *
- * <ul><pre>
+ * <pre>
  * public class Main3 {
  *   public static void main(String[] args) throws Throwable {
  *     Reflection reflection = new Reflection();
  *     cl.run("MyApp", args);
  *   }
  * }
- * </pre></ul>
+ * </pre>
  *
  * <p><b>Note:</b>
  *

src/main/javassist/tools/reflect/Metaobject.java

  * <p>To obtain a metaobject, calls <code>_getMetaobject()</code>
  * on a reflective object.  For example,
  *
- * <ul><pre>Metaobject m = ((Metalevel)reflectiveObject)._getMetaobject();
- * </pre></ul>
+ * <pre>
+ * Metaobject m = ((Metalevel)reflectiveObject)._getMetaobject();
+ * </pre>
  *
  * @see javassist.tools.reflect.ClassMetaobject
  * @see javassist.tools.reflect.Metalevel
      * <p>Note: this method is not invoked if the base-level method
      * is invoked by a constructor in the super class.  For example,
      *
-     * <ul><pre>abstract class A {
+     * <pre>
+     * abstract class A {
      *   abstract void initialize();
      *   A() {
      *       initialize();    // not intercepted
      *       super();
      *       initialize();    // intercepted
      *   }
-     * }</pre></ul>
+     * }</pre>
      *
      * <p>if an instance of B is created,
      * the invocation of initialize() in B is intercepted only once.

src/main/javassist/tools/reflect/Reflection.java

  *
  * <p>To do this, the original class file representing a reflective class:
  *
- * <ul><pre>
+ * <pre>
  * class Person {
  *   public int f(int i) { return i + 1; }
  *   public int value;
  * }
- * </pre></ul>
+ * </pre>
  *
  * <p>is modified so that it represents a class:
  *
- * <ul><pre>
+ * <pre>
  * class Person implements Metalevel {
  *   public int _original_f(int i) { return i + 1; }
  *   public int f(int i) { <i>delegate to the metaobject</i> }
  *   public Metaobject _getMetaobject() { <i>return a metaobject</i> }
  *   public void _setMetaobject(Metaobject m) { <i>change a metaobject</i> }
  * }
- * </pre></ul>
+ * </pre>
  *
  * @see javassist.tools.reflect.ClassMetaobject
  * @see javassist.tools.reflect.Metaobject

src/main/javassist/tools/rmi/ObjectImporter.java

      * <p>If you run a program with <code>javassist.tools.web.Viewer</code>,
      * you can construct an object importer as follows:
      *
-     * <ul><pre>
+     * <pre>
      * Viewer v = (Viewer)this.getClass().getClassLoader();
      * ObjectImporter oi = new ObjectImporter(v.getServer(), v.getPort());
-     * </pre></ul>
+     * </pre>
      *
      * @see javassist.tools.web.Viewer
      */

src/main/javassist/tools/rmi/StubGenerator.java

  *
  * <p>The proxy class for class A is as follows:
  *
- * <ul><pre>public class A implements Proxy, Serializable {
+ * <pre>public class A implements Proxy, Serializable {
  *   private ObjectImporter importer;
  *   private int objectId;
  *   public int _getObjectId() { return objectId; }
  *   }
  *
  *   ... the same methods that the original class A declares ...
- * }</pre></ul>
+ * }</pre>
  *
  * <p>Instances of the proxy class is created by an
  * <code>ObjectImporter</code> object.

src/main/javassist/tools/web/Viewer.java

  *
  * <p>To run, you should type:
  *
- * <ul><code>% java javassist.tools.web.Viewer <i>host port</i> Main arg1, ...</code></ul>
+ * <pre>% java javassist.tools.web.Viewer <i>host port</i> Main arg1, ...</pre>
  *
  * <p>This command calls <code>Main.main()</code> with <code>arg1,...</code>
  * All classes including <code>Main</code> are fetched from
  * a program loaded by this object can call a method in <code>Viewer</code>.
  * For example, you can write something like this:
  *
- * <ul><pre>
+ * <pre>
  * Viewer v = (Viewer)this.getClass().getClassLoader();
  * String port = v.getPort();
- * </pre></ul>
+ * </pre>
  *
  */
 public class Viewer extends ClassLoader {

src/main/javassist/util/HotSwapper.java

 
 /**
  * A utility class for dynamically reloading a class by
- * the Java Platform Debugger Architecture (JPDA), or <it>HotSwap</code>.
+ * the Java Platform Debugger Architecture (JPDA), or <i>HotSwap</i>.
  * It works only with JDK 1.4 and later.
  *
  * <p><b>Note:</b> The new definition of the reloaded class must declare
  * <p>To use this class, the JVM must be launched with the following
  * command line options:
  *
- * <ul>
  * <p>For Java 1.4,<br>
  * <pre>java -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000</pre>
  * <p>For Java 5,<br>
  * <pre>java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8000</pre>
- * </ul>
  *
  * <p>Note that 8000 is the port number used by <code>HotSwapper</code>.
  * Any port number can be specified.  Since <code>HotSwapper</code> does not
  *
  * <p>Using <code>HotSwapper</code> is easy.  See the following example:
  *
- * <ul><pre>
+ * <pre>
  * CtClass clazz = ...
  * byte[] classFile = clazz.toBytecode();
  * HotSwapper hs = new HostSwapper(8000);  // 8000 is a port number.
  * hs.reload("Test", classFile);
- * </pre></ul>
+ * </pre>
  *
  * <p><code>reload()</code>
  * first unload the <code>Test</code> class and load a new version of

src/main/javassist/util/proxy/ProxyFactory.java

  *
  * <p>For example, if the following code is executed,
  * 
- * <ul><pre>
+ * <pre>
  * ProxyFactory f = new ProxyFactory();
  * f.setSuperclass(Foo.class);
  * f.setFilter(new MethodFilter() {
  * };
  * Foo foo = (Foo)c.newInstance();
  * ((Proxy)foo).setHandler(mi);
- * </pre></ul>
+ * </pre>
  *
  * <p>Here, <code>Method</code> is <code>java.lang.reflect.Method</code>.</p>
  *
  * <code>mi</code> and prints a message before executing the originally called method
  * <code>bar()</code> in <code>Foo</code>.
  *
- * <ul><pre>
+ * <pre>
  * foo.bar();
- * </pre></ul>
+ * </pre>
  *
  * <p>The last three lines of the code shown above can be replaced with a call to
  * the helper method <code>create</code>, which generates a proxy class, instantiates
  * it, and sets the method handler of the instance:
  *
- * <ul><pre>
+ * <pre>
  *     :
  * Foo foo = (Foo)f.create(new Class[0], new Object[0], mi);
- * </pre></ul>
+ * </pre>
  *
  * <p>To change the method handler during runtime,
  * execute the following code:
  *
- * <ul><pre>
+ * <pre>
  * MethodHandler mi = ... ;    // alternative handler
  * ((Proxy)foo).setHandler(mi);
- * </pre></ul>
+ * </pre>
  *
  * <p> If setHandler is never called for a proxy instance then it will
  * employ the default handler which proceeds by invoking the original method.
  * The behaviour of the default handler is identical to the following
  * handler:
  *
- * <ul><pre>
+ * <pre>
  * class EmptyHandler implements MethodHandler {
  *     public Object invoke(Object self, Method m,
  *                          Method proceed, Object[] args) throws Exception {
  *         return proceed.invoke(self, args);
  *     }
  * }
- * </pre></ul>
+ * </pre>
  *
  * <p>A proxy factory caches and reuses proxy classes by default. It is possible to reset
  * this default globally by setting static field {@link ProxyFactory#useCache} to false.
      * implementation.
      *
      * <p>Example:
-     * <ul><pre>
+     * <pre>
      * ProxyFactory.classLoaderProvider = new ProxyFactory.ClassLoaderProvider() {
      *     public ClassLoader get(ProxyFactory pf) {
      *         return Thread.currentThread().getContextClassLoader();
      *     }
      * };
-     * </pre></ul>
+     * </pre>
      *
      * @since 3.4
      */