diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/core/runtime/adaptor/package.html b/bundles/org.eclipse.osgi/container/src/org/eclipse/core/runtime/adaptor/package.html
index 65b4819..c801ee0 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/core/runtime/adaptor/package.html
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/core/runtime/adaptor/package.html
@@ -10,8 +10,8 @@
 Package Specification</h2>
 This package specifies API to start the platform.
 <p>
-Clients may use the <tt>EclipseStarter</tt> loader class to start the platform.  The
-<tt>EclipseStarter</tt> class is the only defined API in this package.
+Clients may use the <code>EclipseStarter</code> loader class to start the platform.  The
+<code>EclipseStarter</code> class is the only defined API in this package.
 </p>
 </body>
 </html>
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/Resolver.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/Resolver.java
index a92c482..1544f1f 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/Resolver.java
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/Resolver.java
@@ -43,10 +43,10 @@
 	 * resolution.
 	 * </p>
 	 * @param discard the list of bundles to discard the resolve status and 
-	 * reresolve.  A <tt>null</tt> value indicates that all currently unresolved
+	 * reresolve.  A <code>null</code> value indicates that all currently unresolved
 	 * bundles in the state should be resolved.
 	 * @param platformProperties the platform properties used to match platform filters
-	 * against.  A <tt>null</tt> value indicates that the system properties should
+	 * against.  A <code>null</code> value indicates that the system properties should
 	 * be used to match against
 	 */
 	public void resolve(BundleDescription[] discard, Dictionary<Object, Object>[] platformProperties);
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/State.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/State.java
index f58efa4..7608abe 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/State.java
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/State.java
@@ -309,12 +309,12 @@
 	 * To ensure that this state and the given resovler are properly linked,
 	 * the following expression must be included in this method if the given
 	 * resolver (value) is not identical to the result of this.getResolver().
+	 * </p>
 	 * 
 	 * <pre>
 	 *  if (this.getResolver() != value) value.setState(this);
 	 * </pre>
 	 * 
-	 * </p>
 	 */
 	// TODO what happens if you set the Resolver after some bundles have
 	// been added to the state but it is not resolved?  Should setting
@@ -510,9 +510,8 @@
 	 * <li>org.osgi.framework.language - the language being used.  This property is used to resolve the language attribute 
 	 * of bundle native code (i.e. Bundle-NativeCode).</li>
 	 * </ul>
