Fix incorrect HTML entities in javadoc comments

18 files changed, 48 insertions, 48 deletions

diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/AjcMemberMaker.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/AjcMemberMaker.java
index 1ba711baa..487087604 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/AjcMemberMaker.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/AjcMemberMaker.java
@@ -238,7 +238,7 @@ public class AjcMemberMaker {
 	}
 
 	/**
-	 * Return a resolvedmember representing the synthetic getter for the field. The old style (<1.6.9) is a heavyweight static
+	 * Return a resolvedmember representing the synthetic getter for the field. The old style (&lt;1.6.9) is a heavyweight static
 	 * method with a long name. The new style (1.6.9 and later) is short, and reusable across aspects.
 	 * 
 	 * @param aspectType the aspect attempting the access
@@ -272,7 +272,7 @@ public class AjcMemberMaker {
 	}
 
 	/**
-	 * Return a resolvedmember representing the synthetic setter for the field. The old style (<1.6.9) is a heavyweight static
+	 * Return a resolvedmember representing the synthetic setter for the field. The old style (&lt;1.6.9) is a heavyweight static
 	 * method with a long name. The new style (1.6.9 and later) is short, not always static, and reusable across aspects.
 	 * 
 	 * @param aspectType the aspect attempting the access
@@ -566,8 +566,8 @@ public class AjcMemberMaker {
 	}
 
 	/**
-	 * Sometimes the intertyped method requires a bridge method alongside it. For example if the method 'N SomeI<N>.m()' is put onto
-	 * an interface 'interface I<N extends Number>' and then a concrete implementation is 'class C implements I<Float>' then the ITD
+	 * Sometimes the intertyped method requires a bridge method alongside it. For example if the method 'N SomeI&lt;N&gt;.m()' is put onto
+	 * an interface 'interface I&lt;N extends Number&gt;' and then a concrete implementation is 'class C implements I&lt;Float&gt;' then the ITD
 	 * on the interface will be 'Number m()', whereas the ITD on the 'topmostimplementor' will be 'Float m()'. A bridge method needs
 	 * to be created in the topmostimplementor 'Number m()' that delegates to 'Float m()'
 	 */
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ConcreteTypeMunger.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ConcreteTypeMunger.java
index 81cf351a9..b8f344f2e 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ConcreteTypeMunger.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ConcreteTypeMunger.java
@@ -107,16 +107,16 @@ public abstract class ConcreteTypeMunger implements PartialOrder.PartialComparab
 	}
 
 	/**
-	 * returns true if the ITD target type used type variables, for example I<T>. When they are specified like this, the ITDs
+	 * returns true if the ITD target type used type variables, for example I&lt;T&gt;. When they are specified like this, the ITDs
 	 * 'share' type variables with the generic type. Usually this method is called because we need to know whether to tailor the
 	 * munger for addition to a particular type. For example: <code>
-	 *   interface I<T> {}
+	 *   interface I&lt;T&gt; {}
 	 *   
-	 *   aspect X implements I<String> {
-	 *     List<T> I<T>.foo { return null; }
+	 *   aspect X implements I&lt;String&gt; {
+	 *     List&lt;T&gt; I&lt;T&gt;.foo { return null; }
 	 *   }
 	 * </code> In this case the munger matches X but it matches with the form <code>
-	 *   List<String> foo() { return null; }
+	 *   List&lt;String&gt; foo() { return null; }
 	 * </code>
 	 */
 	public boolean isTargetTypeParameterized() {
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/MemberImpl.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/MemberImpl.java
index d7bd742b8..8414c5707 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/MemberImpl.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/MemberImpl.java
@@ -98,7 +98,7 @@ public class MemberImpl implements Member {
 	// ---- utility methods
 
 	/**
-	 * Build a signature based on the return type and parameter types. For example: "(Ljava/util/Set<Ljava/lang/String;>;)V" or
+	 * Build a signature based on the return type and parameter types. For example: "(Ljava/util/Set&lt;Ljava/lang/String;&gt;;)V" or
 	 * "(Ljava/util/Set;)V". The latter form shows what happens when the generics are erased
 	 */
 	public static String typesToSignature(UnresolvedType returnType, UnresolvedType[] paramTypes, boolean eraseGenerics) {
@@ -121,7 +121,7 @@ public class MemberImpl implements Member {
 	}
 
 	/**
-	 * Returns "(<signaturesOfParamTypes>,...)" - unlike the other typesToSignature that also includes the return type, this one
+	 * Returns "(&lt;signaturesOfParamTypes&gt;,...)" - unlike the other typesToSignature that also includes the return type, this one
 	 * just deals with the parameter types.
 	 */
 	public static String typesToSignature(UnresolvedType[] paramTypes) {
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/NameMangler.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/NameMangler.java
index a2b2f5d1c..f696551f9 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/NameMangler.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/NameMangler.java
@@ -114,8 +114,8 @@ public class NameMangler {
 	}
 
 	/**
-	 * Create the old style (<1.6.9) format getter name which includes the aspect requesting access and the type containing the
-	 * field in the name of the type. At 1.6.9 and above the name is simply ajc$get$<fieldname>
+	 * Create the old style (&lt;1.6.9) format getter name which includes the aspect requesting access and the type containing the
+	 * field in the name of the type. At 1.6.9 and above the name is simply ajc$get$&lt;fieldname&gt;
 	 */
 	public static String privilegedAccessMethodForFieldGet(String name, UnresolvedType objectType, UnresolvedType aspectType) {
 		StringBuilder nameBuilder = new StringBuilder();
@@ -124,8 +124,8 @@ public class NameMangler {
 	}
 
 	/**
-	 * Create the old style (<1.6.9) format setter name which includes the aspect requesting access and the type containing the
-	 * field in the name of the type. At 1.6.9 and above the name is simply ajc$set$<fieldname>
+	 * Create the old style (&lt;1.6.9) format setter name which includes the aspect requesting access and the type containing the
+	 * field in the name of the type. At 1.6.9 and above the name is simply ajc$set$&lt;fieldname&gt;
 	 */
 	public static String privilegedAccessMethodForFieldSet(String name, UnresolvedType objectType, UnresolvedType aspectType) {
 		return makeName("privFieldSet", aspectType.getNameAsIdentifier(), objectType.getNameAsIdentifier(), name);
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/PrivilegedAccessMunger.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/PrivilegedAccessMunger.java
index 3acbf9b4b..b09757ec9 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/PrivilegedAccessMunger.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/PrivilegedAccessMunger.java
@@ -20,7 +20,7 @@ import java.io.IOException;
  * 
  * There are two syntax styles for field access, the older style was in use up to AspectJ 1.6.9 and involves long named getters and
  * setters which include the requesting aspect and the target type. The short style syntax is use from AspectJ 1.6.9 onwards is
- * simply 'ajc$get$<fieldname>' and 'ajc$set$<fieldname>' - as the requesting aspect isn't included in the name they can be shared
+ * simply 'ajc$get$&lt;fieldname&gt;' and 'ajc$set$&lt;fieldname&gt;' - as the requesting aspect isn't included in the name they can be shared
  * across aspects.
  */
 public class PrivilegedAccessMunger extends ResolvedTypeMunger {
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedMemberImpl.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedMemberImpl.java
index 6a12cdd11..7cd7e34cf 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedMemberImpl.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedMemberImpl.java
@@ -462,8 +462,8 @@ public class ResolvedMemberImpl extends MemberImpl implements IHasPosition, Reso
 	}
 
 	/**
-	 * Return the member generic signature that would be suitable for inclusion in a class file Signature attribute. For: <T>
-	 * List<String> getThem(T t) {} we would create: <T:Ljava/lang/Object;>(TT;)Ljava/util/List<Ljava/lang/String;>;;
+	 * Return the member generic signature that would be suitable for inclusion in a class file Signature attribute. For: &lt;T&gt;
+	 * List&lt;String&gt; getThem(T t) {} we would create: &lt;T:Ljava/lang/Object;&gt;(TT;)Ljava/util/List&lt;Ljava/lang/String;&gt;;;
 	 * 
 	 * @return the generic signature for the member that could be inserted into a class file
 	 */
@@ -744,8 +744,8 @@ public class ResolvedMemberImpl extends MemberImpl implements IHasPosition, Reso
 
 	/**
 	 * Return a resolvedmember in which all the type variables in the signature have been replaced with the given bindings. The
-	 * 'isParameterized' flag tells us whether we are creating a raw type version or not. if (isParameterized) then List<T> will
-	 * turn into List<String> (for example) - if (!isParameterized) then List<T> will turn into List.
+	 * 'isParameterized' flag tells us whether we are creating a raw type version or not. if (isParameterized) then List&lt;T&gt; will
+	 * turn into List&lt;String&gt; (for example) - if (!isParameterized) then List&lt;T&gt; will turn into List.
 	 */
 	public ResolvedMemberImpl parameterizedWith(UnresolvedType[] typeParameters, ResolvedType newDeclaringType,
 			boolean isParameterized, List<String> aliases) {
@@ -805,7 +805,7 @@ public class ResolvedMemberImpl extends MemberImpl implements IHasPosition, Reso
 
 	/**
 	 * Replace occurrences of type variables in the signature with values contained in the map. The map is of the form
-	 * A=String,B=Integer and so a signature List<A> Foo.m(B i) {} would become List<String> Foo.m(Integer i) {}
+	 * A=String,B=Integer and so a signature List&lt;A&gt; Foo.m(B i) {} would become List&lt;String&gt; Foo.m(Integer i) {}
 	 */
 	public ResolvedMember parameterizedWith(Map<String, UnresolvedType> m, World w) {
 		// if (//isParameterized && <-- might need this bit...
@@ -926,8 +926,8 @@ public class ResolvedMemberImpl extends MemberImpl implements IHasPosition, Reso
 	}
 
 	/**
-	 * If this member is defined by a parameterized super-type, return the erasure of that member. For example: interface I<T> { T
-	 * foo(T aTea); } class C implements I<String> { String foo(String aString) { return "something"; } } The resolved member for
+	 * If this member is defined by a parameterized super-type, return the erasure of that member. For example: interface I&lt;T&gt; { T
+	 * foo(T aTea); } class C implements I&lt;String&gt; { String foo(String aString) { return "something"; } } The resolved member for
 	 * C.foo has signature String foo(String). The erasure of that member is Object foo(Object) -- use upper bound of type variable.
 	 * A type is a supertype of itself.
 	 */
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedType.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedType.java
index 9a322d98f..b78f855a5 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedType.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedType.java
@@ -690,7 +690,7 @@ public abstract class ResolvedType extends UnresolvedType implements AnnotatedEl
 	/**
 	 * Do the two members conflict?  Due to the change in 1.7.1, field itds on interfaces now act like 'default' fields - so types implementing
 	 * those fields get the field if they don't have it already, otherwise they keep what they have.  The conflict detection below had to be
-	 * altered.  Previously (<1.7.1) it is not a conflict if the declaring types are different.  With v2itds it may still be a conflict if the
+	 * altered.  Previously (&lt;1.7.1) it is not a conflict if the declaring types are different.  With v2itds it may still be a conflict if the
 	 * declaring types are different.
 	 */
 	public static boolean conflictingSignature(Member m1, Member m2, boolean v2itds) {
@@ -1657,8 +1657,8 @@ public abstract class ResolvedType extends UnresolvedType implements AnnotatedEl
 	/**
 	 * Called for all type mungers but only does something if they share type variables with a generic type which they target. When
 	 * this happens this routine will check for the target type in the target hierarchy and 'bind' any type parameters as
-	 * appropriate. For example, for the ITD "List<T> I<T>.x" against a type like this: "class A implements I<String>" this routine
-	 * will return a parameterized form of the ITD "List<String> I.x"
+	 * appropriate. For example, for the ITD "List&lt;T&gt; I&lt;T&gt;.x" against a type like this: "class A implements I&lt;String&gt;" this routine
+	 * will return a parameterized form of the ITD "List&lt;String&gt; I.x"
 	 */
 	public ConcreteTypeMunger fillInAnyTypeParameters(ConcreteTypeMunger munger) {
 		boolean debug = false;
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedTypeMunger.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedTypeMunger.java
index c5b5645fe..3614d45bb 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedTypeMunger.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/ResolvedTypeMunger.java
@@ -414,7 +414,7 @@ public abstract class ResolvedTypeMunger {
 
 	/**
 	 * return true if type variables are specified with the target type for this ITD. e.g. this would return true:
-	 * "int I<A,B>.m() { return 42; }"
+	 * "int I&lt;A,B&gt;.m() { return 42; }"
 	 */
 	public boolean sharesTypeVariablesWithGenericType() {
 		return (typeVariableAliases != null && typeVariableAliases.size() > 0);
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/TypeFactory.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/TypeFactory.java
index 72163e024..74afc6cae 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/TypeFactory.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/TypeFactory.java
@@ -358,7 +358,7 @@ public class TypeFactory {
 
 	/**
 	 * Create a signature then delegate to the other factory method. Same input/output: baseTypeSignature="LSomeType;" arguments[0]=
-	 * something with sig "Pcom/Foo<Ljava/lang/String;>;" signature created = "PSomeType<Pcom/Foo<Ljava/lang/String;>;>;"
+	 * something with sig "Pcom/Foo&lt;Ljava/lang/String;&gt;;" signature created = "PSomeType&lt;Pcom/Foo&lt;Ljava/lang/String;&gt;;&gt;;"
 	 */
 	public static UnresolvedType createUnresolvedParameterizedType(String baseTypeSignature, UnresolvedType[] arguments) {
 		StringBuffer parameterizedSig = new StringBuffer();
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/WeaverStateInfo.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/WeaverStateInfo.java
index 62158cb9a..ed7043eb4 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/WeaverStateInfo.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/WeaverStateInfo.java
@@ -34,9 +34,9 @@ import org.aspectj.weaver.AjAttribute.WeaverVersionInfo;
  * whether reweaving is allowed. The format in the data stream is:
  * 
  * Byte: Kind. UNTOUCHED|WOVEN|EXTENDED - If extended it can have two extra bits set 'REWEAVABLE' and 'REWEAVABLE_COMPRESSION_BIT'
- * Short: typeMungerCount - how many type mungers have affected this type <UnresolvedType & ResolvedTypeMunger>: The type mungers
+ * Short: typeMungerCount - how many type mungers have affected this type &lt;UnresolvedType &amp; ResolvedTypeMunger&gt;: The type mungers
  * themselves If we are reweavable then we also have: Short: Number of aspects that touched this type in some way when it was
- * previously woven <String> The fully qualified name of each type Int: Length of class file data (i.e. the unwovenclassfile)
+ * previously woven &lt;String&gt; The fully qualified name of each type Int: Length of class file data (i.e. the unwovenclassfile)
  * Byte[]: The class file data, compressed if REWEAVABLE_COMPRESSION_BIT set.
  * 
  * @author Andy Clement
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/AndTypePattern.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/AndTypePattern.java
index 781a5881a..f8b476e1a 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/AndTypePattern.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/AndTypePattern.java
@@ -24,7 +24,7 @@ import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 
 /**
- * left && right
+ * left &amp;&amp; right
  * 
  * <p>
  * any binding to formals is explicitly forbidden for any composite by the language
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/AnnotationTypePattern.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/AnnotationTypePattern.java
index 82fb33854..a2fcab87c 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/AnnotationTypePattern.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/AnnotationTypePattern.java
@@ -31,7 +31,7 @@ public abstract class AnnotationTypePattern extends PatternNode {
 	private boolean isForParameterAnnotationMatch;
 
 	/**
-	 * TODO: write, read, equals & hashCode both in annotation hierarchy and in altered TypePattern hierarchy
+	 * TODO: write, read, equals &amp; hashCode both in annotation hierarchy and in altered TypePattern hierarchy
 	 */
 	protected AnnotationTypePattern() {
 		super();
@@ -155,4 +155,4 @@ class EllipsisAnnotationTypePattern extends AnnotationTypePattern {
 	public void setForParameterAnnotationMatch() {
 	}
 
-}
\ No newline at end of file
+}
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/DeclareErrorOrWarning.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/DeclareErrorOrWarning.java
index 0a46fa1e9..8251644ae 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/DeclareErrorOrWarning.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/DeclareErrorOrWarning.java
@@ -33,7 +33,7 @@ public class DeclareErrorOrWarning extends Declare {
 	}
 
 	/**
-	 * returns "declare warning: <message>" or "declare error: <message>"
+	 * returns "declare warning: &lt;message&gt;" or "declare error: &lt;message&gt;"
 	 */
 	public String toString() {
 		StringBuffer buf = new StringBuffer();
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/DeclareTypeErrorOrWarning.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/DeclareTypeErrorOrWarning.java
index daaf84496..9ac12de48 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/DeclareTypeErrorOrWarning.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/DeclareTypeErrorOrWarning.java
@@ -38,7 +38,7 @@ public class DeclareTypeErrorOrWarning extends Declare {
 	}
 
 	/**
-	 * returns "declare warning: <typepattern>: <message>" or "declare error: <typepattern>: <message>"
+	 * returns "declare warning: &lt;typepattern&gt;: &lt;message&gt;" or "declare error: &lt;typepattern&gt;: &lt;message&gt;"
 	 */
 	public String toString() {
 		StringBuffer buf = new StringBuffer();
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/PatternParser.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/PatternParser.java
index c329ba88e..f7ffafdf4 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/PatternParser.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/PatternParser.java
@@ -1049,7 +1049,7 @@ public class PatternParser {
 	}
 
 	/**
-	 * Attempt to parse a typeIs(<category>) construct. If it cannot be parsed we just return null and that should cause the caller
+	 * Attempt to parse a typeIs(&lt;category&gt;) construct. If it cannot be parsed we just return null and that should cause the caller
 	 * to reset their position and attempt to consume it in another way. This means we won't have problems here: execution(*
 	 * typeIs(..)) because someone has decided to call a method the same as our construct.
 	 * 
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/PerThisOrTargetPointcutVisitor.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/PerThisOrTargetPointcutVisitor.java
index 0020cefdc..b5d4e967d 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/PerThisOrTargetPointcutVisitor.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/PerThisOrTargetPointcutVisitor.java
@@ -17,9 +17,9 @@ import org.aspectj.weaver.ResolvedType;
 import org.aspectj.weaver.Shadow;
 
 /**
- * A visitor that turns a pointcut into a type pattern equivalent for a perthis or pertarget matching: - pertarget(target(Foo)) =>
- * Foo+ (this one is a special case..) - pertarget(execution(* Foo.do()) => Foo - perthis(call(* Foo.do()) => * - perthis(!call(*
- * Foo.do()) => * (see how the ! has been absorbed here..)
+ * A visitor that turns a pointcut into a type pattern equivalent for a perthis or pertarget matching: - pertarget(target(Foo)) &rarr;
+ * Foo+ (this one is a special case..) - pertarget(execution(* Foo.do()) &rarr; Foo - perthis(call(* Foo.do()) &rarr; * - perthis(!call(*
+ * Foo.do()) &rarr; * (see how the ! has been absorbed here..)
  * 
  * @author <a href="mailto:alex AT gnilux DOT com">Alexandre Vasseur</a>
  */
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/Pointcut.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/Pointcut.java
index f927286ec..567488c66 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/Pointcut.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/Pointcut.java
@@ -244,7 +244,7 @@ public abstract class Pointcut extends PatternNode {
 	 * Resolves and removes ReferencePointcuts, replacing with basic ones
 	 * 
 	 * @param inAspect the aspect to resolve relative to
-	 * @param bindings a Map from formal index in the current lexical context -> formal index in the concrete advice that will run
+	 * @param bindings a Map from formal index in the current lexical context &rarr; formal index in the concrete advice that will run
 	 * 
 	 *        This must always return a new Pointcut object (even if the concretized Pointcut is identical to the resolved one).
 	 *        That behavior is assumed in many places. XXX fix implementors to handle state
diff --git a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/WildTypePattern.java b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/WildTypePattern.java
index b8c4ac31b..64bda3f54 100644
--- a/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/WildTypePattern.java
+++ b/org.aspectj.matcher/src/main/java/org/aspectj/weaver/patterns/WildTypePattern.java
@@ -51,25 +51,25 @@ import org.aspectj.weaver.World;
  * Foo where Foo exists and is generic Parser creates WildTypePattern namePatterns={Foo} resolveBindings resolves Foo to RT(Foo -
  * raw) return ExactTypePattern(LFoo;)
  * 
- * Foo<String> where Foo exists and String meets the bounds Parser creates WildTypePattern namePatterns = {Foo},
+ * Foo&lt;String&gt; where Foo exists and String meets the bounds Parser creates WildTypePattern namePatterns = {Foo},
  * typeParameters=WTP{String} resolveBindings resolves typeParameters to ExactTypePattern(String) resolves Foo to RT(Foo) returns
- * ExactTypePattern(PFoo<String>; - parameterized)
+ * ExactTypePattern(PFoo&lt;String&gt;; - parameterized)
  * 
- * Foo<Str*> where Foo exists and takes one bound Parser creates WildTypePattern namePatterns = {Foo}, typeParameters=WTP{Str*}
+ * Foo&lt;Str*&gt; where Foo exists and takes one bound Parser creates WildTypePattern namePatterns = {Foo}, typeParameters=WTP{Str*}
  * resolveBindings resolves typeParameters to WTP{Str*} resolves Foo to RT(Foo) returns WildTypePattern(name = Foo, typeParameters =
  * WTP{Str*} isGeneric=false)
  * 
- * Fo*<String> Parser creates WildTypePattern namePatterns = {Fo*}, typeParameters=WTP{String} resolveBindings resolves
+ * Fo*&lt;String&gt; Parser creates WildTypePattern namePatterns = {Fo*}, typeParameters=WTP{String} resolveBindings resolves
  * typeParameters to ETP{String} returns WildTypePattern(name = Fo*, typeParameters = ETP{String} isGeneric=false)
  * 
  * 
- * Foo<?>
+ * Foo&lt;?&gt;
  * 
- * Foo<? extends Number>
+ * Foo&lt;? extends Number&gt;
  * 
- * Foo<? extends Number+>
+ * Foo&lt;? extends Number+&gt;
  * 
- * Foo<? super Number>
+ * Foo&lt;? super Number&gt;
  * 
  */
 public class WildTypePattern extends TypePattern {