-	 * <p>
-	 * The values used for the supported properties can be <tt>String</tt> type
-	 * to specify a single value for the property or they can by <tt>String[]</tt>
+	 * The values used for the supported properties can be <code>String</code> type
+	 * to specify a single value for the property or they can by <code>String[]</code>
 	 * to specify a list of values for the property. 
 	 * @param platformProperties the platform properties of the state
 	 * @return false if the platformProperties specified do not change any of the
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/VersionRange.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/VersionRange.java
index 87e25f9..ec61c40 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/VersionRange.java
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/service/resolver/VersionRange.java
@@ -42,7 +42,7 @@
 	 * is used. 
 	 */
 	public VersionRange(Version minVersion, boolean includeMin, Version maxVersion, boolean includeMax) {
-		super(includeMin ? INCLUDE_MIN : EXCLUDE_MIN, minVersion == null ? Version.emptyVersion : minVersion, versionMax.equals(maxVersion) ? null : maxVersion, includeMax ? INCLUDE_MAX : EXCLUDE_MAX); 
+		super(includeMin ? INCLUDE_MIN : EXCLUDE_MIN, minVersion == null ? Version.emptyVersion : minVersion, versionMax.equals(maxVersion) ? null : maxVersion, includeMax ? INCLUDE_MAX : EXCLUDE_MAX);
 	}
 
 	/**
@@ -50,6 +50,7 @@
 	 * 
 	 * <p>
 	 * Here is the grammar for version range strings.
+	 * </p>
 	 * <pre>
 	 * version-range ::= interval | atleast
 	 * interval ::= ( include-min | exclude-min ) min-version ',' max-version ( include-max | exclude-max )
@@ -61,7 +62,6 @@
 	 * include-max ::= ']'
 	 * exclude-max ::= ')'
 	 * </pre>
-	 * </p>
 	 * 
 	 * @param versionRange string representation of the version range or <code>null</code>
 	 * for the empty range "0.0.0"
diff --git a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/util/TextProcessor.java b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/util/TextProcessor.java
index 66e79e8..4b67065 100644
--- a/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/util/TextProcessor.java
+++ b/bundles/org.eclipse.osgi/container/src/org/eclipse/osgi/util/TextProcessor.java
@@ -111,14 +111,15 @@
 	 * to the provided delimiters. Each segment has the Unicode BiDi algorithm
 	 * applied to it, but as a whole, the string is oriented left to right.
 	 * <p>
-	 * For example a file path such as <tt>d:\myFolder\FOLDER\MYFILE.java</tt>
+	 * For example a file path such as <code>d:\myFolder\FOLDER\MYFILE.java</code>
 	 * (where capital letters indicate RTL text) should render as
-	 * <tt>d:\myFolder\REDLOF\ELIFYM.java</tt> when using the Unicode BiDi
+	 * <code>d:\myFolder\REDLOF\ELIFYM.java</code> when using the Unicode BiDi
 	 * algorithm and segmenting the string according to the specified delimiter
 	 * set.
 	 * </p>
 	 * <p>
 	 * The following algorithm is used:
+	 * </p>
 	 * <ol>
 	 * <li>Scan the string to locate the delimiters.</li>
 	 * <li>While scanning, note the direction of the last strong character
@@ -135,7 +136,6 @@
 	 * LRE/PDF if the string begins with an LTR letter, contains no RTL letter,
 	 * and ends with either a LTR letter or a digit.</li>
 	 * </ol>
-	 * </p>
 	 * <p>
 	 * NOTE: this method will change the shape of the original string passed in
 	 * by inserting punctuation characters into the text in order to make it
diff --git a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/framework/log/package.html b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/framework/log/package.html
index a4db43c..bcfa10a 100644
--- a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/framework/log/package.html
+++ b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/framework/log/package.html
@@ -5,10 +5,10 @@
    <title>Package-level Javadoc</title>
 </head>
 <body>
-Provides the <tt>FrameworkLog</tt> service.
+Provides the <code>FrameworkLog</code> service.
 <h2>
 Package Specification</h2>
-This package specifies the API for the <tt>FrameworkLog</tt> service.
+This package specifies the API for the <code>FrameworkLog</code> service.
 <p>
 Clients needing to log entries to the eclipse log will likely be interested 
 in the types provided by this package.
diff --git a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/datalocation/package.html b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/datalocation/package.html
index 35cb61c..2f2b8ff 100644
--- a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/datalocation/package.html
+++ b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/datalocation/package.html
@@ -5,10 +5,10 @@
    <title>Package-level Javadoc</title>
 </head>
 <body>
-Provides the <tt>Location</tt> service.
+Provides the <code>Location</code> service.
 <h2>
 Package Specification</h2>
-This package specifies the API for the <tt>Location</tt> service.
+This package specifies the API for the <code>Location</code> service.
 <p>
 Clients accessing the configuration, install, instance or user locations will likely be interested 
 in the types provided by this package.
diff --git a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/debug/package.html b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/debug/package.html
index 8c32c76..f07fd51 100644
--- a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/debug/package.html
+++ b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/debug/package.html
@@ -5,10 +5,10 @@
    <title>Package-level Javadoc</title>
 </head>
 <body>
-Provides the <tt>DebugOptions</tt> service.
+Provides the <code>DebugOptions</code> service.
 <h2>
 Package Specification</h2>
-This package specifies the API for the <tt>DebugOptions</tt> service.
+This package specifies the API for the <code>DebugOptions</code> service.
 <p>
 Clients accessing debug and trace options will likely be interested 
 in the types provided by this package.
diff --git a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/environment/package.html b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/environment/package.html
index ef6f904..0e54156 100644
--- a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/environment/package.html
+++ b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/environment/package.html
@@ -5,10 +5,10 @@
    <title>Package-level Javadoc</title>
 </head>
 <body>
-Provides the <tt>EnvironmentInfo</tt> service.
+Provides the <code>EnvironmentInfo</code> service.
 <h2>
 Package Specification</h2>
-This package specifies the API for the <tt>EnvironmentInfo</tt> service.
+This package specifies the API for the <code>EnvironmentInfo</code> service.
 <p>
 Clients accessing the command line used to start the running framework 
 as well as information about the environment will likely be interested  
diff --git a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/localization/package.html b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/localization/package.html
index 07ddb00..1a354a2 100644
--- a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/localization/package.html
+++ b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/service/localization/package.html
@@ -8,8 +8,8 @@
 Provides bundle localization and local provider service APIs.
 <h2>
 Package Specification</h2>
-This package specifies the API for the <tt>BundleLocalization</tt> and
-<tt>LocalePrivder</tt> services.
+This package specifies the API for the <code>BundleLocalization</code> and
+<code>LocalePrivder</code> services.
 <p>
 Clients accessing the localization resource bundles use to localize 
 OSGi bundle manifests will likely be interested in the types provided 
diff --git a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/util/ManifestElement.java b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/util/ManifestElement.java
index 0e1e2e9..fed59f1 100644
--- a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/util/ManifestElement.java
+++ b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/util/ManifestElement.java
@@ -125,7 +125,7 @@
 	 * test1.jar;test2.jar;test3.jar;selection-filter="(os.name=Windows XP)"
 	 * </pre>
 	 * <p>
-	 * This manifest element has a value of <tt>test1.jar;test2.jar;test3.jar</tt>
+	 * This manifest element has a value of <code>test1.jar;test2.jar;test3.jar</code>
 	 * </p>
 	 * 
 	 * @return the value of the manifest element.
diff --git a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/util/NLS.java b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/util/NLS.java
index 3e2e506..6660e46 100644
--- a/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/util/NLS.java
+++ b/bundles/org.eclipse.osgi/supplement/src/org/eclipse/osgi/util/NLS.java
@@ -19,7 +19,12 @@
 import java.lang.reflect.Modifier;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
 import org.eclipse.osgi.framework.log.FrameworkLog;
 import org.eclipse.osgi.framework.log.FrameworkLogEntry;
 import org.eclipse.osgi.internal.util.SupplementDebug;
@@ -131,12 +136,12 @@
 	 * For example, if the locale is set to en_US and <code>org.eclipse.example.nls.messages</code>
 	 * is used as the base name then the following resources will be searched using the class
 	 * loader of the specified class:
+	 * </p>
 	 * <pre>
 	 *   org/eclipse/example/nls/messages_en_US.properties
 	 *   org/eclipse/example/nls/messages_en.properties
 	 *   org/eclipse/example/nls/messages.properties
 	 * </pre>
-	 * </p>
 	 * 
 	 * @param baseName the base name of a fully qualified message properties file.
 	 * @param clazz the class where the constants will exist
